gsupplicant/supplicant.c

   1 /*
   2  *
   3  *  WPA supplicant library with GLib integration
   4  *
   5  *  Copyright (C) 2010  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
  34 #include <glib.h>
  35 #include <gdbus.h>
  36
  37 #include "dbus.h"
  38 #include "gsupplicant.h"
  39
  40 #define TIMEOUT 5000
  41
  42 #define IEEE80211_CAP_ESS       0x0001
  43 #define IEEE80211_CAP_IBSS      0x0002
  44 #define IEEE80211_CAP_PRIVACY   0x0010
  45
  46 static DBusConnection *connection;
  47
  48 static const GSupplicantCallbacks *callbacks_pointer;
  49
  50 static dbus_bool_t system_available = FALSE;
  51 static dbus_bool_t system_ready = FALSE;
  52
  53 static dbus_int32_t debug_level;
  54 static dbus_bool_t debug_timestamp = FALSE;
  55 static dbus_bool_t debug_showkeys = FALSE;
  56
  57 static const char *debug_strings[] = {
  58         "msgdump", "debug", "info", "warning", "error", NULL
  59 };
  60
  61 static unsigned int eap_methods;
  62
  63 struct strvalmap {
  64         const char *str;
  65         unsigned int val;
  66 };
  67
  68 static struct strvalmap eap_method_map[] = {
  69         { "MD5",        G_SUPPLICANT_EAP_METHOD_MD5     },
  70         { "TLS",        G_SUPPLICANT_EAP_METHOD_TLS     },
  71         { "MSCHAPV2",   G_SUPPLICANT_EAP_METHOD_MSCHAPV2        },
  72         { "PEAP",       G_SUPPLICANT_EAP_METHOD_PEAP    },
  73         { "TTLS",       G_SUPPLICANT_EAP_METHOD_TTLS    },
  74         { "GTC",        G_SUPPLICANT_EAP_METHOD_GTC     },
  75         { "OTP",        G_SUPPLICANT_EAP_METHOD_OTP     },
  76         { "LEAP",       G_SUPPLICANT_EAP_METHOD_LEAP    },
  77         { "WSC",        G_SUPPLICANT_EAP_METHOD_WSC     },
  78         { }
  79 };
  80
  81 static struct strvalmap keymgmt_map[] = {
  82         { "none",               G_SUPPLICANT_KEYMGMT_NONE               },
  83         { "ieee8021x",          G_SUPPLICANT_KEYMGMT_IEEE8021X  },
  84         { "wpa-none",           G_SUPPLICANT_KEYMGMT_WPA_NONE   },
  85         { "wpa-psk",            G_SUPPLICANT_KEYMGMT_WPA_PSK    },
  86         { "wpa-psk-sha256",     G_SUPPLICANT_KEYMGMT_WPA_PSK_256        },
  87         { "wpa-ft-psk",         G_SUPPLICANT_KEYMGMT_WPA_FT_PSK },
  88         { "wpa-ft-eap",         G_SUPPLICANT_KEYMGMT_WPA_FT_EAP },
  89         { "wpa-eap",            G_SUPPLICANT_KEYMGMT_WPA_EAP    },
  90         { "wpa-eap-sha256",     G_SUPPLICANT_KEYMGMT_WPA_EAP_256        },
  91         { "wps",                G_SUPPLICANT_KEYMGMT_WPS                },
  92         { }
  93 };
  94
  95 static struct strvalmap authalg_capa_map[] = {
  96         { "open",       G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN    },
  97         { "shared",     G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED  },
  98         { "leap",       G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP    },
  99         { }
 100 };
 101
 102 static struct strvalmap proto_capa_map[] = {
 103         { "wpa",        G_SUPPLICANT_CAPABILITY_PROTO_WPA               },
 104         { "rsn",        G_SUPPLICANT_CAPABILITY_PROTO_RSN               },
 105         { }
 106 };
 107
 108 static struct strvalmap group_map[] = {
 109         { "wep40",      G_SUPPLICANT_GROUP_WEP40        },
 110         { "wep104",     G_SUPPLICANT_GROUP_WEP104       },
 111         { "tkip",       G_SUPPLICANT_GROUP_TKIP },
 112         { "ccmp",       G_SUPPLICANT_GROUP_CCMP },
 113         { }
 114 };
 115
 116 static struct strvalmap pairwise_map[] = {
 117         { "none",       G_SUPPLICANT_PAIRWISE_NONE      },
 118         { "tkip",       G_SUPPLICANT_PAIRWISE_TKIP      },
 119         { "ccmp",       G_SUPPLICANT_PAIRWISE_CCMP      },
 120         { }
 121 };
 122
 123 static struct strvalmap scan_capa_map[] = {
 124         { "active",     G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE     },
 125         { "passive",    G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE    },
 126         { "ssid",       G_SUPPLICANT_CAPABILITY_SCAN_SSID               },
 127         { }
 128 };
 129
 130 static struct strvalmap mode_capa_map[] = {
 131         { "infrastructure",     G_SUPPLICANT_CAPABILITY_MODE_INFRA      },
 132         { "ad-hoc",             G_SUPPLICANT_CAPABILITY_MODE_IBSS       },
 133         { "ap",                 G_SUPPLICANT_CAPABILITY_MODE_AP         },
 134         { }
 135 };
 136
 137 static GHashTable *interface_table;
 138 static GHashTable *bss_mapping;
 139
 140 struct _GSupplicantWpsCredentials {
 141         unsigned char ssid[32];
 142         unsigned int ssid_len;
 143         char *key;
 144 };
 145
 146 struct _GSupplicantInterface {
 147         char *path;
 148         char *network_path;
 149         unsigned int keymgmt_capa;
 150         unsigned int authalg_capa;
 151         unsigned int proto_capa;
 152         unsigned int group_capa;
 153         unsigned int pairwise_capa;
 154         unsigned int scan_capa;
 155         unsigned int mode_capa;
 156         dbus_bool_t ready;
 157         GSupplicantState state;
 158         dbus_bool_t scanning;
 159         GSupplicantInterfaceCallback scan_callback;
 160         void *scan_data;
 161         int apscan;
 162         char *ifname;
 163         char *driver;
 164         char *bridge;
 165         struct _GSupplicantWpsCredentials wps_cred;
 166         GSupplicantWpsState wps_state;
 167         GHashTable *network_table;
 168         GHashTable *net_mapping;
 169         GHashTable *bss_mapping;
 170         void *data;
 171 };
 172
 173 struct g_supplicant_bss {
 174         GSupplicantInterface *interface;
 175         char *path;
 176         unsigned char bssid[6];
 177         unsigned char ssid[32];
 178         unsigned int ssid_len;
 179         dbus_uint16_t frequency;
 180         dbus_uint32_t maxrate;
 181         dbus_int16_t signal;
 182         GSupplicantMode mode;
 183         GSupplicantSecurity security;
 184         unsigned int keymgmt;
 185         unsigned int pairwise;
 186         unsigned int group;
 187         dbus_bool_t privacy;
 188         dbus_bool_t psk;
 189         dbus_bool_t ieee8021x;
 190 };
 191
 192 struct _GSupplicantNetwork {
 193         GSupplicantInterface *interface;
 194         char *path;
 195         char *group;
 196         char *name;
 197         unsigned char ssid[32];
 198         unsigned int ssid_len;
 199         dbus_int16_t signal;
 200         dbus_uint16_t frequency;
 201         struct g_supplicant_bss *best_bss;
 202         GSupplicantMode mode;
 203         GSupplicantSecurity security;
 204         dbus_bool_t wps;
 205         GHashTable *bss_table;
 206         GHashTable *config_table;
 207 };
 208
 209 static inline void debug(const char *format, ...)
 210 {
 211         char str[256];
 212         va_list ap;
 213
 214         if (callbacks_pointer->debug == NULL)
 215                 return;
 216
 217         va_start(ap, format);
 218
 219         if (vsnprintf(str, sizeof(str), format, ap) > 0)
 220                 callbacks_pointer->debug(str);
 221
 222         va_end(ap);
 223 }
 224
 225 #define SUPPLICANT_DBG(fmt, arg...) \
 226         debug("%s:%s() " fmt, __FILE__, __FUNCTION__ , ## arg);
 227
 228 static GSupplicantMode string2mode(const char *mode)
 229 {
 230         if (mode == NULL)
 231                 return G_SUPPLICANT_MODE_UNKNOWN;
 232
 233         if (g_str_equal(mode, "infrastructure") == TRUE)
 234                 return G_SUPPLICANT_MODE_INFRA;
 235         else if (g_str_equal(mode, "ad-hoc") == TRUE)
 236                 return G_SUPPLICANT_MODE_IBSS;
 237
 238         return G_SUPPLICANT_MODE_UNKNOWN;
 239 }
 240
 241 static const char *mode2string(GSupplicantMode mode)
 242 {
 243         switch (mode) {
 244         case G_SUPPLICANT_MODE_UNKNOWN:
 245                 break;
 246         case G_SUPPLICANT_MODE_INFRA:
 247                 return "managed";
 248         case G_SUPPLICANT_MODE_IBSS:
 249                 return "adhoc";
 250         case G_SUPPLICANT_MODE_MASTER:
 251                 return "ap";
 252         }
 253
 254         return NULL;
 255 }
 256
 257 static const char *security2string(GSupplicantSecurity security)
 258 {
 259         switch (security) {
 260         case G_SUPPLICANT_SECURITY_UNKNOWN:
 261                 break;
 262         case G_SUPPLICANT_SECURITY_NONE:
 263                 return "none";
 264         case G_SUPPLICANT_SECURITY_WEP:
 265                 return "wep";
 266         case G_SUPPLICANT_SECURITY_PSK:
 267                 return "psk";
 268         case G_SUPPLICANT_SECURITY_IEEE8021X:
 269                 return "ieee8021x";
 270         }
 271
 272         return NULL;
 273 }
 274
 275 static GSupplicantState string2state(const char *state)
 276 {
 277         if (state == NULL)
 278                 return G_SUPPLICANT_STATE_UNKNOWN;
 279
 280         if (g_str_equal(state, "unknown") == TRUE)
 281                 return G_SUPPLICANT_STATE_UNKNOWN;
 282         else if (g_str_equal(state, "disconnected") == TRUE)
 283                 return G_SUPPLICANT_STATE_DISCONNECTED;
 284         else if (g_str_equal(state, "inactive") == TRUE)
 285                 return G_SUPPLICANT_STATE_INACTIVE;
 286         else if (g_str_equal(state, "scanning") == TRUE)
 287                 return G_SUPPLICANT_STATE_SCANNING;
 288         else if (g_str_equal(state, "authenticating") == TRUE)
 289                 return G_SUPPLICANT_STATE_AUTHENTICATING;
 290         else if (g_str_equal(state, "associating") == TRUE)
 291                 return G_SUPPLICANT_STATE_ASSOCIATING;
 292         else if (g_str_equal(state, "associated") == TRUE)
 293                 return G_SUPPLICANT_STATE_ASSOCIATED;
 294         else if (g_str_equal(state, "group_handshake") == TRUE)
 295                 return G_SUPPLICANT_STATE_GROUP_HANDSHAKE;
 296         else if (g_str_equal(state, "4way_handshake") == TRUE)
 297                 return G_SUPPLICANT_STATE_4WAY_HANDSHAKE;
 298         else if (g_str_equal(state, "completed") == TRUE)
 299                 return G_SUPPLICANT_STATE_COMPLETED;
 300
 301         return G_SUPPLICANT_STATE_UNKNOWN;
 302 }
 303
 304 static void callback_system_ready(void)
 305 {
 306         if (system_ready == TRUE)
 307                 return;
 308
 309         system_ready = TRUE;
 310
 311         if (callbacks_pointer == NULL)
 312                 return;
 313
 314         if (callbacks_pointer->system_ready == NULL)
 315                 return;
 316
 317         callbacks_pointer->system_ready();
 318 }
 319
 320 static void callback_system_killed(void)
 321 {
 322         system_ready = FALSE;
 323
 324         if (callbacks_pointer == NULL)
 325                 return;
 326
 327         if (callbacks_pointer->system_killed == NULL)
 328                 return;
 329
 330         callbacks_pointer->system_killed();
 331 }
 332
 333 static void callback_interface_added(GSupplicantInterface *interface)
 334 {
 335         SUPPLICANT_DBG("");
 336
 337         if (callbacks_pointer == NULL)
 338                 return;
 339
 340         if (callbacks_pointer->interface_added == NULL)
 341                 return;
 342
 343         callbacks_pointer->interface_added(interface);
 344 }
 345
 346 static void callback_interface_state(GSupplicantInterface *interface)
 347 {
 348         if (callbacks_pointer == NULL)
 349                 return;
 350
 351         if (callbacks_pointer->interface_state == NULL)
 352                 return;
 353
 354         callbacks_pointer->interface_state(interface);
 355 }
 356
 357 static void callback_interface_removed(GSupplicantInterface *interface)
 358 {
 359         if (callbacks_pointer == NULL)
 360                 return;
 361
 362         if (callbacks_pointer->interface_removed == NULL)
 363                 return;
 364
 365         callbacks_pointer->interface_removed(interface);
 366 }
 367
 368 static void callback_scan_started(GSupplicantInterface *interface)
 369 {
 370         if (callbacks_pointer == NULL)
 371                 return;
 372
 373         if (callbacks_pointer->scan_started == NULL)
 374                 return;
 375
 376         callbacks_pointer->scan_started(interface);
 377 }
 378
 379 static void callback_scan_finished(GSupplicantInterface *interface)
 380 {
 381         if (callbacks_pointer == NULL)
 382                 return;
 383
 384         if (callbacks_pointer->scan_finished == NULL)
 385                 return;
 386
 387         callbacks_pointer->scan_finished(interface);
 388 }
 389
 390 static void callback_network_added(GSupplicantNetwork *network)
 391 {
 392         if (callbacks_pointer == NULL)
 393                 return;
 394
 395         if (callbacks_pointer->network_added == NULL)
 396                 return;
 397
 398         callbacks_pointer->network_added(network);
 399 }
 400
 401 static void callback_network_removed(GSupplicantNetwork *network)
 402 {
 403         if (callbacks_pointer == NULL)
 404                 return;
 405
 406         if (callbacks_pointer->network_removed == NULL)
 407                 return;
 408
 409         callbacks_pointer->network_removed(network);
 410 }
 411
 412 static void callback_network_changed(GSupplicantNetwork *network,
 413                                         const char *property)
 414 {
 415         if (callbacks_pointer == NULL)
 416                 return;
 417
 418         if (callbacks_pointer->network_changed == NULL)
 419                 return;
 420
 421         callbacks_pointer->network_changed(network, property);
 422 }
 423
 424 static void remove_interface(gpointer data)
 425 {
 426         GSupplicantInterface *interface = data;
 427
 428         g_hash_table_destroy(interface->bss_mapping);
 429         g_hash_table_destroy(interface->net_mapping);
 430         g_hash_table_destroy(interface->network_table);
 431
 432         callback_interface_removed(interface);
 433
 434         g_free(interface->wps_cred.key);
 435         g_free(interface->path);
 436         g_free(interface->network_path);
 437         g_free(interface->ifname);
 438         g_free(interface->driver);
 439         g_free(interface->bridge);
 440         g_free(interface);
 441 }
 442
 443 static void remove_network(gpointer data)
 444 {
 445         GSupplicantNetwork *network = data;
 446
 447         g_hash_table_destroy(network->bss_table);
 448
 449         callback_network_removed(network);
 450
 451         g_hash_table_destroy(network->config_table);
 452
 453         g_free(network->path);
 454         g_free(network->group);
 455         g_free(network->name);
 456         g_free(network);
 457 }
 458
 459 static void remove_bss(gpointer data)
 460 {
 461         struct g_supplicant_bss *bss = data;
 462
 463         g_free(bss->path);
 464         g_free(bss);
 465 }
 466
 467 static void debug_strvalmap(const char *label, struct strvalmap *map,
 468                                                         unsigned int val)
 469 {
 470         int i;
 471
 472         for (i = 0; map[i].str != NULL; i++) {
 473                 if (val & map[i].val)
 474                         SUPPLICANT_DBG("%s: %s", label, map[i].str);
 475         }
 476 }
 477
 478 static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
 479 {
 480         GSupplicantInterface *interface = user_data;
 481         const char *str = NULL;
 482         int i;
 483
 484         dbus_message_iter_get_basic(iter, &str);
 485         if (str == NULL)
 486                 return;
 487
 488         for (i = 0; keymgmt_map[i].str != NULL; i++)
 489                 if (strcmp(str, keymgmt_map[i].str) == 0) {
 490                         interface->keymgmt_capa |= keymgmt_map[i].val;
 491                         break;
 492                 }
 493 }
 494
 495 static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
 496 {
 497         GSupplicantInterface *interface = user_data;
 498         const char *str = NULL;
 499         int i;
 500
 501         dbus_message_iter_get_basic(iter, &str);
 502         if (str == NULL)
 503                 return;
 504
 505         for (i = 0; authalg_capa_map[i].str != NULL; i++)
 506                 if (strcmp(str, authalg_capa_map[i].str) == 0) {
 507                         interface->authalg_capa |= authalg_capa_map[i].val;
 508                         break;
 509                 }
 510 }
 511
 512 static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
 513 {
 514         GSupplicantInterface *interface = user_data;
 515         const char *str = NULL;
 516         int i;
 517
 518         dbus_message_iter_get_basic(iter, &str);
 519         if (str == NULL)
 520                 return;
 521
 522         for (i = 0; proto_capa_map[i].str != NULL; i++)
 523                 if (strcmp(str, proto_capa_map[i].str) == 0) {
 524                         interface->proto_capa |= proto_capa_map[i].val;
 525                         break;
 526                 }
 527 }
 528
 529 static void interface_capability_pairwise(DBusMessageIter *iter,
 530                                                         void *user_data)
 531 {
 532         GSupplicantInterface *interface = user_data;
 533         const char *str = NULL;
 534         int i;
 535
 536         dbus_message_iter_get_basic(iter, &str);
 537         if (str == NULL)
 538                 return;
 539
 540         for (i = 0; pairwise_map[i].str != NULL; i++)
 541                 if (strcmp(str, pairwise_map[i].str) == 0) {
 542                         interface->pairwise_capa |= pairwise_map[i].val;
 543                         break;
 544                 }
 545 }
 546
 547 static void interface_capability_group(DBusMessageIter *iter, void *user_data)
 548 {
 549         GSupplicantInterface *interface = user_data;
 550         const char *str = NULL;
 551         int i;
 552
 553         dbus_message_iter_get_basic(iter, &str);
 554         if (str == NULL)
 555                 return;
 556
 557         for (i = 0; group_map[i].str != NULL; i++)
 558                 if (strcmp(str, group_map[i].str) == 0) {
 559                         interface->group_capa |= group_map[i].val;
 560                         break;
 561                 }
 562 }
 563
 564 static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
 565 {
 566         GSupplicantInterface *interface = user_data;
 567         const char *str = NULL;
 568         int i;
 569
 570         dbus_message_iter_get_basic(iter, &str);
 571         if (str == NULL)
 572                 return;
 573
 574         for (i = 0; scan_capa_map[i].str != NULL; i++)
 575                 if (strcmp(str, scan_capa_map[i].str) == 0) {
 576                         interface->scan_capa |= scan_capa_map[i].val;
 577                         break;
 578                 }
 579 }
 580
 581 static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
 582 {
 583         GSupplicantInterface *interface = user_data;
 584         const char *str = NULL;
 585         int i;
 586
 587         dbus_message_iter_get_basic(iter, &str);
 588         if (str == NULL)
 589                 return;
 590
 591         for (i = 0; mode_capa_map[i].str != NULL; i++)
 592                 if (strcmp(str, mode_capa_map[i].str) == 0) {
 593                         interface->mode_capa |= mode_capa_map[i].val;
 594                         break;
 595                 }
 596 }
 597
 598 static void interface_capability(const char *key, DBusMessageIter *iter,
 599                                                         void *user_data)
 600 {
 601         GSupplicantInterface *interface = user_data;
 602
 603         if (key == NULL)
 604                 return;
 605
 606         if (g_strcmp0(key, "KeyMgmt") == 0)
 607                 supplicant_dbus_array_foreach(iter,
 608                                 interface_capability_keymgmt, interface);
 609         else if (g_strcmp0(key, "AuthAlg") == 0)
 610                 supplicant_dbus_array_foreach(iter,
 611                                 interface_capability_authalg, interface);
 612         else if (g_strcmp0(key, "Protocol") == 0)
 613                 supplicant_dbus_array_foreach(iter,
 614                                 interface_capability_proto, interface);
 615         else if (g_strcmp0(key, "Pairwise") == 0)
 616                 supplicant_dbus_array_foreach(iter,
 617                                 interface_capability_pairwise, interface);
 618         else if (g_strcmp0(key, "Group") == 0)
 619                 supplicant_dbus_array_foreach(iter,
 620                                 interface_capability_group, interface);
 621         else if (g_strcmp0(key, "Scan") == 0)
 622                 supplicant_dbus_array_foreach(iter,
 623                                 interface_capability_scan, interface);
 624         else if (g_strcmp0(key, "Modes") == 0)
 625                 supplicant_dbus_array_foreach(iter,
 626                                 interface_capability_mode, interface);
 627         else
 628                 SUPPLICANT_DBG("key %s type %c",
 629                                 key, dbus_message_iter_get_arg_type(iter));
 630 }
 631
 632 static void set_apscan(DBusMessageIter *iter, void *user_data)
 633 {
 634         unsigned int ap_scan = *(unsigned int *)user_data;
 635
 636         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &ap_scan);
 637 }
 638
 639 int g_supplicant_interface_set_apscan(GSupplicantInterface *interface,
 640                                                         unsigned int ap_scan)
 641 {
 642         return supplicant_dbus_property_set(interface->path,
 643                         SUPPLICANT_INTERFACE ".Interface",
 644                                 "ApScan", DBUS_TYPE_UINT32_AS_STRING,
 645                                         set_apscan, NULL, &ap_scan);
 646 }
 647
 648 void g_supplicant_interface_set_data(GSupplicantInterface *interface,
 649                                                                 void *data)
 650 {
 651         if (interface == NULL)
 652                 return;
 653
 654         interface->data = data;
 655 }
 656
 657 void *g_supplicant_interface_get_data(GSupplicantInterface *interface)
 658 {
 659         if (interface == NULL)
 660                 return NULL;
 661
 662         return interface->data;
 663 }
 664
 665 const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface)
 666 {
 667         if (interface == NULL)
 668                 return NULL;
 669
 670         return interface->ifname;
 671 }
 672
 673 const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface)
 674 {
 675         if (interface == NULL)
 676                 return NULL;
 677
 678         return interface->driver;
 679 }
 680
 681 GSupplicantState g_supplicant_interface_get_state(
 682                                         GSupplicantInterface *interface)
 683 {
 684         if (interface == NULL)
 685                 return G_SUPPLICANT_STATE_UNKNOWN;
 686
 687         return interface->state;
 688 }
 689
 690 const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface)
 691 {
 692         if (interface == NULL)
 693                 return NULL;
 694
 695         return (const char *)interface->wps_cred.key;
 696 }
 697
 698 const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
 699                                                         unsigned int *ssid_len)
 700 {
 701         if (ssid_len == NULL)
 702                 return NULL;
 703
 704         if (interface == NULL || interface->wps_cred.ssid == NULL) {
 705                 *ssid_len = 0;
 706                 return NULL;
 707         }
 708
 709         *ssid_len = interface->wps_cred.ssid_len;
 710         return interface->wps_cred.ssid;
 711 }
 712
 713 GSupplicantWpsState g_supplicant_interface_get_wps_state(
 714                                         GSupplicantInterface *interface)
 715 {
 716         if (interface == NULL)
 717                 return G_SUPPLICANT_WPS_STATE_UNKNOWN;
 718
 719         return interface->wps_state;
 720 }
 721
 722 unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface)
 723 {
 724         if (interface == NULL)
 725                 return 0;
 726
 727         return interface->mode_capa;
 728 }
 729
 730 GSupplicantInterface *g_supplicant_network_get_interface(
 731                                         GSupplicantNetwork *network)
 732 {
 733         if (network == NULL)
 734                 return NULL;
 735
 736         return network->interface;
 737 }
 738
 739 const char *g_supplicant_network_get_name(GSupplicantNetwork *network)
 740 {
 741         if (network == NULL || network->name == NULL)
 742                 return "";
 743
 744         return network->name;
 745 }
 746
 747 const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network)
 748 {
 749         if (network == NULL || network->group == NULL)
 750                 return "";
 751
 752         return network->group;
 753 }
 754
 755 const char *g_supplicant_network_get_path(GSupplicantNetwork *network)
 756 {
 757         if (network == NULL || network->path == NULL)
 758                 return NULL;
 759
 760         return network->path;
 761 }
 762
 763 const char *g_supplicant_network_get_mode(GSupplicantNetwork *network)
 764 {
 765         if (network == NULL)
 766                 return G_SUPPLICANT_MODE_UNKNOWN;
 767
 768         return mode2string(network->mode);
 769 }
 770
 771 const char *g_supplicant_network_get_security(GSupplicantNetwork *network)
 772 {
 773         if (network == NULL)
 774                 return G_SUPPLICANT_SECURITY_UNKNOWN;
 775
 776         return security2string(network->security);
 777 }
 778
 779 const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
 780                                                 unsigned int *ssid_len)
 781 {
 782         if (network == NULL || network->ssid == NULL) {
 783                 *ssid_len = 0;
 784                 return NULL;
 785         }
 786
 787         *ssid_len = network->ssid_len;
 788         return network->ssid;
 789 }
 790
 791 dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network)
 792 {
 793         if (network == NULL)
 794                 return 0;
 795
 796         return network->signal;
 797 }
 798
 799 dbus_uint16_t g_supplicant_network_get_frequency(GSupplicantNetwork *network)
 800 {
 801         if (network == NULL)
 802                 return 0;
 803
 804         return network->frequency;
 805 }
 806
 807 dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network)
 808 {
 809         if (network == NULL)
 810                 return FALSE;
 811
 812         return network->wps;
 813 }
 814
 815 static void merge_network(GSupplicantNetwork *network)
 816 {
 817         GString *str;
 818         const char *ssid, *mode, *key_mgmt;
 819         unsigned int i, ssid_len;
 820         char *group;
 821
 822         ssid = g_hash_table_lookup(network->config_table, "ssid");
 823         mode = g_hash_table_lookup(network->config_table, "mode");
 824         key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
 825
 826         SUPPLICANT_DBG("ssid %s mode %s", ssid, mode);
 827
 828         if (ssid != NULL)
 829                 ssid_len = strlen(ssid);
 830         else
 831                 ssid_len = 0;
 832
 833         str = g_string_sized_new((ssid_len * 2) + 24);
 834         if (str == NULL)
 835                 return;
 836
 837         for (i = 0; i < ssid_len; i++)
 838                 g_string_append_printf(str, "%02x", ssid[i]);
 839
 840         if (g_strcmp0(mode, "0") == 0)
 841                 g_string_append_printf(str, "_managed");
 842         else if (g_strcmp0(mode, "1") == 0)
 843                 g_string_append_printf(str, "_adhoc");
 844
 845         if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
 846                 g_string_append_printf(str, "_psk");
 847
 848         group = g_string_free(str, FALSE);
 849
 850         SUPPLICANT_DBG("%s", group);
 851
 852         g_free(group);
 853
 854         g_hash_table_destroy(network->config_table);
 855
 856         g_free(network->path);
 857         g_free(network);
 858 }
 859
 860 static void network_property(const char *key, DBusMessageIter *iter,
 861                                                         void *user_data)
 862 {
 863         GSupplicantNetwork *network = user_data;
 864
 865         if (network->interface == NULL)
 866                 return;
 867
 868         if (key == NULL) {
 869                 merge_network(network);
 870                 return;
 871         }
 872
 873         if (g_strcmp0(key, "Enabled") == 0) {
 874                 dbus_bool_t enabled = FALSE;
 875
 876                 dbus_message_iter_get_basic(iter, &enabled);
 877         } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
 878                 const char *str = NULL;
 879
 880                 dbus_message_iter_get_basic(iter, &str);
 881                 if (str != NULL) {
 882                         g_hash_table_replace(network->config_table,
 883                                                 g_strdup(key), g_strdup(str));
 884                 }
 885         } else
 886                 SUPPLICANT_DBG("key %s type %c",
 887                                 key, dbus_message_iter_get_arg_type(iter));
 888 }
 889
 890 static void interface_network_added(DBusMessageIter *iter, void *user_data)
 891 {
 892         GSupplicantInterface *interface = user_data;
 893         GSupplicantNetwork *network;
 894         const char *path = NULL;
 895
 896         SUPPLICANT_DBG("");
 897
 898         dbus_message_iter_get_basic(iter, &path);
 899         if (path == NULL)
 900                 return;
 901
 902         if (g_strcmp0(path, "/") == 0)
 903                 return;
 904
 905         network = g_hash_table_lookup(interface->net_mapping, path);
 906         if (network != NULL)
 907                 return;
 908
 909         network = g_try_new0(GSupplicantNetwork, 1);
 910         if (network == NULL)
 911                 return;
 912
 913         network->interface = interface;
 914         network->path = g_strdup(path);
 915
 916         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
 917                                                         g_free, g_free);
 918
 919         dbus_message_iter_next(iter);
 920         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
 921                 supplicant_dbus_property_foreach(iter, network_property,
 922                                                                 network);
 923                 network_property(NULL, NULL, network);
 924                 return;
 925         }
 926
 927         supplicant_dbus_property_get_all(path,
 928                                 SUPPLICANT_INTERFACE ".Network",
 929                                                 network_property, network);
 930 }
 931
 932 static void interface_network_removed(DBusMessageIter *iter, void *user_data)
 933 {
 934         GSupplicantInterface *interface = user_data;
 935         GSupplicantNetwork *network;
 936         const char *path = NULL;
 937
 938         dbus_message_iter_get_basic(iter, &path);
 939         if (path == NULL)
 940                 return;
 941
 942         network = g_hash_table_lookup(interface->net_mapping, path);
 943         if (network == NULL)
 944                 return;
 945
 946         g_hash_table_remove(interface->net_mapping, path);
 947 }
 948
 949 static char *create_name(unsigned char *ssid, int ssid_len)
 950 {
 951         char *name;
 952         int i;
 953
 954         if (ssid_len < 1 || ssid[0] == '\0')
 955                 name = NULL;
 956         else
 957                 name = g_try_malloc0(ssid_len + 1);
 958
 959         if (name == NULL)
 960                 return g_strdup("");
 961
 962         for (i = 0; i < ssid_len; i++) {
 963                 if (g_ascii_isprint(ssid[i]))
 964                         name[i] = ssid[i];
 965                 else
 966                         name[i] = ' ';
 967         }
 968
 969         return name;
 970 }
 971
 972 static char *create_group(struct g_supplicant_bss *bss)
 973 {
 974         GString *str;
 975         unsigned int i;
 976         const char *mode, *security;
 977
 978         str = g_string_sized_new((bss->ssid_len * 2) + 24);
 979         if (str == NULL)
 980                 return NULL;
 981
 982         if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
 983                 for (i = 0; i < bss->ssid_len; i++)
 984                         g_string_append_printf(str, "%02x", bss->ssid[i]);
 985         } else
 986                 g_string_append_printf(str, "hidden");
 987
 988         mode = mode2string(bss->mode);
 989         if (mode != NULL)
 990                 g_string_append_printf(str, "_%s", mode);
 991
 992         security = security2string(bss->security);
 993         if (security != NULL)
 994                 g_string_append_printf(str, "_%s", security);
 995
 996         return g_string_free(str, FALSE);
 997 }
 998
 999 static void add_bss_to_network(struct g_supplicant_bss *bss)
1000 {
1001         GSupplicantInterface *interface = bss->interface;
1002         GSupplicantNetwork *network;
1003         char *group;
1004
1005         group = create_group(bss);
1006         if (group == NULL)
1007                 return;
1008
1009         network = g_hash_table_lookup(interface->network_table, group);
1010         if (network != NULL) {
1011                 g_free(group);
1012                 goto done;
1013         }
1014
1015         network = g_try_new0(GSupplicantNetwork, 1);
1016         if (network == NULL) {
1017                 g_free(group);
1018                 return;
1019         }
1020
1021         network->interface = interface;
1022         if (network->path == NULL)
1023                 network->path = g_strdup(bss->path);
1024         network->group = group;
1025         network->name = create_name(bss->ssid, bss->ssid_len);
1026         network->mode = bss->mode;
1027         network->security = bss->security;
1028         network->ssid_len = bss->ssid_len;
1029         memcpy(network->ssid, bss->ssid, bss->ssid_len);
1030         network->signal = bss->signal;
1031         network->frequency = bss->frequency;
1032         network->best_bss = bss;
1033
1034         network->wps = FALSE;
1035         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0)
1036                 network->wps = TRUE;
1037
1038         network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1039                                                         NULL, remove_bss);
1040
1041         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1042                                                         g_free, g_free);
1043
1044         g_hash_table_replace(interface->network_table,
1045                                                 network->group, network);
1046
1047         callback_network_added(network);
1048
1049 done:
1050         if (bss->signal > network->signal) {
1051                 network->signal = bss->signal;
1052                 network->best_bss = bss;
1053                 callback_network_changed(network, "Signal");
1054         }
1055
1056         g_hash_table_replace(interface->bss_mapping, bss->path, network);
1057         g_hash_table_replace(network->bss_table, bss->path, bss);
1058
1059         g_hash_table_replace(bss_mapping, bss->path, interface);
1060 }
1061
1062 static void bss_rates(DBusMessageIter *iter, void *user_data)
1063 {
1064         struct g_supplicant_bss *bss = user_data;
1065         dbus_uint32_t rate = 0;
1066
1067         dbus_message_iter_get_basic(iter, &rate);
1068         if (rate == 0)
1069                 return;
1070
1071         if (rate > bss->maxrate)
1072                 bss->maxrate = rate;
1073 }
1074
1075 static void bss_keymgmt(DBusMessageIter *iter, void *user_data)
1076 {
1077         struct g_supplicant_bss *bss = user_data;
1078         const char *str = NULL;
1079         int i;
1080
1081         dbus_message_iter_get_basic(iter, &str);
1082         if (str == NULL)
1083                 return;
1084
1085         for (i = 0; keymgmt_map[i].str != NULL; i++)
1086                 if (strcmp(str, keymgmt_map[i].str) == 0) {
1087                         bss->keymgmt |= keymgmt_map[i].val;
1088                         break;
1089                 }
1090 }
1091
1092 static void bss_group(DBusMessageIter *iter, void *user_data)
1093 {
1094         struct g_supplicant_bss *bss = user_data;
1095         const char *str = NULL;
1096         int i;
1097
1098         dbus_message_iter_get_basic(iter, &str);
1099         if (str == NULL)
1100                 return;
1101
1102         for (i = 0; group_map[i].str != NULL; i++)
1103                 if (strcmp(str, group_map[i].str) == 0) {
1104                         bss->group |= group_map[i].val;
1105                         break;
1106                 }
1107 }
1108
1109 static void bss_pairwise(DBusMessageIter *iter, void *user_data)
1110 {
1111         struct g_supplicant_bss *bss = user_data;
1112         const char *str = NULL;
1113         int i;
1114
1115         dbus_message_iter_get_basic(iter, &str);
1116         if (str == NULL)
1117                 return;
1118
1119         for (i = 0; pairwise_map[i].str != NULL; i++)
1120                 if (strcmp(str, pairwise_map[i].str) == 0) {
1121                         bss->pairwise |= pairwise_map[i].val;
1122                         break;
1123                 }
1124 }
1125
1126 static void bss_wpa(const char *key, DBusMessageIter *iter,
1127                         void *user_data)
1128 {
1129         if (g_strcmp0(key, "KeyMgmt") == 0)
1130                 supplicant_dbus_array_foreach(iter, bss_keymgmt, user_data);
1131         else if (g_strcmp0(key, "Group") == 0)
1132                 supplicant_dbus_array_foreach(iter, bss_group, user_data);
1133         else if (g_strcmp0(key, "Pairwise") == 0)
1134                 supplicant_dbus_array_foreach(iter, bss_pairwise, user_data);
1135
1136 }
1137
1138 static unsigned int get_tlv(unsigned char *ie, unsigned int ie_size,
1139                                                         unsigned int type)
1140 {
1141         unsigned int len = 0;
1142
1143         while (len + 4 < ie_size) {
1144                 unsigned int hi = ie[len];
1145                 unsigned int lo = ie[len + 1];
1146                 unsigned int tmp_type = (hi << 8) + lo;
1147                 unsigned int v_len = 0;
1148
1149                 /* hi and lo are used to recreate an unsigned int
1150                  * based on 2 8bits length unsigned int. */
1151
1152                 hi = ie[len + 2];
1153                 lo = ie[len + 3];
1154                 v_len = (hi << 8) + lo;
1155
1156                 if (tmp_type == type) {
1157                         unsigned int ret_value = 0;
1158                         unsigned char *value = (unsigned char *)&ret_value;
1159
1160                         SUPPLICANT_DBG("IE: match type 0x%x", type);
1161
1162                         /* Verifying length relevance */
1163                         if (v_len > sizeof(unsigned int) ||
1164                                 len + 4 + v_len > ie_size)
1165                                 break;
1166
1167                         memcpy(value, ie + len + 4, v_len);
1168
1169                         SUPPLICANT_DBG("returning 0x%x", ret_value);
1170                         return ret_value;
1171                 }
1172
1173                 len += v_len + 4;
1174         }
1175
1176         SUPPLICANT_DBG("returning 0");
1177         return 0;
1178 }
1179
1180 static void bss_process_ies(DBusMessageIter *iter, void *user_data)
1181 {
1182         struct g_supplicant_bss *bss = user_data;
1183         const unsigned char WPS_OUI[] = { 0x00, 0x50, 0xf2, 0x04 };
1184         unsigned char *ie, *ie_end;
1185         DBusMessageIter array;
1186         int ie_len;
1187
1188 #define WMM_WPA1_WPS_INFO 221
1189 #define WPS_INFO_MIN_LEN  6
1190 #define WPS_VERSION_TLV   0x104A
1191 #define WPS_STATE_TLV     0x1044
1192 #define WPS_VERSION       0x10
1193
1194         dbus_message_iter_recurse(iter, &array);
1195         dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
1196
1197         if (ie == NULL || ie_len < 2)
1198                 return;
1199
1200         for (ie_end = ie + ie_len; ie < ie_end && ie + ie[1] + 1 <= ie_end;
1201                                                         ie += ie[1] + 2) {
1202
1203                 if (ie[0] != WMM_WPA1_WPS_INFO || ie[1] < WPS_INFO_MIN_LEN ||
1204                         memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0)
1205                         continue;
1206
1207                 SUPPLICANT_DBG("IE: match WPS_OUI");
1208
1209                 if (get_tlv(&ie[6], ie[1],
1210                                 WPS_VERSION_TLV) == WPS_VERSION &&
1211                         get_tlv(&ie[6], ie[1],
1212                                 WPS_STATE_TLV) != 0)
1213                         bss->keymgmt |= G_SUPPLICANT_KEYMGMT_WPS;
1214         }
1215 }
1216
1217 static void bss_property(const char *key, DBusMessageIter *iter,
1218                                                         void *user_data)
1219 {
1220         struct g_supplicant_bss *bss = user_data;
1221
1222         if (bss->interface == NULL)
1223                 return;
1224
1225         SUPPLICANT_DBG("key %s", key);
1226
1227         if (key == NULL) {
1228                 if (bss->ieee8021x == TRUE)
1229                         bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
1230                 else if (bss->psk == TRUE)
1231                         bss->security = G_SUPPLICANT_SECURITY_PSK;
1232                 else if (bss->privacy == TRUE)
1233                         bss->security = G_SUPPLICANT_SECURITY_WEP;
1234                 else
1235                         bss->security = G_SUPPLICANT_SECURITY_NONE;
1236
1237                 add_bss_to_network(bss);
1238                 return;
1239         }
1240
1241         if (g_strcmp0(key, "BSSID") == 0) {
1242                 DBusMessageIter array;
1243                 unsigned char *addr;
1244                 int addr_len;
1245
1246                 dbus_message_iter_recurse(iter, &array);
1247                 dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
1248
1249                 if (addr_len == 6)
1250                         memcpy(bss->bssid, addr, addr_len);
1251         } else if (g_strcmp0(key, "SSID") == 0) {
1252                 DBusMessageIter array;
1253                 unsigned char *ssid;
1254                 int ssid_len;
1255
1256                 dbus_message_iter_recurse(iter, &array);
1257                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
1258
1259                 if (ssid_len > 0 && ssid_len < 33) {
1260                         memcpy(bss->ssid, ssid, ssid_len);
1261                         bss->ssid_len = ssid_len;
1262                 } else {
1263                         memset(bss->ssid, 0, sizeof(bss->ssid));
1264                         bss->ssid_len = 0;
1265                 }
1266         } else if (g_strcmp0(key, "Capabilities") == 0) {
1267                 dbus_uint16_t capabilities = 0x0000;
1268
1269                 dbus_message_iter_get_basic(iter, &capabilities);
1270
1271                 if (capabilities & IEEE80211_CAP_ESS)
1272                         bss->mode = G_SUPPLICANT_MODE_INFRA;
1273                 else if (capabilities & IEEE80211_CAP_IBSS)
1274                         bss->mode = G_SUPPLICANT_MODE_IBSS;
1275
1276                 if (capabilities & IEEE80211_CAP_PRIVACY)
1277                         bss->privacy = TRUE;
1278         } else if (g_strcmp0(key, "Mode") == 0) {
1279                 const char *mode = NULL;
1280
1281                 dbus_message_iter_get_basic(iter, &mode);
1282                 bss->mode = string2mode(mode);
1283         } else if (g_strcmp0(key, "Frequency") == 0) {
1284                 dbus_uint16_t frequency = 0;
1285
1286                 dbus_message_iter_get_basic(iter, &frequency);
1287                 bss->frequency = frequency;
1288         } else if (g_strcmp0(key, "Signal") == 0) {
1289                 dbus_int16_t signal = 0;
1290
1291                 dbus_message_iter_get_basic(iter, &signal);
1292
1293                 bss->signal = signal;
1294         } else if (g_strcmp0(key, "Level") == 0) {
1295                 dbus_int32_t level = 0;
1296
1297                 dbus_message_iter_get_basic(iter, &level);
1298         } else if (g_strcmp0(key, "Rates") == 0) {
1299                 supplicant_dbus_array_foreach(iter, bss_rates, bss);
1300         } else if (g_strcmp0(key, "MaxRate") == 0) {
1301                 dbus_uint32_t maxrate = 0;
1302
1303                 dbus_message_iter_get_basic(iter, &maxrate);
1304                 if (maxrate != 0)
1305                         bss->maxrate = maxrate;
1306         } else if (g_strcmp0(key, "Privacy") == 0) {
1307                 dbus_bool_t privacy = FALSE;
1308
1309                 dbus_message_iter_get_basic(iter, &privacy);
1310                 bss->privacy = privacy;
1311         } else if ((g_strcmp0(key, "RSN") == 0) ||
1312                         (g_strcmp0(key, "WPA") == 0)) {
1313                 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
1314
1315                 if (bss->keymgmt &
1316                         (G_SUPPLICANT_KEYMGMT_WPA_EAP |
1317                                 G_SUPPLICANT_KEYMGMT_WPA_FT_EAP |
1318                                 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
1319                         bss->ieee8021x = TRUE;
1320
1321                 if (bss->keymgmt &
1322                         (G_SUPPLICANT_KEYMGMT_WPA_PSK |
1323                                 G_SUPPLICANT_KEYMGMT_WPA_FT_PSK |
1324                                 G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
1325                         bss->psk = TRUE;
1326         } else if (g_strcmp0(key, "IEs") == 0)
1327                 bss_process_ies(iter, bss);
1328         else
1329                 SUPPLICANT_DBG("key %s type %c",
1330                                 key, dbus_message_iter_get_arg_type(iter));
1331 }
1332
1333 static struct g_supplicant_bss *interface_bss_added(DBusMessageIter *iter,
1334                                                         void *user_data)
1335 {
1336         GSupplicantInterface *interface = user_data;
1337         GSupplicantNetwork *network;
1338         struct g_supplicant_bss *bss;
1339         const char *path = NULL;
1340
1341         SUPPLICANT_DBG("");
1342
1343         dbus_message_iter_get_basic(iter, &path);
1344         if (path == NULL)
1345                 return NULL;
1346
1347         if (g_strcmp0(path, "/") == 0)
1348                 return NULL;
1349
1350         SUPPLICANT_DBG("%s", path);
1351
1352         network = g_hash_table_lookup(interface->bss_mapping, path);
1353         if (network != NULL) {
1354                 bss = g_hash_table_lookup(network->bss_table, path);
1355                 if (bss != NULL)
1356                         return NULL;
1357         }
1358
1359         bss = g_try_new0(struct g_supplicant_bss, 1);
1360         if (bss == NULL)
1361                 return NULL;
1362
1363         bss->interface = interface;
1364         bss->path = g_strdup(path);
1365
1366         return bss;
1367 }
1368
1369 static void interface_bss_added_with_keys(DBusMessageIter *iter,
1370                                                 void *user_data)
1371 {
1372         struct g_supplicant_bss *bss;
1373
1374         SUPPLICANT_DBG("");
1375
1376         bss = interface_bss_added(iter, user_data);
1377         if (bss == NULL)
1378                 return;
1379
1380         dbus_message_iter_next(iter);
1381
1382         if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_INVALID)
1383                 return;
1384
1385         supplicant_dbus_property_foreach(iter, bss_property, bss);
1386         bss_property(NULL, NULL, bss);
1387 }
1388
1389 static void interface_bss_added_without_keys(DBusMessageIter *iter,
1390                                                 void *user_data)
1391 {
1392         struct g_supplicant_bss *bss;
1393
1394         SUPPLICANT_DBG("");
1395
1396         bss = interface_bss_added(iter, user_data);
1397         if (bss == NULL)
1398                 return;
1399
1400         supplicant_dbus_property_get_all(bss->path,
1401                                         SUPPLICANT_INTERFACE ".BSS",
1402                                                         bss_property, bss);
1403 }
1404
1405 static void update_signal(gpointer key, gpointer value,
1406                                                 gpointer user_data)
1407 {
1408         struct g_supplicant_bss *bss = value;
1409         GSupplicantNetwork *network = user_data;
1410
1411         if (bss->signal > network->signal) {
1412                 network->signal = bss->signal;
1413                 network->best_bss = bss;
1414         }
1415 }
1416
1417 static void update_network_signal(GSupplicantNetwork *network)
1418 {
1419         if (g_hash_table_size(network->bss_table) <= 1)
1420                 return;
1421
1422         g_hash_table_foreach(network->bss_table,
1423                                 update_signal, network);
1424
1425         SUPPLICANT_DBG("New network signal %d", network->signal);
1426 }
1427
1428 static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
1429 {
1430         GSupplicantInterface *interface = user_data;
1431         GSupplicantNetwork *network;
1432         const char *path = NULL;
1433
1434         dbus_message_iter_get_basic(iter, &path);
1435         if (path == NULL)
1436                 return;
1437
1438         network = g_hash_table_lookup(interface->bss_mapping, path);
1439         if (network == NULL)
1440                 return;
1441
1442         g_hash_table_remove(bss_mapping, path);
1443
1444         g_hash_table_remove(interface->bss_mapping, path);
1445         g_hash_table_remove(network->bss_table, path);
1446
1447         update_network_signal(network);
1448
1449         if (g_hash_table_size(network->bss_table) == 0)
1450                 g_hash_table_remove(interface->network_table, network->group);
1451 }
1452
1453 static void interface_property(const char *key, DBusMessageIter *iter,
1454                                                         void *user_data)
1455 {
1456         GSupplicantInterface *interface = user_data;
1457
1458         if (interface == NULL)
1459                 return;
1460
1461         SUPPLICANT_DBG("%s", key);
1462
1463         if (key == NULL) {
1464                 debug_strvalmap("KeyMgmt capability", keymgmt_map,
1465                                                 interface->keymgmt_capa);
1466                 debug_strvalmap("AuthAlg capability", authalg_capa_map,
1467                                                 interface->authalg_capa);
1468                 debug_strvalmap("Protocol capability", proto_capa_map,
1469                                                 interface->proto_capa);
1470                 debug_strvalmap("Pairwise capability", pairwise_map,
1471                                                 interface->pairwise_capa);
1472                 debug_strvalmap("Group capability", group_map,
1473                                                 interface->group_capa);
1474                 debug_strvalmap("Scan capability", scan_capa_map,
1475                                                 interface->scan_capa);
1476                 debug_strvalmap("Mode capability", mode_capa_map,
1477                                                 interface->mode_capa);
1478
1479                 interface->ready = TRUE;
1480                 callback_interface_added(interface);
1481                 return;
1482         }
1483
1484         if (g_strcmp0(key, "Capabilities") == 0) {
1485                 supplicant_dbus_property_foreach(iter, interface_capability,
1486                                                                 interface);
1487         } else if (g_strcmp0(key, "State") == 0) {
1488                 const char *str = NULL;
1489
1490                 dbus_message_iter_get_basic(iter, &str);
1491                 if (str != NULL)
1492                         if (string2state(str) != interface->state) {
1493                                 interface->state = string2state(str);
1494                                 callback_interface_state(interface);
1495                         }
1496
1497                 SUPPLICANT_DBG("state %s (%d)", str, interface->state);
1498         } else if (g_strcmp0(key, "Scanning") == 0) {
1499                 dbus_bool_t scanning = FALSE;
1500
1501                 dbus_message_iter_get_basic(iter, &scanning);
1502                 interface->scanning = scanning;
1503
1504                 if (interface->ready == TRUE) {
1505                         if (interface->scanning == TRUE)
1506                                 callback_scan_started(interface);
1507                         else
1508                                 callback_scan_finished(interface);
1509                 }
1510         } else if (g_strcmp0(key, "ApScan") == 0) {
1511                 int apscan = 1;
1512
1513                 dbus_message_iter_get_basic(iter, &apscan);
1514                 interface->apscan = apscan;
1515         } else if (g_strcmp0(key, "Ifname") == 0) {
1516                 const char *str = NULL;
1517
1518                 dbus_message_iter_get_basic(iter, &str);
1519                 if (str != NULL) {
1520                         g_free(interface->ifname);
1521                         interface->ifname = g_strdup(str);
1522                 }
1523         } else if (g_strcmp0(key, "Driver") == 0) {
1524                 const char *str = NULL;
1525
1526                 dbus_message_iter_get_basic(iter, &str);
1527                 if (str != NULL) {
1528                         g_free(interface->driver);
1529                         interface->driver = g_strdup(str);
1530                 }
1531         } else if (g_strcmp0(key, "BridgeIfname") == 0) {
1532                 const char *str = NULL;
1533
1534                 dbus_message_iter_get_basic(iter, &str);
1535                 if (str != NULL) {
1536                         g_free(interface->bridge);
1537                         interface->bridge = g_strdup(str);
1538                 }
1539         } else if (g_strcmp0(key, "CurrentBSS") == 0) {
1540                 interface_bss_added_without_keys(iter, interface);
1541         } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
1542                 interface_network_added(iter, interface);
1543         } else if (g_strcmp0(key, "BSSs") == 0) {
1544                 supplicant_dbus_array_foreach(iter, interface_bss_added_without_keys,
1545                                                                 interface);
1546         } else if (g_strcmp0(key, "Blobs") == 0) {
1547                 /* Nothing */
1548         } else if (g_strcmp0(key, "Networks") == 0) {
1549                 supplicant_dbus_array_foreach(iter, interface_network_added,
1550                                                                 interface);
1551         } else
1552                 SUPPLICANT_DBG("key %s type %c",
1553                                 key, dbus_message_iter_get_arg_type(iter));
1554 }
1555
1556 static void scan_network_update(DBusMessageIter *iter, void *user_data)
1557 {
1558         GSupplicantInterface *interface = user_data;
1559         GSupplicantNetwork *network;
1560         char *path;
1561
1562         if (iter == NULL)
1563                 return;
1564
1565         dbus_message_iter_get_basic(iter, &path);
1566
1567         if (path == NULL)
1568                 return;
1569
1570         if (g_strcmp0(path, "/") == 0)
1571                 return;
1572
1573         /* Update the network details based on scan BSS data */
1574         network = g_hash_table_lookup(interface->bss_mapping, path);
1575         if (network != NULL)
1576                 callback_network_added(network);
1577 }
1578
1579 static void scan_bss_data(const char *key, DBusMessageIter *iter,
1580                                 void *user_data)
1581 {
1582         GSupplicantInterface *interface = user_data;
1583
1584         if (iter)
1585                 supplicant_dbus_array_foreach(iter, scan_network_update,
1586                                                 interface);
1587
1588         if (interface->scan_callback != NULL)
1589                 interface->scan_callback(0, interface, interface->scan_data);
1590
1591         interface->scan_callback = NULL;
1592         interface->scan_data = NULL;
1593 }
1594
1595 static GSupplicantInterface *interface_alloc(const char *path)
1596 {
1597         GSupplicantInterface *interface;
1598
1599         interface = g_try_new0(GSupplicantInterface, 1);
1600         if (interface == NULL)
1601                 return NULL;
1602
1603         interface->path = g_strdup(path);
1604
1605         interface->network_table = g_hash_table_new_full(g_str_hash,
1606                                         g_str_equal, NULL, remove_network);
1607
1608         interface->net_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
1609                                                                 NULL, NULL);
1610         interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
1611                                                                 NULL, NULL);
1612
1613         g_hash_table_replace(interface_table, interface->path, interface);
1614
1615         return interface;
1616 }
1617
1618 static void interface_added(DBusMessageIter *iter, void *user_data)
1619 {
1620         GSupplicantInterface *interface;
1621         const char *path = NULL;
1622
1623         SUPPLICANT_DBG("");
1624
1625         dbus_message_iter_get_basic(iter, &path);
1626         if (path == NULL)
1627                 return;
1628
1629         if (g_strcmp0(path, "/") == 0)
1630                 return;
1631
1632         interface = g_hash_table_lookup(interface_table, path);
1633         if (interface != NULL)
1634                 return;
1635
1636         interface = interface_alloc(path);
1637         if (interface == NULL)
1638                 return;
1639
1640         dbus_message_iter_next(iter);
1641         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
1642                 supplicant_dbus_property_foreach(iter, interface_property,
1643                                                                 interface);
1644                 interface_property(NULL, NULL, interface);
1645                 return;
1646         }
1647
1648         supplicant_dbus_property_get_all(path,
1649                                         SUPPLICANT_INTERFACE ".Interface",
1650                                                 interface_property, interface);
1651 }
1652
1653 static void interface_removed(DBusMessageIter *iter, void *user_data)
1654 {
1655         const char *path = NULL;
1656
1657         dbus_message_iter_get_basic(iter, &path);
1658         if (path == NULL)
1659                 return;
1660
1661         g_hash_table_remove(interface_table, path);
1662 }
1663
1664 static void eap_method(DBusMessageIter *iter, void *user_data)
1665 {
1666         const char *str = NULL;
1667         int i;
1668
1669         dbus_message_iter_get_basic(iter, &str);
1670         if (str == NULL)
1671                 return;
1672
1673         for (i = 0; eap_method_map[i].str != NULL; i++)
1674                 if (strcmp(str, eap_method_map[i].str) == 0) {
1675                         eap_methods |= eap_method_map[i].val;
1676                         break;
1677                 }
1678 }
1679
1680 static void service_property(const char *key, DBusMessageIter *iter,
1681                                                         void *user_data)
1682 {
1683         if (key == NULL) {
1684                 callback_system_ready();
1685                 return;
1686         }
1687
1688         if (g_strcmp0(key, "DebugLevel") == 0) {
1689                 const char *str = NULL;
1690                 int i;
1691
1692                 dbus_message_iter_get_basic(iter, &str);
1693                 for (i = 0; debug_strings[i] != NULL; i++)
1694                         if (g_strcmp0(debug_strings[i], str) == 0) {
1695                                 debug_level = i;
1696                                 break;
1697                         }
1698                 SUPPLICANT_DBG("Debug level %d", debug_level);
1699         } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
1700                 dbus_message_iter_get_basic(iter, &debug_timestamp);
1701                 SUPPLICANT_DBG("Debug timestamp %u", debug_timestamp);
1702         } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
1703                 dbus_message_iter_get_basic(iter, &debug_showkeys);
1704                 SUPPLICANT_DBG("Debug show keys %u", debug_showkeys);
1705         } else if (g_strcmp0(key, "Interfaces") == 0) {
1706                 supplicant_dbus_array_foreach(iter, interface_added, NULL);
1707         } else if (g_strcmp0(key, "EapMethods") == 0) {
1708                 supplicant_dbus_array_foreach(iter, eap_method, NULL);
1709                 debug_strvalmap("EAP method", eap_method_map, eap_methods);
1710         } else if (g_strcmp0(key, "Country") == 0) {
1711                 const char *country = NULL;
1712
1713                 dbus_message_iter_get_basic(iter, &country);
1714                 SUPPLICANT_DBG("Country %s", country);
1715         } else
1716                 SUPPLICANT_DBG("key %s type %c",
1717                                 key, dbus_message_iter_get_arg_type(iter));
1718 }
1719
1720 static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
1721 {
1722         const char *name = NULL, *old = NULL, *new = NULL;
1723
1724         SUPPLICANT_DBG("");
1725
1726         if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
1727                 return;
1728
1729         dbus_message_iter_get_basic(iter, &name);
1730         if (name == NULL)
1731                 return;
1732
1733         if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
1734                 return;
1735
1736         dbus_message_iter_next(iter);
1737         dbus_message_iter_get_basic(iter, &old);
1738         dbus_message_iter_next(iter);
1739         dbus_message_iter_get_basic(iter, &new);
1740
1741         if (old == NULL || new == NULL)
1742                 return;
1743
1744         if (strlen(old) > 0 && strlen(new) == 0) {
1745                 system_available = FALSE;
1746                 g_hash_table_remove_all(bss_mapping);
1747                 g_hash_table_remove_all(interface_table);
1748                 callback_system_killed();
1749         }
1750
1751         if (strlen(new) > 0 && strlen(old) == 0) {
1752                 system_available = TRUE;
1753                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
1754                                                         SUPPLICANT_INTERFACE,
1755                                                         service_property, NULL);
1756         }
1757 }
1758
1759 static void signal_properties_changed(const char *path, DBusMessageIter *iter)
1760 {
1761         SUPPLICANT_DBG("");
1762
1763         if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
1764                 return;
1765
1766         supplicant_dbus_property_foreach(iter, service_property, NULL);
1767 }
1768
1769 static void signal_interface_added(const char *path, DBusMessageIter *iter)
1770 {
1771         SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
1772
1773         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
1774                 interface_added(iter, NULL);
1775 }
1776
1777 static void signal_interface_removed(const char *path, DBusMessageIter *iter)
1778 {
1779         SUPPLICANT_DBG("");
1780
1781         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
1782                 interface_removed(iter, NULL);
1783 }
1784
1785 static void signal_interface_changed(const char *path, DBusMessageIter *iter)
1786 {
1787         GSupplicantInterface *interface;
1788
1789         SUPPLICANT_DBG("");
1790
1791         interface = g_hash_table_lookup(interface_table, path);
1792         if (interface == NULL)
1793                 return;
1794
1795         supplicant_dbus_property_foreach(iter, interface_property, interface);
1796 }
1797
1798 static void signal_scan_done(const char *path, DBusMessageIter *iter)
1799 {
1800         GSupplicantInterface *interface;
1801         dbus_bool_t success = FALSE;
1802
1803         SUPPLICANT_DBG("");
1804
1805         interface = g_hash_table_lookup(interface_table, path);
1806         if (interface == NULL)
1807                 return;
1808
1809         dbus_message_iter_get_basic(iter, &success);
1810
1811         /*
1812          * If scan is unsuccessful return -EIO else get the scanned BSSs
1813          * and update the network details accordingly
1814          */
1815         if (success == FALSE) {
1816                 if (interface->scan_callback != NULL)
1817                         interface->scan_callback(-EIO, interface,
1818                                                 interface->scan_data);
1819
1820                 interface->scan_callback = NULL;
1821                 interface->scan_data = NULL;
1822
1823                 return;
1824         }
1825
1826         supplicant_dbus_property_get(path, SUPPLICANT_INTERFACE ".Interface",
1827                                         "BSSs", scan_bss_data, interface);
1828 }
1829
1830 static void signal_bss_added(const char *path, DBusMessageIter *iter)
1831 {
1832         GSupplicantInterface *interface;
1833
1834         SUPPLICANT_DBG("");
1835
1836         interface = g_hash_table_lookup(interface_table, path);
1837         if (interface == NULL)
1838                 return;
1839
1840         interface_bss_added_with_keys(iter, interface);
1841 }
1842
1843 static void signal_bss_removed(const char *path, DBusMessageIter *iter)
1844 {
1845         GSupplicantInterface *interface;
1846
1847         SUPPLICANT_DBG("");
1848
1849         interface = g_hash_table_lookup(interface_table, path);
1850         if (interface == NULL)
1851                 return;
1852
1853         interface_bss_removed(iter, interface);
1854 }
1855
1856 static void signal_network_added(const char *path, DBusMessageIter *iter)
1857 {
1858         GSupplicantInterface *interface;
1859
1860         SUPPLICANT_DBG("");
1861
1862         interface = g_hash_table_lookup(interface_table, path);
1863         if (interface == NULL)
1864                 return;
1865
1866         interface_network_added(iter, interface);
1867 }
1868
1869 static void signal_network_removed(const char *path, DBusMessageIter *iter)
1870 {
1871         GSupplicantInterface *interface;
1872
1873         SUPPLICANT_DBG("");
1874
1875         interface = g_hash_table_lookup(interface_table, path);
1876         if (interface == NULL)
1877                 return;
1878
1879         interface_network_removed(iter, interface);
1880 }
1881
1882 static void signal_bss_changed(const char *path, DBusMessageIter *iter)
1883 {
1884         GSupplicantInterface *interface;
1885         GSupplicantNetwork *network;
1886         struct g_supplicant_bss *bss;
1887
1888         SUPPLICANT_DBG("");
1889
1890         interface = g_hash_table_lookup(bss_mapping, path);
1891         if (interface == NULL)
1892                 return;
1893
1894         network = g_hash_table_lookup(interface->bss_mapping, path);
1895         if (network == NULL)
1896                 return;
1897
1898         bss = g_hash_table_lookup(network->bss_table, path);
1899         if (bss == NULL)
1900                 return;
1901
1902         supplicant_dbus_property_foreach(iter, bss_property, bss);
1903
1904         if (bss->signal == network->signal)
1905                 return;
1906
1907         /*
1908          * If the new signal is lower than the SSID signal, we need
1909          * to check for the new maximum.
1910          */
1911         if (bss->signal < network->signal) {
1912                 if (bss != network->best_bss)
1913                         return;
1914                 network->signal = bss->signal;
1915                 update_network_signal(network);
1916         } else {
1917                 network->signal = bss->signal;
1918                 network->best_bss = bss;
1919         }
1920
1921         SUPPLICANT_DBG("New network signal for %s %d dBm", network->ssid, network->signal);
1922
1923         callback_network_changed(network, "Signal");
1924 }
1925
1926 static void wps_credentials(const char *key, DBusMessageIter *iter,
1927                         void *user_data)
1928 {
1929         GSupplicantInterface *interface = user_data;
1930
1931         if (key == NULL)
1932                 return;
1933
1934         SUPPLICANT_DBG("key %s", key);
1935
1936         if (g_strcmp0(key, "Key") == 0) {
1937                 DBusMessageIter array;
1938                 unsigned char *key;
1939                 int key_len;
1940
1941                 dbus_message_iter_recurse(iter, &array);
1942                 dbus_message_iter_get_fixed_array(&array, &key, &key_len);
1943
1944                 g_free(interface->wps_cred.key);
1945                 interface->wps_cred.key = g_try_malloc0(
1946                                                 sizeof(char) * key_len+1);
1947
1948                 if (interface->wps_cred.key == NULL)
1949                         return;
1950
1951                 memcpy(interface->wps_cred.key, key, sizeof(char) * key_len);
1952
1953                 SUPPLICANT_DBG("WPS key present");
1954         } else if (g_strcmp0(key, "SSID") == 0) {
1955                 DBusMessageIter array;
1956                 unsigned char *ssid;
1957                 int ssid_len;
1958
1959                 dbus_message_iter_recurse(iter, &array);
1960                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
1961
1962                 if (ssid_len > 0 && ssid_len < 33) {
1963                         memcpy(interface->wps_cred.ssid, ssid, ssid_len);
1964                         interface->wps_cred.ssid_len = ssid_len;
1965                 } else {
1966                         memset(interface->wps_cred.ssid, 0, 32);
1967                         interface->wps_cred.ssid_len = 0;
1968                 }
1969         }
1970 }
1971
1972 static void signal_wps_credentials(const char *path, DBusMessageIter *iter)
1973 {
1974         GSupplicantInterface *interface;
1975
1976         SUPPLICANT_DBG("");
1977
1978         interface = g_hash_table_lookup(interface_table, path);
1979         if (interface == NULL)
1980                 return;
1981
1982         supplicant_dbus_property_foreach(iter, wps_credentials, interface);
1983 }
1984
1985 static void wps_event_args(const char *key, DBusMessageIter *iter,
1986                         void *user_data)
1987 {
1988         GSupplicantInterface *interface = user_data;
1989
1990         if (key == NULL || interface == NULL)
1991                 return;
1992
1993         SUPPLICANT_DBG("Arg Key %s", key);
1994 }
1995
1996 static void signal_wps_event(const char *path, DBusMessageIter *iter)
1997 {
1998         GSupplicantInterface *interface;
1999         const char *name = NULL;
2000
2001         SUPPLICANT_DBG("");
2002
2003         interface = g_hash_table_lookup(interface_table, path);
2004         if (interface == NULL)
2005                 return;
2006
2007         dbus_message_iter_get_basic(iter, &name);
2008
2009         SUPPLICANT_DBG("Name: %s", name);
2010
2011         if (g_strcmp0(name, "success") == 0)
2012                 interface->wps_state = G_SUPPLICANT_WPS_STATE_SUCCESS;
2013         else if (g_strcmp0(name, "failed") == 0)
2014                 interface->wps_state = G_SUPPLICANT_WPS_STATE_FAIL;
2015         else
2016                 interface->wps_state = G_SUPPLICANT_WPS_STATE_UNKNOWN;
2017
2018         if (!dbus_message_iter_has_next(iter))
2019                 return;
2020
2021         dbus_message_iter_next(iter);
2022
2023         supplicant_dbus_property_foreach(iter, wps_event_args, interface);
2024 }
2025
2026 static struct {
2027         const char *interface;
2028         const char *member;
2029         void (*function) (const char *path, DBusMessageIter *iter);
2030 } signal_map[] = {
2031         { DBUS_INTERFACE_DBUS,  "NameOwnerChanged",  signal_name_owner_changed },
2032
2033         { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
2034         { SUPPLICANT_INTERFACE, "InterfaceAdded",    signal_interface_added    },
2035         { SUPPLICANT_INTERFACE, "InterfaceCreated",  signal_interface_added    },
2036         { SUPPLICANT_INTERFACE, "InterfaceRemoved",  signal_interface_removed  },
2037
2038         { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
2039         { SUPPLICANT_INTERFACE ".Interface", "ScanDone",          signal_scan_done         },
2040         { SUPPLICANT_INTERFACE ".Interface", "BSSAdded",          signal_bss_added         },
2041         { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved",        signal_bss_removed       },
2042         { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded",      signal_network_added     },
2043         { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved",    signal_network_removed   },
2044
2045         { SUPPLICANT_INTERFACE ".BSS", "PropertiesChanged", signal_bss_changed   },
2046
2047         { SUPPLICANT_INTERFACE ".Interface.WPS", "Credentials", signal_wps_credentials },
2048         { SUPPLICANT_INTERFACE ".Interface.WPS", "Event",       signal_wps_event       },
2049
2050         { }
2051 };
2052
2053 static DBusHandlerResult g_supplicant_filter(DBusConnection *conn,
2054                                         DBusMessage *message, void *data)
2055 {
2056         DBusMessageIter iter;
2057         const char *path;
2058         int i;
2059
2060         path = dbus_message_get_path(message);
2061         if (path == NULL)
2062                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2063
2064         if (dbus_message_iter_init(message, &iter) == FALSE)
2065                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2066
2067         for (i = 0; signal_map[i].interface != NULL; i++) {
2068                 if (dbus_message_has_interface(message,
2069                                         signal_map[i].interface) == FALSE)
2070                         continue;
2071
2072                 if (dbus_message_has_member(message,
2073                                         signal_map[i].member) == FALSE)
2074                         continue;
2075
2076                 signal_map[i].function(path, &iter);
2077                 break;
2078         }
2079
2080         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2081 }
2082
2083 struct supplicant_regdom {
2084         GSupplicantCountryCallback callback;
2085         const void *user_data;
2086 };
2087
2088 static void country_result(const char *error,
2089                                 DBusMessageIter *iter, void *user_data)
2090 {
2091         struct supplicant_regdom *regdom = user_data;
2092         char *alpha2;
2093
2094         SUPPLICANT_DBG("Country setting result");
2095
2096         if (user_data == NULL)
2097                 return;
2098
2099         if (error == NULL) {
2100                 alpha2 = (char *)regdom->user_data;
2101         } else {
2102                 SUPPLICANT_DBG("Country setting failure %s", error);
2103                 alpha2 = NULL;
2104         }
2105
2106         if (regdom->callback)
2107                 regdom->callback(alpha2);
2108
2109         g_free(regdom);
2110 }
2111
2112 static void country_params(DBusMessageIter *iter, void *user_data)
2113 {
2114         struct supplicant_regdom *regdom = user_data;
2115         const char *country;
2116
2117         country = regdom->user_data;
2118
2119         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &country);
2120 }
2121
2122 int g_supplicant_set_country(const char *alpha2,
2123                                 GSupplicantCountryCallback callback,
2124                                         const void *user_data)
2125 {
2126         struct supplicant_regdom *regdom;
2127
2128         SUPPLICANT_DBG("Country setting %s", alpha2);
2129
2130         if (system_available == FALSE)
2131                 return -EFAULT;
2132
2133         regdom = dbus_malloc0(sizeof(*regdom));
2134         if (regdom == NULL)
2135                 return -ENOMEM;
2136
2137         regdom->callback = callback;
2138         regdom->user_data = user_data;
2139
2140         return supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
2141                                         "Country", DBUS_TYPE_STRING_AS_STRING,
2142                                         country_params, country_result,
2143                                                 regdom);
2144 }
2145
2146 struct interface_data {
2147         GSupplicantInterface *interface;
2148         GSupplicantInterfaceCallback callback;
2149         void *user_data;
2150 };
2151
2152 struct interface_create_data {
2153         const char *ifname;
2154         const char *driver;
2155         const char *bridge;
2156         GSupplicantInterface *interface;
2157         GSupplicantInterfaceCallback callback;
2158         void *user_data;
2159 };
2160
2161 struct interface_connect_data {
2162         GSupplicantInterface *interface;
2163         GSupplicantInterfaceCallback callback;
2164         GSupplicantSSID *ssid;
2165         void *user_data;
2166 };
2167
2168 static void interface_create_property(const char *key, DBusMessageIter *iter,
2169                                                         void *user_data)
2170 {
2171         struct interface_create_data *data = user_data;
2172         GSupplicantInterface *interface = data->interface;
2173
2174         if (key == NULL) {
2175                 if (data->callback != NULL)
2176                         data->callback(0, data->interface, data->user_data);
2177
2178                 dbus_free(data);
2179         }
2180
2181         interface_property(key, iter, interface);
2182 }
2183
2184 static void interface_create_result(const char *error,
2185                                 DBusMessageIter *iter, void *user_data)
2186 {
2187         struct interface_create_data *data = user_data;
2188         const char *path = NULL;
2189         int err;
2190
2191         SUPPLICANT_DBG("");
2192
2193         if (error != NULL) {
2194                 g_critical("error %s", error);
2195                 err = -EIO;
2196                 goto done;
2197         }
2198
2199         dbus_message_iter_get_basic(iter, &path);
2200         if (path == NULL) {
2201                 err = -EINVAL;
2202                 goto done;
2203         }
2204
2205         if (system_available == FALSE) {
2206                 err = -EFAULT;
2207                 goto done;
2208         }
2209
2210         data->interface = g_hash_table_lookup(interface_table, path);
2211         if (data->interface == NULL) {
2212                 data->interface = interface_alloc(path);
2213                 if (data->interface == NULL) {
2214                         err = -ENOMEM;
2215                         goto done;
2216                 }
2217         }
2218
2219         err = supplicant_dbus_property_get_all(path,
2220                                         SUPPLICANT_INTERFACE ".Interface",
2221                                         interface_create_property, data);
2222         if (err == 0)
2223                 return;
2224
2225 done:
2226         if (data->callback != NULL)
2227                 data->callback(err, NULL, data->user_data);
2228
2229         dbus_free(data);
2230 }
2231
2232 static void interface_create_params(DBusMessageIter *iter, void *user_data)
2233 {
2234         struct interface_create_data *data = user_data;
2235         DBusMessageIter dict;
2236
2237         SUPPLICANT_DBG("");
2238
2239         supplicant_dbus_dict_open(iter, &dict);
2240
2241         supplicant_dbus_dict_append_basic(&dict, "Ifname",
2242                                         DBUS_TYPE_STRING, &data->ifname);
2243
2244         if (data->driver != NULL)
2245                 supplicant_dbus_dict_append_basic(&dict, "Driver",
2246                                         DBUS_TYPE_STRING, &data->driver);
2247
2248         if (data->bridge != NULL)
2249                 supplicant_dbus_dict_append_basic(&dict, "BridgeIfname",
2250                                         DBUS_TYPE_STRING, &data->bridge);
2251
2252         supplicant_dbus_dict_close(iter, &dict);
2253 }
2254
2255 static void interface_get_result(const char *error,
2256                                 DBusMessageIter *iter, void *user_data)
2257 {
2258         struct interface_create_data *data = user_data;
2259         GSupplicantInterface *interface;
2260         const char *path = NULL;
2261         int err;
2262
2263         SUPPLICANT_DBG("");
2264
2265         if (error != NULL) {
2266                 SUPPLICANT_DBG("Interface not created yet");
2267                 err = -EIO;
2268                 goto create;
2269         }
2270
2271         dbus_message_iter_get_basic(iter, &path);
2272         if (path == NULL) {
2273                 err = -EINVAL;
2274                 goto done;
2275         }
2276
2277         interface = g_hash_table_lookup(interface_table, path);
2278         if (interface == NULL) {
2279                 err = -ENOENT;
2280                 goto done;
2281         }
2282
2283         if (data->callback != NULL)
2284                 data->callback(0, interface, data->user_data);
2285
2286         dbus_free(data);
2287
2288         return;
2289
2290 create:
2291         if (system_available == FALSE) {
2292                 err = -EFAULT;
2293                 goto done;
2294         }
2295
2296         SUPPLICANT_DBG("Creating interface");
2297
2298         err = supplicant_dbus_method_call(SUPPLICANT_PATH,
2299                                                 SUPPLICANT_INTERFACE,
2300                                                 "CreateInterface",
2301                                                 interface_create_params,
2302                                                 interface_create_result, data);
2303         if (err == 0)
2304                 return;
2305
2306 done:
2307         if (data->callback != NULL)
2308                 data->callback(err, NULL, data->user_data);
2309
2310         dbus_free(data);
2311 }
2312
2313 static void interface_get_params(DBusMessageIter *iter, void *user_data)
2314 {
2315         struct interface_create_data *data = user_data;
2316
2317         SUPPLICANT_DBG("");
2318
2319         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
2320 }
2321
2322 int g_supplicant_interface_create(const char *ifname, const char *driver,
2323                                         const char *bridge,
2324                                         GSupplicantInterfaceCallback callback,
2325                                                         void *user_data)
2326 {
2327         struct interface_create_data *data;
2328
2329         SUPPLICANT_DBG("ifname %s", ifname);
2330
2331         if (ifname == NULL)
2332                 return -EINVAL;
2333
2334         if (system_available == FALSE)
2335                 return -EFAULT;
2336
2337         data = dbus_malloc0(sizeof(*data));
2338         if (data == NULL)
2339                 return -ENOMEM;
2340
2341         data->ifname = ifname;
2342         data->driver = driver;
2343         data->bridge = bridge;
2344         data->callback = callback;
2345         data->user_data = user_data;
2346
2347         return supplicant_dbus_method_call(SUPPLICANT_PATH,
2348                                                 SUPPLICANT_INTERFACE,
2349                                                 "GetInterface",
2350                                                 interface_get_params,
2351                                                 interface_get_result, data);
2352 }
2353
2354 static void interface_remove_result(const char *error,
2355                                 DBusMessageIter *iter, void *user_data)
2356 {
2357         struct interface_data *data = user_data;
2358         int err;
2359
2360         if (error != NULL) {
2361                 err = -EIO;
2362                 goto done;
2363         }
2364
2365         if (system_available == FALSE) {
2366                 err = -EFAULT;
2367                 goto done;
2368         }
2369
2370         /*
2371          * The gsupplicant interface is already freed by the InterfaceRemoved
2372          * signal callback. Simply invoke the interface_data callback.
2373          */
2374         err = 0;
2375
2376 done:
2377         if (data->callback != NULL)
2378                 data->callback(err, NULL, data->user_data);
2379
2380         dbus_free(data);
2381 }
2382
2383
2384 static void interface_remove_params(DBusMessageIter *iter, void *user_data)
2385 {
2386         struct interface_data *data = user_data;
2387
2388         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
2389                                                         &data->interface->path);
2390 }
2391
2392
2393 int g_supplicant_interface_remove(GSupplicantInterface *interface,
2394                         GSupplicantInterfaceCallback callback,
2395                                                         void *user_data)
2396 {
2397         struct interface_data *data;
2398
2399         if (interface == NULL)
2400                 return -EINVAL;
2401
2402         if (system_available == FALSE)
2403                 return -EFAULT;
2404
2405         data = dbus_malloc0(sizeof(*data));
2406         if (data == NULL)
2407                 return -ENOMEM;
2408
2409         data->interface = interface;
2410         data->callback = callback;
2411         data->user_data = user_data;
2412
2413         return supplicant_dbus_method_call(SUPPLICANT_PATH,
2414                                                 SUPPLICANT_INTERFACE,
2415                                                 "RemoveInterface",
2416                                                 interface_remove_params,
2417                                                 interface_remove_result, data);
2418 }
2419
2420 static void interface_scan_result(const char *error,
2421                                 DBusMessageIter *iter, void *user_data)
2422 {
2423         struct interface_data *data = user_data;
2424
2425         if (error != NULL) {
2426                 if (data->callback != NULL)
2427                         data->callback(-EIO, data->interface, data->user_data);
2428         } else {
2429                 data->interface->scan_callback = data->callback;
2430                 data->interface->scan_data = data->user_data;
2431         }
2432
2433         dbus_free(data);
2434 }
2435
2436 static void interface_scan_params(DBusMessageIter *iter, void *user_data)
2437 {
2438         DBusMessageIter dict;
2439         const char *type = "passive";
2440
2441         supplicant_dbus_dict_open(iter, &dict);
2442
2443         supplicant_dbus_dict_append_basic(&dict, "Type",
2444                                                 DBUS_TYPE_STRING, &type);
2445
2446         supplicant_dbus_dict_close(iter, &dict);
2447 }
2448
2449 int g_supplicant_interface_scan(GSupplicantInterface *interface,
2450                                 GSupplicantInterfaceCallback callback,
2451                                                         void *user_data)
2452 {
2453         struct interface_data *data;
2454
2455         if (interface == NULL)
2456                 return -EINVAL;
2457
2458         if (system_available == FALSE)
2459                 return -EFAULT;
2460
2461         if (interface->scanning == TRUE)
2462                 return -EALREADY;
2463
2464         switch (interface->state) {
2465         case G_SUPPLICANT_STATE_AUTHENTICATING:
2466         case G_SUPPLICANT_STATE_ASSOCIATING:
2467         case G_SUPPLICANT_STATE_ASSOCIATED:
2468         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2469         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2470                 return -EBUSY;
2471         case G_SUPPLICANT_STATE_UNKNOWN:
2472         case G_SUPPLICANT_STATE_DISCONNECTED:
2473         case G_SUPPLICANT_STATE_INACTIVE:
2474         case G_SUPPLICANT_STATE_SCANNING:
2475         case G_SUPPLICANT_STATE_COMPLETED:
2476                 break;
2477         }
2478
2479         data = dbus_malloc0(sizeof(*data));
2480         if (data == NULL)
2481                 return -ENOMEM;
2482
2483         data->interface = interface;
2484         data->callback = callback;
2485         data->user_data = user_data;
2486
2487         return supplicant_dbus_method_call(interface->path,
2488                         SUPPLICANT_INTERFACE ".Interface", "Scan",
2489                         interface_scan_params, interface_scan_result, data);
2490 }
2491
2492 static int parse_supplicant_error(DBusMessageIter *iter)
2493 {
2494         int err = -ECANCELED;
2495         char *key;
2496
2497         while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
2498                 dbus_message_iter_get_basic(iter, &key);
2499                 if (strncmp(key, "psk", 4) == 0 ||
2500                         strncmp(key, "wep_key", 7) == 0) {
2501                         err = -ENOKEY;
2502                         break;
2503                 }
2504                 dbus_message_iter_next(iter);
2505         }
2506
2507         return err;
2508 }
2509
2510 static void interface_select_network_result(const char *error,
2511                                 DBusMessageIter *iter, void *user_data)
2512 {
2513         struct interface_connect_data *data = user_data;
2514         int err;
2515
2516         SUPPLICANT_DBG("");
2517
2518         err = 0;
2519         if (error != NULL) {
2520                 SUPPLICANT_DBG("SelectNetwork error %s", error);
2521                 err = parse_supplicant_error(iter);
2522         }
2523
2524         if (data->callback != NULL)
2525                 data->callback(err, data->interface, data->user_data);
2526
2527         g_free(data->ssid);
2528         dbus_free(data);
2529 }
2530
2531 static void interface_select_network_params(DBusMessageIter *iter,
2532                                                         void *user_data)
2533 {
2534         struct interface_connect_data *data = user_data;
2535         GSupplicantInterface *interface = data->interface;
2536
2537         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
2538                                         &interface->network_path);
2539 }
2540
2541 static void interface_add_network_result(const char *error,
2542                                 DBusMessageIter *iter, void *user_data)
2543 {
2544         struct interface_connect_data *data = user_data;
2545         GSupplicantInterface *interface = data->interface;
2546         const char *path;
2547         int err;
2548
2549         if (error != NULL)
2550                 goto error;
2551
2552         dbus_message_iter_get_basic(iter, &path);
2553         if (path == NULL)
2554                 goto error;
2555
2556         SUPPLICANT_DBG("PATH: %s", path);
2557
2558         g_free(interface->network_path);
2559         interface->network_path = g_strdup(path);
2560
2561         supplicant_dbus_method_call(data->interface->path,
2562                         SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
2563                         interface_select_network_params,
2564                         interface_select_network_result, data);
2565
2566         return;
2567
2568 error:
2569         SUPPLICANT_DBG("AddNetwork error %s", error);
2570         err = parse_supplicant_error(iter);
2571         if (data->callback != NULL)
2572                 data->callback(err, data->interface, data->user_data);
2573
2574         g_free(interface->network_path);
2575         interface->network_path = NULL;
2576         g_free(data->ssid);
2577         g_free(data);
2578 }
2579
2580 static void add_network_security_wep(DBusMessageIter *dict,
2581                                         GSupplicantSSID *ssid)
2582 {
2583         const char *auth_alg = "OPEN SHARED";
2584         const char *key_index = "0";
2585
2586         supplicant_dbus_dict_append_basic(dict, "auth_alg",
2587                                         DBUS_TYPE_STRING, &auth_alg);
2588
2589         if (ssid->passphrase) {
2590                 int size = strlen(ssid->passphrase);
2591                 if (size == 10 || size == 26) {
2592                         unsigned char *key = g_try_malloc(13);
2593                         char tmp[3];
2594                         int i;
2595
2596                         memset(tmp, 0, sizeof(tmp));
2597                         if (key == NULL)
2598                                 size = 0;
2599
2600                         for (i = 0; i < size / 2; i++) {
2601                                 memcpy(tmp, ssid->passphrase + (i * 2), 2);
2602                                 key[i] = (unsigned char) strtol(tmp, NULL, 16);
2603                         }
2604
2605                         supplicant_dbus_dict_append_fixed_array(dict,
2606                                                         "wep_key0",
2607                                                         DBUS_TYPE_BYTE,
2608                                                         &key, size / 2);
2609                         g_free(key);
2610                 } else if (size == 5 || size == 13) {
2611                         unsigned char *key = g_try_malloc(13);
2612                         int i;
2613
2614                         if (key == NULL)
2615                                 size = 0;
2616
2617                         for (i = 0; i < size; i++)
2618                                 key[i] = (unsigned char) ssid->passphrase[i];
2619
2620                         supplicant_dbus_dict_append_fixed_array(dict,
2621                                                                 "wep_key0",
2622                                                                 DBUS_TYPE_BYTE,
2623                                                                 &key, size);
2624                         g_free(key);
2625                 } else
2626                         supplicant_dbus_dict_append_basic(dict,
2627                                                         "wep_key0",
2628                                                         DBUS_TYPE_STRING,
2629                                                         &ssid->passphrase);
2630
2631                 supplicant_dbus_dict_append_basic(dict, "wep_tx_keyidx",
2632                                         DBUS_TYPE_STRING, &key_index);
2633         }
2634 }
2635
2636 static dbus_bool_t is_psk_raw_key(const char *psk)
2637 {
2638         int i;
2639
2640         /* A raw key is always 64 bytes length... */
2641         if (strlen(psk) != 64)
2642                 return FALSE;
2643
2644         /* ... and its content is in hex representation */
2645         for (i = 0; i < 64; i++)
2646                 if (!isxdigit((unsigned char) psk[i]))
2647                         return FALSE;
2648
2649         return TRUE;
2650 }
2651
2652 static void add_network_security_psk(DBusMessageIter *dict,
2653                                         GSupplicantSSID *ssid)
2654 {
2655         if (ssid->passphrase && strlen(ssid->passphrase) > 0) {
2656
2657                 if (is_psk_raw_key(ssid->passphrase) == TRUE)
2658                         supplicant_dbus_property_append_fixed_array(dict,
2659                                                         "psk", DBUS_TYPE_BYTE,
2660                                                         &ssid->passphrase, 64);
2661                 else
2662                         supplicant_dbus_dict_append_basic(dict, "psk",
2663                                                         DBUS_TYPE_STRING,
2664                                                         &ssid->passphrase);
2665         }
2666 }
2667
2668 static void add_network_security_tls(DBusMessageIter *dict,
2669                                         GSupplicantSSID *ssid)
2670 {
2671         /*
2672          * For TLS, we at least need:
2673          *              The client certificate
2674          *              The client private key file
2675          *              The client private key file password
2676          *
2677          * The Authority certificate is optional.
2678          */
2679         if (ssid->client_cert_path == NULL)
2680                 return;
2681
2682         if (ssid->private_key_path == NULL)
2683                 return;
2684
2685         if (ssid->private_key_passphrase == NULL)
2686                 return;
2687
2688         if (ssid->ca_cert_path)
2689                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
2690                                         DBUS_TYPE_STRING, &ssid->ca_cert_path);
2691
2692         supplicant_dbus_dict_append_basic(dict, "private_key",
2693                                                 DBUS_TYPE_STRING,
2694                                                 &ssid->private_key_path);
2695         supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
2696                                                 DBUS_TYPE_STRING,
2697                                                 &ssid->private_key_passphrase);
2698         supplicant_dbus_dict_append_basic(dict, "client_cert",
2699                                                 DBUS_TYPE_STRING,
2700                                                 &ssid->client_cert_path);
2701 }
2702
2703 static void add_network_security_peap(DBusMessageIter *dict,
2704                                         GSupplicantSSID *ssid)
2705 {
2706         char *phase2_auth;
2707
2708         /*
2709          * For PEAP/TTLS, we at least need
2710          *              The authority certificate
2711          *              The 2nd phase authentication method
2712          *              The 2nd phase passphrase
2713          *
2714          * The Client certificate is optional although strongly recommended
2715          * When setting it, we need in addition
2716          *              The Client private key file
2717          *              The Client private key file password
2718          */
2719         if (ssid->passphrase == NULL)
2720                 return;
2721
2722         if (ssid->phase2_auth == NULL)
2723                 return;
2724
2725         if (ssid->client_cert_path) {
2726                 if (ssid->private_key_path == NULL)
2727                         return;
2728
2729                 if (ssid->private_key_passphrase == NULL)
2730                         return;
2731
2732                 supplicant_dbus_dict_append_basic(dict, "client_cert",
2733                                                 DBUS_TYPE_STRING,
2734                                                 &ssid->client_cert_path);
2735
2736                 supplicant_dbus_dict_append_basic(dict, "private_key",
2737                                                 DBUS_TYPE_STRING,
2738                                                 &ssid->private_key_path);
2739
2740                 supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
2741                                                 DBUS_TYPE_STRING,
2742                                                 &ssid->private_key_passphrase);
2743
2744         }
2745
2746         if (g_str_has_prefix(ssid->phase2_auth, "EAP-") == TRUE) {
2747                 phase2_auth = g_strdup_printf("autheap=%s",
2748                                         ssid->phase2_auth + strlen("EAP-"));
2749         } else
2750                 phase2_auth = g_strdup_printf("auth=%s", ssid->phase2_auth);
2751
2752         supplicant_dbus_dict_append_basic(dict, "password",
2753                                                 DBUS_TYPE_STRING,
2754                                                 &ssid->passphrase);
2755
2756         if (ssid->ca_cert_path)
2757                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
2758                                                 DBUS_TYPE_STRING,
2759                                                 &ssid->ca_cert_path);
2760
2761         supplicant_dbus_dict_append_basic(dict, "phase2",
2762                                                 DBUS_TYPE_STRING,
2763                                                 &phase2_auth);
2764
2765         g_free(phase2_auth);
2766 }
2767
2768 static void add_network_security_eap(DBusMessageIter *dict,
2769                                         GSupplicantSSID *ssid)
2770 {
2771         char *eap_value;
2772
2773         if (ssid->eap == NULL || ssid->identity == NULL)
2774                 return;
2775
2776         if (g_strcmp0(ssid->eap, "tls") == 0) {
2777                 add_network_security_tls(dict, ssid);
2778         } else if (g_strcmp0(ssid->eap, "peap") == 0 ||
2779                                 g_strcmp0(ssid->eap, "ttls") == 0) {
2780                 add_network_security_peap(dict, ssid);
2781         } else
2782                 return;
2783
2784         eap_value = g_ascii_strup(ssid->eap, -1);
2785
2786         supplicant_dbus_dict_append_basic(dict, "eap",
2787                                                 DBUS_TYPE_STRING,
2788                                                 &eap_value);
2789         supplicant_dbus_dict_append_basic(dict, "identity",
2790                                                 DBUS_TYPE_STRING,
2791                                                 &ssid->identity);
2792
2793         g_free(eap_value);
2794 }
2795
2796 static void add_network_security_ciphers(DBusMessageIter *dict,
2797                                                 GSupplicantSSID *ssid)
2798 {
2799         unsigned int p_cipher, g_cipher, i;
2800         char *pairwise, *group;
2801         char *pair_ciphers[4];
2802         char *group_ciphers[5];
2803
2804         p_cipher = ssid->pairwise_cipher;
2805         g_cipher = ssid->group_cipher;
2806
2807         if (p_cipher == 0 && g_cipher == 0)
2808                 return;
2809
2810         i = 0;
2811
2812         if (p_cipher & G_SUPPLICANT_PAIRWISE_CCMP)
2813                 pair_ciphers[i++] = "CCMP";
2814
2815         if (p_cipher & G_SUPPLICANT_PAIRWISE_TKIP)
2816                 pair_ciphers[i++] = "TKIP";
2817
2818         if (p_cipher & G_SUPPLICANT_PAIRWISE_NONE)
2819                 pair_ciphers[i++] = "NONE";
2820
2821         pair_ciphers[i] = NULL;
2822
2823         i = 0;
2824
2825         if (g_cipher & G_SUPPLICANT_GROUP_CCMP)
2826                 group_ciphers[i++] = "CCMP";
2827
2828         if (g_cipher & G_SUPPLICANT_GROUP_TKIP)
2829                 group_ciphers[i++] = "TKIP";
2830
2831         if (g_cipher & G_SUPPLICANT_GROUP_WEP104)
2832                 group_ciphers[i++] = "WEP104";
2833
2834         if (g_cipher & G_SUPPLICANT_GROUP_WEP40)
2835                 group_ciphers[i++] = "WEP40";
2836
2837         group_ciphers[i] = NULL;
2838
2839         pairwise = g_strjoinv(" ", pair_ciphers);
2840         group = g_strjoinv(" ", group_ciphers);
2841
2842         SUPPLICANT_DBG("cipher %s %s", pairwise, group);
2843
2844         supplicant_dbus_dict_append_basic(dict, "pairwise",
2845                                                 DBUS_TYPE_STRING,
2846                                                 &pairwise);
2847         supplicant_dbus_dict_append_basic(dict, "group",
2848                                                 DBUS_TYPE_STRING,
2849                                                 &group);
2850
2851         g_free(pairwise);
2852         g_free(group);
2853 }
2854
2855 static void add_network_security_proto(DBusMessageIter *dict,
2856                                                 GSupplicantSSID *ssid)
2857 {
2858         unsigned int protocol, i;
2859         char *proto;
2860         char *protos[3];
2861
2862         protocol = ssid->protocol;
2863
2864         if (protocol == 0)
2865                 return;
2866
2867         i = 0;
2868
2869         if (protocol & G_SUPPLICANT_PROTO_RSN)
2870                 protos[i++] = "RSN";
2871
2872         if (protocol & G_SUPPLICANT_PROTO_WPA)
2873                 protos[i++] = "WPA";
2874
2875         protos[i] = NULL;
2876
2877         proto = g_strjoinv(" ", protos);
2878
2879         SUPPLICANT_DBG("proto %s", proto);
2880
2881         supplicant_dbus_dict_append_basic(dict, "proto",
2882                                                 DBUS_TYPE_STRING,
2883                                                 &proto);
2884
2885         g_free(proto);
2886 }
2887
2888 static void add_network_security(DBusMessageIter *dict, GSupplicantSSID *ssid)
2889 {
2890         char *key_mgmt;
2891
2892         switch (ssid->security) {
2893         case G_SUPPLICANT_SECURITY_UNKNOWN:
2894         case G_SUPPLICANT_SECURITY_NONE:
2895         case G_SUPPLICANT_SECURITY_WEP:
2896                 key_mgmt = "NONE";
2897                 add_network_security_wep(dict, ssid);
2898                 add_network_security_ciphers(dict, ssid);
2899                 break;
2900         case G_SUPPLICANT_SECURITY_PSK:
2901                 key_mgmt = "WPA-PSK";
2902                 add_network_security_psk(dict, ssid);
2903                 add_network_security_ciphers(dict, ssid);
2904                 add_network_security_proto(dict, ssid);
2905                 break;
2906         case G_SUPPLICANT_SECURITY_IEEE8021X:
2907                 key_mgmt = "WPA-EAP";
2908                 add_network_security_eap(dict, ssid);
2909                 add_network_security_ciphers(dict, ssid);
2910                 add_network_security_proto(dict, ssid);
2911                 break;
2912         }
2913
2914         supplicant_dbus_dict_append_basic(dict, "key_mgmt",
2915                                 DBUS_TYPE_STRING, &key_mgmt);
2916 }
2917
2918 static void add_network_mode(DBusMessageIter *dict, GSupplicantSSID *ssid)
2919 {
2920         dbus_uint32_t mode;
2921
2922         switch (ssid->mode) {
2923         case G_SUPPLICANT_MODE_UNKNOWN:
2924         case G_SUPPLICANT_MODE_INFRA:
2925                 mode = 0;
2926                 break;
2927         case G_SUPPLICANT_MODE_IBSS:
2928                 mode = 1;
2929                 break;
2930         case G_SUPPLICANT_MODE_MASTER:
2931                 mode = 2;
2932                 break;
2933         }
2934
2935         supplicant_dbus_dict_append_basic(dict, "mode",
2936                                 DBUS_TYPE_UINT32, &mode);
2937 }
2938
2939 static void interface_add_network_params(DBusMessageIter *iter, void *user_data)
2940 {
2941         DBusMessageIter dict;
2942         struct interface_connect_data *data = user_data;
2943         GSupplicantSSID *ssid = data->ssid;
2944
2945         supplicant_dbus_dict_open(iter, &dict);
2946
2947         if (ssid->scan_ssid)
2948                 supplicant_dbus_dict_append_basic(&dict, "scan_ssid",
2949                                          DBUS_TYPE_UINT32, &ssid->scan_ssid);
2950
2951         if (ssid->freq)
2952                 supplicant_dbus_dict_append_basic(&dict, "frequency",
2953                                          DBUS_TYPE_UINT32, &ssid->freq);
2954
2955         add_network_mode(&dict, ssid);
2956
2957         add_network_security(&dict, ssid);
2958
2959         supplicant_dbus_dict_append_fixed_array(&dict, "ssid",
2960                                         DBUS_TYPE_BYTE, &ssid->ssid,
2961                                                 ssid->ssid_len);
2962
2963         supplicant_dbus_dict_close(iter, &dict);
2964 }
2965
2966 static void interface_wps_start_result(const char *error,
2967                                 DBusMessageIter *iter, void *user_data)
2968 {
2969         struct interface_connect_data *data = user_data;
2970
2971         SUPPLICANT_DBG("");
2972         if (error != NULL)
2973                 SUPPLICANT_DBG("error: %s", error);
2974
2975         g_free(data->ssid);
2976         dbus_free(data);
2977 }
2978
2979 static void interface_add_wps_params(DBusMessageIter *iter, void *user_data)
2980 {
2981         struct interface_connect_data *data = user_data;
2982         GSupplicantSSID *ssid = data->ssid;
2983         const char *role = "enrollee", *type;
2984         DBusMessageIter dict;
2985
2986         SUPPLICANT_DBG("");
2987
2988         supplicant_dbus_dict_open(iter, &dict);
2989
2990         supplicant_dbus_dict_append_basic(&dict, "Role",
2991                                                 DBUS_TYPE_STRING, &role);
2992
2993         type = "pbc";
2994         if (ssid->pin_wps != NULL) {
2995                 type = "pin";
2996                 supplicant_dbus_dict_append_basic(&dict, "Pin",
2997                                         DBUS_TYPE_STRING, &ssid->pin_wps);
2998         }
2999
3000         supplicant_dbus_dict_append_basic(&dict, "Type",
3001                                         DBUS_TYPE_STRING, &type);
3002
3003         supplicant_dbus_dict_close(iter, &dict);
3004 }
3005
3006 static void wps_start(const char *error, DBusMessageIter *iter, void *user_data)
3007 {
3008         struct interface_connect_data *data = user_data;
3009
3010         SUPPLICANT_DBG("");
3011
3012         if (error != NULL) {
3013                 SUPPLICANT_DBG("error: %s", error);
3014                 g_free(data->ssid);
3015                 dbus_free(data);
3016                 return;
3017         }
3018
3019         supplicant_dbus_method_call(data->interface->path,
3020                         SUPPLICANT_INTERFACE ".Interface.WPS", "Start",
3021                         interface_add_wps_params,
3022                         interface_wps_start_result, data);
3023 }
3024
3025 static void wps_process_credentials(DBusMessageIter *iter, void *user_data)
3026 {
3027         dbus_bool_t credentials = TRUE;
3028
3029         SUPPLICANT_DBG("");
3030
3031         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &credentials);
3032 }
3033
3034
3035 int g_supplicant_interface_connect(GSupplicantInterface *interface,
3036                                 GSupplicantSSID *ssid,
3037                                 GSupplicantInterfaceCallback callback,
3038                                                         void *user_data)
3039 {
3040         struct interface_connect_data *data;
3041         int ret;
3042
3043         if (interface == NULL)
3044                 return -EINVAL;
3045
3046         if (system_available == FALSE)
3047                 return -EFAULT;
3048
3049         /* TODO: Check if we're already connected and switch */
3050
3051         data = dbus_malloc0(sizeof(*data));
3052         if (data == NULL)
3053                 return -ENOMEM;
3054
3055         data->interface = interface;
3056         data->callback = callback;
3057         data->ssid = ssid;
3058         data->user_data = user_data;
3059
3060         if (ssid->use_wps == TRUE) {
3061                 g_free(interface->wps_cred.key);
3062                 memset(&interface->wps_cred, 0,
3063                                 sizeof(struct _GSupplicantWpsCredentials));
3064
3065                 ret = supplicant_dbus_property_set(interface->path,
3066                         SUPPLICANT_INTERFACE ".Interface.WPS",
3067                         "ProcessCredentials", DBUS_TYPE_BOOLEAN_AS_STRING,
3068                         wps_process_credentials, wps_start, data);
3069         } else
3070                 ret = supplicant_dbus_method_call(interface->path,
3071                         SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
3072                         interface_add_network_params,
3073                         interface_add_network_result, data);
3074
3075         if (ret < 0)
3076                 return ret;
3077
3078         return -EINPROGRESS;
3079 }
3080
3081 static void network_remove_result(const char *error,
3082                                 DBusMessageIter *iter, void *user_data)
3083 {
3084         struct interface_data *data = user_data;
3085         int result = 0;
3086
3087         SUPPLICANT_DBG("");
3088
3089         if (error != NULL)
3090                 result = -EIO;
3091
3092         if (data->callback != NULL)
3093                 data->callback(result, data->interface, data->user_data);
3094
3095         dbus_free(data);
3096 }
3097
3098 static void network_remove_params(DBusMessageIter *iter, void *user_data)
3099 {
3100         struct interface_data *data = user_data;
3101         const char *path = data->interface->network_path;
3102
3103         SUPPLICANT_DBG("path %s", path);
3104
3105         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
3106 }
3107
3108 static int network_remove(struct interface_data *data)
3109 {
3110         GSupplicantInterface *interface = data->interface;
3111
3112         SUPPLICANT_DBG("");
3113
3114         return supplicant_dbus_method_call(interface->path,
3115                         SUPPLICANT_INTERFACE ".Interface", "RemoveNetwork",
3116                         network_remove_params, network_remove_result, data);
3117 }
3118
3119 static void interface_disconnect_result(const char *error,
3120                                 DBusMessageIter *iter, void *user_data)
3121 {
3122         struct interface_data *data = user_data;
3123
3124         SUPPLICANT_DBG("");
3125
3126         if (error != NULL && data->callback != NULL)
3127                 data->callback(-EIO, data->interface, data->user_data);
3128
3129         /* If we are disconnecting from previous WPS successful
3130          * association. i.e.: it did not went through AddNetwork,
3131          * and interface->network_path was never set. */
3132         if (data->interface->network_path == NULL)
3133                 return;
3134
3135         network_remove(data);
3136 }
3137
3138 int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
3139                                         GSupplicantInterfaceCallback callback,
3140                                                         void *user_data)
3141 {
3142         struct interface_data *data;
3143
3144         SUPPLICANT_DBG("");
3145
3146         if (interface == NULL)
3147                 return -EINVAL;
3148
3149         if (system_available == FALSE)
3150                 return -EFAULT;
3151
3152         data = dbus_malloc0(sizeof(*data));
3153         if (data == NULL)
3154                 return -ENOMEM;
3155
3156         data->interface = interface;
3157         data->callback = callback;
3158         data->user_data = user_data;
3159
3160         return supplicant_dbus_method_call(interface->path,
3161                         SUPPLICANT_INTERFACE ".Interface", "Disconnect",
3162                                 NULL, interface_disconnect_result, data);
3163 }
3164
3165
3166 static const char *g_supplicant_rule0 = "type=signal,"
3167                                         "path=" DBUS_PATH_DBUS ","
3168                                         "sender=" DBUS_SERVICE_DBUS ","
3169                                         "interface=" DBUS_INTERFACE_DBUS ","
3170                                         "member=NameOwnerChanged,"
3171                                         "arg0=" SUPPLICANT_SERVICE;
3172 static const char *g_supplicant_rule1 = "type=signal,"
3173                         "interface=" SUPPLICANT_INTERFACE;
3174 static const char *g_supplicant_rule2 = "type=signal,"
3175                         "interface=" SUPPLICANT_INTERFACE ".Interface";
3176 static const char *g_supplicant_rule3 = "type=signal,"
3177                         "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
3178 static const char *g_supplicant_rule4 = "type=signal,"
3179                         "interface=" SUPPLICANT_INTERFACE ".BSS";
3180 static const char *g_supplicant_rule5 = "type=signal,"
3181                         "interface=" SUPPLICANT_INTERFACE ".Network";
3182
3183 static void invoke_introspect_method(void)
3184 {
3185         DBusMessage *message;
3186
3187         message = dbus_message_new_method_call(SUPPLICANT_SERVICE,
3188                                         SUPPLICANT_PATH,
3189                                         DBUS_INTERFACE_INTROSPECTABLE,
3190                                         "Introspect");
3191
3192         if (message == NULL)
3193                 return;
3194
3195         dbus_message_set_no_reply(message, TRUE);
3196         dbus_connection_send(connection, message, NULL);
3197         dbus_message_unref(message);
3198 }
3199
3200 int g_supplicant_register(const GSupplicantCallbacks *callbacks)
3201 {
3202         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
3203         if (connection == NULL)
3204                 return -EIO;
3205
3206         if (dbus_connection_add_filter(connection,
3207                                 g_supplicant_filter, NULL, NULL) == FALSE) {
3208                 dbus_connection_unref(connection);
3209                 connection = NULL;
3210                 return -EIO;
3211         }
3212
3213         callbacks_pointer = callbacks;
3214         eap_methods = 0;
3215
3216         interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
3217                                                 NULL, remove_interface);
3218
3219         bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
3220                                                                 NULL, NULL);
3221
3222         supplicant_dbus_setup(connection);
3223
3224         dbus_bus_add_match(connection, g_supplicant_rule0, NULL);
3225         dbus_bus_add_match(connection, g_supplicant_rule1, NULL);
3226         dbus_bus_add_match(connection, g_supplicant_rule2, NULL);
3227         dbus_bus_add_match(connection, g_supplicant_rule3, NULL);
3228         dbus_bus_add_match(connection, g_supplicant_rule4, NULL);
3229         dbus_bus_add_match(connection, g_supplicant_rule5, NULL);
3230         dbus_connection_flush(connection);
3231
3232         if (dbus_bus_name_has_owner(connection,
3233                                         SUPPLICANT_SERVICE, NULL) == TRUE) {
3234                 system_available = TRUE;
3235                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
3236                                                 SUPPLICANT_INTERFACE,
3237                                                 service_property, NULL);
3238         } else
3239                 invoke_introspect_method();
3240
3241         return 0;
3242 }
3243
3244 static void unregister_interface_remove_params(DBusMessageIter *iter,
3245                                                 void *user_data)
3246 {
3247         const char *path = user_data;
3248
3249         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
3250                                                         &path);
3251 }
3252
3253
3254 static void unregister_remove_interface(gpointer key, gpointer value,
3255                                                 gpointer user_data)
3256 {
3257         GSupplicantInterface *interface = value;
3258
3259         supplicant_dbus_method_call(SUPPLICANT_PATH,
3260                                         SUPPLICANT_INTERFACE,
3261                                         "RemoveInterface",
3262                                         unregister_interface_remove_params,
3263                                                 NULL, interface->path);
3264 }
3265
3266 void g_supplicant_unregister(const GSupplicantCallbacks *callbacks)
3267 {
3268         SUPPLICANT_DBG("");
3269
3270         if (connection != NULL) {
3271                 dbus_bus_remove_match(connection, g_supplicant_rule5, NULL);
3272                 dbus_bus_remove_match(connection, g_supplicant_rule4, NULL);
3273                 dbus_bus_remove_match(connection, g_supplicant_rule3, NULL);
3274                 dbus_bus_remove_match(connection, g_supplicant_rule2, NULL);
3275                 dbus_bus_remove_match(connection, g_supplicant_rule1, NULL);
3276                 dbus_bus_remove_match(connection, g_supplicant_rule0, NULL);
3277                 dbus_connection_flush(connection);
3278
3279                 dbus_connection_remove_filter(connection,
3280                                                 g_supplicant_filter, NULL);
3281         }
3282
3283         if (bss_mapping != NULL) {
3284                 g_hash_table_destroy(bss_mapping);
3285                 bss_mapping = NULL;
3286         }
3287
3288         if (system_available == TRUE)
3289                 callback_system_killed();
3290
3291         if (interface_table != NULL) {
3292                 g_hash_table_foreach(interface_table,
3293                                         unregister_remove_interface, NULL);
3294                 g_hash_table_destroy(interface_table);
3295                 interface_table = NULL;
3296         }
3297
3298         if (connection != NULL) {
3299                 dbus_connection_unref(connection);
3300                 connection = NULL;
3301         }
3302
3303         callbacks_pointer = NULL;
3304         eap_methods = 0;
3305 }