gsupplicant/supplicant.c

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