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