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