gsupplicant/supplicant.c

   1 /*
   2  *
   3  *  WPA supplicant library with GLib integration
   4  *
   5  *  Copyright (C) 2012-2013  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdint.h>
  31 #include <syslog.h>
  32 #include <ctype.h>
  33 #include <stdbool.h>
  34 #include <netinet/if_ether.h>
  35 #include <netinet/in.h>
  36
  37 #include <glib.h>
  38 #include <gdbus.h>
  39
  40 #include "dbus.h"
  41 #include "gsupplicant.h"
  42
  43 #define IEEE80211_CAP_ESS       0x0001
  44 #define IEEE80211_CAP_IBSS      0x0002
  45 #define IEEE80211_CAP_PRIVACY   0x0010
  46
  47 #define BSS_UNKNOWN_STRENGTH    -90
  48
  49 static DBusConnection *connection;
  50
  51 static const GSupplicantCallbacks *callbacks_pointer;
  52
  53 static dbus_bool_t system_available = FALSE;
  54 static dbus_bool_t system_ready = FALSE;
  55
  56 static dbus_int32_t debug_level;
  57 static dbus_bool_t debug_timestamp = FALSE;
  58 static dbus_bool_t debug_showkeys = FALSE;
  59
  60 static const char *debug_strings[] = {
  61         "msgdump", "debug", "info", "warning", "error", NULL
  62 };
  63
  64 static unsigned int eap_methods;
  65
  66 struct strvalmap {
  67         const char *str;
  68         unsigned int val;
  69 };
  70
  71 static struct strvalmap eap_method_map[] = {
  72         { "MD5",        G_SUPPLICANT_EAP_METHOD_MD5     },
  73         { "TLS",        G_SUPPLICANT_EAP_METHOD_TLS     },
  74         { "MSCHAPV2",   G_SUPPLICANT_EAP_METHOD_MSCHAPV2        },
  75         { "PEAP",       G_SUPPLICANT_EAP_METHOD_PEAP    },
  76         { "TTLS",       G_SUPPLICANT_EAP_METHOD_TTLS    },
  77         { "GTC",        G_SUPPLICANT_EAP_METHOD_GTC     },
  78         { "OTP",        G_SUPPLICANT_EAP_METHOD_OTP     },
  79         { "LEAP",       G_SUPPLICANT_EAP_METHOD_LEAP    },
  80         { "WSC",        G_SUPPLICANT_EAP_METHOD_WSC     },
  81         { }
  82 };
  83
  84 static struct strvalmap keymgmt_map[] = {
  85         { "none",               G_SUPPLICANT_KEYMGMT_NONE               },
  86         { "ieee8021x",          G_SUPPLICANT_KEYMGMT_IEEE8021X  },
  87         { "wpa-none",           G_SUPPLICANT_KEYMGMT_WPA_NONE   },
  88         { "wpa-psk",            G_SUPPLICANT_KEYMGMT_WPA_PSK    },
  89         { "wpa-psk-sha256",     G_SUPPLICANT_KEYMGMT_WPA_PSK_256        },
  90         { "wpa-ft-psk",         G_SUPPLICANT_KEYMGMT_WPA_FT_PSK },
  91         { "wpa-ft-eap",         G_SUPPLICANT_KEYMGMT_WPA_FT_EAP },
  92         { "wpa-eap",            G_SUPPLICANT_KEYMGMT_WPA_EAP    },
  93         { "wpa-eap-sha256",     G_SUPPLICANT_KEYMGMT_WPA_EAP_256        },
  94         { "wps",                G_SUPPLICANT_KEYMGMT_WPS                },
  95         { }
  96 };
  97
  98 static struct strvalmap authalg_capa_map[] = {
  99         { "open",       G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN    },
 100         { "shared",     G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED  },
 101         { "leap",       G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP    },
 102         { }
 103 };
 104
 105 static struct strvalmap proto_capa_map[] = {
 106         { "wpa",        G_SUPPLICANT_CAPABILITY_PROTO_WPA               },
 107         { "rsn",        G_SUPPLICANT_CAPABILITY_PROTO_RSN               },
 108         { }
 109 };
 110
 111 static struct strvalmap group_map[] = {
 112         { "wep40",      G_SUPPLICANT_GROUP_WEP40        },
 113         { "wep104",     G_SUPPLICANT_GROUP_WEP104       },
 114         { "tkip",       G_SUPPLICANT_GROUP_TKIP },
 115         { "ccmp",       G_SUPPLICANT_GROUP_CCMP },
 116         { }
 117 };
 118
 119 static struct strvalmap pairwise_map[] = {
 120         { "none",       G_SUPPLICANT_PAIRWISE_NONE      },
 121         { "tkip",       G_SUPPLICANT_PAIRWISE_TKIP      },
 122         { "ccmp",       G_SUPPLICANT_PAIRWISE_CCMP      },
 123         { }
 124 };
 125
 126 static struct strvalmap scan_capa_map[] = {
 127         { "active",     G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE     },
 128         { "passive",    G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE    },
 129         { "ssid",       G_SUPPLICANT_CAPABILITY_SCAN_SSID               },
 130         { }
 131 };
 132
 133 static struct strvalmap mode_capa_map[] = {
 134         { "infrastructure",     G_SUPPLICANT_CAPABILITY_MODE_INFRA      },
 135         { "ad-hoc",             G_SUPPLICANT_CAPABILITY_MODE_IBSS       },
 136         { "ap",                 G_SUPPLICANT_CAPABILITY_MODE_AP         },
 137         { "p2p",                G_SUPPLICANT_CAPABILITY_MODE_P2P        },
 138         { }
 139 };
 140
 141 static GHashTable *interface_table;
 142 static GHashTable *bss_mapping;
 143 static GHashTable *peer_mapping;
 144 static GHashTable *group_mapping;
 145 static GHashTable *pending_peer_connection;
 146
 147 struct _GSupplicantWpsCredentials {
 148         unsigned char ssid[32];
 149         unsigned int ssid_len;
 150         char *key;
 151 };
 152
 153 struct _GSupplicantInterface {
 154         char *path;
 155         char *network_path;
 156         unsigned int keymgmt_capa;
 157         unsigned int authalg_capa;
 158         unsigned int proto_capa;
 159         unsigned int group_capa;
 160         unsigned int pairwise_capa;
 161         unsigned int scan_capa;
 162         unsigned int mode_capa;
 163         unsigned int max_scan_ssids;
 164         bool p2p_support;
 165         bool p2p_finding;
 166         dbus_bool_t ready;
 167         GSupplicantState state;
 168         dbus_bool_t scanning;
 169         GSupplicantInterfaceCallback scan_callback;
 170         void *scan_data;
 171         int apscan;
 172         char *ifname;
 173         char *driver;
 174         char *bridge;
 175         struct _GSupplicantWpsCredentials wps_cred;
 176         GSupplicantWpsState wps_state;
 177         GHashTable *network_table;
 178         GHashTable *peer_table;
 179         GHashTable *group_table;
 180         GHashTable *net_mapping;
 181         GHashTable *bss_mapping;
 182         void *data;
 183         const char *pending_peer_path;
 184 #if defined TIZEN_EXT
 185         int disconnect_reason;
 186 #endif
 187 };
 188
 189 struct g_supplicant_bss {
 190         GSupplicantInterface *interface;
 191         char *path;
 192         unsigned char bssid[6];
 193         unsigned char ssid[32];
 194         unsigned int ssid_len;
 195         dbus_uint16_t frequency;
 196         dbus_uint32_t maxrate;
 197         dbus_int16_t signal;
 198         GSupplicantMode mode;
 199         GSupplicantSecurity security;
 200         dbus_bool_t rsn_selected;
 201         unsigned int wpa_keymgmt;
 202         unsigned int wpa_pairwise;
 203         unsigned int wpa_group;
 204         unsigned int rsn_keymgmt;
 205         unsigned int rsn_pairwise;
 206         unsigned int rsn_group;
 207         unsigned int keymgmt;
 208         dbus_bool_t privacy;
 209         dbus_bool_t psk;
 210         dbus_bool_t ieee8021x;
 211 #if defined TIZEN_EXT
 212         dbus_bool_t ft_psk;
 213         dbus_bool_t ft_ieee8021x;
 214 #endif
 215         unsigned int wps_capabilities;
 216 };
 217
 218 struct _GSupplicantNetwork {
 219         GSupplicantInterface *interface;
 220         char *path;
 221         char *group;
 222         char *name;
 223         unsigned char ssid[32];
 224         unsigned int ssid_len;
 225         dbus_int16_t signal;
 226         dbus_uint16_t frequency;
 227         struct g_supplicant_bss *best_bss;
 228         GSupplicantMode mode;
 229         GSupplicantSecurity security;
 230         dbus_bool_t wps;
 231         unsigned int wps_capabilities;
 232         GHashTable *bss_table;
 233         GHashTable *config_table;
 234 #if defined TIZEN_EXT
 235         unsigned int isHS20AP;
 236         char *eap;
 237         char *identity;
 238         char *phase2;
 239         unsigned int keymgmt;
 240 #endif
 241 };
 242
 243 struct _GSupplicantPeer {
 244         GSupplicantInterface *interface;
 245         char *path;
 246         unsigned char device_address[ETH_ALEN];
 247         unsigned char iface_address[ETH_ALEN];
 248         char *name;
 249         unsigned char *widi_ies;
 250         int widi_ies_length;
 251         char *identifier;
 252         unsigned int wps_capabilities;
 253         GSList *groups;
 254         const GSupplicantInterface *current_group_iface;
 255         bool connection_requested;
 256 };
 257
 258 struct _GSupplicantGroup {
 259         GSupplicantInterface *interface;
 260         GSupplicantInterface *orig_interface;
 261         char *path;
 262         int role;
 263         GSList *members;
 264 };
 265
 266 static inline void debug(const char *format, ...)
 267 {
 268         char str[256];
 269         va_list ap;
 270
 271         if (!callbacks_pointer->debug)
 272                 return;
 273
 274         va_start(ap, format);
 275
 276         if (vsnprintf(str, sizeof(str), format, ap) > 0)
 277                 callbacks_pointer->debug(str);
 278
 279         va_end(ap);
 280 }
 281
 282 #define SUPPLICANT_DBG(fmt, arg...) \
 283         debug("%s:%s() " fmt, __FILE__, __FUNCTION__ , ## arg);
 284
 285 static GSupplicantMode string2mode(const char *mode)
 286 {
 287         if (!mode)
 288                 return G_SUPPLICANT_MODE_UNKNOWN;
 289
 290         if (g_str_equal(mode, "infrastructure"))
 291                 return G_SUPPLICANT_MODE_INFRA;
 292         else if (g_str_equal(mode, "ad-hoc"))
 293                 return G_SUPPLICANT_MODE_IBSS;
 294
 295         return G_SUPPLICANT_MODE_UNKNOWN;
 296 }
 297
 298 static const char *mode2string(GSupplicantMode mode)
 299 {
 300         switch (mode) {
 301         case G_SUPPLICANT_MODE_UNKNOWN:
 302                 break;
 303         case G_SUPPLICANT_MODE_INFRA:
 304                 return "managed";
 305         case G_SUPPLICANT_MODE_IBSS:
 306                 return "adhoc";
 307         case G_SUPPLICANT_MODE_MASTER:
 308                 return "ap";
 309         }
 310
 311         return NULL;
 312 }
 313
 314 static const char *security2string(GSupplicantSecurity security)
 315 {
 316         switch (security) {
 317         case G_SUPPLICANT_SECURITY_UNKNOWN:
 318                 break;
 319         case G_SUPPLICANT_SECURITY_NONE:
 320                 return "none";
 321         case G_SUPPLICANT_SECURITY_WEP:
 322                 return "wep";
 323         case G_SUPPLICANT_SECURITY_PSK:
 324                 return "psk";
 325         case G_SUPPLICANT_SECURITY_IEEE8021X:
 326                 return "ieee8021x";
 327 #if defined TIZEN_EXT
 328         case G_SUPPLICANT_SECURITY_FT_PSK:
 329                 return "ft_psk";
 330         case G_SUPPLICANT_SECURITY_FT_IEEE8021X:
 331                 return "ft_ieee8021x";
 332 #endif
 333         }
 334
 335         return NULL;
 336 }
 337
 338 static GSupplicantState string2state(const char *state)
 339 {
 340         if (!state)
 341                 return G_SUPPLICANT_STATE_UNKNOWN;
 342
 343         if (g_str_equal(state, "unknown"))
 344                 return G_SUPPLICANT_STATE_UNKNOWN;
 345         else if (g_str_equal(state, "interface_disabled"))
 346                 return G_SUPPLICANT_STATE_DISABLED;
 347         else if (g_str_equal(state, "disconnected"))
 348                 return G_SUPPLICANT_STATE_DISCONNECTED;
 349         else if (g_str_equal(state, "inactive"))
 350                 return G_SUPPLICANT_STATE_INACTIVE;
 351         else if (g_str_equal(state, "scanning"))
 352                 return G_SUPPLICANT_STATE_SCANNING;
 353         else if (g_str_equal(state, "authenticating"))
 354                 return G_SUPPLICANT_STATE_AUTHENTICATING;
 355         else if (g_str_equal(state, "associating"))
 356                 return G_SUPPLICANT_STATE_ASSOCIATING;
 357         else if (g_str_equal(state, "associated"))
 358                 return G_SUPPLICANT_STATE_ASSOCIATED;
 359         else if (g_str_equal(state, "group_handshake"))
 360                 return G_SUPPLICANT_STATE_GROUP_HANDSHAKE;
 361         else if (g_str_equal(state, "4way_handshake"))
 362                 return G_SUPPLICANT_STATE_4WAY_HANDSHAKE;
 363         else if (g_str_equal(state, "completed"))
 364                 return G_SUPPLICANT_STATE_COMPLETED;
 365
 366         return G_SUPPLICANT_STATE_UNKNOWN;
 367 }
 368
 369 static void callback_system_ready(void)
 370 {
 371         if (system_ready)
 372                 return;
 373
 374         system_ready = TRUE;
 375
 376         if (!callbacks_pointer)
 377                 return;
 378
 379         if (!callbacks_pointer->system_ready)
 380                 return;
 381
 382         callbacks_pointer->system_ready();
 383 }
 384
 385 static void callback_system_killed(void)
 386 {
 387         system_ready = FALSE;
 388
 389         if (!callbacks_pointer)
 390                 return;
 391
 392         if (!callbacks_pointer->system_killed)
 393                 return;
 394
 395         callbacks_pointer->system_killed();
 396 }
 397
 398 static void callback_interface_added(GSupplicantInterface *interface)
 399 {
 400         SUPPLICANT_DBG("");
 401
 402         if (!callbacks_pointer)
 403                 return;
 404
 405         if (!callbacks_pointer->interface_added)
 406                 return;
 407
 408         callbacks_pointer->interface_added(interface);
 409 }
 410
 411 static void callback_interface_state(GSupplicantInterface *interface)
 412 {
 413         if (!callbacks_pointer)
 414                 return;
 415
 416         if (!callbacks_pointer->interface_state)
 417                 return;
 418
 419         callbacks_pointer->interface_state(interface);
 420 }
 421
 422 static void callback_interface_removed(GSupplicantInterface *interface)
 423 {
 424         if (!callbacks_pointer)
 425                 return;
 426
 427         if (!callbacks_pointer->interface_removed)
 428                 return;
 429
 430         callbacks_pointer->interface_removed(interface);
 431 }
 432
 433 #if !defined TIZEN_EXT
 434 static void callback_p2p_support(GSupplicantInterface *interface)
 435 {
 436         SUPPLICANT_DBG("");
 437
 438         if (!interface->p2p_support)
 439                 return;
 440
 441         if (callbacks_pointer && callbacks_pointer->p2p_support)
 442                 callbacks_pointer->p2p_support(interface);
 443 }
 444 #endif
 445
 446 static void callback_scan_started(GSupplicantInterface *interface)
 447 {
 448         if (!callbacks_pointer)
 449                 return;
 450
 451         if (!callbacks_pointer->scan_started)
 452                 return;
 453
 454         callbacks_pointer->scan_started(interface);
 455 }
 456
 457 static void callback_scan_finished(GSupplicantInterface *interface)
 458 {
 459         if (!callbacks_pointer)
 460                 return;
 461
 462         if (!callbacks_pointer->scan_finished)
 463                 return;
 464
 465         callbacks_pointer->scan_finished(interface);
 466 }
 467
 468 static void callback_network_added(GSupplicantNetwork *network)
 469 {
 470         if (!callbacks_pointer)
 471                 return;
 472
 473         if (!callbacks_pointer->network_added)
 474                 return;
 475
 476         callbacks_pointer->network_added(network);
 477 }
 478
 479 static void callback_network_removed(GSupplicantNetwork *network)
 480 {
 481         if (!callbacks_pointer)
 482                 return;
 483
 484         if (!callbacks_pointer->network_removed)
 485                 return;
 486
 487         callbacks_pointer->network_removed(network);
 488 }
 489
 490 #if defined TIZEN_EXT
 491 static void callback_network_merged(GSupplicantNetwork *network)
 492 {
 493         if (!callbacks_pointer)
 494                 return;
 495
 496         if (!callbacks_pointer->network_merged)
 497                 return;
 498
 499         callbacks_pointer->network_merged(network);
 500 }
 501 #endif
 502
 503 static void callback_network_changed(GSupplicantNetwork *network,
 504                                         const char *property)
 505 {
 506         if (!callbacks_pointer)
 507                 return;
 508
 509         if (!callbacks_pointer->network_changed)
 510                 return;
 511
 512         callbacks_pointer->network_changed(network, property);
 513 }
 514
 515 static void callback_peer_found(GSupplicantPeer *peer)
 516 {
 517         if (!callbacks_pointer)
 518                 return;
 519
 520         if (!callbacks_pointer->peer_found)
 521                 return;
 522
 523         callbacks_pointer->peer_found(peer);
 524 }
 525
 526 static void callback_peer_lost(GSupplicantPeer *peer)
 527 {
 528         if (!callbacks_pointer)
 529                 return;
 530
 531         if (!callbacks_pointer->peer_lost)
 532                 return;
 533
 534         callbacks_pointer->peer_lost(peer);
 535 }
 536
 537 static void callback_peer_changed(GSupplicantPeer *peer,
 538                                                 GSupplicantPeerState state)
 539 {
 540         if (!callbacks_pointer)
 541                 return;
 542
 543         if (!callbacks_pointer->peer_changed)
 544                 return;
 545
 546         callbacks_pointer->peer_changed(peer, state);
 547 }
 548
 549 static void callback_peer_request(GSupplicantPeer *peer)
 550 {
 551         if (!callbacks_pointer)
 552                 return;
 553
 554         if (!callbacks_pointer->peer_request)
 555                 return;
 556
 557         peer->connection_requested = true;
 558
 559         callbacks_pointer->peer_request(peer);
 560 }
 561
 562 static void callback_disconnect_reason_code(GSupplicantInterface *interface,
 563                                         int reason_code)
 564 {
 565         if (!callbacks_pointer)
 566                 return;
 567
 568         if (!callbacks_pointer->disconnect_reasoncode)
 569                 return;
 570
 571         if (reason_code != 0)
 572                 callbacks_pointer->disconnect_reasoncode(interface,
 573                                                         reason_code);
 574 }
 575
 576 static void remove_group(gpointer data)
 577 {
 578         GSupplicantGroup *group = data;
 579
 580         if (group->members)
 581                 g_slist_free_full(group->members, g_free);
 582
 583         g_free(group->path);
 584         g_free(group);
 585 }
 586
 587 static void remove_interface(gpointer data)
 588 {
 589         GSupplicantInterface *interface = data;
 590
 591         g_hash_table_destroy(interface->bss_mapping);
 592         g_hash_table_destroy(interface->net_mapping);
 593         g_hash_table_destroy(interface->network_table);
 594         g_hash_table_destroy(interface->peer_table);
 595         g_hash_table_destroy(interface->group_table);
 596
 597         if (interface->scan_callback) {
 598                 SUPPLICANT_DBG("call interface %p callback %p scanning %d",
 599                                 interface, interface->scan_callback,
 600                                 interface->scanning);
 601
 602                 interface->scan_callback(-EIO, interface, interface->scan_data);
 603                 interface->scan_callback = NULL;
 604                 interface->scan_data = NULL;
 605
 606                 if (interface->scanning) {
 607                         interface->scanning = FALSE;
 608                         callback_scan_finished(interface);
 609                 }
 610         }
 611
 612         callback_interface_removed(interface);
 613
 614         g_free(interface->wps_cred.key);
 615         g_free(interface->path);
 616         g_free(interface->network_path);
 617 #if defined TIZEN_EXT
 618         interface->network_path = NULL;
 619 #endif
 620         g_free(interface->ifname);
 621         g_free(interface->driver);
 622         g_free(interface->bridge);
 623         g_free(interface);
 624 }
 625
 626 static void remove_network(gpointer data)
 627 {
 628         GSupplicantNetwork *network = data;
 629
 630         g_hash_table_destroy(network->bss_table);
 631
 632         callback_network_removed(network);
 633
 634         g_hash_table_destroy(network->config_table);
 635
 636         g_free(network->path);
 637         g_free(network->group);
 638         g_free(network->name);
 639 #if defined TIZEN_EXT
 640         g_free(network->eap);
 641         g_free(network->identity);
 642         g_free(network->phase2);
 643 #endif
 644         g_free(network);
 645 }
 646
 647 static void remove_bss(gpointer data)
 648 {
 649         struct g_supplicant_bss *bss = data;
 650
 651         g_free(bss->path);
 652         g_free(bss);
 653 }
 654
 655 static void remove_peer(gpointer data)
 656 {
 657         GSupplicantPeer *peer = data;
 658
 659         callback_peer_lost(peer);
 660
 661         if (peer->groups)
 662                 g_slist_free_full(peer->groups, g_free);
 663
 664         if (peer_mapping)
 665                 g_hash_table_remove(peer_mapping, peer->path);
 666
 667         if (pending_peer_connection)
 668                 g_hash_table_remove(pending_peer_connection, peer->path);
 669
 670         g_free(peer->path);
 671         g_free(peer->name);
 672         g_free(peer->identifier);
 673
 674         g_free(peer);
 675 }
 676
 677 static void debug_strvalmap(const char *label, struct strvalmap *map,
 678                                                         unsigned int val)
 679 {
 680         int i;
 681
 682         for (i = 0; map[i].str; i++) {
 683                 if (val & map[i].val)
 684                         SUPPLICANT_DBG("%s: %s", label, map[i].str);
 685         }
 686 }
 687
 688 static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
 689 {
 690         GSupplicantInterface *interface = user_data;
 691         const char *str = NULL;
 692         int i;
 693
 694         dbus_message_iter_get_basic(iter, &str);
 695         if (!str)
 696                 return;
 697
 698         for (i = 0; keymgmt_map[i].str; i++)
 699                 if (strcmp(str, keymgmt_map[i].str) == 0) {
 700                         interface->keymgmt_capa |= keymgmt_map[i].val;
 701                         break;
 702                 }
 703 }
 704
 705 static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
 706 {
 707         GSupplicantInterface *interface = user_data;
 708         const char *str = NULL;
 709         int i;
 710
 711         dbus_message_iter_get_basic(iter, &str);
 712         if (!str)
 713                 return;
 714
 715         for (i = 0; authalg_capa_map[i].str; i++)
 716                 if (strcmp(str, authalg_capa_map[i].str) == 0) {
 717                         interface->authalg_capa |= authalg_capa_map[i].val;
 718                         break;
 719                 }
 720 }
 721
 722 static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
 723 {
 724         GSupplicantInterface *interface = user_data;
 725         const char *str = NULL;
 726         int i;
 727
 728         dbus_message_iter_get_basic(iter, &str);
 729         if (!str)
 730                 return;
 731
 732         for (i = 0; proto_capa_map[i].str; i++)
 733                 if (strcmp(str, proto_capa_map[i].str) == 0) {
 734                         interface->proto_capa |= proto_capa_map[i].val;
 735                         break;
 736                 }
 737 }
 738
 739 static void interface_capability_pairwise(DBusMessageIter *iter,
 740                                                         void *user_data)
 741 {
 742         GSupplicantInterface *interface = user_data;
 743         const char *str = NULL;
 744         int i;
 745
 746         dbus_message_iter_get_basic(iter, &str);
 747         if (!str)
 748                 return;
 749
 750         for (i = 0; pairwise_map[i].str; i++)
 751                 if (strcmp(str, pairwise_map[i].str) == 0) {
 752                         interface->pairwise_capa |= pairwise_map[i].val;
 753                         break;
 754                 }
 755 }
 756
 757 static void interface_capability_group(DBusMessageIter *iter, void *user_data)
 758 {
 759         GSupplicantInterface *interface = user_data;
 760         const char *str = NULL;
 761         int i;
 762
 763         dbus_message_iter_get_basic(iter, &str);
 764         if (!str)
 765                 return;
 766
 767         for (i = 0; group_map[i].str; i++)
 768                 if (strcmp(str, group_map[i].str) == 0) {
 769                         interface->group_capa |= group_map[i].val;
 770                         break;
 771                 }
 772 }
 773
 774 static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
 775 {
 776         GSupplicantInterface *interface = user_data;
 777         const char *str = NULL;
 778         int i;
 779
 780         dbus_message_iter_get_basic(iter, &str);
 781         if (!str)
 782                 return;
 783
 784         for (i = 0; scan_capa_map[i].str; i++)
 785                 if (strcmp(str, scan_capa_map[i].str) == 0) {
 786                         interface->scan_capa |= scan_capa_map[i].val;
 787                         break;
 788                 }
 789 }
 790
 791 static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
 792 {
 793         GSupplicantInterface *interface = user_data;
 794         const char *str = NULL;
 795         int i;
 796
 797         dbus_message_iter_get_basic(iter, &str);
 798         if (!str)
 799                 return;
 800
 801         for (i = 0; mode_capa_map[i].str; i++)
 802                 if (strcmp(str, mode_capa_map[i].str) == 0) {
 803                         interface->mode_capa |= mode_capa_map[i].val;
 804                         break;
 805                 }
 806 }
 807
 808 static void interface_capability(const char *key, DBusMessageIter *iter,
 809                                                         void *user_data)
 810 {
 811         GSupplicantInterface *interface = user_data;
 812
 813         if (!key)
 814                 return;
 815
 816         if (g_strcmp0(key, "KeyMgmt") == 0)
 817                 supplicant_dbus_array_foreach(iter,
 818                                 interface_capability_keymgmt, interface);
 819         else if (g_strcmp0(key, "AuthAlg") == 0)
 820                 supplicant_dbus_array_foreach(iter,
 821                                 interface_capability_authalg, interface);
 822         else if (g_strcmp0(key, "Protocol") == 0)
 823                 supplicant_dbus_array_foreach(iter,
 824                                 interface_capability_proto, interface);
 825         else if (g_strcmp0(key, "Pairwise") == 0)
 826                 supplicant_dbus_array_foreach(iter,
 827                                 interface_capability_pairwise, interface);
 828         else if (g_strcmp0(key, "Group") == 0)
 829                 supplicant_dbus_array_foreach(iter,
 830                                 interface_capability_group, interface);
 831         else if (g_strcmp0(key, "Scan") == 0)
 832                 supplicant_dbus_array_foreach(iter,
 833                                 interface_capability_scan, interface);
 834         else if (g_strcmp0(key, "Modes") == 0)
 835                 supplicant_dbus_array_foreach(iter,
 836                                 interface_capability_mode, interface);
 837         else if (g_strcmp0(key, "MaxScanSSID") == 0) {
 838                 dbus_int32_t max_scan_ssid;
 839
 840                 dbus_message_iter_get_basic(iter, &max_scan_ssid);
 841                 if (max_scan_ssid < 2)
 842                         max_scan_ssid = 0;
 843                 interface->max_scan_ssids = max_scan_ssid;
 844
 845         } else
 846                 SUPPLICANT_DBG("key %s type %c",
 847                                 key, dbus_message_iter_get_arg_type(iter));
 848 }
 849
 850 static void set_apscan(DBusMessageIter *iter, void *user_data)
 851 {
 852         unsigned int ap_scan = *(unsigned int *)user_data;
 853
 854         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &ap_scan);
 855 }
 856
 857 int g_supplicant_interface_set_apscan(GSupplicantInterface *interface,
 858                                                         unsigned int ap_scan)
 859 {
 860         return supplicant_dbus_property_set(interface->path,
 861                         SUPPLICANT_INTERFACE ".Interface",
 862                                 "ApScan", DBUS_TYPE_UINT32_AS_STRING,
 863                                         set_apscan, NULL, &ap_scan, NULL);
 864 }
 865
 866 void g_supplicant_interface_set_data(GSupplicantInterface *interface,
 867                                                                 void *data)
 868 {
 869         if (!interface)
 870                 return;
 871
 872         interface->data = data;
 873
 874         if (!data)
 875                 interface->scan_callback = NULL;
 876 }
 877
 878 void *g_supplicant_interface_get_data(GSupplicantInterface *interface)
 879 {
 880         if (!interface)
 881                 return NULL;
 882
 883         return interface->data;
 884 }
 885
 886 const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface)
 887 {
 888         if (!interface)
 889                 return NULL;
 890
 891         return interface->ifname;
 892 }
 893
 894 const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface)
 895 {
 896         if (!interface)
 897                 return NULL;
 898
 899         return interface->driver;
 900 }
 901
 902 GSupplicantState g_supplicant_interface_get_state(
 903                                         GSupplicantInterface *interface)
 904 {
 905         if (!interface)
 906                 return G_SUPPLICANT_STATE_UNKNOWN;
 907
 908         return interface->state;
 909 }
 910
 911 const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface)
 912 {
 913         if (!interface)
 914                 return NULL;
 915
 916         return (const char *)interface->wps_cred.key;
 917 }
 918
 919 const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
 920                                                         unsigned int *ssid_len)
 921 {
 922         if (!ssid_len)
 923                 return NULL;
 924
 925         if (!interface || interface->wps_cred.ssid_len == 0) {
 926                 *ssid_len = 0;
 927                 return NULL;
 928         }
 929
 930         *ssid_len = interface->wps_cred.ssid_len;
 931         return interface->wps_cred.ssid;
 932 }
 933
 934 GSupplicantWpsState g_supplicant_interface_get_wps_state(
 935                                         GSupplicantInterface *interface)
 936 {
 937         if (!interface)
 938                 return G_SUPPLICANT_WPS_STATE_UNKNOWN;
 939
 940         return interface->wps_state;
 941 }
 942
 943 unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface)
 944 {
 945         if (!interface)
 946                 return 0;
 947
 948         return interface->mode_capa;
 949 }
 950
 951 unsigned int g_supplicant_interface_get_max_scan_ssids(
 952                                 GSupplicantInterface *interface)
 953 {
 954         if (!interface)
 955                 return 0;
 956
 957         if (interface->max_scan_ssids == 0)
 958                 return WPAS_MAX_SCAN_SSIDS;
 959
 960         return interface->max_scan_ssids;
 961 }
 962
 963 static void set_network_enabled(DBusMessageIter *iter, void *user_data)
 964 {
 965         dbus_bool_t enable = *(dbus_bool_t *)user_data;
 966
 967         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
 968 }
 969
 970 int g_supplicant_interface_enable_selected_network(GSupplicantInterface *interface,
 971                                                         dbus_bool_t enable)
 972 {
 973         if (!interface)
 974                 return -1;
 975
 976         if (!interface->network_path)
 977                 return -1;
 978
 979         SUPPLICANT_DBG(" ");
 980         return supplicant_dbus_property_set(interface->network_path,
 981                                 SUPPLICANT_INTERFACE ".Network",
 982                                 "Enabled", DBUS_TYPE_BOOLEAN_AS_STRING,
 983                                 set_network_enabled, NULL, &enable, NULL);
 984 }
 985
 986 dbus_bool_t g_supplicant_interface_get_ready(GSupplicantInterface *interface)
 987 {
 988         if (!interface)
 989                 return FALSE;
 990
 991         return interface->ready;
 992 }
 993
 994 GSupplicantInterface *g_supplicant_network_get_interface(
 995                                         GSupplicantNetwork *network)
 996 {
 997         if (!network)
 998                 return NULL;
 999
1000         return network->interface;
1001 }
1002
1003 const char *g_supplicant_network_get_name(GSupplicantNetwork *network)
1004 {
1005         if (!network || !network->name)
1006                 return "";
1007
1008         return network->name;
1009 }
1010
1011 const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network)
1012 {
1013         if (!network || !network->group)
1014                 return "";
1015
1016         return network->group;
1017 }
1018
1019 const char *g_supplicant_network_get_path(GSupplicantNetwork *network)
1020 {
1021         if (!network || !network->path)
1022                 return NULL;
1023
1024         return network->path;
1025 }
1026
1027 const char *g_supplicant_network_get_mode(GSupplicantNetwork *network)
1028 {
1029         if (!network)
1030                 return G_SUPPLICANT_MODE_UNKNOWN;
1031
1032         return mode2string(network->mode);
1033 }
1034
1035 const char *g_supplicant_network_get_security(GSupplicantNetwork *network)
1036 {
1037         if (!network)
1038                 return G_SUPPLICANT_SECURITY_UNKNOWN;
1039
1040         return security2string(network->security);
1041 }
1042
1043 const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
1044                                                 unsigned int *ssid_len)
1045 {
1046         if (!network) {
1047                 *ssid_len = 0;
1048                 return NULL;
1049         }
1050
1051         *ssid_len = network->ssid_len;
1052         return network->ssid;
1053 }
1054
1055 dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network)
1056 {
1057         if (!network)
1058                 return 0;
1059
1060         return network->signal;
1061 }
1062
1063 dbus_uint16_t g_supplicant_network_get_frequency(GSupplicantNetwork *network)
1064 {
1065         if (!network)
1066                 return 0;
1067
1068         return network->frequency;
1069 }
1070
1071 dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network)
1072 {
1073         if (!network)
1074                 return FALSE;
1075
1076         return network->wps;
1077 }
1078
1079 dbus_bool_t g_supplicant_network_is_wps_active(GSupplicantNetwork *network)
1080 {
1081         if (!network)
1082                 return FALSE;
1083
1084         if (network->wps_capabilities & G_SUPPLICANT_WPS_CONFIGURED)
1085                 return TRUE;
1086
1087         return FALSE;
1088 }
1089
1090 dbus_bool_t g_supplicant_network_is_wps_pbc(GSupplicantNetwork *network)
1091 {
1092         if (!network)
1093                 return FALSE;
1094
1095         if (network->wps_capabilities & G_SUPPLICANT_WPS_PBC)
1096                 return TRUE;
1097
1098         return FALSE;
1099 }
1100
1101 dbus_bool_t g_supplicant_network_is_wps_advertizing(GSupplicantNetwork *network)
1102 {
1103         if (!network)
1104                 return FALSE;
1105
1106         if (network->wps_capabilities & G_SUPPLICANT_WPS_REGISTRAR)
1107                 return TRUE;
1108
1109         return FALSE;
1110 }
1111
1112 GSupplicantInterface *g_supplicant_peer_get_interface(GSupplicantPeer *peer)
1113 {
1114         if (!peer)
1115                 return NULL;
1116
1117         return peer->interface;
1118 }
1119
1120 const char *g_supplicant_peer_get_path(GSupplicantPeer *peer)
1121 {
1122         if (!peer)
1123                 return NULL;
1124
1125         return peer->path;
1126 }
1127
1128 const char *g_supplicant_peer_get_identifier(GSupplicantPeer *peer)
1129 {
1130         if (!peer)
1131                 return NULL;
1132
1133         return peer->identifier;
1134 }
1135
1136 const void *g_supplicant_peer_get_device_address(GSupplicantPeer *peer)
1137 {
1138         if (!peer)
1139                 return NULL;
1140
1141         return peer->device_address;
1142 }
1143
1144 const void *g_supplicant_peer_get_iface_address(GSupplicantPeer *peer)
1145 {
1146         if (!peer)
1147                 return NULL;
1148
1149         return peer->iface_address;
1150 }
1151
1152 const char *g_supplicant_peer_get_name(GSupplicantPeer *peer)
1153 {
1154         if (!peer)
1155                 return NULL;
1156
1157         return peer->name;
1158 }
1159
1160 #if defined TIZEN_EXT
1161 unsigned int g_supplicant_network_is_hs20AP(GSupplicantNetwork *network)
1162 {
1163         if (!network)
1164                 return 0;
1165
1166         return network->isHS20AP;
1167 }
1168
1169 const char *g_supplicant_network_get_eap(GSupplicantNetwork *network)
1170 {
1171         if (!network || !network->eap)
1172                 return NULL;
1173
1174         return network->eap;
1175 }
1176
1177 const char *g_supplicant_network_get_identity(GSupplicantNetwork *network)
1178 {
1179         if (!network || !network->identity)
1180                 return NULL;
1181
1182         return network->identity;
1183 }
1184
1185 const char *g_supplicant_network_get_phase2(GSupplicantNetwork *network)
1186 {
1187         if (!network || !network->phase2)
1188                 return NULL;
1189
1190         return network->phase2;
1191 }
1192
1193 unsigned int g_supplicant_network_get_keymgmt(GSupplicantNetwork *network)
1194 {
1195         if (network == NULL)
1196                 return 0;
1197
1198         return network->keymgmt;
1199 }
1200 #endif
1201
1202 const unsigned char *g_supplicant_peer_get_widi_ies(GSupplicantPeer *peer,
1203                                                                 int *length)
1204 {
1205         if (!peer || !length)
1206                 return NULL;
1207
1208         *length = peer->widi_ies_length;
1209         return peer->widi_ies;
1210 }
1211
1212 bool g_supplicant_peer_is_wps_pbc(GSupplicantPeer *peer)
1213 {
1214         if (!peer)
1215                 return false;
1216
1217         if (peer->wps_capabilities & G_SUPPLICANT_WPS_PBC)
1218                 return true;
1219
1220         return false;
1221 }
1222
1223 bool g_supplicant_peer_is_wps_pin(GSupplicantPeer *peer)
1224 {
1225         if (!peer)
1226                 return false;
1227
1228         if (peer->wps_capabilities & G_SUPPLICANT_WPS_PIN)
1229                 return true;
1230
1231         return false;
1232 }
1233
1234 bool g_supplicant_peer_is_in_a_group(GSupplicantPeer *peer)
1235 {
1236         if (!peer || !peer->groups)
1237                 return false;
1238
1239         return true;
1240 }
1241
1242 GSupplicantInterface *g_supplicant_peer_get_group_interface(GSupplicantPeer *peer)
1243 {
1244         if (!peer)
1245                 return NULL;
1246
1247         return (GSupplicantInterface *) peer->current_group_iface;
1248 }
1249
1250 bool g_supplicant_peer_is_client(GSupplicantPeer *peer)
1251 {
1252         GSupplicantGroup *group;
1253         GSList *list;
1254
1255         if (!peer)
1256                 return false;
1257
1258         for (list = peer->groups; list; list = list->next) {
1259                 const char *path = list->data;
1260
1261                 group = g_hash_table_lookup(group_mapping, path);
1262                 if (!group)
1263                         continue;
1264
1265                 if (group->role != G_SUPPLICANT_GROUP_ROLE_CLIENT ||
1266                                 group->orig_interface != peer->interface)
1267                         continue;
1268
1269                 if (group->interface == peer->current_group_iface)
1270                         return true;
1271         }
1272
1273         return false;
1274 }
1275
1276 bool g_supplicant_peer_has_requested_connection(GSupplicantPeer *peer)
1277 {
1278         if (!peer)
1279                 return false;
1280
1281         return peer->connection_requested;
1282 }
1283
1284 #if defined TIZEN_EXT
1285 /*
1286  * Description: Network client requires additional wifi specific info
1287  */
1288 const unsigned char *g_supplicant_network_get_bssid(GSupplicantNetwork *network)
1289 {
1290         if (network == NULL || network->best_bss == NULL)
1291                 return NULL;
1292
1293         return (const unsigned char *)network->best_bss->bssid;
1294 }
1295
1296 unsigned int g_supplicant_network_get_maxrate(GSupplicantNetwork *network)
1297 {
1298         if (network == NULL || network->best_bss == NULL)
1299                 return 0;
1300
1301         return network->best_bss->maxrate;
1302 }
1303
1304 const char *g_supplicant_network_get_enc_mode(GSupplicantNetwork *network)
1305 {
1306         if (network == NULL || network->best_bss == NULL)
1307                 return NULL;
1308
1309         if (network->best_bss->security == G_SUPPLICANT_SECURITY_PSK ||
1310             network->best_bss->security == G_SUPPLICANT_SECURITY_IEEE8021X) {
1311                 unsigned int pairwise;
1312
1313                 pairwise = network->best_bss->rsn_pairwise |
1314                                 network->best_bss->wpa_pairwise;
1315
1316                 if ((pairwise & G_SUPPLICANT_PAIRWISE_CCMP) &&
1317                     (pairwise & G_SUPPLICANT_PAIRWISE_TKIP))
1318                         return "mixed";
1319                 else if (pairwise & G_SUPPLICANT_PAIRWISE_CCMP)
1320                         return "aes";
1321                 else if (pairwise & G_SUPPLICANT_PAIRWISE_TKIP)
1322                         return "tkip";
1323
1324         } else if (network->best_bss->security == G_SUPPLICANT_SECURITY_WEP)
1325                 return "wep";
1326         else if (network->best_bss->security == G_SUPPLICANT_SECURITY_NONE)
1327                 return "none";
1328
1329         return NULL;
1330 }
1331
1332 bool g_supplicant_network_get_rsn_mode(GSupplicantNetwork *network)
1333 {
1334         if (network == NULL || network->best_bss == NULL)
1335                 return 0;
1336
1337         if (network->best_bss->rsn_selected) {
1338                 const char *mode = g_supplicant_network_get_enc_mode(network);
1339                 if (g_strcmp0(mode, "aes") == 0 ||
1340                                 g_strcmp0(mode, "mixed") == 0)
1341                         return true;
1342                 else
1343                         return false;
1344         } else
1345                 return false;
1346 }
1347
1348 #endif
1349
1350 static void merge_network(GSupplicantNetwork *network)
1351 {
1352         GString *str;
1353         const char *ssid, *mode, *key_mgmt;
1354 #if defined TIZEN_EXT
1355         GSupplicantInterface *interface;
1356         const char *isHS20AP;
1357         const char *eap, *identity, *phase2;
1358 #endif
1359         unsigned int i, ssid_len;
1360         char *group;
1361
1362         ssid = g_hash_table_lookup(network->config_table, "ssid");
1363         mode = g_hash_table_lookup(network->config_table, "mode");
1364         key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
1365 #if defined TIZEN_EXT
1366         isHS20AP = g_hash_table_lookup(network->config_table, "isHS20AP");
1367         eap = g_hash_table_lookup(network->config_table, "eap");
1368         identity = g_hash_table_lookup(network->config_table, "identity");
1369         phase2 = g_hash_table_lookup(network->config_table, "phase2");
1370         interface = network->interface;
1371 #endif
1372
1373         SUPPLICANT_DBG("ssid %s mode %s", ssid, mode);
1374
1375         if (ssid)
1376                 ssid_len = strlen(ssid);
1377         else
1378                 ssid_len = 0;
1379
1380         str = g_string_sized_new((ssid_len * 2) + 24);
1381         if (!str)
1382                 return;
1383
1384         for (i = 0; i < ssid_len; i++)
1385 #if defined TIZEN_EXT
1386         {
1387                 if (ssid[i] != '"')
1388 #endif
1389                 g_string_append_printf(str, "%02x", ssid[i]);
1390 #if defined TIZEN_EXT
1391         }
1392 #endif
1393
1394         if (g_strcmp0(mode, "0") == 0)
1395                 g_string_append_printf(str, "_managed");
1396         else if (g_strcmp0(mode, "1") == 0)
1397                 g_string_append_printf(str, "_adhoc");
1398
1399         if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
1400                 g_string_append_printf(str, "_psk");
1401 #if defined TIZEN_EXT
1402         else if (g_strcmp0(key_mgmt, "WPA-EAP") == 0)
1403                 g_string_append_printf(str, "_ieee8021x");
1404         else
1405                 g_string_append_printf(str, "_none");
1406 #endif
1407
1408         group = g_string_free(str, FALSE);
1409
1410         SUPPLICANT_DBG("%s", group);
1411
1412 #if defined TIZEN_EXT
1413         if (g_strcmp0(isHS20AP, "1") == 0) {
1414                 network->isHS20AP = 1;
1415                 if (network->eap)
1416                         g_free(network->eap);
1417                 network->eap = g_strdup(eap);
1418
1419                 if (network->identity)
1420                         g_free(network->identity);
1421                 network->identity = g_strdup(identity);
1422
1423                 if (network->phase2)
1424                         g_free(network->phase2);
1425                 network->phase2 = g_strdup(phase2);
1426         } else
1427                 network->isHS20AP = 0;
1428
1429         if (interface)
1430                 interface->network_path = g_strdup(network->path);
1431
1432         network->group = g_strdup(group);
1433         callback_network_merged(network);
1434 #endif
1435
1436         g_free(group);
1437
1438         g_hash_table_destroy(network->config_table);
1439
1440         g_free(network->path);
1441         g_free(network);
1442 }
1443
1444 static void network_property(const char *key, DBusMessageIter *iter,
1445                                                         void *user_data)
1446 {
1447         GSupplicantNetwork *network = user_data;
1448
1449         if (!network->interface)
1450                 return;
1451
1452         if (!key) {
1453                 merge_network(network);
1454                 return;
1455         }
1456
1457         if (g_strcmp0(key, "Enabled") == 0) {
1458                 dbus_bool_t enabled = FALSE;
1459
1460                 dbus_message_iter_get_basic(iter, &enabled);
1461         } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
1462                 const char *str = NULL;
1463
1464                 dbus_message_iter_get_basic(iter, &str);
1465                 if (str) {
1466                         g_hash_table_replace(network->config_table,
1467                                                 g_strdup(key), g_strdup(str));
1468                 }
1469         } else
1470                 SUPPLICANT_DBG("key %s type %c",
1471                                 key, dbus_message_iter_get_arg_type(iter));
1472 }
1473
1474 static void interface_network_added(DBusMessageIter *iter, void *user_data)
1475 {
1476         GSupplicantInterface *interface = user_data;
1477         GSupplicantNetwork *network;
1478         const char *path = NULL;
1479
1480         SUPPLICANT_DBG("");
1481
1482         dbus_message_iter_get_basic(iter, &path);
1483         if (!path)
1484                 return;
1485
1486         if (g_strcmp0(path, "/") == 0)
1487                 return;
1488
1489         network = g_hash_table_lookup(interface->net_mapping, path);
1490         if (network)
1491                 return;
1492
1493         network = g_try_new0(GSupplicantNetwork, 1);
1494         if (!network)
1495                 return;
1496
1497         network->interface = interface;
1498         network->path = g_strdup(path);
1499
1500         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1501                                                         g_free, g_free);
1502
1503         dbus_message_iter_next(iter);
1504         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
1505                 supplicant_dbus_property_foreach(iter, network_property,
1506                                                                 network);
1507                 network_property(NULL, NULL, network);
1508                 return;
1509         }
1510
1511         supplicant_dbus_property_get_all(path,
1512                                 SUPPLICANT_INTERFACE ".Network",
1513                                         network_property, network, NULL);
1514 }
1515
1516 static void interface_network_removed(DBusMessageIter *iter, void *user_data)
1517 {
1518         GSupplicantInterface *interface = user_data;
1519         GSupplicantNetwork *network;
1520         const char *path = NULL;
1521
1522         dbus_message_iter_get_basic(iter, &path);
1523         if (!path)
1524                 return;
1525
1526         network = g_hash_table_lookup(interface->net_mapping, path);
1527         if (!network)
1528                 return;
1529
1530         g_hash_table_remove(interface->net_mapping, path);
1531 }
1532
1533 static char *create_name(unsigned char *ssid, int ssid_len)
1534 {
1535         GString *string;
1536         const gchar *remainder, *invalid;
1537         int valid_bytes, remaining_bytes;
1538
1539         if (ssid_len < 1 || ssid[0] == '\0')
1540                 return g_strdup("");
1541
1542         string = NULL;
1543         remainder = (const gchar *)ssid;
1544         remaining_bytes = ssid_len;
1545
1546         while (remaining_bytes != 0) {
1547                 if (g_utf8_validate(remainder, remaining_bytes,
1548                                         &invalid)) {
1549                         break;
1550                 }
1551
1552                 valid_bytes = invalid - remainder;
1553
1554                 if (!string)
1555                         string = g_string_sized_new(remaining_bytes);
1556
1557                 g_string_append_len(string, remainder, valid_bytes);
1558
1559                 /* append U+FFFD REPLACEMENT CHARACTER */
1560                 g_string_append(string, "\357\277\275");
1561
1562                 remaining_bytes -= valid_bytes + 1;
1563                 remainder = invalid + 1;
1564         }
1565
1566         if (!string)
1567                 return g_strndup((const gchar *)ssid, ssid_len + 1);
1568
1569         g_string_append(string, remainder);
1570
1571         return g_string_free(string, FALSE);
1572 }
1573
1574 static char *create_group(struct g_supplicant_bss *bss)
1575 {
1576         GString *str;
1577         unsigned int i;
1578         const char *mode, *security;
1579
1580         str = g_string_sized_new((bss->ssid_len * 2) + 24);
1581         if (!str)
1582                 return NULL;
1583
1584         if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
1585                 for (i = 0; i < bss->ssid_len; i++)
1586                         g_string_append_printf(str, "%02x", bss->ssid[i]);
1587         } else
1588                 g_string_append_printf(str, "hidden");
1589
1590         mode = mode2string(bss->mode);
1591         if (mode)
1592                 g_string_append_printf(str, "_%s", mode);
1593
1594         security = security2string(bss->security);
1595         if (security)
1596                 g_string_append_printf(str, "_%s", security);
1597
1598         return g_string_free(str, FALSE);
1599 }
1600
1601 static void add_or_replace_bss_to_network(struct g_supplicant_bss *bss)
1602 {
1603         GSupplicantInterface *interface = bss->interface;
1604         GSupplicantNetwork *network;
1605         char *group;
1606
1607         group = create_group(bss);
1608         SUPPLICANT_DBG("New group created: %s", group);
1609
1610         if (!group)
1611                 return;
1612
1613         network = g_hash_table_lookup(interface->network_table, group);
1614         if (network) {
1615                 g_free(group);
1616                 SUPPLICANT_DBG("Network %s already exist", network->name);
1617
1618                 goto done;
1619         }
1620
1621         network = g_try_new0(GSupplicantNetwork, 1);
1622         if (!network) {
1623                 g_free(group);
1624                 return;
1625         }
1626
1627         network->interface = interface;
1628         if (!network->path)
1629                 network->path = g_strdup(bss->path);
1630         network->group = group;
1631         network->name = create_name(bss->ssid, bss->ssid_len);
1632         network->mode = bss->mode;
1633         network->security = bss->security;
1634         network->ssid_len = bss->ssid_len;
1635         memcpy(network->ssid, bss->ssid, bss->ssid_len);
1636         network->signal = bss->signal;
1637         network->frequency = bss->frequency;
1638         network->best_bss = bss;
1639
1640 #if defined TIZEN_EXT
1641         network->keymgmt = bss->keymgmt;
1642 #endif
1643
1644         SUPPLICANT_DBG("New network %s created", network->name);
1645
1646         network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1647                                                         NULL, remove_bss);
1648
1649         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1650                                                         g_free, g_free);
1651
1652         g_hash_table_replace(interface->network_table,
1653                                                 network->group, network);
1654
1655         callback_network_added(network);
1656
1657 done:
1658         /* We update network's WPS properties if only bss provides WPS. */
1659         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
1660                 network->wps = TRUE;
1661                 network->wps_capabilities |= bss->wps_capabilities;
1662         }
1663
1664         if (bss->signal > network->signal) {
1665                 network->signal = bss->signal;
1666                 network->best_bss = bss;
1667                 callback_network_changed(network, "Signal");
1668         }
1669
1670         g_hash_table_replace(interface->bss_mapping, bss->path, network);
1671         g_hash_table_replace(network->bss_table, bss->path, bss);
1672
1673         g_hash_table_replace(bss_mapping, bss->path, interface);
1674 }
1675
1676 static void bss_rates(DBusMessageIter *iter, void *user_data)
1677 {
1678         struct g_supplicant_bss *bss = user_data;
1679         dbus_uint32_t rate = 0;
1680
1681         dbus_message_iter_get_basic(iter, &rate);
1682         if (rate == 0)
1683                 return;
1684
1685         if (rate > bss->maxrate)
1686                 bss->maxrate = rate;
1687 }
1688
1689 static void bss_keymgmt(DBusMessageIter *iter, void *user_data)
1690 {
1691         unsigned int *keymgmt = user_data;
1692         const char *str = NULL;
1693         int i;
1694
1695         dbus_message_iter_get_basic(iter, &str);
1696         if (!str)
1697                 return;
1698
1699         for (i = 0; keymgmt_map[i].str; i++)
1700                 if (strcmp(str, keymgmt_map[i].str) == 0) {
1701                         SUPPLICANT_DBG("Keymgmt: %s", str);
1702                         *keymgmt |= keymgmt_map[i].val;
1703                         break;
1704                 }
1705 }
1706
1707 static void bss_group(DBusMessageIter *iter, void *user_data)
1708 {
1709         unsigned int *group = user_data;
1710         const char *str = NULL;
1711         int i;
1712
1713         dbus_message_iter_get_basic(iter, &str);
1714         if (!str)
1715                 return;
1716
1717         for (i = 0; group_map[i].str; i++)
1718                 if (strcmp(str, group_map[i].str) == 0) {
1719                         SUPPLICANT_DBG("Group: %s", str);
1720                         *group |= group_map[i].val;
1721                         break;
1722                 }
1723 }
1724
1725 static void bss_pairwise(DBusMessageIter *iter, void *user_data)
1726 {
1727         unsigned int *pairwise = user_data;
1728         const char *str = NULL;
1729         int i;
1730
1731         dbus_message_iter_get_basic(iter, &str);
1732         if (!str)
1733                 return;
1734
1735         for (i = 0; pairwise_map[i].str; i++)
1736                 if (strcmp(str, pairwise_map[i].str) == 0) {
1737                         SUPPLICANT_DBG("Pairwise: %s", str);
1738                         *pairwise |= pairwise_map[i].val;
1739                         break;
1740                 }
1741 }
1742
1743 static void bss_wpa(const char *key, DBusMessageIter *iter,
1744                         void *user_data)
1745 {
1746         struct g_supplicant_bss *bss = user_data;
1747         unsigned int value = 0;
1748
1749         SUPPLICANT_DBG("Key: %s", key);
1750
1751         if (g_strcmp0(key, "KeyMgmt") == 0) {
1752                 supplicant_dbus_array_foreach(iter, bss_keymgmt, &value);
1753
1754                 if (bss->rsn_selected)
1755                         bss->rsn_keymgmt = value;
1756                 else
1757                         bss->wpa_keymgmt = value;
1758         } else if (g_strcmp0(key, "Group") == 0) {
1759                 supplicant_dbus_array_foreach(iter, bss_group, &value);
1760
1761                 if (bss->rsn_selected)
1762                         bss->rsn_group = value;
1763                 else
1764                         bss->wpa_group = value;
1765         } else if (g_strcmp0(key, "Pairwise") == 0) {
1766                 supplicant_dbus_array_foreach(iter, bss_pairwise, &value);
1767
1768                 if (bss->rsn_selected)
1769                         bss->rsn_pairwise = value;
1770                 else
1771                         bss->wpa_pairwise = value;
1772         }
1773 }
1774
1775 static unsigned int get_tlv(unsigned char *ie, unsigned int ie_size,
1776                                                         unsigned int type)
1777 {
1778         unsigned int len = 0;
1779
1780         while (len + 4 < ie_size) {
1781                 unsigned int hi = ie[len];
1782                 unsigned int lo = ie[len + 1];
1783                 unsigned int tmp_type = (hi << 8) + lo;
1784                 unsigned int v_len = 0;
1785
1786                 /* hi and lo are used to recreate an unsigned int
1787                  * based on 2 8bits length unsigned int. */
1788
1789                 hi = ie[len + 2];
1790                 lo = ie[len + 3];
1791                 v_len = (hi << 8) + lo;
1792
1793                 if (tmp_type == type) {
1794                         unsigned int ret_value = 0;
1795                         unsigned char *value = (unsigned char *)&ret_value;
1796
1797                         SUPPLICANT_DBG("IE: match type 0x%x", type);
1798
1799                         /* Verifying length relevance */
1800                         if (v_len > sizeof(unsigned int) ||
1801                                 len + 4 + v_len > ie_size)
1802                                 break;
1803
1804                         memcpy(value, ie + len + 4, v_len);
1805
1806                         SUPPLICANT_DBG("returning 0x%x", ret_value);
1807                         return ret_value;
1808                 }
1809
1810                 len += v_len + 4;
1811         }
1812
1813         SUPPLICANT_DBG("returning 0");
1814         return 0;
1815 }
1816
1817 static void bss_process_ies(DBusMessageIter *iter, void *user_data)
1818 {
1819         struct g_supplicant_bss *bss = user_data;
1820         const unsigned char WPS_OUI[] = { 0x00, 0x50, 0xf2, 0x04 };
1821         unsigned char *ie, *ie_end;
1822         DBusMessageIter array;
1823         unsigned int value;
1824         int ie_len;
1825
1826 #define WMM_WPA1_WPS_INFO 221
1827 #define WPS_INFO_MIN_LEN  6
1828 #define WPS_VERSION_TLV   0x104A
1829 #define WPS_STATE_TLV     0x1044
1830 #define WPS_METHODS_TLV   0x1012
1831 #define WPS_REGISTRAR_TLV 0x1041
1832 #define WPS_VERSION       0x10
1833 #define WPS_PBC           0x04
1834 #define WPS_PIN           0x00
1835 #define WPS_CONFIGURED    0x02
1836
1837         dbus_message_iter_recurse(iter, &array);
1838         dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
1839
1840         if (!ie || ie_len < 2)
1841                 return;
1842
1843         bss->wps_capabilities = 0;
1844         bss->keymgmt = 0;
1845
1846         for (ie_end = ie + ie_len; ie < ie_end && ie + ie[1] + 1 <= ie_end;
1847                                                         ie += ie[1] + 2) {
1848
1849                 if (ie[0] != WMM_WPA1_WPS_INFO || ie[1] < WPS_INFO_MIN_LEN ||
1850                         memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0)
1851                         continue;
1852
1853                 SUPPLICANT_DBG("IE: match WPS_OUI");
1854
1855                 value = get_tlv(&ie[6], ie[1], WPS_STATE_TLV);
1856                 if (get_tlv(&ie[6], ie[1], WPS_VERSION_TLV) == WPS_VERSION &&
1857                                                                 value != 0) {
1858                         bss->keymgmt |= G_SUPPLICANT_KEYMGMT_WPS;
1859
1860                         if (value == WPS_CONFIGURED)
1861                                 bss->wps_capabilities |=
1862                                         G_SUPPLICANT_WPS_CONFIGURED;
1863                 }
1864
1865                 value = get_tlv(&ie[6], ie[1], WPS_METHODS_TLV);
1866                 if (value != 0) {
1867                         if (GUINT16_FROM_BE(value) == WPS_PBC)
1868                                 bss->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
1869                         if (GUINT16_FROM_BE(value) == WPS_PIN)
1870                                 bss->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
1871                 } else
1872                         bss->wps_capabilities |=
1873                                 G_SUPPLICANT_WPS_PBC | G_SUPPLICANT_WPS_PIN;
1874
1875                 /* If the AP sends this it means it's advertizing
1876                  * as a registrar and the WPS process is launched
1877                  * on its side */
1878                 if (get_tlv(&ie[6], ie[1], WPS_REGISTRAR_TLV) != 0)
1879                         bss->wps_capabilities |= G_SUPPLICANT_WPS_REGISTRAR;
1880
1881                 SUPPLICANT_DBG("WPS Methods 0x%x", bss->wps_capabilities);
1882         }
1883 }
1884
1885 static void bss_compute_security(struct g_supplicant_bss *bss)
1886 {
1887         /*
1888          * Combining RSN and WPA keymgmt
1889          * We combine it since parsing IEs might have set something for WPS. */
1890         bss->keymgmt |= bss->rsn_keymgmt | bss->wpa_keymgmt;
1891
1892         bss->ieee8021x = FALSE;
1893         bss->psk = FALSE;
1894 #if defined TIZEN_EXT
1895         bss->ft_ieee8021x = FALSE;
1896         bss->ft_psk = FALSE;
1897 #endif
1898
1899 #if defined TIZEN_EXT
1900         if (bss->keymgmt &
1901                         (G_SUPPLICANT_KEYMGMT_WPA_EAP |
1902                                         G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
1903                 bss->ieee8021x = TRUE;
1904         else if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_EAP)
1905                 bss->ft_ieee8021x = TRUE;
1906 #else
1907         if (bss->keymgmt &
1908                         (G_SUPPLICANT_KEYMGMT_WPA_EAP |
1909                                 G_SUPPLICANT_KEYMGMT_WPA_FT_EAP |
1910                                 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
1911                 bss->ieee8021x = TRUE;
1912 #endif
1913
1914 #if defined TIZEN_EXT
1915         if (bss->keymgmt &
1916                         (G_SUPPLICANT_KEYMGMT_WPA_PSK |
1917                                         G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
1918                 bss->psk = TRUE;
1919         else if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_PSK)
1920                 bss->ft_psk = TRUE;
1921 #else
1922         if (bss->keymgmt &
1923                         (G_SUPPLICANT_KEYMGMT_WPA_PSK |
1924                                 G_SUPPLICANT_KEYMGMT_WPA_FT_PSK |
1925                                 G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
1926                 bss->psk = TRUE;
1927 #endif
1928
1929         if (bss->ieee8021x)
1930                 bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
1931         else if (bss->psk)
1932                 bss->security = G_SUPPLICANT_SECURITY_PSK;
1933 #if defined TIZEN_EXT
1934         else if (bss->ft_psk)
1935                 bss->security = G_SUPPLICANT_SECURITY_FT_PSK;
1936         else if (bss->ft_ieee8021x == TRUE)
1937                 bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
1938 #endif
1939         else if (bss->privacy)
1940                 bss->security = G_SUPPLICANT_SECURITY_WEP;
1941         else
1942                 bss->security = G_SUPPLICANT_SECURITY_NONE;
1943 }
1944
1945
1946 static void bss_property(const char *key, DBusMessageIter *iter,
1947                                                         void *user_data)
1948 {
1949         struct g_supplicant_bss *bss = user_data;
1950
1951         if (!bss->interface)
1952                 return;
1953
1954         SUPPLICANT_DBG("key %s", key);
1955
1956         if (!key)
1957                 return;
1958
1959         if (g_strcmp0(key, "BSSID") == 0) {
1960                 DBusMessageIter array;
1961                 unsigned char *addr;
1962                 int addr_len;
1963
1964                 dbus_message_iter_recurse(iter, &array);
1965                 dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
1966
1967                 if (addr_len == 6)
1968                         memcpy(bss->bssid, addr, addr_len);
1969         } else if (g_strcmp0(key, "SSID") == 0) {
1970                 DBusMessageIter array;
1971                 unsigned char *ssid;
1972                 int ssid_len;
1973
1974                 dbus_message_iter_recurse(iter, &array);
1975                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
1976
1977                 if (ssid_len > 0 && ssid_len < 33) {
1978                         memcpy(bss->ssid, ssid, ssid_len);
1979                         bss->ssid_len = ssid_len;
1980                 } else {
1981                         memset(bss->ssid, 0, sizeof(bss->ssid));
1982                         bss->ssid_len = 0;
1983                 }
1984         } else if (g_strcmp0(key, "Capabilities") == 0) {
1985                 dbus_uint16_t capabilities = 0x0000;
1986
1987                 dbus_message_iter_get_basic(iter, &capabilities);
1988
1989                 if (capabilities & IEEE80211_CAP_ESS)
1990                         bss->mode = G_SUPPLICANT_MODE_INFRA;
1991                 else if (capabilities & IEEE80211_CAP_IBSS)
1992                         bss->mode = G_SUPPLICANT_MODE_IBSS;
1993
1994                 if (capabilities & IEEE80211_CAP_PRIVACY)
1995                         bss->privacy = TRUE;
1996         } else if (g_strcmp0(key, "Mode") == 0) {
1997                 const char *mode = NULL;
1998
1999                 dbus_message_iter_get_basic(iter, &mode);
2000                 bss->mode = string2mode(mode);
2001         } else if (g_strcmp0(key, "Frequency") == 0) {
2002                 dbus_uint16_t frequency = 0;
2003
2004                 dbus_message_iter_get_basic(iter, &frequency);
2005                 bss->frequency = frequency;
2006         } else if (g_strcmp0(key, "Signal") == 0) {
2007                 dbus_int16_t signal = 0;
2008
2009                 dbus_message_iter_get_basic(iter, &signal);
2010
2011                 bss->signal = signal;
2012                 if (!bss->signal)
2013                         bss->signal = BSS_UNKNOWN_STRENGTH;
2014
2015         } else if (g_strcmp0(key, "Level") == 0) {
2016                 dbus_int32_t level = 0;
2017
2018                 dbus_message_iter_get_basic(iter, &level);
2019         } else if (g_strcmp0(key, "Rates") == 0) {
2020                 supplicant_dbus_array_foreach(iter, bss_rates, bss);
2021         } else if (g_strcmp0(key, "MaxRate") == 0) {
2022                 dbus_uint32_t maxrate = 0;
2023
2024                 dbus_message_iter_get_basic(iter, &maxrate);
2025                 if (maxrate != 0)
2026                         bss->maxrate = maxrate;
2027         } else if (g_strcmp0(key, "Privacy") == 0) {
2028                 dbus_bool_t privacy = FALSE;
2029
2030                 dbus_message_iter_get_basic(iter, &privacy);
2031                 bss->privacy = privacy;
2032         } else if (g_strcmp0(key, "RSN") == 0) {
2033                 bss->rsn_selected = TRUE;
2034
2035                 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
2036         } else if (g_strcmp0(key, "WPA") == 0) {
2037                 bss->rsn_selected = FALSE;
2038
2039                 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
2040         } else if (g_strcmp0(key, "IEs") == 0)
2041                 bss_process_ies(iter, bss);
2042         else
2043                 SUPPLICANT_DBG("key %s type %c",
2044                                 key, dbus_message_iter_get_arg_type(iter));
2045 }
2046
2047 static struct g_supplicant_bss *interface_bss_added(DBusMessageIter *iter,
2048                                                         void *user_data)
2049 {
2050         GSupplicantInterface *interface = user_data;
2051         GSupplicantNetwork *network;
2052         struct g_supplicant_bss *bss;
2053         const char *path = NULL;
2054
2055         SUPPLICANT_DBG("");
2056
2057         dbus_message_iter_get_basic(iter, &path);
2058         if (!path)
2059                 return NULL;
2060
2061         if (g_strcmp0(path, "/") == 0)
2062                 return NULL;
2063
2064         SUPPLICANT_DBG("%s", path);
2065
2066         network = g_hash_table_lookup(interface->bss_mapping, path);
2067         if (network) {
2068                 bss = g_hash_table_lookup(network->bss_table, path);
2069                 if (bss)
2070                         return NULL;
2071         }
2072
2073         bss = g_try_new0(struct g_supplicant_bss, 1);
2074         if (!bss)
2075                 return NULL;
2076
2077         bss->interface = interface;
2078         bss->path = g_strdup(path);
2079         bss->signal = BSS_UNKNOWN_STRENGTH;
2080
2081         return bss;
2082 }
2083
2084 static void interface_bss_added_with_keys(DBusMessageIter *iter,
2085                                                 void *user_data)
2086 {
2087         struct g_supplicant_bss *bss;
2088
2089         SUPPLICANT_DBG("");
2090
2091         bss = interface_bss_added(iter, user_data);
2092         if (!bss)
2093                 return;
2094
2095         dbus_message_iter_next(iter);
2096
2097         if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_INVALID)
2098                 return;
2099
2100         supplicant_dbus_property_foreach(iter, bss_property, bss);
2101
2102         bss_compute_security(bss);
2103         add_or_replace_bss_to_network(bss);
2104 }
2105
2106 static void interface_bss_added_without_keys(DBusMessageIter *iter,
2107                                                 void *user_data)
2108 {
2109         struct g_supplicant_bss *bss;
2110
2111         SUPPLICANT_DBG("");
2112
2113         bss = interface_bss_added(iter, user_data);
2114         if (!bss)
2115                 return;
2116
2117         supplicant_dbus_property_get_all(bss->path,
2118                                         SUPPLICANT_INTERFACE ".BSS",
2119                                         bss_property, bss, NULL);
2120
2121         bss_compute_security(bss);
2122         add_or_replace_bss_to_network(bss);
2123 }
2124
2125 static void update_signal(gpointer key, gpointer value,
2126                                                 gpointer user_data)
2127 {
2128         struct g_supplicant_bss *bss = value;
2129         GSupplicantNetwork *network = user_data;
2130
2131         if (bss->signal > network->signal) {
2132                 network->signal = bss->signal;
2133                 network->best_bss = bss;
2134         }
2135 }
2136
2137 static void update_network_signal(GSupplicantNetwork *network)
2138 {
2139         if (g_hash_table_size(network->bss_table) <= 1 && network->best_bss)
2140                 return;
2141
2142         g_hash_table_foreach(network->bss_table,
2143                                 update_signal, network);
2144
2145         SUPPLICANT_DBG("New network signal %d", network->signal);
2146 }
2147
2148 static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
2149 {
2150         GSupplicantInterface *interface = user_data;
2151         GSupplicantNetwork *network;
2152         struct g_supplicant_bss *bss = NULL;
2153         const char *path = NULL;
2154
2155         dbus_message_iter_get_basic(iter, &path);
2156         if (!path)
2157                 return;
2158
2159         network = g_hash_table_lookup(interface->bss_mapping, path);
2160         if (!network)
2161                 return;
2162
2163         bss = g_hash_table_lookup(network->bss_table, path);
2164         if (network->best_bss == bss) {
2165                 network->best_bss = NULL;
2166                 network->signal = BSS_UNKNOWN_STRENGTH;
2167         }
2168
2169         g_hash_table_remove(bss_mapping, path);
2170
2171         g_hash_table_remove(interface->bss_mapping, path);
2172         g_hash_table_remove(network->bss_table, path);
2173
2174         update_network_signal(network);
2175
2176         if (g_hash_table_size(network->bss_table) == 0)
2177                 g_hash_table_remove(interface->network_table, network->group);
2178 }
2179
2180 static void set_config_methods(DBusMessageIter *iter, void *user_data)
2181 {
2182         const char *config_methods = "push_button";
2183
2184         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
2185                                                         &config_methods);
2186 }
2187
2188 static void interface_property(const char *key, DBusMessageIter *iter,
2189                                                         void *user_data)
2190 {
2191         GSupplicantInterface *interface = user_data;
2192
2193         if (!interface)
2194                 return;
2195
2196         SUPPLICANT_DBG("%s", key);
2197
2198         if (!key) {
2199                 debug_strvalmap("KeyMgmt capability", keymgmt_map,
2200                                                 interface->keymgmt_capa);
2201                 debug_strvalmap("AuthAlg capability", authalg_capa_map,
2202                                                 interface->authalg_capa);
2203                 debug_strvalmap("Protocol capability", proto_capa_map,
2204                                                 interface->proto_capa);
2205                 debug_strvalmap("Pairwise capability", pairwise_map,
2206                                                 interface->pairwise_capa);
2207                 debug_strvalmap("Group capability", group_map,
2208                                                 interface->group_capa);
2209                 debug_strvalmap("Scan capability", scan_capa_map,
2210                                                 interface->scan_capa);
2211                 debug_strvalmap("Mode capability", mode_capa_map,
2212                                                 interface->mode_capa);
2213
2214
2215                 supplicant_dbus_property_set(interface->path,
2216                                 SUPPLICANT_INTERFACE ".Interface.WPS",
2217                                 "ConfigMethods", DBUS_TYPE_STRING_AS_STRING,
2218                                 set_config_methods, NULL, NULL, NULL);
2219
2220                 if (interface->ready)
2221                         callback_interface_added(interface);
2222
2223                 return;
2224         }
2225
2226         if (g_strcmp0(key, "Capabilities") == 0) {
2227                 supplicant_dbus_property_foreach(iter, interface_capability,
2228                                                                 interface);
2229 #if !defined TIZEN_EXT
2230                 if (interface->mode_capa & G_SUPPLICANT_CAPABILITY_MODE_P2P)
2231                         interface->p2p_support = true;
2232 #endif
2233         } else if (g_strcmp0(key, "State") == 0) {
2234                 const char *str = NULL;
2235
2236                 dbus_message_iter_get_basic(iter, &str);
2237                 if (str)
2238                         if (string2state(str) != interface->state) {
2239                                 interface->state = string2state(str);
2240                                 callback_interface_state(interface);
2241                         }
2242                 if (interface->state == G_SUPPLICANT_STATE_DISABLED)
2243                         interface->ready = FALSE;
2244                 else
2245                         interface->ready = TRUE;
2246
2247                 SUPPLICANT_DBG("state %s (%d)", str, interface->state);
2248         } else if (g_strcmp0(key, "Scanning") == 0) {
2249                 dbus_bool_t scanning = FALSE;
2250
2251                 dbus_message_iter_get_basic(iter, &scanning);
2252                 interface->scanning = scanning;
2253
2254                 if (interface->ready) {
2255                         if (interface->scanning)
2256                                 callback_scan_started(interface);
2257                         else
2258                                 callback_scan_finished(interface);
2259                 }
2260         } else if (g_strcmp0(key, "ApScan") == 0) {
2261                 int apscan = 1;
2262
2263                 dbus_message_iter_get_basic(iter, &apscan);
2264                 interface->apscan = apscan;
2265         } else if (g_strcmp0(key, "Ifname") == 0) {
2266                 const char *str = NULL;
2267
2268                 dbus_message_iter_get_basic(iter, &str);
2269                 if (str) {
2270                         g_free(interface->ifname);
2271                         interface->ifname = g_strdup(str);
2272                 }
2273         } else if (g_strcmp0(key, "Driver") == 0) {
2274                 const char *str = NULL;
2275
2276                 dbus_message_iter_get_basic(iter, &str);
2277                 if (str) {
2278                         g_free(interface->driver);
2279                         interface->driver = g_strdup(str);
2280                 }
2281         } else if (g_strcmp0(key, "BridgeIfname") == 0) {
2282                 const char *str = NULL;
2283
2284                 dbus_message_iter_get_basic(iter, &str);
2285                 if (str) {
2286                         g_free(interface->bridge);
2287                         interface->bridge = g_strdup(str);
2288                 }
2289         } else if (g_strcmp0(key, "CurrentBSS") == 0) {
2290                 interface_bss_added_without_keys(iter, interface);
2291         } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
2292 #if defined TIZEN_EXT
2293                 if (interface->state != G_SUPPLICANT_STATE_COMPLETED)
2294 #endif
2295                 interface_network_added(iter, interface);
2296         } else if (g_strcmp0(key, "BSSs") == 0) {
2297                 supplicant_dbus_array_foreach(iter,
2298                                         interface_bss_added_without_keys,
2299                                         interface);
2300         } else if (g_strcmp0(key, "Blobs") == 0) {
2301                 /* Nothing */
2302         } else if (g_strcmp0(key, "Networks") == 0) {
2303                 supplicant_dbus_array_foreach(iter, interface_network_added,
2304                                                                 interface);
2305         } else if (g_strcmp0(key, "DisconnectReason") == 0) {
2306                 int reason_code;
2307                 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
2308                         dbus_message_iter_get_basic(iter, &reason_code);
2309                         callback_disconnect_reason_code(interface, reason_code);
2310                 }
2311         } else
2312                 SUPPLICANT_DBG("key %s type %c",
2313                                 key, dbus_message_iter_get_arg_type(iter));
2314 }
2315
2316 static void scan_network_update(DBusMessageIter *iter, void *user_data)
2317 {
2318         GSupplicantInterface *interface = user_data;
2319         GSupplicantNetwork *network;
2320         char *path;
2321
2322         if (!iter)
2323                 return;
2324
2325         dbus_message_iter_get_basic(iter, &path);
2326
2327         if (!path)
2328                 return;
2329
2330         if (g_strcmp0(path, "/") == 0)
2331                 return;
2332
2333         /* Update the network details based on scan BSS data */
2334         network = g_hash_table_lookup(interface->bss_mapping, path);
2335         if (network)
2336                 callback_network_added(network);
2337 }
2338
2339 static void scan_bss_data(const char *key, DBusMessageIter *iter,
2340                                 void *user_data)
2341 {
2342         GSupplicantInterface *interface = user_data;
2343
2344 /*Fixed : stucking in scanning state when scan failed*/
2345 #if defined TIZEN_EXT
2346                 GSupplicantInterfaceCallback scan_callback;
2347 #endif
2348
2349         if (iter)
2350                 supplicant_dbus_array_foreach(iter, scan_network_update,
2351                                                 interface);
2352
2353 #if defined TIZEN_EXT
2354                 scan_callback = interface->scan_callback;
2355 #endif
2356
2357         if (interface->scan_callback)
2358                 interface->scan_callback(0, interface, interface->scan_data);
2359
2360 #if defined TIZEN_EXT
2361                 if (interface->scan_callback == scan_callback) {
2362 #endif
2363         interface->scan_callback = NULL;
2364         interface->scan_data = NULL;
2365 #if defined TIZEN_EXT
2366         }
2367 #endif
2368 }
2369
2370 static GSupplicantInterface *interface_alloc(const char *path)
2371 {
2372         GSupplicantInterface *interface;
2373
2374         interface = g_try_new0(GSupplicantInterface, 1);
2375         if (!interface)
2376                 return NULL;
2377
2378         interface->path = g_strdup(path);
2379
2380         interface->network_table = g_hash_table_new_full(g_str_hash,
2381                                         g_str_equal, NULL, remove_network);
2382         interface->peer_table = g_hash_table_new_full(g_str_hash,
2383                                         g_str_equal, NULL, remove_peer);
2384         interface->group_table = g_hash_table_new_full(g_str_hash,
2385                                         g_str_equal, NULL, remove_group);
2386         interface->net_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
2387                                                                 NULL, NULL);
2388         interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
2389                                                                 NULL, NULL);
2390
2391         g_hash_table_replace(interface_table, interface->path, interface);
2392
2393         return interface;
2394 }
2395
2396 static void interface_added(DBusMessageIter *iter, void *user_data)
2397 {
2398         GSupplicantInterface *interface;
2399         const char *path = NULL;
2400
2401         SUPPLICANT_DBG("");
2402
2403         dbus_message_iter_get_basic(iter, &path);
2404         if (!path)
2405                 return;
2406
2407         if (g_strcmp0(path, "/") == 0)
2408                 return;
2409
2410         interface = g_hash_table_lookup(interface_table, path);
2411         if (interface)
2412                 return;
2413
2414         interface = interface_alloc(path);
2415         if (!interface)
2416                 return;
2417
2418         dbus_message_iter_next(iter);
2419         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
2420                 supplicant_dbus_property_foreach(iter, interface_property,
2421                                                                 interface);
2422                 interface_property(NULL, NULL, interface);
2423                 return;
2424         }
2425
2426         supplicant_dbus_property_get_all(path,
2427                                         SUPPLICANT_INTERFACE ".Interface",
2428                                         interface_property, interface,
2429                                         interface);
2430 }
2431
2432 static void interface_removed(DBusMessageIter *iter, void *user_data)
2433 {
2434         const char *path = NULL;
2435         GSupplicantInterface *interface = user_data;
2436
2437         dbus_message_iter_get_basic(iter, &path);
2438         if (!path)
2439                 return;
2440
2441         interface = g_hash_table_lookup(interface_table, path);
2442         g_supplicant_interface_cancel(interface);
2443
2444         g_hash_table_remove(interface_table, path);
2445 }
2446
2447 static void eap_method(DBusMessageIter *iter, void *user_data)
2448 {
2449         const char *str = NULL;
2450         int i;
2451
2452         dbus_message_iter_get_basic(iter, &str);
2453         if (!str)
2454                 return;
2455
2456         for (i = 0; eap_method_map[i].str; i++)
2457                 if (strcmp(str, eap_method_map[i].str) == 0) {
2458                         eap_methods |= eap_method_map[i].val;
2459                         break;
2460                 }
2461 }
2462
2463 static void service_property(const char *key, DBusMessageIter *iter,
2464                                                         void *user_data)
2465 {
2466         if (!key) {
2467                 callback_system_ready();
2468                 return;
2469         }
2470
2471         if (g_strcmp0(key, "DebugLevel") == 0) {
2472                 const char *str = NULL;
2473                 int i;
2474
2475                 dbus_message_iter_get_basic(iter, &str);
2476                 for (i = 0; debug_strings[i]; i++)
2477                         if (g_strcmp0(debug_strings[i], str) == 0) {
2478                                 debug_level = i;
2479                                 break;
2480                         }
2481                 SUPPLICANT_DBG("Debug level %d", debug_level);
2482         } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
2483                 dbus_message_iter_get_basic(iter, &debug_timestamp);
2484                 SUPPLICANT_DBG("Debug timestamp %u", debug_timestamp);
2485         } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
2486                 dbus_message_iter_get_basic(iter, &debug_showkeys);
2487                 SUPPLICANT_DBG("Debug show keys %u", debug_showkeys);
2488         } else if (g_strcmp0(key, "Interfaces") == 0) {
2489                 supplicant_dbus_array_foreach(iter, interface_added, NULL);
2490         } else if (g_strcmp0(key, "EapMethods") == 0) {
2491                 supplicant_dbus_array_foreach(iter, eap_method, NULL);
2492                 debug_strvalmap("EAP method", eap_method_map, eap_methods);
2493         } else if (g_strcmp0(key, "Country") == 0) {
2494                 const char *country = NULL;
2495
2496                 dbus_message_iter_get_basic(iter, &country);
2497                 SUPPLICANT_DBG("Country %s", country);
2498         } else
2499                 SUPPLICANT_DBG("key %s type %c",
2500                                 key, dbus_message_iter_get_arg_type(iter));
2501 }
2502
2503 static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
2504 {
2505         const char *name = NULL, *old = NULL, *new = NULL;
2506
2507         SUPPLICANT_DBG("");
2508
2509         if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
2510                 return;
2511
2512         dbus_message_iter_get_basic(iter, &name);
2513         if (!name)
2514                 return;
2515
2516         if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
2517                 return;
2518
2519         dbus_message_iter_next(iter);
2520         dbus_message_iter_get_basic(iter, &old);
2521         dbus_message_iter_next(iter);
2522         dbus_message_iter_get_basic(iter, &new);
2523
2524         if (!old || !new)
2525                 return;
2526
2527         if (strlen(old) > 0 && strlen(new) == 0) {
2528                 system_available = FALSE;
2529                 g_hash_table_remove_all(bss_mapping);
2530                 g_hash_table_remove_all(peer_mapping);
2531                 g_hash_table_remove_all(group_mapping);
2532                 g_hash_table_remove_all(interface_table);
2533                 callback_system_killed();
2534         }
2535
2536         if (strlen(new) > 0 && strlen(old) == 0) {
2537                 system_available = TRUE;
2538                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
2539                                                 SUPPLICANT_INTERFACE,
2540                                                 service_property, NULL, NULL);
2541         }
2542 }
2543
2544 static void signal_properties_changed(const char *path, DBusMessageIter *iter)
2545 {
2546         SUPPLICANT_DBG("");
2547
2548         if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
2549                 return;
2550
2551         supplicant_dbus_property_foreach(iter, service_property, NULL);
2552 }
2553
2554 static void signal_interface_added(const char *path, DBusMessageIter *iter)
2555 {
2556         SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
2557
2558         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
2559                 interface_added(iter, NULL);
2560 }
2561
2562 static void signal_interface_removed(const char *path, DBusMessageIter *iter)
2563 {
2564         SUPPLICANT_DBG("");
2565
2566         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
2567                 interface_removed(iter, NULL);
2568 }
2569
2570 static void signal_interface_changed(const char *path, DBusMessageIter *iter)
2571 {
2572         GSupplicantInterface *interface;
2573
2574         SUPPLICANT_DBG("");
2575
2576         interface = g_hash_table_lookup(interface_table, path);
2577         if (!interface)
2578                 return;
2579
2580         supplicant_dbus_property_foreach(iter, interface_property, interface);
2581 }
2582
2583 static void signal_scan_done(const char *path, DBusMessageIter *iter)
2584 {
2585         GSupplicantInterface *interface;
2586         dbus_bool_t success = FALSE;
2587
2588         SUPPLICANT_DBG("");
2589
2590         interface = g_hash_table_lookup(interface_table, path);
2591         if (!interface)
2592                 return;
2593
2594         dbus_message_iter_get_basic(iter, &success);
2595
2596         if (interface->scanning) {
2597                 callback_scan_finished(interface);
2598                 interface->scanning = FALSE;
2599         }
2600
2601         /*
2602          * If scan is unsuccessful return -EIO else get the scanned BSSs
2603          * and update the network details accordingly
2604          */
2605         if (!success) {
2606                 if (interface->scan_callback)
2607                         interface->scan_callback(-EIO, interface,
2608                                                 interface->scan_data);
2609
2610                 interface->scan_callback = NULL;
2611                 interface->scan_data = NULL;
2612
2613                 return;
2614         }
2615
2616         supplicant_dbus_property_get(path, SUPPLICANT_INTERFACE ".Interface",
2617                                 "BSSs", scan_bss_data, interface, interface);
2618 }
2619
2620 static void signal_bss_added(const char *path, DBusMessageIter *iter)
2621 {
2622         GSupplicantInterface *interface;
2623
2624         SUPPLICANT_DBG("");
2625
2626         interface = g_hash_table_lookup(interface_table, path);
2627         if (!interface)
2628                 return;
2629
2630         interface_bss_added_with_keys(iter, interface);
2631 }
2632
2633 static void signal_bss_removed(const char *path, DBusMessageIter *iter)
2634 {
2635         GSupplicantInterface *interface;
2636
2637         SUPPLICANT_DBG("");
2638
2639         interface = g_hash_table_lookup(interface_table, path);
2640         if (!interface)
2641                 return;
2642
2643         interface_bss_removed(iter, interface);
2644 }
2645
2646 static void signal_network_added(const char *path, DBusMessageIter *iter)
2647 {
2648         GSupplicantInterface *interface;
2649
2650         SUPPLICANT_DBG("");
2651
2652         interface = g_hash_table_lookup(interface_table, path);
2653         if (!interface)
2654                 return;
2655
2656         interface_network_added(iter, interface);
2657 }
2658
2659 static void signal_network_removed(const char *path, DBusMessageIter *iter)
2660 {
2661         GSupplicantInterface *interface;
2662
2663         SUPPLICANT_DBG("");
2664
2665         interface = g_hash_table_lookup(interface_table, path);
2666         if (!interface)
2667                 return;
2668
2669         interface_network_removed(iter, interface);
2670 }
2671
2672 static void signal_bss_changed(const char *path, DBusMessageIter *iter)
2673 {
2674         GSupplicantInterface *interface;
2675         GSupplicantNetwork *network;
2676         GSupplicantSecurity old_security;
2677         struct g_supplicant_bss *bss;
2678
2679         SUPPLICANT_DBG("");
2680
2681         interface = g_hash_table_lookup(bss_mapping, path);
2682         if (!interface)
2683                 return;
2684
2685         network = g_hash_table_lookup(interface->bss_mapping, path);
2686         if (!network)
2687                 return;
2688
2689         bss = g_hash_table_lookup(network->bss_table, path);
2690         if (!bss)
2691                 return;
2692
2693         supplicant_dbus_property_foreach(iter, bss_property, bss);
2694 #if defined TIZEN_EXT
2695         network->frequency = bss->frequency;
2696 #endif
2697         old_security = network->security;
2698         bss_compute_security(bss);
2699
2700         if (old_security != bss->security) {
2701                 struct g_supplicant_bss *new_bss;
2702
2703                 SUPPLICANT_DBG("New network security for %s", bss->ssid);
2704
2705                 /* Security change policy:
2706                  * - we first copy the current bss into a new one with
2707                  * its own pointer (path)
2708                  * - we remove the current bss related network which will
2709                  * tell the plugin about such removal. This is done due
2710                  * to the fact that a security change means a group change
2711                  * so a complete network change.
2712                  * (current bss becomes invalid as well)
2713                  * - we add the new bss: it adds new network and tell the
2714                  * plugin about it. */
2715
2716                 new_bss = g_try_new0(struct g_supplicant_bss, 1);
2717                 if (!new_bss)
2718                         return;
2719
2720                 memcpy(new_bss, bss, sizeof(struct g_supplicant_bss));
2721                 new_bss->path = g_strdup(bss->path);
2722
2723                 g_hash_table_remove(interface->network_table, network->group);
2724
2725                 add_or_replace_bss_to_network(new_bss);
2726
2727                 return;
2728         }
2729
2730 #if defined TIZEN_EXT
2731         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
2732                 network->wps = TRUE;
2733                 network->wps_capabilities |= bss->wps_capabilities;
2734         } else
2735                 network->wps = FALSE;
2736 #endif
2737
2738         if (bss->signal == network->signal)
2739 #ifndef TIZEN_EXT
2740                 return;
2741 #else
2742         {
2743                 callback_network_changed(network, "");
2744                 return;
2745         }
2746 #endif
2747
2748         /*
2749          * If the new signal is lower than the SSID signal, we need
2750          * to check for the new maximum.
2751          */
2752         if (bss->signal < network->signal) {
2753                 if (bss != network->best_bss)
2754 #ifndef TIZEN_EXT
2755                         return;
2756 #else
2757                 {
2758                         callback_network_changed(network, "");
2759                         return;
2760                 }
2761 #endif
2762                 network->signal = bss->signal;
2763                 update_network_signal(network);
2764         } else {
2765                 network->signal = bss->signal;
2766                 network->best_bss = bss;
2767         }
2768
2769         SUPPLICANT_DBG("New network signal for %s %d dBm", network->ssid,
2770                         network->signal);
2771
2772         callback_network_changed(network, "Signal");
2773 }
2774
2775 static void wps_credentials(const char *key, DBusMessageIter *iter,
2776                         void *user_data)
2777 {
2778         GSupplicantInterface *interface = user_data;
2779
2780         if (!key)
2781                 return;
2782
2783         SUPPLICANT_DBG("key %s", key);
2784
2785         if (g_strcmp0(key, "Key") == 0) {
2786                 DBusMessageIter array;
2787                 unsigned char *key_val;
2788                 int key_len;
2789
2790                 dbus_message_iter_recurse(iter, &array);
2791                 dbus_message_iter_get_fixed_array(&array, &key_val, &key_len);
2792
2793                 g_free(interface->wps_cred.key);
2794                 interface->wps_cred.key = g_try_malloc0(
2795                                                 sizeof(char) * key_len + 1);
2796
2797                 if (!interface->wps_cred.key)
2798                         return;
2799
2800                 memcpy(interface->wps_cred.key, key_val,
2801                                                 sizeof(char) * key_len);
2802
2803                 SUPPLICANT_DBG("WPS key present");
2804         } else if (g_strcmp0(key, "SSID") == 0) {
2805                 DBusMessageIter array;
2806                 unsigned char *ssid;
2807                 int ssid_len;
2808
2809                 dbus_message_iter_recurse(iter, &array);
2810                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
2811
2812                 if (ssid_len > 0 && ssid_len < 33) {
2813                         memcpy(interface->wps_cred.ssid, ssid, ssid_len);
2814                         interface->wps_cred.ssid_len = ssid_len;
2815                 } else {
2816                         memset(interface->wps_cred.ssid, 0, 32);
2817                         interface->wps_cred.ssid_len = 0;
2818                 }
2819         }
2820 }
2821
2822 static void signal_wps_credentials(const char *path, DBusMessageIter *iter)
2823 {
2824         GSupplicantInterface *interface;
2825
2826         SUPPLICANT_DBG("");
2827
2828         interface = g_hash_table_lookup(interface_table, path);
2829         if (!interface)
2830                 return;
2831
2832         supplicant_dbus_property_foreach(iter, wps_credentials, interface);
2833 }
2834
2835 static void wps_event_args(const char *key, DBusMessageIter *iter,
2836                         void *user_data)
2837 {
2838         GSupplicantInterface *interface = user_data;
2839
2840         if (!key || !interface)
2841                 return;
2842
2843         SUPPLICANT_DBG("Arg Key %s", key);
2844 }
2845
2846 static void signal_wps_event(const char *path, DBusMessageIter *iter)
2847 {
2848         GSupplicantInterface *interface;
2849         const char *name = NULL;
2850
2851         SUPPLICANT_DBG("");
2852
2853         interface = g_hash_table_lookup(interface_table, path);
2854         if (!interface)
2855                 return;
2856
2857         dbus_message_iter_get_basic(iter, &name);
2858
2859         SUPPLICANT_DBG("Name: %s", name);
2860
2861         if (g_strcmp0(name, "success") == 0)
2862                 interface->wps_state = G_SUPPLICANT_WPS_STATE_SUCCESS;
2863         else if (g_strcmp0(name, "failed") == 0)
2864                 interface->wps_state = G_SUPPLICANT_WPS_STATE_FAIL;
2865         else
2866                 interface->wps_state = G_SUPPLICANT_WPS_STATE_UNKNOWN;
2867
2868         if (!dbus_message_iter_has_next(iter))
2869                 return;
2870
2871         dbus_message_iter_next(iter);
2872
2873         supplicant_dbus_property_foreach(iter, wps_event_args, interface);
2874 }
2875
2876 #if defined TIZEN_EXT
2877 static void signal_power_off(const char *path, DBusMessageIter *iter)
2878 {
2879         int poweroff_state = 0;
2880
2881         dbus_message_iter_get_basic(iter, &poweroff_state);
2882
2883         SUPPLICANT_DBG("poweroff_state(%d)", poweroff_state);
2884
2885         /* POWER_OFF_DIRECT 2 && POWER_OFF_RESTART 3 */
2886         if (poweroff_state != 2 && poweroff_state != 3)
2887                 return;
2888
2889         if (callbacks_pointer == NULL)
2890                 return;
2891
2892         if (callbacks_pointer->system_power_off == NULL)
2893                 return;
2894
2895         callbacks_pointer->system_power_off();
2896 }
2897 #endif
2898
2899 static void signal_station_connected(const char *path, DBusMessageIter *iter)
2900 {
2901         GSupplicantInterface *interface;
2902         const char *sta_mac = NULL;
2903
2904         SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
2905
2906         if (callbacks_pointer->add_station == NULL)
2907                 return;
2908
2909         if (g_strcmp0(path, "/") == 0)
2910                 return;
2911
2912         interface = g_hash_table_lookup(interface_table, path);
2913         if (interface == NULL)
2914                 return;
2915
2916         dbus_message_iter_get_basic(iter, &sta_mac);
2917         if (sta_mac == NULL)
2918                 return;
2919
2920         SUPPLICANT_DBG("New station %s connected", sta_mac);
2921         callbacks_pointer->add_station(sta_mac);
2922 }
2923
2924 static void signal_station_disconnected(const char *path, DBusMessageIter *iter)
2925 {
2926         GSupplicantInterface *interface;
2927         const char *sta_mac = NULL;
2928
2929         SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
2930
2931         if (callbacks_pointer->remove_station == NULL)
2932                 return;
2933
2934         if (g_strcmp0(path, "/") == 0)
2935                 return;
2936
2937         interface = g_hash_table_lookup(interface_table, path);
2938         if (interface == NULL)
2939                 return;
2940
2941         dbus_message_iter_get_basic(iter, &sta_mac);
2942         if (sta_mac == NULL)
2943                 return;
2944
2945         SUPPLICANT_DBG("Station %s disconnected", sta_mac);
2946         callbacks_pointer->remove_station(sta_mac);
2947 }
2948
2949 static void create_peer_identifier(GSupplicantPeer *peer)
2950 {
2951         const unsigned char test[ETH_ALEN] = {};
2952
2953         if (!peer)
2954                 return;
2955
2956         if (!memcmp(peer->device_address, test, ETH_ALEN)) {
2957                 peer->identifier = g_strdup(peer->name);
2958                 return;
2959         }
2960
2961         peer->identifier = g_malloc0(19);
2962         snprintf(peer->identifier, 19, "%02x%02x%02x%02x%02x%02x",
2963                                                 peer->device_address[0],
2964                                                 peer->device_address[1],
2965                                                 peer->device_address[2],
2966                                                 peer->device_address[3],
2967                                                 peer->device_address[4],
2968                                                 peer->device_address[5]);
2969 }
2970
2971 struct peer_property_data {
2972         GSupplicantPeer *peer;
2973         GSList *old_groups;
2974         bool groups_changed;
2975         bool services_changed;
2976 };
2977
2978 static void peer_groups_relation(DBusMessageIter *iter, void *user_data)
2979 {
2980         struct peer_property_data *data = user_data;
2981         GSupplicantPeer *peer = data->peer;
2982         GSupplicantGroup *group;
2983         const char *str = NULL;
2984         GSList *elem;
2985
2986         dbus_message_iter_get_basic(iter, &str);
2987         if (!str)
2988                 return;
2989
2990         group = g_hash_table_lookup(group_mapping, str);
2991         if (!group)
2992                 return;
2993
2994         elem = g_slist_find_custom(data->old_groups, str, g_str_equal);
2995         if (elem) {
2996                 data->old_groups = g_slist_remove_link(data->old_groups, elem);
2997                 peer->groups = g_slist_concat(elem, peer->groups);
2998         } else {
2999                 peer->groups = g_slist_prepend(peer->groups, g_strdup(str));
3000                 data->groups_changed = true;
3001         }
3002 }
3003
3004 static void peer_property(const char *key, DBusMessageIter *iter,
3005                                                         void *user_data)
3006 {
3007         GSupplicantPeer *pending_peer;
3008         struct peer_property_data *data = user_data;
3009         GSupplicantPeer *peer = data->peer;
3010
3011         SUPPLICANT_DBG("key: %s", key);
3012
3013         if (!peer->interface)
3014                 return;
3015
3016         if (!key) {
3017                 if (peer->name) {
3018                         create_peer_identifier(peer);
3019                         callback_peer_found(peer);
3020                         pending_peer = g_hash_table_lookup(
3021                                         pending_peer_connection, peer->path);
3022
3023                         if (pending_peer && pending_peer == peer) {
3024                                 callback_peer_request(peer);
3025                                 g_hash_table_remove(pending_peer_connection,
3026                                                 peer->path);
3027                         }
3028
3029                         dbus_free(data);
3030                 }
3031
3032                 return;
3033         }
3034
3035         if (g_strcmp0(key, "DeviceAddress") == 0) {
3036                 unsigned char *dev_addr;
3037                 DBusMessageIter array;
3038                 int len;
3039
3040                 dbus_message_iter_recurse(iter, &array);
3041                 dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
3042
3043                 if (len == ETH_ALEN)
3044                         memcpy(peer->device_address, dev_addr, len);
3045         } else if (g_strcmp0(key, "DeviceName") == 0) {
3046                 const char *str = NULL;
3047
3048                 dbus_message_iter_get_basic(iter, &str);
3049                 if (str)
3050                         peer->name = g_strdup(str);
3051         } else if (g_strcmp0(key, "config_method") == 0) {
3052                 uint16_t wps_config;
3053
3054                 dbus_message_iter_get_basic(iter, &wps_config);
3055
3056                 if (wps_config & G_SUPPLICANT_WPS_CONFIG_PBC)
3057                         peer->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
3058                 if (wps_config & ~G_SUPPLICANT_WPS_CONFIG_PBC)
3059                         peer->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
3060         } else if (g_strcmp0(key, "Groups") == 0) {
3061                 data->old_groups = peer->groups;
3062                 peer->groups = NULL;
3063
3064                 supplicant_dbus_array_foreach(iter,
3065                                                 peer_groups_relation, data);
3066                 if (g_slist_length(data->old_groups) > 0) {
3067                         g_slist_free_full(data->old_groups, g_free);
3068                         data->groups_changed = true;
3069                 }
3070         } else if (g_strcmp0(key, "IEs") == 0) {
3071                 DBusMessageIter array;
3072                 unsigned char *ie;
3073                 int ie_len;
3074
3075                 dbus_message_iter_recurse(iter, &array);
3076                 dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
3077
3078                 if (!ie || ie_len < 2)
3079                         return;
3080
3081                 if (peer->widi_ies) {
3082                         if (memcmp(peer->widi_ies, ie, ie_len) == 0)
3083                                 return;
3084
3085                         g_free(peer->widi_ies);
3086                         peer->widi_ies_length = 0;
3087                 }
3088
3089                 peer->widi_ies = g_malloc0(ie_len * sizeof(unsigned char));
3090
3091                 memcpy(peer->widi_ies, ie, ie_len);
3092                 peer->widi_ies_length = ie_len;
3093                 data->services_changed = true;
3094         }
3095 }
3096
3097 static void signal_peer_found(const char *path, DBusMessageIter *iter)
3098 {
3099         struct peer_property_data *property_data;
3100         GSupplicantInterface *interface;
3101         const char *obj_path = NULL;
3102         GSupplicantPeer *peer;
3103
3104         SUPPLICANT_DBG("");
3105
3106         interface = g_hash_table_lookup(interface_table, path);
3107         if (!interface)
3108                 return;
3109
3110         dbus_message_iter_get_basic(iter, &obj_path);
3111         if (!obj_path || g_strcmp0(obj_path, "/") == 0)
3112                 return;
3113
3114         peer = g_hash_table_lookup(interface->peer_table, obj_path);
3115         if (peer)
3116                 return;
3117
3118         peer = g_try_new0(GSupplicantPeer, 1);
3119         if (!peer)
3120                 return;
3121
3122         peer->interface = interface;
3123         peer->path = g_strdup(obj_path);
3124         g_hash_table_insert(interface->peer_table, peer->path, peer);
3125         g_hash_table_replace(peer_mapping, peer->path, interface);
3126
3127         property_data = dbus_malloc0(sizeof(struct peer_property_data));
3128         property_data->peer = peer;
3129
3130         dbus_message_iter_next(iter);
3131         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
3132                 supplicant_dbus_property_foreach(iter, peer_property,
3133                                                         property_data);
3134                 peer_property(NULL, NULL, property_data);
3135                 return;
3136         }
3137
3138         supplicant_dbus_property_get_all(obj_path,
3139                                         SUPPLICANT_INTERFACE ".Peer",
3140                                         peer_property, property_data, NULL);
3141 }
3142
3143 static void signal_peer_lost(const char *path, DBusMessageIter *iter)
3144 {
3145         GSupplicantInterface *interface;
3146         const char *obj_path = NULL;
3147         GSupplicantPeer *peer;
3148
3149         SUPPLICANT_DBG("");
3150
3151         interface = g_hash_table_lookup(interface_table, path);
3152         if (!interface)
3153                 return;
3154
3155         dbus_message_iter_get_basic(iter, &obj_path);
3156         if (!obj_path || g_strcmp0(obj_path, "/") == 0)
3157                 return;
3158
3159         peer = g_hash_table_lookup(interface->peer_table, obj_path);
3160         if (!peer)
3161                 return;
3162
3163         g_hash_table_remove(interface->peer_table, obj_path);
3164 }
3165
3166 static void signal_peer_changed(const char *path, DBusMessageIter *iter)
3167 {
3168         struct peer_property_data *property_data;
3169         GSupplicantInterface *interface;
3170         GSupplicantPeer *peer;
3171
3172         SUPPLICANT_DBG("");
3173
3174         interface = g_hash_table_lookup(peer_mapping, path);
3175         if (!interface)
3176                 return;
3177
3178         peer = g_hash_table_lookup(interface->peer_table, path);
3179         if (!peer) {
3180                 g_hash_table_remove(peer_mapping, path);
3181                 return;
3182         }
3183
3184         property_data = dbus_malloc0(sizeof(struct peer_property_data));
3185         property_data->peer = peer;
3186
3187         supplicant_dbus_property_foreach(iter, peer_property, property_data);
3188         if (property_data->services_changed)
3189                 callback_peer_changed(peer,
3190                                         G_SUPPLICANT_PEER_SERVICES_CHANGED);
3191
3192         if (property_data->groups_changed)
3193                 callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_CHANGED);
3194
3195         dbus_free(property_data);
3196
3197         if (!g_supplicant_peer_is_in_a_group(peer))
3198                 peer->connection_requested = false;
3199 }
3200
3201 struct group_sig_data {
3202         const char *peer_obj_path;
3203         unsigned char iface_address[ETH_ALEN];
3204         const char *interface_obj_path;
3205         const char *group_obj_path;
3206         int role;
3207 };
3208
3209 static void group_sig_property(const char *key, DBusMessageIter *iter,
3210                                                         void *user_data)
3211 {
3212         struct group_sig_data *data = user_data;
3213
3214         if (!key)
3215                 return;
3216
3217         if (g_strcmp0(key, "peer_interface_addr") == 0) {
3218                 unsigned char *dev_addr;
3219                 DBusMessageIter array;
3220                 int len;
3221
3222                 dbus_message_iter_recurse(iter, &array);
3223                 dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
3224
3225                 if (len == ETH_ALEN)
3226                         memcpy(data->iface_address, dev_addr, len);
3227         } else if (g_strcmp0(key, "role") == 0) {
3228                 const char *str = NULL;
3229
3230                 dbus_message_iter_get_basic(iter, &str);
3231                 if (g_strcmp0(str, "GO") == 0)
3232                         data->role = G_SUPPLICANT_GROUP_ROLE_GO;
3233                 else
3234                         data->role = G_SUPPLICANT_GROUP_ROLE_CLIENT;
3235         } else if (g_strcmp0(key, "peer_object") == 0)
3236                 dbus_message_iter_get_basic(iter, &data->peer_obj_path);
3237         else if (g_strcmp0(key, "interface_object") == 0)
3238                 dbus_message_iter_get_basic(iter, &data->interface_obj_path);
3239         else if (g_strcmp0(key, "group_object") == 0)
3240                 dbus_message_iter_get_basic(iter, &data->group_obj_path);
3241
3242 }
3243
3244 static void signal_group_success(const char *path, DBusMessageIter *iter)
3245 {
3246         GSupplicantInterface *interface;
3247         struct group_sig_data data = {};
3248         GSupplicantPeer *peer;
3249
3250         SUPPLICANT_DBG("");
3251
3252         interface = g_hash_table_lookup(interface_table, path);
3253         if (!interface)
3254                 return;
3255
3256         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
3257         if (!data.peer_obj_path)
3258                 return;
3259
3260         peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
3261         if (!peer)
3262                 return;
3263
3264         memcpy(peer->iface_address, data.iface_address, ETH_ALEN);
3265         interface->pending_peer_path = peer->path;
3266 }
3267
3268 static void signal_group_failure(const char *path, DBusMessageIter *iter)
3269 {
3270         GSupplicantInterface *interface;
3271         struct group_sig_data data = {};
3272         GSupplicantPeer *peer;
3273
3274         SUPPLICANT_DBG("");
3275
3276         interface = g_hash_table_lookup(interface_table, path);
3277         if (!interface)
3278                 return;
3279
3280         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
3281         if (!data.peer_obj_path)
3282                 return;
3283
3284         peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
3285         if (!peer)
3286                 return;
3287
3288         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_FAILED);
3289         peer->connection_requested = false;
3290 }
3291
3292 static void signal_group_started(const char *path, DBusMessageIter *iter)
3293 {
3294         GSupplicantInterface *interface, *g_interface;
3295         struct group_sig_data data = {};
3296         GSupplicantGroup *group;
3297         GSupplicantPeer *peer;
3298
3299         SUPPLICANT_DBG("");
3300
3301         interface = g_hash_table_lookup(interface_table, path);
3302         if (!interface)
3303                 return;
3304
3305         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
3306         if (!data.interface_obj_path || !data.group_obj_path)
3307                 return;
3308
3309         peer = g_hash_table_lookup(interface->peer_table,
3310                                                 interface->pending_peer_path);
3311         interface->pending_peer_path = NULL;
3312         if (!peer)
3313                 return;
3314
3315         g_interface = g_hash_table_lookup(interface_table,
3316                                                 data.interface_obj_path);
3317         if (!g_interface)
3318                 return;
3319
3320         group = g_hash_table_lookup(interface->group_table,
3321                                                 data.group_obj_path);
3322         if (group)
3323                 return;
3324
3325         group = g_try_new0(GSupplicantGroup, 1);
3326         if (!group)
3327                 return;
3328
3329         group->interface = g_interface;
3330         group->orig_interface = interface;
3331         group->path = g_strdup(data.group_obj_path);
3332         group->role = data.role;
3333
3334         g_hash_table_insert(interface->group_table, group->path, group);
3335         g_hash_table_replace(group_mapping, group->path, group);
3336
3337         peer->current_group_iface = g_interface;
3338         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_STARTED);
3339 }
3340
3341 static void remove_peer_group_interface(GHashTable *group_table,
3342                                 const char* path)
3343 {
3344         GSupplicantGroup *group;
3345         GHashTableIter iter;
3346         gpointer value, key;
3347
3348         if (!group_table)
3349                 return;
3350
3351         group = g_hash_table_lookup(group_table, path);
3352
3353         if (!group || !group->orig_interface)
3354                 return;
3355
3356         g_hash_table_iter_init(&iter, group->orig_interface->peer_table);
3357
3358         while (g_hash_table_iter_next(&iter, &key, &value)) {
3359                 GSupplicantPeer *peer = value;
3360
3361                 if (peer->current_group_iface == group->interface)
3362                         peer->current_group_iface = NULL;
3363         }
3364 }
3365
3366 static void signal_group_finished(const char *path, DBusMessageIter *iter)
3367 {
3368         GSupplicantInterface *interface;
3369         struct group_sig_data data = {};
3370
3371         SUPPLICANT_DBG("");
3372
3373         interface = g_hash_table_lookup(interface_table, path);
3374         if (!interface)
3375                 return;
3376
3377         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
3378         if (!data.interface_obj_path || !data.group_obj_path)
3379                 return;
3380
3381         remove_peer_group_interface(interface->group_table, data.group_obj_path);
3382
3383         g_hash_table_remove(group_mapping, data.group_obj_path);
3384
3385         g_hash_table_remove(interface->group_table, data.group_obj_path);
3386 }
3387
3388 static void signal_group_request(const char *path, DBusMessageIter *iter)
3389 {
3390         GSupplicantInterface *interface;
3391         GSupplicantPeer *peer;
3392         const char *obj_path;
3393
3394         SUPPLICANT_DBG("");
3395
3396         interface = g_hash_table_lookup(interface_table, path);
3397         if (!interface)
3398                 return;
3399
3400         dbus_message_iter_get_basic(iter, &obj_path);
3401         if (!obj_path || !g_strcmp0(obj_path, "/"))
3402                 return;
3403
3404         peer = g_hash_table_lookup(interface->peer_table, obj_path);
3405         if (!peer)
3406                 return;
3407
3408         /*
3409          * Peer has been previously found and property set,
3410          * otherwise, defer connection to when peer property
3411          * is set.
3412          */
3413         if (peer->identifier)
3414                 callback_peer_request(peer);
3415         else
3416                 g_hash_table_replace(pending_peer_connection, peer->path, peer);
3417 }
3418
3419 static void signal_group_peer_joined(const char *path, DBusMessageIter *iter)
3420 {
3421         const char *peer_path = NULL;
3422         GSupplicantInterface *interface;
3423         GSupplicantGroup *group;
3424         GSupplicantPeer *peer;
3425
3426         SUPPLICANT_DBG("");
3427
3428         group = g_hash_table_lookup(group_mapping, path);
3429         if (!group)
3430                 return;
3431
3432         dbus_message_iter_get_basic(iter, &peer_path);
3433         if (!peer_path)
3434                 return;
3435
3436         interface = g_hash_table_lookup(peer_mapping, peer_path);
3437         if (!interface)
3438                 return;
3439
3440         peer = g_hash_table_lookup(interface->peer_table, peer_path);
3441         if (!peer)
3442                 return;
3443
3444         group->members = g_slist_prepend(group->members, g_strdup(peer_path));
3445
3446         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_JOINED);
3447 }
3448
3449 static void signal_group_peer_disconnected(const char *path, DBusMessageIter *iter)
3450 {
3451         const char *peer_path = NULL;
3452         GSupplicantInterface *interface;
3453         GSupplicantGroup *group;
3454         GSupplicantPeer *peer;
3455         GSList *elem;
3456
3457         SUPPLICANT_DBG("");
3458
3459         group = g_hash_table_lookup(group_mapping, path);
3460         if (!group)
3461                 return;
3462
3463         dbus_message_iter_get_basic(iter, &peer_path);
3464         if (!peer_path)
3465                 return;
3466
3467         for (elem = group->members; elem; elem = elem->next) {
3468                 if (!g_strcmp0(elem->data, peer_path))
3469                         break;
3470         }
3471
3472         if (!elem)
3473                 return;
3474
3475         g_free(elem->data);
3476         group->members = g_slist_delete_link(group->members, elem);
3477
3478         interface = g_hash_table_lookup(peer_mapping, peer_path);
3479         if (!interface)
3480                 return;
3481
3482         peer = g_hash_table_lookup(interface->peer_table, peer_path);
3483         if (!peer)
3484                 return;
3485
3486         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_DISCONNECTED);
3487         peer->connection_requested = false;
3488 }
3489
3490 static struct {
3491         const char *interface;
3492         const char *member;
3493         void (*function) (const char *path, DBusMessageIter *iter);
3494 } signal_map[] = {
3495         { DBUS_INTERFACE_DBUS,  "NameOwnerChanged",  signal_name_owner_changed },
3496
3497         { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
3498         { SUPPLICANT_INTERFACE, "InterfaceAdded",    signal_interface_added    },
3499         { SUPPLICANT_INTERFACE, "InterfaceCreated",  signal_interface_added    },
3500         { SUPPLICANT_INTERFACE, "InterfaceRemoved",  signal_interface_removed  },
3501
3502         { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
3503         { SUPPLICANT_INTERFACE ".Interface", "ScanDone",          signal_scan_done         },
3504         { SUPPLICANT_INTERFACE ".Interface", "BSSAdded",          signal_bss_added         },
3505         { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved",        signal_bss_removed       },
3506         { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded",      signal_network_added     },
3507         { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved",    signal_network_removed   },
3508
3509         { SUPPLICANT_INTERFACE ".BSS", "PropertiesChanged", signal_bss_changed   },
3510
3511         { SUPPLICANT_INTERFACE ".Interface.WPS", "Credentials", signal_wps_credentials },
3512         { SUPPLICANT_INTERFACE ".Interface.WPS", "Event",       signal_wps_event       },
3513 #if defined TIZEN_EXT
3514         { "org.tizen.system.deviced.PowerOff", "ChangeState", signal_power_off },
3515 #endif
3516
3517         { SUPPLICANT_INTERFACE".Interface", "StaAuthorized", signal_station_connected      },
3518         { SUPPLICANT_INTERFACE".Interface", "StaDeauthorized", signal_station_disconnected },
3519
3520         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceFound", signal_peer_found },
3521         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceLost",  signal_peer_lost  },
3522
3523         { SUPPLICANT_INTERFACE ".Peer", "PropertiesChanged", signal_peer_changed },
3524
3525         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationSuccess", signal_group_success },
3526         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationFailure", signal_group_failure },
3527         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupStarted", signal_group_started },
3528         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupFinished", signal_group_finished },
3529         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationRequest", signal_group_request },
3530
3531         { SUPPLICANT_INTERFACE ".Group", "PeerJoined", signal_group_peer_joined },
3532         { SUPPLICANT_INTERFACE ".Group", "PeerDisconnected", signal_group_peer_disconnected },
3533
3534         { }
3535 };
3536
3537 static DBusHandlerResult g_supplicant_filter(DBusConnection *conn,
3538                                         DBusMessage *message, void *data)
3539 {
3540         DBusMessageIter iter;
3541         const char *path;
3542         int i;
3543
3544         path = dbus_message_get_path(message);
3545         if (!path)
3546                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
3547
3548         if (!dbus_message_iter_init(message, &iter))
3549                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
3550
3551         for (i = 0; signal_map[i].interface; i++) {
3552                 if (!dbus_message_has_interface(message, signal_map[i].interface))
3553                         continue;
3554
3555                 if (!dbus_message_has_member(message, signal_map[i].member))
3556                         continue;
3557
3558                 signal_map[i].function(path, &iter);
3559                 break;
3560         }
3561
3562         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
3563 }
3564
3565 void g_supplicant_interface_cancel(GSupplicantInterface *interface)
3566 {
3567         SUPPLICANT_DBG("Cancelling any pending DBus calls");
3568         supplicant_dbus_method_call_cancel_all(interface);
3569         supplicant_dbus_property_call_cancel_all(interface);
3570 }
3571
3572 struct supplicant_regdom {
3573         GSupplicantCountryCallback callback;
3574         const char *alpha2;
3575         const void *user_data;
3576 };
3577
3578 static void country_result(const char *error,
3579                                 DBusMessageIter *iter, void *user_data)
3580 {
3581         struct supplicant_regdom *regdom = user_data;
3582         int result = 0;
3583
3584         SUPPLICANT_DBG("Country setting result");
3585
3586         if (!user_data)
3587                 return;
3588
3589         if (error) {
3590                 SUPPLICANT_DBG("Country setting failure %s", error);
3591                 result = -EINVAL;
3592         }
3593
3594         if (regdom->callback)
3595                 regdom->callback(result, regdom->alpha2,
3596                                         (void *) regdom->user_data);
3597
3598         g_free(regdom);
3599 }
3600
3601 static void country_params(DBusMessageIter *iter, void *user_data)
3602 {
3603         struct supplicant_regdom *regdom = user_data;
3604
3605         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
3606                                                         &regdom->alpha2);
3607 }
3608
3609 int g_supplicant_set_country(const char *alpha2,
3610                                 GSupplicantCountryCallback callback,
3611                                         const void *user_data)
3612 {
3613         struct supplicant_regdom *regdom;
3614
3615         SUPPLICANT_DBG("Country setting %s", alpha2);
3616
3617         if (!system_available)
3618                 return -EFAULT;
3619
3620         regdom = dbus_malloc0(sizeof(*regdom));
3621         if (!regdom)
3622                 return -ENOMEM;
3623
3624         regdom->callback = callback;
3625         regdom->alpha2 = alpha2;
3626         regdom->user_data = user_data;
3627
3628         return supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
3629                                         "Country", DBUS_TYPE_STRING_AS_STRING,
3630                                         country_params, country_result,
3631                                         regdom, NULL);
3632 }
3633
3634 int g_supplicant_interface_set_country(GSupplicantInterface *interface,
3635                                         GSupplicantCountryCallback callback,
3636                                                         const char *alpha2,
3637                                                         void *user_data)
3638 {
3639         struct supplicant_regdom *regdom;
3640
3641         regdom = dbus_malloc0(sizeof(*regdom));
3642         if (!regdom)
3643                 return -ENOMEM;
3644
3645         regdom->callback = callback;
3646         regdom->alpha2 = alpha2;
3647         regdom->user_data = user_data;
3648
3649         return supplicant_dbus_property_set(interface->path,
3650                                 SUPPLICANT_INTERFACE ".Interface",
3651                                 "Country", DBUS_TYPE_STRING_AS_STRING,
3652                                 country_params, country_result,
3653                                         regdom, NULL);
3654 }
3655
3656 bool g_supplicant_interface_has_p2p(GSupplicantInterface *interface)
3657 {
3658         if (!interface)
3659                 return false;
3660
3661         return interface->p2p_support;
3662 }
3663
3664 struct supplicant_p2p_dev_config {
3665         char *device_name;
3666         char *dev_type;
3667 };
3668
3669 static void p2p_device_config_result(const char *error,
3670                                         DBusMessageIter *iter, void *user_data)
3671 {
3672         struct supplicant_p2p_dev_config *config = user_data;
3673
3674         if (error)
3675                 SUPPLICANT_DBG("Unable to set P2P Device configuration: %s",
3676                                                                         error);
3677
3678         g_free(config->device_name);
3679         g_free(config->dev_type);
3680         dbus_free(config);
3681 }
3682
3683 static int dev_type_str2bin(const char *type, unsigned char dev_type[8])
3684 {
3685         int length, pos, end;
3686         char b[3] = {};
3687         char *e = NULL;
3688
3689         end = strlen(type);
3690         for (length = pos = 0; type[pos] != '\0' && length < 8; length++) {
3691                 if (pos+2 > end)
3692                         return 0;
3693
3694                 b[0] = type[pos];
3695                 b[1] = type[pos+1];
3696
3697                 dev_type[length] = strtol(b, &e, 16);
3698                 if (e && *e != '\0')
3699                         return 0;
3700
3701                 pos += 2;
3702         }
3703
3704         return 8;
3705 }
3706
3707 static void p2p_device_config_params(DBusMessageIter *iter, void *user_data)
3708 {
3709         struct supplicant_p2p_dev_config *config = user_data;
3710         DBusMessageIter dict;
3711
3712         supplicant_dbus_dict_open(iter, &dict);
3713
3714         supplicant_dbus_dict_append_basic(&dict, "DeviceName",
3715                                 DBUS_TYPE_STRING, &config->device_name);
3716
3717         if (config->dev_type) {
3718                 unsigned char dev_type[8] = {}, *type;
3719                 int len;
3720
3721                 len = dev_type_str2bin(config->dev_type, dev_type);
3722                 if (len) {
3723                         type = dev_type;
3724                         supplicant_dbus_dict_append_fixed_array(&dict,
3725                                         "PrimaryDeviceType",
3726                                         DBUS_TYPE_BYTE, &type, len);
3727                 }
3728         }
3729
3730         supplicant_dbus_dict_close(iter, &dict);
3731 }
3732
3733 int g_supplicant_interface_set_p2p_device_config(GSupplicantInterface *interface,
3734                                         const char *device_name,
3735                                         const char *primary_dev_type)
3736 {
3737         struct supplicant_p2p_dev_config *config;
3738         int ret;
3739
3740         SUPPLICANT_DBG("P2P Device settings %s/%s",
3741                                         device_name, primary_dev_type);
3742
3743         config = dbus_malloc0(sizeof(*config));
3744         if (!config)
3745                 return -ENOMEM;
3746
3747         config->device_name = g_strdup(device_name);
3748         config->dev_type = g_strdup(primary_dev_type);
3749
3750         ret = supplicant_dbus_property_set(interface->path,
3751                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
3752                                 "P2PDeviceConfig",
3753                                 DBUS_TYPE_ARRAY_AS_STRING
3754                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
3755                                 DBUS_TYPE_STRING_AS_STRING
3756                                 DBUS_TYPE_VARIANT_AS_STRING
3757                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
3758                                 p2p_device_config_params,
3759                                 p2p_device_config_result, config, NULL);
3760         if (ret < 0) {
3761                 g_free(config->device_name);
3762                 g_free(config->dev_type);
3763                 dbus_free(config);
3764                 SUPPLICANT_DBG("Unable to set P2P Device configuration");
3765         }
3766
3767         return ret;
3768 }
3769
3770 static gboolean peer_lookup_by_identifier(gpointer key, gpointer value,
3771                                                         gpointer user_data)
3772 {
3773         const GSupplicantPeer *peer = value;
3774         const char *identifier = user_data;
3775
3776         if (!g_strcmp0(identifier, peer->identifier))
3777                 return TRUE;
3778
3779         return FALSE;
3780 }
3781
3782 GSupplicantPeer *g_supplicant_interface_peer_lookup(GSupplicantInterface *interface,
3783                                                         const char *identifier)
3784 {
3785         GSupplicantPeer *peer;
3786
3787         peer = g_hash_table_find(interface->peer_table,
3788                                         peer_lookup_by_identifier,
3789                                         (void *) identifier);
3790         return peer;
3791 }
3792
3793 struct interface_data {
3794         GSupplicantInterface *interface;
3795         char *path; /* Interface path cannot be taken from interface (above) as
3796                      * it might have been freed already.
3797                      */
3798         GSupplicantInterfaceCallback callback;
3799         void *user_data;
3800 };
3801
3802 struct interface_create_data {
3803         char *ifname;
3804         char *driver;
3805         char *bridge;
3806         GSupplicantInterface *interface;
3807         GSupplicantInterfaceCallback callback;
3808         void *user_data;
3809 };
3810
3811 struct interface_connect_data {
3812         GSupplicantInterface *interface;
3813         char *path;
3814         GSupplicantInterfaceCallback callback;
3815         union {
3816                 GSupplicantSSID *ssid;
3817                 GSupplicantPeerParams *peer;
3818         };
3819         void *user_data;
3820 };
3821
3822 struct interface_scan_data {
3823         GSupplicantInterface *interface;
3824         char *path;
3825         GSupplicantInterfaceCallback callback;
3826         GSupplicantScanParams *scan_params;
3827         void *user_data;
3828 };
3829
3830 static void interface_create_data_free(struct interface_create_data *data)
3831 {
3832         g_free(data->ifname);
3833         g_free(data->driver);
3834         g_free(data->bridge);
3835         dbus_free(data);
3836 }
3837
3838 static bool interface_exists(GSupplicantInterface *interface,
3839                                 const char *path)
3840 {
3841         GSupplicantInterface *tmp;
3842
3843         tmp = g_hash_table_lookup(interface_table, path);
3844         if (tmp && tmp == interface)
3845                 return true;
3846
3847         return false;
3848 }
3849
3850 static void interface_create_property(const char *key, DBusMessageIter *iter,
3851                                                         void *user_data)
3852 {
3853         struct interface_create_data *data = user_data;
3854         GSupplicantInterface *interface = data->interface;
3855
3856         if (!key) {
3857                 if (data->callback) {
3858                         data->callback(0, data->interface, data->user_data);
3859 #if !defined TIZEN_EXT
3860                         callback_p2p_support(interface);
3861 #endif
3862                 }
3863
3864                 interface_create_data_free(data);
3865         }
3866
3867         interface_property(key, iter, interface);
3868 }
3869
3870 static void interface_create_result(const char *error,
3871                                 DBusMessageIter *iter, void *user_data)
3872 {
3873         struct interface_create_data *data = user_data;
3874         const char *path = NULL;
3875         int err;
3876
3877         SUPPLICANT_DBG("");
3878
3879         if (error) {
3880                 g_warning("error %s", error);
3881                 err = -EIO;
3882                 goto done;
3883         }
3884
3885         dbus_message_iter_get_basic(iter, &path);
3886         if (!path) {
3887                 err = -EINVAL;
3888                 goto done;
3889         }
3890
3891         if (!system_available) {
3892                 err = -EFAULT;
3893                 goto done;
3894         }
3895
3896         data->interface = g_hash_table_lookup(interface_table, path);
3897         if (!data->interface) {
3898                 data->interface = interface_alloc(path);
3899                 if (!data->interface) {
3900                         err = -ENOMEM;
3901                         goto done;
3902                 }
3903         }
3904
3905         err = supplicant_dbus_property_get_all(path,
3906                                         SUPPLICANT_INTERFACE ".Interface",
3907                                         interface_create_property, data,
3908                                         NULL);
3909         if (err == 0)
3910                 return;
3911
3912 done:
3913         if (data->callback)
3914                 data->callback(err, NULL, data->user_data);
3915
3916         interface_create_data_free(data);
3917 }
3918
3919 static void interface_create_params(DBusMessageIter *iter, void *user_data)
3920 {
3921         struct interface_create_data *data = user_data;
3922         DBusMessageIter dict;
3923
3924         SUPPLICANT_DBG("");
3925
3926         supplicant_dbus_dict_open(iter, &dict);
3927
3928         supplicant_dbus_dict_append_basic(&dict, "Ifname",
3929                                         DBUS_TYPE_STRING, &data->ifname);
3930
3931         if (data->driver)
3932                 supplicant_dbus_dict_append_basic(&dict, "Driver",
3933                                         DBUS_TYPE_STRING, &data->driver);
3934
3935         if (data->bridge)
3936                 supplicant_dbus_dict_append_basic(&dict, "BridgeIfname",
3937                                         DBUS_TYPE_STRING, &data->bridge);
3938
3939         supplicant_dbus_dict_close(iter, &dict);
3940 }
3941
3942 static void interface_get_result(const char *error,
3943                                 DBusMessageIter *iter, void *user_data)
3944 {
3945         struct interface_create_data *data = user_data;
3946         GSupplicantInterface *interface;
3947         const char *path = NULL;
3948         int err;
3949
3950         SUPPLICANT_DBG("");
3951
3952         if (error) {
3953                 SUPPLICANT_DBG("Interface not created yet");
3954                 goto create;
3955         }
3956
3957         dbus_message_iter_get_basic(iter, &path);
3958         if (!path) {
3959                 err = -EINVAL;
3960                 goto done;
3961         }
3962
3963         interface = g_hash_table_lookup(interface_table, path);
3964         if (!interface) {
3965                 err = -ENOENT;
3966                 goto done;
3967         }
3968
3969         if (data->callback) {
3970                 data->callback(0, interface, data->user_data);
3971 #if !defined TIZEN_EXT
3972                 callback_p2p_support(interface);
3973 #endif
3974         }
3975
3976         interface_create_data_free(data);
3977
3978         return;
3979
3980 create:
3981         if (!system_available) {
3982                 err = -EFAULT;
3983                 goto done;
3984         }
3985
3986         SUPPLICANT_DBG("Creating interface");
3987
3988         err = supplicant_dbus_method_call(SUPPLICANT_PATH,
3989                                                 SUPPLICANT_INTERFACE,
3990                                                 "CreateInterface",
3991                                                 interface_create_params,
3992                                                 interface_create_result, data,
3993                                                 NULL);
3994         if (err == 0)
3995                 return;
3996
3997 done:
3998         if (data->callback)
3999                 data->callback(err, NULL, data->user_data);
4000
4001         interface_create_data_free(data);
4002 }
4003
4004 static void interface_get_params(DBusMessageIter *iter, void *user_data)
4005 {
4006         struct interface_create_data *data = user_data;
4007
4008         SUPPLICANT_DBG("");
4009
4010         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
4011 }
4012
4013 int g_supplicant_interface_create(const char *ifname, const char *driver,
4014                                         const char *bridge,
4015                                         GSupplicantInterfaceCallback callback,
4016                                                         void *user_data)
4017 {
4018         struct interface_create_data *data;
4019         int ret;
4020
4021         SUPPLICANT_DBG("ifname %s", ifname);
4022
4023         if (!ifname)
4024                 return -EINVAL;
4025
4026         if (!system_available)
4027                 return -EFAULT;
4028
4029         data = dbus_malloc0(sizeof(*data));
4030         if (!data)
4031                 return -ENOMEM;
4032
4033         data->ifname = g_strdup(ifname);
4034         data->driver = g_strdup(driver);
4035         data->bridge = g_strdup(bridge);
4036         data->callback = callback;
4037         data->user_data = user_data;
4038
4039         ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
4040                                                 SUPPLICANT_INTERFACE,
4041                                                 "GetInterface",
4042                                                 interface_get_params,
4043                                                 interface_get_result, data,
4044                                                 NULL);
4045         if (ret < 0)
4046                 interface_create_data_free(data);
4047
4048         return ret;
4049 }
4050
4051 static void interface_remove_result(const char *error,
4052                                 DBusMessageIter *iter, void *user_data)
4053 {
4054         struct interface_data *data = user_data;
4055         int err;
4056
4057         if (error) {
4058                 err = -EIO;
4059                 goto done;
4060         }
4061
4062         if (!system_available) {
4063                 err = -EFAULT;
4064                 goto done;
4065         }
4066
4067         /*
4068          * The gsupplicant interface is already freed by the InterfaceRemoved
4069          * signal callback. Simply invoke the interface_data callback.
4070          */
4071         err = 0;
4072
4073 done:
4074         g_free(data->path);
4075
4076         if (data->callback)
4077                 data->callback(err, NULL, data->user_data);
4078
4079         dbus_free(data);
4080 }
4081
4082
4083 static void interface_remove_params(DBusMessageIter *iter, void *user_data)
4084 {
4085         struct interface_data *data = user_data;
4086
4087         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
4088                                                         &data->interface->path);
4089 }
4090
4091
4092 int g_supplicant_interface_remove(GSupplicantInterface *interface,
4093                         GSupplicantInterfaceCallback callback,
4094                                                         void *user_data)
4095 {
4096         struct interface_data *data;
4097         int ret;
4098
4099         if (!interface)
4100                 return -EINVAL;
4101
4102         if (!system_available)
4103                 return -EFAULT;
4104
4105         g_supplicant_interface_cancel(interface);
4106
4107         data = dbus_malloc0(sizeof(*data));
4108         if (!data)
4109                 return -ENOMEM;
4110
4111         data->interface = interface;
4112         data->path = g_strdup(interface->path);
4113         data->callback = callback;
4114         data->user_data = user_data;
4115
4116         ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
4117                                                 SUPPLICANT_INTERFACE,
4118                                                 "RemoveInterface",
4119                                                 interface_remove_params,
4120                                                 interface_remove_result, data,
4121                                                 NULL);
4122         if (ret < 0) {
4123                 g_free(data->path);
4124                 dbus_free(data);
4125         }
4126         return ret;
4127 }
4128
4129 static void interface_scan_result(const char *error,
4130                                 DBusMessageIter *iter, void *user_data)
4131 {
4132         struct interface_scan_data *data = user_data;
4133         int err = 0;
4134
4135         if (error) {
4136                 SUPPLICANT_DBG("error %s", error);
4137                 err = -EIO;
4138         }
4139
4140         /* A non ready interface cannot send/receive anything */
4141         if (interface_exists(data->interface, data->path)) {
4142                 if (!data->interface->ready)
4143                         err = -ENOLINK;
4144         }
4145
4146         g_free(data->path);
4147
4148         if (err != 0) {
4149                 if (data->callback)
4150                         data->callback(err, data->interface, data->user_data);
4151         } else {
4152                 data->interface->scan_callback = data->callback;
4153                 data->interface->scan_data = data->user_data;
4154         }
4155
4156         if (data->scan_params)
4157                 g_supplicant_free_scan_params(data->scan_params);
4158
4159         dbus_free(data);
4160 }
4161
4162 static void add_scan_frequency(DBusMessageIter *iter, unsigned int freq)
4163 {
4164         DBusMessageIter data;
4165         unsigned int width = 0; /* Not used by wpa_supplicant atm */
4166
4167         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &data);
4168
4169         dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &freq);
4170         dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &width);
4171
4172         dbus_message_iter_close_container(iter, &data);
4173 }
4174
4175 static void add_scan_frequencies(DBusMessageIter *iter,
4176                                                 void *user_data)
4177 {
4178         GSupplicantScanParams *scan_data = user_data;
4179         unsigned int freq;
4180         int i;
4181
4182         for (i = 0; i < scan_data->num_freqs; i++) {
4183                 freq = scan_data->freqs[i];
4184                 if (!freq)
4185                         break;
4186
4187                 add_scan_frequency(iter, freq);
4188         }
4189 }
4190
4191 static void append_ssid(DBusMessageIter *iter,
4192                         const void *ssid, unsigned int len)
4193 {
4194         DBusMessageIter array;
4195
4196         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
4197         DBUS_TYPE_BYTE_AS_STRING, &array);
4198
4199         dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
4200                                                                 &ssid, len);
4201         dbus_message_iter_close_container(iter, &array);
4202 }
4203
4204 static void append_ssids(DBusMessageIter *iter, void *user_data)
4205 {
4206         GSupplicantScanParams *scan_data = user_data;
4207         GSList *list;
4208
4209         for (list = scan_data->ssids; list; list = list->next) {
4210                 struct scan_ssid *scan_ssid = list->data;
4211
4212                 append_ssid(iter, scan_ssid->ssid, scan_ssid->ssid_len);
4213         }
4214 }
4215
4216 static void supplicant_add_scan_frequency(DBusMessageIter *dict,
4217                 supplicant_dbus_array_function function,
4218                                         void *user_data)
4219 {
4220         GSupplicantScanParams *scan_params = user_data;
4221         DBusMessageIter entry, value, array;
4222         const char *key = "Channels";
4223
4224         if (scan_params->freqs && scan_params->freqs[0] != 0) {
4225                 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
4226                                                 NULL, &entry);
4227
4228                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
4229
4230                 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
4231                                         DBUS_TYPE_ARRAY_AS_STRING
4232                                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
4233                                         DBUS_TYPE_UINT32_AS_STRING
4234                                         DBUS_TYPE_UINT32_AS_STRING
4235                                         DBUS_STRUCT_END_CHAR_AS_STRING,
4236                                         &value);
4237
4238                 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
4239                                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
4240                                         DBUS_TYPE_UINT32_AS_STRING
4241                                         DBUS_TYPE_UINT32_AS_STRING
4242                                         DBUS_STRUCT_END_CHAR_AS_STRING,
4243                                         &array);
4244
4245                 if (function)
4246                         function(&array, user_data);
4247
4248                 dbus_message_iter_close_container(&value, &array);
4249                 dbus_message_iter_close_container(&entry, &value);
4250                 dbus_message_iter_close_container(dict, &entry);
4251         }
4252 }
4253
4254 static void interface_scan_params(DBusMessageIter *iter, void *user_data)
4255 {
4256         DBusMessageIter dict;
4257         const char *type = "passive";
4258         struct interface_scan_data *data = user_data;
4259
4260         supplicant_dbus_dict_open(iter, &dict);
4261
4262         if (data && data->scan_params) {
4263                 type = "active";
4264
4265                 supplicant_dbus_dict_append_basic(&dict, "Type",
4266                                         DBUS_TYPE_STRING, &type);
4267
4268                 supplicant_dbus_dict_append_array(&dict, "SSIDs",
4269                                                 DBUS_TYPE_STRING,
4270                                                 append_ssids,
4271                                                 data->scan_params);
4272
4273                 supplicant_add_scan_frequency(&dict, add_scan_frequencies,
4274                                                 data->scan_params);
4275         } else
4276                 supplicant_dbus_dict_append_basic(&dict, "Type",
4277                                         DBUS_TYPE_STRING, &type);
4278
4279         supplicant_dbus_dict_close(iter, &dict);
4280 }
4281
4282 static int interface_ready_to_scan(GSupplicantInterface *interface)
4283 {
4284         if (!interface)
4285                 return -EINVAL;
4286
4287         if (!system_available)
4288                 return -EFAULT;
4289
4290         if (interface->scanning)
4291                 return -EALREADY;
4292
4293         switch (interface->state) {
4294         case G_SUPPLICANT_STATE_AUTHENTICATING:
4295         case G_SUPPLICANT_STATE_ASSOCIATING:
4296         case G_SUPPLICANT_STATE_ASSOCIATED:
4297         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4298         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4299                 return -EBUSY;
4300 #if defined TIZEN_EXT
4301         case G_SUPPLICANT_STATE_DISABLED:
4302                 return -ENOLINK;
4303         case G_SUPPLICANT_STATE_UNKNOWN:
4304 #else
4305         case G_SUPPLICANT_STATE_UNKNOWN:
4306         case G_SUPPLICANT_STATE_DISABLED:
4307 #endif
4308         case G_SUPPLICANT_STATE_DISCONNECTED:
4309         case G_SUPPLICANT_STATE_INACTIVE:
4310         case G_SUPPLICANT_STATE_SCANNING:
4311         case G_SUPPLICANT_STATE_COMPLETED:
4312                 break;
4313         }
4314
4315         return 0;
4316 }
4317
4318 int g_supplicant_interface_scan(GSupplicantInterface *interface,
4319                                 GSupplicantScanParams *scan_data,
4320                                 GSupplicantInterfaceCallback callback,
4321                                                         void *user_data)
4322 {
4323         struct interface_scan_data *data;
4324         int ret;
4325
4326         ret = interface_ready_to_scan(interface);
4327         if (ret)
4328                 return ret;
4329
4330         data = dbus_malloc0(sizeof(*data));
4331         if (!data)
4332                 return -ENOMEM;
4333
4334         data->interface = interface;
4335         data->path = g_strdup(interface->path);
4336 #if defined TIZEN_EXT
4337         data->interface->scan_callback = data->callback = callback;
4338         data->interface->scan_data = data->user_data = user_data;
4339 #else
4340         data->callback = callback;
4341         data->user_data = user_data;
4342 #endif
4343         data->scan_params = scan_data;
4344
4345         interface->scan_callback = callback;
4346         interface->scan_data = user_data;
4347
4348         ret = supplicant_dbus_method_call(interface->path,
4349                         SUPPLICANT_INTERFACE ".Interface", "Scan",
4350                         interface_scan_params, interface_scan_result, data,
4351                         interface);
4352
4353         if (ret < 0) {
4354                 g_free(data->path);
4355                 dbus_free(data);
4356         }
4357
4358         return ret;
4359 }
4360
4361 static int parse_supplicant_error(DBusMessageIter *iter)
4362 {
4363         int err = -ECANCELED;
4364         char *key;
4365
4366         if (!iter)
4367                 return err;
4368
4369         /* If the given passphrase is malformed wpa_s returns
4370          * "invalid message format" but this error should be interpreted as
4371          * invalid-key.
4372          */
4373         while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
4374                 dbus_message_iter_get_basic(iter, &key);
4375                 if (strncmp(key, "psk", 3) == 0 ||
4376                                 strncmp(key, "wep_key", 7) == 0 ||
4377                                 strcmp(key, "invalid message format") == 0) {
4378                         err = -ENOKEY;
4379                         break;
4380                 }
4381                 dbus_message_iter_next(iter);
4382         }
4383
4384         return err;
4385 }
4386
4387 static void interface_select_network_result(const char *error,
4388                                 DBusMessageIter *iter, void *user_data)
4389 {
4390         struct interface_connect_data *data = user_data;
4391         int err;
4392
4393         SUPPLICANT_DBG("");
4394
4395         err = 0;
4396         if (error) {
4397 #if defined TIZEN_EXT
4398                 SUPPLICANT_DBG("SelectNetwork errorFreq %s", error);
4399 #else
4400                 SUPPLICANT_DBG("SelectNetwork error %s", error);
4401 #endif
4402                 err = parse_supplicant_error(iter);
4403         }
4404
4405         g_free(data->path);
4406
4407         if (data->callback)
4408                 data->callback(err, data->interface, data->user_data);
4409
4410         g_free(data->ssid);
4411         dbus_free(data);
4412 }
4413
4414 static void interface_select_network_params(DBusMessageIter *iter,
4415                                                         void *user_data)
4416 {
4417         struct interface_connect_data *data = user_data;
4418         GSupplicantInterface *interface = data->interface;
4419 #if defined TIZEN_EXT
4420         GSupplicantSSID *ssid = data->ssid;
4421 #endif
4422
4423         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
4424                                         &interface->network_path);
4425 #if defined TIZEN_EXT
4426         dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &ssid->freq);
4427 #endif
4428 }
4429
4430 static void interface_add_network_result(const char *error,
4431                                 DBusMessageIter *iter, void *user_data)
4432 {
4433         struct interface_connect_data *data = user_data;
4434         GSupplicantInterface *interface = data->interface;
4435         const char *path;
4436         int err;
4437
4438         if (error)
4439                 goto error;
4440
4441         dbus_message_iter_get_basic(iter, &path);
4442         if (!path)
4443                 goto error;
4444
4445         SUPPLICANT_DBG("PATH: %s", path);
4446
4447         g_free(interface->network_path);
4448         interface->network_path = g_strdup(path);
4449
4450 #if defined TIZEN_EXT
4451         SUPPLICANT_DBG(".Interface.SelectNetworkFreq");
4452 #endif
4453
4454 #if defined TIZEN_EXT
4455         supplicant_dbus_method_call(data->interface->path,
4456                         SUPPLICANT_INTERFACE ".Interface", "SelectNetworkFreq",
4457                         interface_select_network_params,
4458                         interface_select_network_result, data,
4459                         interface);
4460 #else
4461         supplicant_dbus_method_call(data->interface->path,
4462                         SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
4463                         interface_select_network_params,
4464                         interface_select_network_result, data,
4465                         interface);
4466 #endif
4467
4468         return;
4469
4470 error:
4471         SUPPLICANT_DBG("AddNetwork error %s", error);
4472
4473         if (interface_exists(data->interface, data->interface->path)) {
4474                 err = parse_supplicant_error(iter);
4475                 if (data->callback)
4476                         data->callback(err, data->interface, data->user_data);
4477
4478                 g_free(interface->network_path);
4479                 interface->network_path = NULL;
4480         }
4481
4482         g_free(data->path);
4483         g_free(data->ssid);
4484         g_free(data);
4485 }
4486
4487 static void add_network_security_none(DBusMessageIter *dict)
4488 {
4489         const char *auth_alg = "OPEN";
4490
4491         supplicant_dbus_dict_append_basic(dict, "auth_alg",
4492                                         DBUS_TYPE_STRING, &auth_alg);
4493 }
4494
4495 static void add_network_security_wep(DBusMessageIter *dict,
4496                                         GSupplicantSSID *ssid)
4497 {
4498         const char *auth_alg = "OPEN SHARED";
4499         dbus_uint32_t key_index = 0;
4500
4501         supplicant_dbus_dict_append_basic(dict, "auth_alg",
4502                                         DBUS_TYPE_STRING, &auth_alg);
4503
4504         if (ssid->passphrase) {
4505                 int size = strlen(ssid->passphrase);
4506                 if (size == 10 || size == 26) {
4507                         unsigned char *key = g_try_malloc(13);
4508                         char tmp[3];
4509                         int i;
4510
4511                         memset(tmp, 0, sizeof(tmp));
4512                         if (!key)
4513                                 size = 0;
4514
4515                         for (i = 0; i < size / 2; i++) {
4516                                 memcpy(tmp, ssid->passphrase + (i * 2), 2);
4517                                 key[i] = (unsigned char) strtol(tmp, NULL, 16);
4518                         }
4519
4520                         supplicant_dbus_dict_append_fixed_array(dict,
4521                                                         "wep_key0",
4522                                                         DBUS_TYPE_BYTE,
4523                                                         &key, size / 2);
4524                         g_free(key);
4525                 } else if (size == 5 || size == 13) {
4526                         unsigned char *key = g_try_malloc(13);
4527                         int i;
4528
4529                         if (!key)
4530                                 size = 0;
4531
4532                         for (i = 0; i < size; i++)
4533                                 key[i] = (unsigned char) ssid->passphrase[i];
4534
4535                         supplicant_dbus_dict_append_fixed_array(dict,
4536                                                                 "wep_key0",
4537                                                                 DBUS_TYPE_BYTE,
4538                                                                 &key, size);
4539                         g_free(key);
4540                 } else
4541                         supplicant_dbus_dict_append_basic(dict,
4542                                                         "wep_key0",
4543                                                         DBUS_TYPE_STRING,
4544                                                         &ssid->passphrase);
4545
4546                 supplicant_dbus_dict_append_basic(dict, "wep_tx_keyidx",
4547                                         DBUS_TYPE_UINT32, &key_index);
4548         }
4549 }
4550
4551 static dbus_bool_t is_psk_raw_key(const char *psk)
4552 {
4553         int i;
4554
4555         /* A raw key is always 64 bytes length... */
4556         if (strlen(psk) != 64)
4557                 return FALSE;
4558
4559         /* ... and its content is in hex representation */
4560         for (i = 0; i < 64; i++)
4561                 if (!isxdigit((unsigned char) psk[i]))
4562                         return FALSE;
4563
4564         return TRUE;
4565 }
4566
4567 static unsigned char hexchar2bin(char c)
4568 {
4569         if ((c >= '0') && (c <= '9'))
4570                 return c - '0';
4571         else if ((c >= 'A') && (c <= 'F'))
4572                 return c - 'A' + 10;
4573         else if ((c >= 'a') && (c <= 'f'))
4574                 return c - 'a' + 10;
4575         else
4576                 return c;
4577 }
4578
4579 static void hexstring2bin(const char *string, unsigned char *data,
4580                                 size_t data_len)
4581 {
4582         size_t i;
4583
4584         for (i = 0; i < data_len; i++)
4585                 data[i] = (hexchar2bin(string[i * 2 + 0]) << 4 |
4586                            hexchar2bin(string[i * 2 + 1]) << 0);
4587 }
4588
4589 static void add_network_security_psk(DBusMessageIter *dict,
4590                                         GSupplicantSSID *ssid)
4591 {
4592         if (ssid->passphrase && strlen(ssid->passphrase) > 0) {
4593                 const char *key = "psk";
4594
4595                 if (is_psk_raw_key(ssid->passphrase)) {
4596                         unsigned char data[32];
4597                         unsigned char *datap = data;
4598
4599                         /* The above pointer alias is required by D-Bus because
4600                          * with D-Bus and GCC, non-heap-allocated arrays cannot
4601                          * be passed directly by their base pointer. */
4602
4603                         hexstring2bin(ssid->passphrase, datap, sizeof(data));
4604
4605                         supplicant_dbus_dict_append_fixed_array(dict,
4606                                                         key, DBUS_TYPE_BYTE,
4607                                                         &datap, sizeof(data));
4608                 } else
4609                         supplicant_dbus_dict_append_basic(dict,
4610                                                         key, DBUS_TYPE_STRING,
4611                                                         &ssid->passphrase);
4612         }
4613 }
4614
4615 static void add_network_security_tls(DBusMessageIter *dict,
4616                                         GSupplicantSSID *ssid)
4617 {
4618         /*
4619          * For TLS, we at least need:
4620          *              The client certificate
4621          *              The client private key file
4622          *              The client private key file password
4623          *
4624          * The Authority certificate is optional.
4625          */
4626         if (!ssid->client_cert_path)
4627                 return;
4628
4629         if (!ssid->private_key_path)
4630                 return;
4631
4632 #if !defined TIZEN_EXT
4633         if (!ssid->private_key_passphrase)
4634                 return;
4635 #endif
4636
4637         if (ssid->ca_cert_path)
4638                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
4639                                         DBUS_TYPE_STRING, &ssid->ca_cert_path);
4640
4641         supplicant_dbus_dict_append_basic(dict, "private_key",
4642                                                 DBUS_TYPE_STRING,
4643                                                 &ssid->private_key_path);
4644 #if !defined TIZEN_EXT
4645         supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
4646                                                 DBUS_TYPE_STRING,
4647                                                 &ssid->private_key_passphrase);
4648 #endif
4649         supplicant_dbus_dict_append_basic(dict, "client_cert",
4650                                                 DBUS_TYPE_STRING,
4651                                                 &ssid->client_cert_path);
4652 }
4653
4654 static void add_network_security_peap(DBusMessageIter *dict,
4655                                         GSupplicantSSID *ssid)
4656 {
4657         char *phase2_auth;
4658
4659         /*
4660          * For PEAP/TTLS, we at least need
4661          *              The authority certificate
4662          *              The 2nd phase authentication method
4663          *              The 2nd phase passphrase
4664          *
4665          * The Client certificate is optional although strongly recommended
4666          * When setting it, we need in addition
4667          *              The Client private key file
4668          *              The Client private key file password
4669          */
4670         if (!ssid->passphrase)
4671                 return;
4672
4673         if (!ssid->phase2_auth)
4674                 return;
4675
4676         if (ssid->client_cert_path) {
4677                 if (!ssid->private_key_path)
4678                         return;
4679
4680 #if !defined TIZEN_EXT
4681                 if (!ssid->private_key_passphrase)
4682                         return;
4683 #endif
4684
4685                 supplicant_dbus_dict_append_basic(dict, "client_cert",
4686                                                 DBUS_TYPE_STRING,
4687                                                 &ssid->client_cert_path);
4688
4689                 supplicant_dbus_dict_append_basic(dict, "private_key",
4690                                                 DBUS_TYPE_STRING,
4691                                                 &ssid->private_key_path);
4692
4693 #if !defined TIZEN_EXT
4694                 supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
4695                                                 DBUS_TYPE_STRING,
4696                                                 &ssid->private_key_passphrase);
4697 #endif
4698
4699         }
4700
4701         if (g_str_has_prefix(ssid->phase2_auth, "EAP-")) {
4702                 phase2_auth = g_strdup_printf("autheap=%s",
4703                                         ssid->phase2_auth + strlen("EAP-"));
4704         } else
4705                 phase2_auth = g_strdup_printf("auth=%s", ssid->phase2_auth);
4706
4707         supplicant_dbus_dict_append_basic(dict, "password",
4708                                                 DBUS_TYPE_STRING,
4709                                                 &ssid->passphrase);
4710
4711         if (ssid->ca_cert_path)
4712                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
4713                                                 DBUS_TYPE_STRING,
4714                                                 &ssid->ca_cert_path);
4715
4716         supplicant_dbus_dict_append_basic(dict, "phase2",
4717                                                 DBUS_TYPE_STRING,
4718                                                 &phase2_auth);
4719
4720         g_free(phase2_auth);
4721 }
4722
4723 #if defined TIZEN_EXT
4724 static void add_network_security_aka_sim(DBusMessageIter *dict,
4725                                         GSupplicantSSID *ssid)
4726 {
4727         if (!ssid->passphrase)
4728                 return;
4729
4730         supplicant_dbus_dict_append_basic(dict, "password",
4731                         DBUS_TYPE_STRING,
4732                         &ssid->passphrase);
4733 }
4734 #endif
4735
4736 static void add_network_security_eap(DBusMessageIter *dict,
4737                                         GSupplicantSSID *ssid)
4738 {
4739         char *eap_value;
4740
4741 #if defined TIZEN_EXT
4742         if (!ssid->eap)
4743 #else
4744         if (!ssid->eap || !ssid->identity)
4745 #endif
4746                 return;
4747
4748         if (g_strcmp0(ssid->eap, "tls") == 0) {
4749                 add_network_security_tls(dict, ssid);
4750         } else if (g_strcmp0(ssid->eap, "peap") == 0 ||
4751                                 g_strcmp0(ssid->eap, "ttls") == 0) {
4752 #if defined TIZEN_EXT
4753                 if (!ssid->identity)
4754                         return;
4755 #endif
4756                 add_network_security_peap(dict, ssid);
4757
4758 #if defined TIZEN_EXT
4759         } else if (g_strcmp0(ssid->eap, "sim") == 0 ||
4760                         g_strcmp0(ssid->eap, "aka") == 0) {
4761                 add_network_security_aka_sim(dict, ssid);
4762 #endif
4763         } else
4764                 return;
4765
4766         eap_value = g_ascii_strup(ssid->eap, -1);
4767
4768         supplicant_dbus_dict_append_basic(dict, "eap",
4769                                                 DBUS_TYPE_STRING,
4770                                                 &eap_value);
4771 #if defined TIZEN_EXT
4772         if (ssid->identity != NULL)
4773                 supplicant_dbus_dict_append_basic(dict, "identity",
4774                                                         DBUS_TYPE_STRING,
4775                                                         &ssid->identity);
4776 #else
4777         supplicant_dbus_dict_append_basic(dict, "identity",
4778                                                 DBUS_TYPE_STRING,
4779                                                 &ssid->identity);
4780 #endif
4781
4782         g_free(eap_value);
4783 }
4784
4785 static void add_network_security_ciphers(DBusMessageIter *dict,
4786                                                 GSupplicantSSID *ssid)
4787 {
4788         unsigned int p_cipher, g_cipher, i;
4789         char *pairwise, *group;
4790         char *pair_ciphers[4];
4791         char *group_ciphers[5];
4792
4793         p_cipher = ssid->pairwise_cipher;
4794         g_cipher = ssid->group_cipher;
4795
4796         if (p_cipher == 0 && g_cipher == 0)
4797                 return;
4798
4799         i = 0;
4800
4801         if (p_cipher & G_SUPPLICANT_PAIRWISE_CCMP)
4802                 pair_ciphers[i++] = "CCMP";
4803
4804         if (p_cipher & G_SUPPLICANT_PAIRWISE_TKIP)
4805                 pair_ciphers[i++] = "TKIP";
4806
4807         if (p_cipher & G_SUPPLICANT_PAIRWISE_NONE)
4808                 pair_ciphers[i++] = "NONE";
4809
4810         pair_ciphers[i] = NULL;
4811
4812         i = 0;
4813
4814         if (g_cipher & G_SUPPLICANT_GROUP_CCMP)
4815                 group_ciphers[i++] = "CCMP";
4816
4817         if (g_cipher & G_SUPPLICANT_GROUP_TKIP)
4818                 group_ciphers[i++] = "TKIP";
4819
4820         if (g_cipher & G_SUPPLICANT_GROUP_WEP104)
4821                 group_ciphers[i++] = "WEP104";
4822
4823         if (g_cipher & G_SUPPLICANT_GROUP_WEP40)
4824                 group_ciphers[i++] = "WEP40";
4825
4826         group_ciphers[i] = NULL;
4827
4828         pairwise = g_strjoinv(" ", pair_ciphers);
4829         group = g_strjoinv(" ", group_ciphers);
4830
4831         SUPPLICANT_DBG("cipher %s %s", pairwise, group);
4832
4833         supplicant_dbus_dict_append_basic(dict, "pairwise",
4834                                                 DBUS_TYPE_STRING,
4835                                                 &pairwise);
4836         supplicant_dbus_dict_append_basic(dict, "group",
4837                                                 DBUS_TYPE_STRING,
4838                                                 &group);
4839
4840         g_free(pairwise);
4841         g_free(group);
4842 }
4843
4844 static void add_network_security_proto(DBusMessageIter *dict,
4845                                                 GSupplicantSSID *ssid)
4846 {
4847         unsigned int protocol, i;
4848         char *proto;
4849         char *protos[3];
4850
4851         protocol = ssid->protocol;
4852
4853         if (protocol == 0)
4854                 return;
4855
4856         i = 0;
4857
4858         if (protocol & G_SUPPLICANT_PROTO_RSN)
4859                 protos[i++] = "RSN";
4860
4861         if (protocol & G_SUPPLICANT_PROTO_WPA)
4862                 protos[i++] = "WPA";
4863
4864         protos[i] = NULL;
4865
4866         proto = g_strjoinv(" ", protos);
4867
4868         SUPPLICANT_DBG("proto %s", proto);
4869
4870         supplicant_dbus_dict_append_basic(dict, "proto",
4871                                                 DBUS_TYPE_STRING,
4872                                                 &proto);
4873
4874         g_free(proto);
4875 }
4876
4877 static void add_network_security(DBusMessageIter *dict, GSupplicantSSID *ssid)
4878 {
4879         char *key_mgmt;
4880
4881         switch (ssid->security) {
4882         case G_SUPPLICANT_SECURITY_NONE:
4883                 key_mgmt = "NONE";
4884                 add_network_security_none(dict);
4885                 add_network_security_ciphers(dict, ssid);
4886                 break;
4887         case G_SUPPLICANT_SECURITY_UNKNOWN:
4888         case G_SUPPLICANT_SECURITY_WEP:
4889                 key_mgmt = "NONE";
4890                 add_network_security_wep(dict, ssid);
4891                 add_network_security_ciphers(dict, ssid);
4892                 break;
4893         case G_SUPPLICANT_SECURITY_PSK:
4894                 key_mgmt = "WPA-PSK";
4895                 add_network_security_psk(dict, ssid);
4896                 add_network_security_ciphers(dict, ssid);
4897                 add_network_security_proto(dict, ssid);
4898                 break;
4899         case G_SUPPLICANT_SECURITY_IEEE8021X:
4900                 key_mgmt = "WPA-EAP";
4901                 add_network_security_eap(dict, ssid);
4902                 add_network_security_ciphers(dict, ssid);
4903                 add_network_security_proto(dict, ssid);
4904                 break;
4905 #if defined TIZEN_EXT
4906         case G_SUPPLICANT_SECURITY_FT_PSK:
4907                 key_mgmt = "FT-PSK";
4908                 add_network_security_psk(dict, ssid);
4909                 add_network_security_ciphers(dict, ssid);
4910                 add_network_security_proto(dict, ssid);
4911                 break;
4912         case G_SUPPLICANT_SECURITY_FT_IEEE8021X:
4913                 key_mgmt = "FT-EAP";
4914                 add_network_security_eap(dict, ssid);
4915                 add_network_security_ciphers(dict, ssid);
4916                 add_network_security_proto(dict, ssid);
4917                 break;
4918 #endif
4919         }
4920
4921         supplicant_dbus_dict_append_basic(dict, "key_mgmt",
4922                                 DBUS_TYPE_STRING, &key_mgmt);
4923 }
4924
4925 static void add_network_mode(DBusMessageIter *dict, GSupplicantSSID *ssid)
4926 {
4927         dbus_uint32_t mode;
4928
4929         switch (ssid->mode) {
4930         case G_SUPPLICANT_MODE_UNKNOWN:
4931         case G_SUPPLICANT_MODE_INFRA:
4932                 mode = 0;
4933                 break;
4934         case G_SUPPLICANT_MODE_IBSS:
4935                 mode = 1;
4936                 break;
4937         case G_SUPPLICANT_MODE_MASTER:
4938                 mode = 2;
4939                 break;
4940         }
4941
4942         supplicant_dbus_dict_append_basic(dict, "mode",
4943                                 DBUS_TYPE_UINT32, &mode);
4944 }
4945
4946 static void interface_add_network_params(DBusMessageIter *iter, void *user_data)
4947 {
4948         DBusMessageIter dict;
4949         struct interface_connect_data *data = user_data;
4950         GSupplicantSSID *ssid = data->ssid;
4951
4952         supplicant_dbus_dict_open(iter, &dict);
4953
4954         if (ssid->scan_ssid)
4955                 supplicant_dbus_dict_append_basic(&dict, "scan_ssid",
4956                                          DBUS_TYPE_UINT32, &ssid->scan_ssid);
4957
4958         if (ssid->freq)
4959                 supplicant_dbus_dict_append_basic(&dict, "frequency",
4960                                          DBUS_TYPE_UINT32, &ssid->freq);
4961
4962         if (ssid->bgscan)
4963                 supplicant_dbus_dict_append_basic(&dict, "bgscan",
4964                                         DBUS_TYPE_STRING, &ssid->bgscan);
4965
4966         add_network_mode(&dict, ssid);
4967
4968         add_network_security(&dict, ssid);
4969
4970         supplicant_dbus_dict_append_fixed_array(&dict, "ssid",
4971                                         DBUS_TYPE_BYTE, &ssid->ssid,
4972                                                 ssid->ssid_len);
4973
4974         supplicant_dbus_dict_append_basic(&dict, "ignore_broadcast_ssid",
4975                                         DBUS_TYPE_INT32,
4976                                         &ssid->ignore_broadcast_ssid);
4977
4978 #if defined TIZEN_EXT
4979         if (ssid->bssid) {
4980                 char *bssid = NULL;
4981                 bssid = g_try_malloc0(18);
4982                 snprintf(bssid, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
4983                                         ssid->bssid[0], ssid->bssid[1], ssid->bssid[2],
4984                                         ssid->bssid[3], ssid->bssid[4], ssid->bssid[5]);
4985                 supplicant_dbus_dict_append_basic(&dict, "bssid",
4986                                         DBUS_TYPE_STRING, &bssid);
4987                 g_free(bssid);
4988         }
4989 #endif
4990
4991         supplicant_dbus_dict_close(iter, &dict);
4992 }
4993
4994 static void interface_wps_start_result(const char *error,
4995                                 DBusMessageIter *iter, void *user_data)
4996 {
4997         struct interface_connect_data *data = user_data;
4998         int err;
4999
5000         SUPPLICANT_DBG("");
5001
5002         err = 0;
5003         if (error) {
5004                 SUPPLICANT_DBG("error: %s", error);
5005                 err = parse_supplicant_error(iter);
5006         }
5007
5008         if(data->callback)
5009                 data->callback(err, data->interface, data->user_data);
5010
5011         g_free(data->path);
5012         g_free(data->ssid);
5013         dbus_free(data);
5014 }
5015
5016 static void interface_add_wps_params(DBusMessageIter *iter, void *user_data)
5017 {
5018         struct interface_connect_data *data = user_data;
5019         GSupplicantSSID *ssid = data->ssid;
5020         const char *role = "enrollee", *type;
5021         DBusMessageIter dict;
5022
5023         SUPPLICANT_DBG("");
5024
5025         supplicant_dbus_dict_open(iter, &dict);
5026
5027         supplicant_dbus_dict_append_basic(&dict, "Role",
5028                                                 DBUS_TYPE_STRING, &role);
5029
5030         type = "pbc";
5031         if (ssid->pin_wps) {
5032                 type = "pin";
5033                 supplicant_dbus_dict_append_basic(&dict, "Pin",
5034                                         DBUS_TYPE_STRING, &ssid->pin_wps);
5035         }
5036
5037         supplicant_dbus_dict_append_basic(&dict, "Type",
5038                                         DBUS_TYPE_STRING, &type);
5039
5040 #if defined TIZEN_EXT
5041         if (ssid->bssid)
5042                 supplicant_dbus_dict_append_fixed_array(&dict, "Bssid",
5043                                                 DBUS_TYPE_BYTE, &ssid->bssid, 6);
5044 #endif
5045
5046         supplicant_dbus_dict_close(iter, &dict);
5047 }
5048
5049 static void wps_start(const char *error, DBusMessageIter *iter, void *user_data)
5050 {
5051         struct interface_connect_data *data = user_data;
5052
5053         SUPPLICANT_DBG("");
5054
5055         if (error) {
5056                 SUPPLICANT_DBG("error: %s", error);
5057                 g_free(data->path);
5058                 g_free(data->ssid);
5059                 dbus_free(data);
5060                 return;
5061         }
5062 #if defined TIZEN_EXT
5063         GSupplicantSSID *ssid = data->ssid;
5064         if (ssid->pin_wps != NULL) {
5065                 if (!g_utf8_validate(ssid->pin_wps, 8, NULL)) {
5066                         SUPPLICANT_DBG("Invalid characters in WPS_PIN");
5067                         g_free(data->ssid);
5068                         dbus_free(data);
5069                         return;
5070                 }
5071         }
5072 #endif
5073         supplicant_dbus_method_call(data->interface->path,
5074                         SUPPLICANT_INTERFACE ".Interface.WPS", "Start",
5075                         interface_add_wps_params,
5076                         interface_wps_start_result, data, NULL);
5077 }
5078
5079 static void wps_process_credentials(DBusMessageIter *iter, void *user_data)
5080 {
5081         dbus_bool_t credentials = TRUE;
5082
5083         SUPPLICANT_DBG("");
5084
5085         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &credentials);
5086 }
5087
5088
5089 int g_supplicant_interface_connect(GSupplicantInterface *interface,
5090                                 GSupplicantSSID *ssid,
5091                                 GSupplicantInterfaceCallback callback,
5092                                                         void *user_data)
5093 {
5094         struct interface_connect_data *data;
5095         int ret;
5096
5097         if (!interface)
5098                 return -EINVAL;
5099
5100         if (!system_available)
5101                 return -EFAULT;
5102
5103         /* TODO: Check if we're already connected and switch */
5104
5105         data = dbus_malloc0(sizeof(*data));
5106         if (!data)
5107                 return -ENOMEM;
5108
5109         data->interface = interface;
5110         data->path = g_strdup(interface->path);
5111         data->callback = callback;
5112         data->ssid = ssid;
5113         data->user_data = user_data;
5114
5115         if (ssid->use_wps) {
5116                 g_free(interface->wps_cred.key);
5117                 memset(&interface->wps_cred, 0,
5118                                 sizeof(struct _GSupplicantWpsCredentials));
5119
5120                 ret = supplicant_dbus_property_set(interface->path,
5121                         SUPPLICANT_INTERFACE ".Interface.WPS",
5122                         "ProcessCredentials", DBUS_TYPE_BOOLEAN_AS_STRING,
5123                         wps_process_credentials, wps_start, data, interface);
5124         } else
5125                 ret = supplicant_dbus_method_call(interface->path,
5126                         SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
5127                         interface_add_network_params,
5128                         interface_add_network_result, data,
5129                         interface);
5130
5131         if (ret < 0) {
5132                 g_free(data->path);
5133                 dbus_free(data);
5134                 return ret;
5135         }
5136
5137         return -EINPROGRESS;
5138 }
5139
5140 static void network_remove_result(const char *error,
5141                                 DBusMessageIter *iter, void *user_data)
5142 {
5143         struct interface_data *data = user_data;
5144         int result = 0;
5145
5146         SUPPLICANT_DBG("");
5147
5148         if (error) {
5149                 result = -EIO;
5150                 if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
5151                                                 error) == 0)
5152                         result = -ECONNABORTED;
5153         }
5154
5155         g_free(data->path);
5156
5157         if (data->callback)
5158                 data->callback(result, data->interface, data->user_data);
5159
5160         dbus_free(data);
5161 }
5162
5163 static void network_remove_params(DBusMessageIter *iter, void *user_data)
5164 {
5165         struct interface_data *data = user_data;
5166         const char *path = data->interface->network_path;
5167
5168         SUPPLICANT_DBG("path %s", path);
5169
5170         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
5171 }
5172
5173 static int network_remove(struct interface_data *data)
5174 {
5175         GSupplicantInterface *interface = data->interface;
5176
5177         SUPPLICANT_DBG("");
5178
5179 #if defined TIZEN_EXT
5180         GSupplicantInterface *intf = NULL;
5181         /*
5182          * Check if 'interface' is valid
5183          */
5184         intf = g_hash_table_lookup(interface_table, interface->path);
5185         if (intf == NULL)
5186                 return -EINVAL;
5187 #endif
5188
5189         return supplicant_dbus_method_call(interface->path,
5190                         SUPPLICANT_INTERFACE ".Interface", "RemoveNetwork",
5191                         network_remove_params, network_remove_result, data,
5192                         interface);
5193 }
5194
5195 static void interface_disconnect_result(const char *error,
5196                                 DBusMessageIter *iter, void *user_data)
5197 {
5198         struct interface_data *data = user_data;
5199         int result = 0;
5200
5201         SUPPLICANT_DBG("");
5202
5203         if (error) {
5204                 result = -EIO;
5205                 if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
5206                                                 error) == 0)
5207                         result = -ECONNABORTED;
5208         }
5209
5210         if (result < 0 && data->callback) {
5211                 data->callback(result, data->interface, data->user_data);
5212                 data->callback = NULL;
5213         }
5214
5215         /* If we are disconnecting from previous WPS successful
5216          * association. i.e.: it did not went through AddNetwork,
5217          * and interface->network_path was never set. */
5218         if (!data->interface->network_path) {
5219                 g_free(data->path);
5220                 dbus_free(data);
5221                 return;
5222         }
5223
5224         if (result != -ECONNABORTED) {
5225                 if (network_remove(data) < 0) {
5226                         g_free(data->path);
5227                         dbus_free(data);
5228                 }
5229         } else {
5230                 g_free(data->path);
5231                 dbus_free(data);
5232         }
5233 }
5234
5235 int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
5236                                         GSupplicantInterfaceCallback callback,
5237                                                         void *user_data)
5238 {
5239         struct interface_data *data;
5240         int ret;
5241
5242         SUPPLICANT_DBG("");
5243
5244         if (!interface)
5245                 return -EINVAL;
5246
5247         if (!system_available)
5248                 return -EFAULT;
5249
5250         data = dbus_malloc0(sizeof(*data));
5251         if (!data)
5252                 return -ENOMEM;
5253
5254         data->interface = interface;
5255         data->path = g_strdup(interface->path);
5256         data->callback = callback;
5257         data->user_data = user_data;
5258
5259         ret = supplicant_dbus_method_call(interface->path,
5260                         SUPPLICANT_INTERFACE ".Interface", "Disconnect",
5261                         NULL, interface_disconnect_result, data,
5262                         interface);
5263
5264         if (ret < 0) {
5265                 g_free(data->path);
5266                 dbus_free(data);
5267         }
5268
5269         return ret;
5270 }
5271
5272 static void interface_p2p_find_result(const char *error,
5273                                         DBusMessageIter *iter, void *user_data)
5274 {
5275         struct interface_scan_data *data = user_data;
5276         int err = 0;
5277
5278         SUPPLICANT_DBG("error %s", error);
5279
5280         if (error)
5281                 err = -EIO;
5282
5283         if (interface_exists(data->interface, data->path)) {
5284                 if (!data->interface->ready)
5285                         err = -ENOLINK;
5286                 if (!err)
5287                         data->interface->p2p_finding = true;
5288         }
5289
5290         if (data->callback)
5291                 data->callback(err, data->interface, data->user_data);
5292
5293         g_free(data->path);
5294         dbus_free(data);
5295 }
5296
5297 static void interface_p2p_find_params(DBusMessageIter *iter, void *user_data)
5298 {
5299         DBusMessageIter dict;
5300
5301         supplicant_dbus_dict_open(iter, &dict);
5302         supplicant_dbus_dict_close(iter, &dict);
5303 }
5304
5305 int g_supplicant_interface_p2p_find(GSupplicantInterface *interface,
5306                                         GSupplicantInterfaceCallback callback,
5307                                                         void *user_data)
5308 {
5309         struct interface_scan_data *data;
5310         int ret;
5311
5312         if (!interface->p2p_support)
5313                 return -ENOTSUP;
5314
5315         ret = interface_ready_to_scan(interface);
5316         if (ret && ret != -EALREADY)
5317                 return ret;
5318
5319         data = dbus_malloc0(sizeof(*data));
5320         if (!data)
5321                 return -ENOMEM;
5322
5323         data->interface = interface;
5324         data->path = g_strdup(interface->path);
5325         data->callback = callback;
5326         data->user_data = user_data;
5327
5328         ret = supplicant_dbus_method_call(interface->path,
5329                         SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Find",
5330                         interface_p2p_find_params, interface_p2p_find_result,
5331                         data, interface);
5332         if (ret < 0) {
5333                 g_free(data->path);
5334                 dbus_free(data);
5335         }
5336
5337         return ret;
5338 }
5339
5340 bool g_supplicant_interface_is_p2p_finding(GSupplicantInterface *interface)
5341 {
5342         if (!interface)
5343                 return false;
5344
5345         return interface->p2p_finding;
5346 }
5347
5348 int g_supplicant_interface_p2p_stop_find(GSupplicantInterface *interface)
5349 {
5350         if (!interface->p2p_finding)
5351                 return 0;
5352
5353         SUPPLICANT_DBG("");
5354
5355         interface->p2p_finding = false;
5356
5357         return supplicant_dbus_method_call(interface->path,
5358                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "StopFind",
5359                 NULL, NULL, NULL, NULL);
5360 }
5361
5362 static void interface_p2p_connect_result(const char *error,
5363                                         DBusMessageIter *iter, void *user_data)
5364 {
5365         struct interface_connect_data *data = user_data;
5366         int err = 0;
5367
5368         SUPPLICANT_DBG("");
5369
5370         if (error)
5371                 err = parse_supplicant_error(iter);
5372
5373         if (data->callback)
5374                 data->callback(err, data->interface, data->user_data);
5375
5376         g_free(data->path);
5377         g_free(data->peer->wps_pin);
5378         g_free(data->peer->path);
5379         g_free(data->peer);
5380         g_free(data);
5381 }
5382
5383 static void interface_p2p_connect_params(DBusMessageIter *iter, void *user_data)
5384 {
5385         struct interface_connect_data *data = user_data;
5386         const char *wps = "pbc";
5387         DBusMessageIter dict;
5388         int go_intent = 7;
5389
5390         SUPPLICANT_DBG("");
5391
5392         supplicant_dbus_dict_open(iter, &dict);
5393
5394         if (data->peer->master)
5395                 go_intent = 15;
5396
5397         if (data->peer->wps_pin)
5398                 wps = "pin";
5399
5400         supplicant_dbus_dict_append_basic(&dict, "peer",
5401                                 DBUS_TYPE_OBJECT_PATH, &data->peer->path);
5402         supplicant_dbus_dict_append_basic(&dict, "wps_method",
5403                                 DBUS_TYPE_STRING, &wps);
5404         if (data->peer->wps_pin) {
5405                 supplicant_dbus_dict_append_basic(&dict, "pin",
5406                                 DBUS_TYPE_STRING, &data->peer->wps_pin);
5407         }
5408
5409         supplicant_dbus_dict_append_basic(&dict, "go_intent",
5410                                         DBUS_TYPE_INT32, &go_intent);
5411
5412         supplicant_dbus_dict_close(iter, &dict);
5413 }
5414
5415 int g_supplicant_interface_p2p_connect(GSupplicantInterface *interface,
5416                                         GSupplicantPeerParams *peer_params,
5417                                         GSupplicantInterfaceCallback callback,
5418                                         void *user_data)
5419 {
5420         struct interface_connect_data *data;
5421         int ret;
5422
5423         SUPPLICANT_DBG("");
5424
5425         if (!interface->p2p_support)
5426                 return -ENOTSUP;
5427
5428         data = dbus_malloc0(sizeof(*data));
5429         data->interface = interface;
5430         data->path = g_strdup(interface->path);
5431         data->peer = peer_params;
5432         data->callback = callback;
5433         data->user_data = user_data;
5434
5435         ret = supplicant_dbus_method_call(interface->path,
5436                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Connect",
5437                 interface_p2p_connect_params, interface_p2p_connect_result,
5438                 data, interface);
5439         if (ret < 0) {
5440                 g_free(data->path);
5441                 dbus_free(data);
5442                 return ret;
5443         }
5444
5445         return -EINPROGRESS;
5446 }
5447
5448 int g_supplicant_interface_p2p_disconnect(GSupplicantInterface *interface,
5449                                         GSupplicantPeerParams *peer_params)
5450 {
5451         GSupplicantPeer *peer;
5452         int count = 0;
5453         GSList *list;
5454
5455         SUPPLICANT_DBG("");
5456
5457         if (!interface->p2p_support)
5458                 return -ENOTSUP;
5459
5460         peer = g_hash_table_lookup(interface->peer_table, peer_params->path);
5461         if (!peer)
5462                 return -ENODEV;
5463
5464         for (list = peer->groups; list; list = list->next, count++) {
5465                 const char *group_obj_path = list->data;
5466                 GSupplicantInterface *g_interface;
5467                 GSupplicantGroup *group;
5468
5469                 group = g_hash_table_lookup(group_mapping, group_obj_path);
5470                 if (!group || !group->interface)
5471                         continue;
5472
5473                 g_interface = group->interface;
5474                 supplicant_dbus_method_call(g_interface->path,
5475                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
5476                                 "Disconnect", NULL, NULL, NULL, g_interface);
5477         }
5478
5479         if (count == 0 && peer->current_group_iface) {
5480                 supplicant_dbus_method_call(peer->current_group_iface->path,
5481                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
5482                                 "Disconnect", NULL, NULL, NULL,
5483                                 peer->current_group_iface->path);
5484         }
5485
5486         peer->current_group_iface = NULL;
5487
5488         return -EINPROGRESS;
5489 }
5490
5491 struct p2p_service_data {
5492         bool registration;
5493         GSupplicantInterface *interface;
5494         GSupplicantP2PServiceParams *service;
5495         GSupplicantInterfaceCallback callback;
5496         void *user_data;
5497 };
5498
5499 static void interface_p2p_service_result(const char *error,
5500                                         DBusMessageIter *iter, void *user_data)
5501 {
5502         struct p2p_service_data *data = user_data;
5503         int result = 0;
5504
5505         SUPPLICANT_DBG("%s result - %s", data->registration ?
5506                                 "Registration" : "Deletion",
5507                                 error ? error : "Success");
5508         if (error)
5509                 result = -EINVAL;
5510
5511         if (data->callback)
5512                 data->callback(result, data->interface, data->user_data);
5513
5514         g_free(data->service->query);
5515         g_free(data->service->response);
5516         g_free(data->service->service);
5517         g_free(data->service->wfd_ies);
5518         g_free(data->service);
5519         dbus_free(data);
5520 }
5521
5522 static void interface_p2p_service_params(DBusMessageIter *iter,
5523                                                         void *user_data)
5524 {
5525         struct p2p_service_data *data = user_data;
5526         GSupplicantP2PServiceParams *service;
5527         DBusMessageIter dict;
5528         const char *type;
5529
5530         SUPPLICANT_DBG("");
5531
5532         service = data->service;
5533
5534         supplicant_dbus_dict_open(iter, &dict);
5535
5536         if (service->query && service->response) {
5537                 type = "bonjour";
5538                 supplicant_dbus_dict_append_basic(&dict, "service_type",
5539                                                 DBUS_TYPE_STRING, &type);
5540                 supplicant_dbus_dict_append_fixed_array(&dict, "query",
5541                                         DBUS_TYPE_BYTE, &service->query,
5542                                         service->query_length);
5543                 supplicant_dbus_dict_append_fixed_array(&dict, "response",
5544                                         DBUS_TYPE_BYTE, &service->response,
5545                                         service->response_length);
5546         } else if (service->version && service->service) {
5547                 type = "upnp";
5548                 supplicant_dbus_dict_append_basic(&dict, "service_type",
5549                                                 DBUS_TYPE_STRING, &type);
5550                 supplicant_dbus_dict_append_basic(&dict, "version",
5551                                         DBUS_TYPE_INT32, &service->version);
5552                 supplicant_dbus_dict_append_basic(&dict, "service",
5553                                         DBUS_TYPE_STRING, &service->service);
5554         }
5555
5556         supplicant_dbus_dict_close(iter, &dict);
5557 }
5558
5559 int g_supplicant_interface_p2p_add_service(GSupplicantInterface *interface,
5560                                 GSupplicantInterfaceCallback callback,
5561                                 GSupplicantP2PServiceParams *p2p_service_params,
5562                                 void *user_data)
5563 {
5564         struct p2p_service_data *data;
5565         int ret;
5566
5567         SUPPLICANT_DBG("");
5568
5569         if (!interface->p2p_support)
5570                 return -ENOTSUP;
5571
5572         data = dbus_malloc0(sizeof(*data));
5573         data->registration = true;
5574         data->interface = interface;
5575         data->service = p2p_service_params;
5576         data->callback = callback;
5577         data->user_data = user_data;
5578
5579         ret = supplicant_dbus_method_call(interface->path,
5580                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "AddService",
5581                 interface_p2p_service_params, interface_p2p_service_result,
5582                 data, interface);
5583         if (ret < 0) {
5584                 dbus_free(data);
5585                 return ret;
5586         }
5587
5588         return -EINPROGRESS;
5589 }
5590
5591 int g_supplicant_interface_p2p_del_service(GSupplicantInterface *interface,
5592                                 GSupplicantP2PServiceParams *p2p_service_params)
5593 {
5594         struct p2p_service_data *data;
5595         int ret;
5596
5597         SUPPLICANT_DBG("");
5598
5599         if (!interface->p2p_support)
5600                 return -ENOTSUP;
5601
5602         data = dbus_malloc0(sizeof(*data));
5603         data->interface = interface;
5604         data->service = p2p_service_params;
5605
5606         ret = supplicant_dbus_method_call(interface->path,
5607                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeleteService",
5608                 interface_p2p_service_params, interface_p2p_service_result,
5609                 data, interface);
5610         if (ret < 0) {
5611                 dbus_free(data);
5612                 return ret;
5613         }
5614
5615         return -EINPROGRESS;
5616 }
5617
5618 struct p2p_listen_data {
5619         int period;
5620         int interval;
5621 };
5622
5623 static void interface_p2p_listen_params(DBusMessageIter *iter, void *user_data)
5624 {
5625         struct p2p_listen_data *params = user_data;
5626         DBusMessageIter dict;
5627
5628         supplicant_dbus_dict_open(iter, &dict);
5629
5630         supplicant_dbus_dict_append_basic(&dict, "period",
5631                                         DBUS_TYPE_INT32, &params->period);
5632         supplicant_dbus_dict_append_basic(&dict, "interval",
5633                                         DBUS_TYPE_INT32, &params->interval);
5634         supplicant_dbus_dict_close(iter, &dict);
5635 }
5636
5637 int g_supplicant_interface_p2p_listen(GSupplicantInterface *interface,
5638                                                 int period, int interval)
5639 {
5640         struct p2p_listen_data params;
5641
5642         SUPPLICANT_DBG("");
5643
5644         if (!interface->p2p_support)
5645                 return -ENOTSUP;
5646
5647         params.period = period;
5648         params.interval = interval;
5649
5650         return supplicant_dbus_method_call(interface->path,
5651                         SUPPLICANT_INTERFACE ".Interface.P2PDevice",
5652                         "ExtendedListen", interface_p2p_listen_params,
5653                         NULL, &params, NULL);
5654 }
5655
5656 static void widi_ies_params(DBusMessageIter *iter, void *user_data)
5657 {
5658         struct p2p_service_data *data = user_data;
5659         GSupplicantP2PServiceParams *service = data->service;
5660         DBusMessageIter array;
5661
5662         SUPPLICANT_DBG("%p - %d", service->wfd_ies, service->wfd_ies_length);
5663
5664         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
5665                                         DBUS_TYPE_BYTE_AS_STRING, &array);
5666
5667         if (service->wfd_ies && service->wfd_ies_length > 0) {
5668                 dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
5669                                 &service->wfd_ies, service->wfd_ies_length);
5670         }
5671
5672         dbus_message_iter_close_container(iter, &array);
5673 }
5674
5675 int g_supplicant_set_widi_ies(GSupplicantP2PServiceParams *p2p_service_params,
5676                                         GSupplicantInterfaceCallback callback,
5677                                         void *user_data)
5678 {
5679         struct p2p_service_data *data;
5680         int ret;
5681
5682         SUPPLICANT_DBG("");
5683
5684         if (!system_available)
5685                 return -EFAULT;
5686
5687         data = dbus_malloc0(sizeof(*data));
5688         data->service = p2p_service_params;
5689         data->callback = callback;
5690         data->user_data = user_data;
5691
5692         if (p2p_service_params->wfd_ies)
5693                 data->registration = true;
5694
5695         ret = supplicant_dbus_property_set(SUPPLICANT_PATH,
5696                                         SUPPLICANT_INTERFACE, "WFDIEs",
5697                                         DBUS_TYPE_ARRAY_AS_STRING
5698                                         DBUS_TYPE_BYTE_AS_STRING,
5699                                         widi_ies_params,
5700                                         interface_p2p_service_result,
5701                                         data, NULL);
5702         if (ret < 0 && ret != -EINPROGRESS) {
5703                 dbus_free(data);
5704                 return ret;
5705         }
5706
5707         return -EINPROGRESS;
5708 }
5709
5710 #if defined TIZEN_EXT
5711 int g_supplicant_interface_remove_network(GSupplicantInterface *interface)
5712 {
5713         struct interface_data *data;
5714
5715         SUPPLICANT_DBG("");
5716
5717         if (interface == NULL)
5718                 return -EINVAL;
5719
5720         if (system_available == FALSE)
5721                 return -EFAULT;
5722
5723         data = dbus_malloc0(sizeof(*data));
5724         if (data == NULL)
5725                 return -ENOMEM;
5726
5727         data->interface = interface;
5728
5729         return network_remove(data);
5730 }
5731 #endif
5732
5733 static const char *g_supplicant_rule0 = "type=signal,"
5734                                         "path=" DBUS_PATH_DBUS ","
5735                                         "sender=" DBUS_SERVICE_DBUS ","
5736                                         "interface=" DBUS_INTERFACE_DBUS ","
5737                                         "member=NameOwnerChanged,"
5738                                         "arg0=" SUPPLICANT_SERVICE;
5739 static const char *g_supplicant_rule1 = "type=signal,"
5740                         "interface=" SUPPLICANT_INTERFACE;
5741 static const char *g_supplicant_rule2 = "type=signal,"
5742                         "interface=" SUPPLICANT_INTERFACE ".Interface";
5743 static const char *g_supplicant_rule3 = "type=signal,"
5744                         "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
5745 static const char *g_supplicant_rule4 = "type=signal,"
5746                         "interface=" SUPPLICANT_INTERFACE ".BSS";
5747 static const char *g_supplicant_rule5 = "type=signal,"
5748                         "interface=" SUPPLICANT_INTERFACE ".Network";
5749 #if !defined TIZEN_EXT
5750 static const char *g_supplicant_rule6 = "type=signal,"
5751                 "interface=" SUPPLICANT_INTERFACE ".Interface.P2PDevice";
5752 static const char *g_supplicant_rule7 = "type=signal,"
5753                 "interface=" SUPPLICANT_INTERFACE ".Peer";
5754 static const char *g_supplicant_rule8 = "type=signal,"
5755                 "interface=" SUPPLICANT_INTERFACE ".Group";
5756 #endif
5757
5758 static void invoke_introspect_method(void)
5759 {
5760         DBusMessage *message;
5761
5762         message = dbus_message_new_method_call(SUPPLICANT_SERVICE,
5763                                         SUPPLICANT_PATH,
5764                                         DBUS_INTERFACE_INTROSPECTABLE,
5765                                         "Introspect");
5766
5767         if (!message)
5768                 return;
5769
5770         dbus_message_set_no_reply(message, TRUE);
5771         dbus_connection_send(connection, message, NULL);
5772         dbus_message_unref(message);
5773 }
5774
5775 int g_supplicant_register(const GSupplicantCallbacks *callbacks)
5776 {
5777         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
5778         if (!connection)
5779                 return -EIO;
5780
5781         if (!dbus_connection_add_filter(connection, g_supplicant_filter,
5782                                                 NULL, NULL)) {
5783                 dbus_connection_unref(connection);
5784                 connection = NULL;
5785                 return -EIO;
5786         }
5787
5788         callbacks_pointer = callbacks;
5789         eap_methods = 0;
5790
5791         interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
5792                                                 NULL, remove_interface);
5793
5794         bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
5795                                                                 NULL, NULL);
5796         peer_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
5797                                                                 NULL, NULL);
5798         group_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
5799                                                                 NULL, NULL);
5800         pending_peer_connection = g_hash_table_new_full(g_str_hash, g_str_equal,
5801                                                                 NULL, NULL);
5802
5803         supplicant_dbus_setup(connection);
5804
5805         dbus_bus_add_match(connection, g_supplicant_rule0, NULL);
5806         dbus_bus_add_match(connection, g_supplicant_rule1, NULL);
5807         dbus_bus_add_match(connection, g_supplicant_rule2, NULL);
5808         dbus_bus_add_match(connection, g_supplicant_rule3, NULL);
5809         dbus_bus_add_match(connection, g_supplicant_rule4, NULL);
5810         dbus_bus_add_match(connection, g_supplicant_rule5, NULL);
5811 #if defined TIZEN_EXT
5812         dbus_bus_add_match(connection,
5813                         "type=signal,interface=org.tizen.system.deviced.PowerOff,"
5814                         "member=ChangeState", NULL);
5815 #endif
5816 #if !defined TIZEN_EXT
5817         dbus_bus_add_match(connection, g_supplicant_rule6, NULL);
5818         dbus_bus_add_match(connection, g_supplicant_rule7, NULL);
5819         dbus_bus_add_match(connection, g_supplicant_rule8, NULL);
5820 #endif
5821         dbus_connection_flush(connection);
5822
5823         if (dbus_bus_name_has_owner(connection,
5824                                         SUPPLICANT_SERVICE, NULL)) {
5825                 system_available = TRUE;
5826                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
5827                                                 SUPPLICANT_INTERFACE,
5828                                                 service_property, NULL, NULL);
5829         } else
5830                 invoke_introspect_method();
5831
5832         return 0;
5833 }
5834
5835 static void unregister_interface_remove_params(DBusMessageIter *iter,
5836                                                 void *user_data)
5837 {
5838         const char *path = user_data;
5839
5840         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
5841                                                         &path);
5842 }
5843
5844
5845 static void unregister_remove_interface(gpointer key, gpointer value,
5846                                                 gpointer user_data)
5847 {
5848         GSupplicantInterface *interface = value;
5849
5850         supplicant_dbus_method_call(SUPPLICANT_PATH,
5851                                         SUPPLICANT_INTERFACE,
5852                                         "RemoveInterface",
5853                                         unregister_interface_remove_params,
5854                                         NULL, interface->path, NULL);
5855 }
5856
5857 void g_supplicant_unregister(const GSupplicantCallbacks *callbacks)
5858 {
5859         SUPPLICANT_DBG("");
5860
5861         if (connection) {
5862 #if !defined TIZEN_EXT
5863                 dbus_bus_remove_match(connection, g_supplicant_rule8, NULL);
5864                 dbus_bus_remove_match(connection, g_supplicant_rule7, NULL);
5865                 dbus_bus_remove_match(connection, g_supplicant_rule6, NULL);
5866 #endif
5867                 dbus_bus_remove_match(connection, g_supplicant_rule5, NULL);
5868                 dbus_bus_remove_match(connection, g_supplicant_rule4, NULL);
5869                 dbus_bus_remove_match(connection, g_supplicant_rule3, NULL);
5870                 dbus_bus_remove_match(connection, g_supplicant_rule2, NULL);
5871                 dbus_bus_remove_match(connection, g_supplicant_rule1, NULL);
5872                 dbus_bus_remove_match(connection, g_supplicant_rule0, NULL);
5873                 dbus_connection_flush(connection);
5874
5875                 dbus_connection_remove_filter(connection,
5876                                                 g_supplicant_filter, NULL);
5877         }
5878
5879         if (bss_mapping) {
5880                 g_hash_table_destroy(bss_mapping);
5881                 bss_mapping = NULL;
5882         }
5883
5884         if (peer_mapping) {
5885                 g_hash_table_destroy(peer_mapping);
5886                 peer_mapping = NULL;
5887         }
5888
5889         if (group_mapping) {
5890                 g_hash_table_destroy(group_mapping);
5891                 group_mapping = NULL;
5892         }
5893
5894         if (interface_table) {
5895                 g_hash_table_foreach(interface_table,
5896                                         unregister_remove_interface, NULL);
5897                 g_hash_table_destroy(interface_table);
5898                 interface_table = NULL;
5899         }
5900
5901         if (system_available)
5902                 callback_system_killed();
5903
5904         if (connection) {
5905                 dbus_connection_unref(connection);
5906                 connection = NULL;
5907         }
5908
5909         callbacks_pointer = NULL;
5910         eap_methods = 0;
5911 }