wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  *
  14  * This file implements functions for registering and unregistering
  15  * %wpa_supplicant interfaces. In addition, this file contains number of
  16  * functions for managing network connections.
  17  */
  18
  19 #include "includes.h"
  20
  21 #include "common.h"
  22 #include "eapol_supp/eapol_supp_sm.h"
  23 #include "eap_peer/eap.h"
  24 #include "wpa.h"
  25 #include "eloop.h"
  26 #include "drivers/driver.h"
  27 #include "config.h"
  28 #include "l2_packet/l2_packet.h"
  29 #include "wpa_supplicant_i.h"
  30 #include "ctrl_iface.h"
  31 #include "ctrl_iface_dbus.h"
  32 #include "pcsc_funcs.h"
  33 #include "version.h"
  34 #include "preauth.h"
  35 #include "pmksa_cache.h"
  36 #include "wpa_ctrl.h"
  37 #include "mlme.h"
  38 #include "ieee802_11_defs.h"
  39 #include "blacklist.h"
  40 #include "wpas_glue.h"
  41
  42 const char *wpa_supplicant_version =
  43 "wpa_supplicant v" VERSION_STR "\n"
  44 "Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> and contributors";
  45
  46 const char *wpa_supplicant_license =
  47 "This program is free software. You can distribute it and/or modify it\n"
  48 "under the terms of the GNU General Public License version 2.\n"
  49 "\n"
  50 "Alternatively, this software may be distributed under the terms of the\n"
  51 "BSD license. See README and COPYING for more details.\n"
  52 #ifdef EAP_TLS_OPENSSL
  53 "\nThis product includes software developed by the OpenSSL Project\n"
  54 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  55 #endif /* EAP_TLS_OPENSSL */
  56 ;
  57
  58 #ifndef CONFIG_NO_STDOUT_DEBUG
  59 /* Long text divided into parts in order to fit in C89 strings size limits. */
  60 const char *wpa_supplicant_full_license1 =
  61 "This program is free software; you can redistribute it and/or modify\n"
  62 "it under the terms of the GNU General Public License version 2 as\n"
  63 "published by the Free Software Foundation.\n"
  64 "\n"
  65 "This program is distributed in the hope that it will be useful,\n"
  66 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  67 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
  68 "GNU General Public License for more details.\n"
  69 "\n";
  70 const char *wpa_supplicant_full_license2 =
  71 "You should have received a copy of the GNU General Public License\n"
  72 "along with this program; if not, write to the Free Software\n"
  73 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n"
  74 "\n"
  75 "Alternatively, this software may be distributed under the terms of the\n"
  76 "BSD license.\n"
  77 "\n"
  78 "Redistribution and use in source and binary forms, with or without\n"
  79 "modification, are permitted provided that the following conditions are\n"
  80 "met:\n"
  81 "\n";
  82 const char *wpa_supplicant_full_license3 =
  83 "1. Redistributions of source code must retain the above copyright\n"
  84 "   notice, this list of conditions and the following disclaimer.\n"
  85 "\n"
  86 "2. Redistributions in binary form must reproduce the above copyright\n"
  87 "   notice, this list of conditions and the following disclaimer in the\n"
  88 "   documentation and/or other materials provided with the distribution.\n"
  89 "\n";
  90 const char *wpa_supplicant_full_license4 =
  91 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
  92 "   names of its contributors may be used to endorse or promote products\n"
  93 "   derived from this software without specific prior written permission.\n"
  94 "\n"
  95 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
  96 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
  97 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
  98 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
  99 const char *wpa_supplicant_full_license5 =
 100 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
 101 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
 102 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
 103 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
 104 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 105 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 106 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 107 "\n";
 108 #endif /* CONFIG_NO_STDOUT_DEBUG */
 109
 110 extern struct wpa_driver_ops *wpa_supplicant_drivers[];
 111
 112 extern int wpa_debug_level;
 113 extern int wpa_debug_show_keys;
 114 extern int wpa_debug_timestamp;
 115
 116 /* Configure default/group WEP keys for static WEP */
 117 static int wpa_set_wep_keys(struct wpa_supplicant *wpa_s,
 118                             struct wpa_ssid *ssid)
 119 {
 120         int i, set = 0;
 121
 122         for (i = 0; i < NUM_WEP_KEYS; i++) {
 123                 if (ssid->wep_key_len[i] == 0)
 124                         continue;
 125
 126                 set = 1;
 127                 wpa_drv_set_key(wpa_s, WPA_ALG_WEP,
 128                                 (u8 *) "\xff\xff\xff\xff\xff\xff",
 129                                 i, i == ssid->wep_tx_keyidx, (u8 *) "", 0,
 130                                 ssid->wep_key[i], ssid->wep_key_len[i]);
 131         }
 132
 133         return set;
 134 }
 135
 136
 137 static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
 138                                            struct wpa_ssid *ssid)
 139 {
 140         u8 key[32];
 141         size_t keylen;
 142         wpa_alg alg;
 143         u8 seq[6] = { 0 };
 144
 145         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 146          * sending unicast and multicast packets. */
 147
 148         if (ssid->mode != IEEE80211_MODE_IBSS) {
 149                 wpa_printf(MSG_INFO, "WPA: Invalid mode %d (not IBSS/ad-hoc) "
 150                            "for WPA-None", ssid->mode);
 151                 return -1;
 152         }
 153
 154         if (!ssid->psk_set) {
 155                 wpa_printf(MSG_INFO, "WPA: No PSK configured for WPA-None");
 156                 return -1;
 157         }
 158
 159         switch (wpa_s->group_cipher) {
 160         case WPA_CIPHER_CCMP:
 161                 os_memcpy(key, ssid->psk, 16);
 162                 keylen = 16;
 163                 alg = WPA_ALG_CCMP;
 164                 break;
 165         case WPA_CIPHER_TKIP:
 166                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 167                 os_memcpy(key, ssid->psk, 16 + 8);
 168                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 169                 keylen = 32;
 170                 alg = WPA_ALG_TKIP;
 171                 break;
 172         default:
 173                 wpa_printf(MSG_INFO, "WPA: Invalid group cipher %d for "
 174                            "WPA-None", wpa_s->group_cipher);
 175                 return -1;
 176         }
 177
 178         /* TODO: should actually remember the previously used seq#, both for TX
 179          * and RX from each STA.. */
 180
 181         return wpa_drv_set_key(wpa_s, alg, (u8 *) "\xff\xff\xff\xff\xff\xff",
 182                                0, 1, seq, 6, key, keylen);
 183 }
 184
 185
 186 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 187 {
 188         struct wpa_supplicant *wpa_s = eloop_ctx;
 189         const u8 *bssid = wpa_s->bssid;
 190         if (is_zero_ether_addr(bssid))
 191                 bssid = wpa_s->pending_bssid;
 192         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 193                 MAC2STR(bssid));
 194         wpa_blacklist_add(wpa_s, bssid);
 195         wpa_sm_notify_disassoc(wpa_s->wpa);
 196         wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 197         wpa_s->reassociate = 1;
 198         wpa_supplicant_req_scan(wpa_s, 0, 0);
 199 }
 200
 201
 202 /**
 203  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 204  * @wpa_s: Pointer to wpa_supplicant data
 205  * @sec: Number of seconds after which to time out authentication
 206  * @usec: Number of microseconds after which to time out authentication
 207  *
 208  * This function is used to schedule a timeout for the current authentication
 209  * attempt.
 210  */
 211 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 212                                      int sec, int usec)
 213 {
 214         if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
 215             wpa_s->driver && os_strcmp(wpa_s->driver->name, "wired") == 0)
 216                 return;
 217
 218         wpa_msg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 219                 "%d usec", sec, usec);
 220         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 221         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 222 }
 223
 224
 225 /**
 226  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 227  * @wpa_s: Pointer to wpa_supplicant data
 228  *
 229  * This function is used to cancel authentication timeout scheduled with
 230  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 231  * been completed.
 232  */
 233 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 234 {
 235         wpa_msg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 236         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 237         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 238 }
 239
 240
 241 /**
 242  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 243  * @wpa_s: Pointer to wpa_supplicant data
 244  *
 245  * This function is used to configure EAPOL state machine based on the selected
 246  * authentication mode.
 247  */
 248 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 249 {
 250 #ifdef IEEE8021X_EAPOL
 251         struct eapol_config eapol_conf;
 252         struct wpa_ssid *ssid = wpa_s->current_ssid;
 253
 254         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 255                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 256                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 257         }
 258         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 259             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 260                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 261         else
 262                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 263
 264         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 265         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 266                 eapol_conf.accept_802_1x_keys = 1;
 267                 eapol_conf.required_keys = 0;
 268                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 269                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 270                 }
 271                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 272                         eapol_conf.required_keys |=
 273                                 EAPOL_REQUIRE_KEY_BROADCAST;
 274                 }
 275
 276                 if (wpa_s->conf && wpa_s->driver &&
 277                     os_strcmp(wpa_s->driver->name, "wired") == 0) {
 278                         eapol_conf.required_keys = 0;
 279                 }
 280         }
 281         if (wpa_s->conf)
 282                 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 283         eapol_conf.workaround = ssid->eap_workaround;
 284         eapol_conf.eap_disabled =
 285                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 286                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 287         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 288 #endif /* IEEE8021X_EAPOL */
 289 }
 290
 291
 292 /**
 293  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 294  * @wpa_s: Pointer to wpa_supplicant data
 295  * @ssid: Configuration data for the network
 296  *
 297  * This function is used to configure WPA state machine and related parameters
 298  * to a mode where WPA is not enabled. This is called as part of the
 299  * authentication configuration when the selected network does not use WPA.
 300  */
 301 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 302                                        struct wpa_ssid *ssid)
 303 {
 304         int i;
 305
 306         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 307                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 308         else
 309                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 310         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 311         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 312         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 313         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 314         wpa_s->group_cipher = WPA_CIPHER_NONE;
 315         wpa_s->mgmt_group_cipher = 0;
 316
 317         for (i = 0; i < NUM_WEP_KEYS; i++) {
 318                 if (ssid->wep_key_len[i] > 5) {
 319                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 320                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 321                         break;
 322                 } else if (ssid->wep_key_len[i] > 0) {
 323                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 324                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 325                         break;
 326                 }
 327         }
 328
 329         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 330         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 331         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 332                          wpa_s->pairwise_cipher);
 333         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 334 #ifdef CONFIG_IEEE80211W
 335         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 336                          wpa_s->mgmt_group_cipher);
 337 #endif /* CONFIG_IEEE80211W */
 338
 339         pmksa_cache_clear_current(wpa_s->wpa);
 340 }
 341
 342
 343 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 344 {
 345         scard_deinit(wpa_s->scard);
 346         wpa_s->scard = NULL;
 347         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 348         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 349         l2_packet_deinit(wpa_s->l2);
 350         wpa_s->l2 = NULL;
 351         if (wpa_s->l2_br) {
 352                 l2_packet_deinit(wpa_s->l2_br);
 353                 wpa_s->l2_br = NULL;
 354         }
 355
 356         if (wpa_s->ctrl_iface) {
 357                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 358                 wpa_s->ctrl_iface = NULL;
 359         }
 360         if (wpa_s->conf != NULL) {
 361                 wpa_config_free(wpa_s->conf);
 362                 wpa_s->conf = NULL;
 363         }
 364
 365         os_free(wpa_s->confname);
 366         wpa_s->confname = NULL;
 367
 368         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 369         eapol_sm_deinit(wpa_s->eapol);
 370         wpa_s->eapol = NULL;
 371
 372         rsn_preauth_deinit(wpa_s->wpa);
 373
 374         pmksa_candidate_free(wpa_s->wpa);
 375         wpa_sm_deinit(wpa_s->wpa);
 376         wpa_s->wpa = NULL;
 377         wpa_blacklist_clear(wpa_s);
 378
 379         wpa_scan_results_free(wpa_s->scan_res);
 380         wpa_s->scan_res = NULL;
 381
 382         wpa_supplicant_cancel_scan(wpa_s);
 383         wpa_supplicant_cancel_auth_timeout(wpa_s);
 384
 385         ieee80211_sta_deinit(wpa_s);
 386 }
 387
 388
 389 /**
 390  * wpa_clear_keys - Clear keys configured for the driver
 391  * @wpa_s: Pointer to wpa_supplicant data
 392  * @addr: Previously used BSSID or %NULL if not available
 393  *
 394  * This function clears the encryption keys that has been previously configured
 395  * for the driver.
 396  */
 397 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 398 {
 399         u8 *bcast = (u8 *) "\xff\xff\xff\xff\xff\xff";
 400
 401         if (wpa_s->keys_cleared) {
 402                 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
 403                  * timing issues with keys being cleared just before new keys
 404                  * are set or just after association or something similar. This
 405                  * shows up in group key handshake failing often because of the
 406                  * client not receiving the first encrypted packets correctly.
 407                  * Skipping some of the extra key clearing steps seems to help
 408                  * in completing group key handshake more reliably. */
 409                 wpa_printf(MSG_DEBUG, "No keys have been configured - "
 410                            "skip key clearing");
 411                 return;
 412         }
 413
 414         /* MLME-DELETEKEYS.request */
 415         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 0, 0, NULL, 0, NULL, 0);
 416         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 1, 0, NULL, 0, NULL, 0);
 417         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 2, 0, NULL, 0, NULL, 0);
 418         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 3, 0, NULL, 0, NULL, 0);
 419         if (addr) {
 420                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 421                                 0);
 422                 /* MLME-SETPROTECTION.request(None) */
 423                 wpa_drv_mlme_setprotection(
 424                         wpa_s, addr,
 425                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 426                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 427         }
 428         wpa_s->keys_cleared = 1;
 429 }
 430
 431
 432 /**
 433  * wpa_supplicant_state_txt - Get the connection state name as a text string
 434  * @state: State (wpa_state; WPA_*)
 435  * Returns: The state name as a printable text string
 436  */
 437 const char * wpa_supplicant_state_txt(int state)
 438 {
 439         switch (state) {
 440         case WPA_DISCONNECTED:
 441                 return "DISCONNECTED";
 442         case WPA_INACTIVE:
 443                 return "INACTIVE";
 444         case WPA_SCANNING:
 445                 return "SCANNING";
 446         case WPA_ASSOCIATING:
 447                 return "ASSOCIATING";
 448         case WPA_ASSOCIATED:
 449                 return "ASSOCIATED";
 450         case WPA_4WAY_HANDSHAKE:
 451                 return "4WAY_HANDSHAKE";
 452         case WPA_GROUP_HANDSHAKE:
 453                 return "GROUP_HANDSHAKE";
 454         case WPA_COMPLETED:
 455                 return "COMPLETED";
 456         default:
 457                 return "UNKNOWN";
 458         }
 459 }
 460
 461
 462 /**
 463  * wpa_supplicant_set_state - Set current connection state
 464  * @wpa_s: Pointer to wpa_supplicant data
 465  * @state: The new connection state
 466  *
 467  * This function is called whenever the connection state changes, e.g.,
 468  * association is completed for WPA/WPA2 4-Way Handshake is started.
 469  */
 470 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state)
 471 {
 472         wpa_printf(MSG_DEBUG, "State: %s -> %s",
 473                    wpa_supplicant_state_txt(wpa_s->wpa_state),
 474                    wpa_supplicant_state_txt(state));
 475
 476         wpa_supplicant_dbus_notify_state_change(wpa_s, state,
 477                                                 wpa_s->wpa_state);
 478
 479         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 480 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 481                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 482                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 483                         MACSTR " completed %s [id=%d id_str=%s]",
 484                         MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
 485                         "(reauth)" : "(auth)",
 486                         ssid ? ssid->id : -1,
 487                         ssid && ssid->id_str ? ssid->id_str : "");
 488 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 489                 wpa_s->new_connection = 0;
 490                 wpa_s->reassociated_connection = 1;
 491                 wpa_drv_set_operstate(wpa_s, 1);
 492         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 493                    state == WPA_ASSOCIATED) {
 494                 wpa_s->new_connection = 1;
 495                 wpa_drv_set_operstate(wpa_s, 0);
 496         }
 497         wpa_s->wpa_state = state;
 498 }
 499
 500
 501 static void wpa_supplicant_terminate(int sig, void *eloop_ctx,
 502                                      void *signal_ctx)
 503 {
 504         struct wpa_global *global = eloop_ctx;
 505         struct wpa_supplicant *wpa_s;
 506         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 507                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
 508                         "received", sig);
 509         }
 510         eloop_terminate();
 511 }
 512
 513
 514 static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 515 {
 516         wpa_s->pairwise_cipher = 0;
 517         wpa_s->group_cipher = 0;
 518         wpa_s->mgmt_group_cipher = 0;
 519         wpa_s->key_mgmt = 0;
 520         wpa_s->wpa_state = WPA_DISCONNECTED;
 521 }
 522
 523
 524 /**
 525  * wpa_supplicant_reload_configuration - Reload configuration data
 526  * @wpa_s: Pointer to wpa_supplicant data
 527  * Returns: 0 on success or -1 if configuration parsing failed
 528  *
 529  * This function can be used to request that the configuration data is reloaded
 530  * (e.g., after configuration file change). This function is reloading
 531  * configuration only for one interface, so this may need to be called multiple
 532  * times if %wpa_supplicant is controlling multiple interfaces and all
 533  * interfaces need reconfiguration.
 534  */
 535 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 536 {
 537         struct wpa_config *conf;
 538         int reconf_ctrl;
 539         if (wpa_s->confname == NULL)
 540                 return -1;
 541         conf = wpa_config_read(wpa_s->confname);
 542         if (conf == NULL) {
 543                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 544                         "file '%s' - exiting", wpa_s->confname);
 545                 return -1;
 546         }
 547
 548         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 549                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 550                     os_strcmp(conf->ctrl_interface,
 551                               wpa_s->conf->ctrl_interface) != 0);
 552
 553         if (reconf_ctrl && wpa_s->ctrl_iface) {
 554                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 555                 wpa_s->ctrl_iface = NULL;
 556         }
 557
 558         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 559         wpa_s->current_ssid = NULL;
 560         /*
 561          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 562          * pkcs11_engine_path, pkcs11_module_path.
 563          */
 564         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 565                 /*
 566                  * Clear forced success to clear EAP state for next
 567                  * authentication.
 568                  */
 569                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 570         }
 571         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 572         wpa_sm_set_config(wpa_s->wpa, NULL);
 573         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 574         rsn_preauth_deinit(wpa_s->wpa);
 575         wpa_config_free(wpa_s->conf);
 576         wpa_s->conf = conf;
 577         if (reconf_ctrl)
 578                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 579
 580         wpa_supplicant_clear_status(wpa_s);
 581         wpa_s->reassociate = 1;
 582         wpa_supplicant_req_scan(wpa_s, 0, 0);
 583         wpa_msg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 584         return 0;
 585 }
 586
 587
 588 static void wpa_supplicant_reconfig(int sig, void *eloop_ctx,
 589                                     void *signal_ctx)
 590 {
 591         struct wpa_global *global = eloop_ctx;
 592         struct wpa_supplicant *wpa_s;
 593         wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig);
 594         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 595                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 596                         eloop_terminate();
 597                 }
 598         }
 599 }
 600
 601
 602 static wpa_cipher cipher_suite2driver(int cipher)
 603 {
 604         switch (cipher) {
 605         case WPA_CIPHER_NONE:
 606                 return CIPHER_NONE;
 607         case WPA_CIPHER_WEP40:
 608                 return CIPHER_WEP40;
 609         case WPA_CIPHER_WEP104:
 610                 return CIPHER_WEP104;
 611         case WPA_CIPHER_CCMP:
 612                 return CIPHER_CCMP;
 613         case WPA_CIPHER_TKIP:
 614         default:
 615                 return CIPHER_TKIP;
 616         }
 617 }
 618
 619
 620 static wpa_key_mgmt key_mgmt2driver(int key_mgmt)
 621 {
 622         switch (key_mgmt) {
 623         case WPA_KEY_MGMT_NONE:
 624                 return KEY_MGMT_NONE;
 625         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 626                 return KEY_MGMT_802_1X_NO_WPA;
 627         case WPA_KEY_MGMT_IEEE8021X:
 628                 return KEY_MGMT_802_1X;
 629         case WPA_KEY_MGMT_WPA_NONE:
 630                 return KEY_MGMT_WPA_NONE;
 631         case WPA_KEY_MGMT_FT_IEEE8021X:
 632                 return KEY_MGMT_FT_802_1X;
 633         case WPA_KEY_MGMT_FT_PSK:
 634                 return KEY_MGMT_FT_PSK;
 635         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 636                 return KEY_MGMT_802_1X_SHA256;
 637         case WPA_KEY_MGMT_PSK_SHA256:
 638                 return KEY_MGMT_PSK_SHA256;
 639         case WPA_KEY_MGMT_PSK:
 640         default:
 641                 return KEY_MGMT_PSK;
 642         }
 643 }
 644
 645
 646 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 647                                          struct wpa_ssid *ssid,
 648                                          struct wpa_ie_data *ie)
 649 {
 650         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 651         if (ret) {
 652                 if (ret == -2) {
 653                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 654                                 "from association info");
 655                 }
 656                 return -1;
 657         }
 658
 659         wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher "
 660                    "suites");
 661         if (!(ie->group_cipher & ssid->group_cipher)) {
 662                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 663                         "cipher 0x%x (mask 0x%x) - reject",
 664                         ie->group_cipher, ssid->group_cipher);
 665                 return -1;
 666         }
 667         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 668                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 669                         "cipher 0x%x (mask 0x%x) - reject",
 670                         ie->pairwise_cipher, ssid->pairwise_cipher);
 671                 return -1;
 672         }
 673         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 674                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 675                         "management 0x%x (mask 0x%x) - reject",
 676                         ie->key_mgmt, ssid->key_mgmt);
 677                 return -1;
 678         }
 679
 680 #ifdef CONFIG_IEEE80211W
 681         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 682             ssid->ieee80211w == IEEE80211W_REQUIRED) {
 683                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 684                         "that does not support management frame protection - "
 685                         "reject");
 686                 return -1;
 687         }
 688 #endif /* CONFIG_IEEE80211W */
 689
 690         return 0;
 691 }
 692
 693
 694 /**
 695  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 696  * @wpa_s: Pointer to wpa_supplicant data
 697  * @bss: Scan results for the selected BSS, or %NULL if not available
 698  * @ssid: Configuration data for the selected network
 699  * @wpa_ie: Buffer for the WPA/RSN IE
 700  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 701  * used buffer length in case the functions returns success.
 702  * Returns: 0 on success or -1 on failure
 703  *
 704  * This function is used to configure authentication and encryption parameters
 705  * based on the network configuration and scan result for the selected BSS (if
 706  * available).
 707  */
 708 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 709                               struct wpa_scan_res *bss,
 710                               struct wpa_ssid *ssid,
 711                               u8 *wpa_ie, size_t *wpa_ie_len)
 712 {
 713         struct wpa_ie_data ie;
 714         int sel, proto;
 715         const u8 *bss_wpa, *bss_rsn;
 716
 717         if (bss) {
 718                 bss_wpa = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 719                 bss_rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
 720         } else
 721                 bss_wpa = bss_rsn = NULL;
 722
 723         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
 724             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
 725             (ie.group_cipher & ssid->group_cipher) &&
 726             (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 727             (ie.key_mgmt & ssid->key_mgmt)) {
 728                 wpa_msg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
 729                 proto = WPA_PROTO_RSN;
 730         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
 731                    wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
 732                    (ie.group_cipher & ssid->group_cipher) &&
 733                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 734                    (ie.key_mgmt & ssid->key_mgmt)) {
 735                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 736                 proto = WPA_PROTO_WPA;
 737         } else if (bss) {
 738                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
 739                 return -1;
 740         } else {
 741                 if (ssid->proto & WPA_PROTO_RSN)
 742                         proto = WPA_PROTO_RSN;
 743                 else
 744                         proto = WPA_PROTO_WPA;
 745                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
 746                         os_memset(&ie, 0, sizeof(ie));
 747                         ie.group_cipher = ssid->group_cipher;
 748                         ie.pairwise_cipher = ssid->pairwise_cipher;
 749                         ie.key_mgmt = ssid->key_mgmt;
 750 #ifdef CONFIG_IEEE80211W
 751                         ie.mgmt_group_cipher =
 752                                 ssid->ieee80211w != NO_IEEE80211W ?
 753                                 WPA_CIPHER_AES_128_CMAC : 0;
 754 #endif /* CONFIG_IEEE80211W */
 755                         wpa_printf(MSG_DEBUG, "WPA: Set cipher suites based "
 756                                    "on configuration");
 757                 } else
 758                         proto = ie.proto;
 759         }
 760
 761         wpa_printf(MSG_DEBUG, "WPA: Selected cipher suites: group %d "
 762                    "pairwise %d key_mgmt %d proto %d",
 763                    ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
 764 #ifdef CONFIG_IEEE80211W
 765         if (ssid->ieee80211w) {
 766                 wpa_printf(MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
 767                            ie.mgmt_group_cipher);
 768         }
 769 #endif /* CONFIG_IEEE80211W */
 770
 771         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
 772         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
 773                          !!(ssid->proto & WPA_PROTO_RSN));
 774
 775         if (bss || !wpa_s->ap_ies_from_associnfo) {
 776                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
 777                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
 778                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
 779                                          bss_rsn ? 2 + bss_rsn[1] : 0))
 780                         return -1;
 781         }
 782
 783         sel = ie.group_cipher & ssid->group_cipher;
 784         if (sel & WPA_CIPHER_CCMP) {
 785                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
 786                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
 787         } else if (sel & WPA_CIPHER_TKIP) {
 788                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
 789                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
 790         } else if (sel & WPA_CIPHER_WEP104) {
 791                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
 792                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
 793         } else if (sel & WPA_CIPHER_WEP40) {
 794                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
 795                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
 796         } else {
 797                 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
 798                 return -1;
 799         }
 800
 801         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
 802         if (sel & WPA_CIPHER_CCMP) {
 803                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
 804                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
 805         } else if (sel & WPA_CIPHER_TKIP) {
 806                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
 807                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
 808         } else if (sel & WPA_CIPHER_NONE) {
 809                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 810                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
 811         } else {
 812                 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
 813                            "cipher.");
 814                 return -1;
 815         }
 816
 817         sel = ie.key_mgmt & ssid->key_mgmt;
 818         if (0) {
 819 #ifdef CONFIG_IEEE80211R
 820         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
 821                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
 822                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
 823         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
 824                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
 825                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
 826 #endif /* CONFIG_IEEE80211R */
 827 #ifdef CONFIG_IEEE80211W
 828         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
 829                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
 830                 wpa_msg(wpa_s, MSG_DEBUG,
 831                         "WPA: using KEY_MGMT 802.1X with SHA256");
 832         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
 833                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
 834                 wpa_msg(wpa_s, MSG_DEBUG,
 835                         "WPA: using KEY_MGMT PSK with SHA256");
 836 #endif /* CONFIG_IEEE80211W */
 837         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
 838                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 839                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
 840         } else if (sel & WPA_KEY_MGMT_PSK) {
 841                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
 842                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
 843         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
 844                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
 845                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
 846         } else {
 847                 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
 848                            "key management type.");
 849                 return -1;
 850         }
 851
 852         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 853         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 854                          wpa_s->pairwise_cipher);
 855         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 856
 857 #ifdef CONFIG_IEEE80211W
 858         sel = ie.mgmt_group_cipher;
 859         if (ssid->ieee80211w == NO_IEEE80211W ||
 860             !(ie.capabilities & WPA_CAPABILITY_MFPC))
 861                 sel = 0;
 862         if (sel & WPA_CIPHER_AES_128_CMAC) {
 863                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
 864                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
 865                         "AES-128-CMAC");
 866         } else {
 867                 wpa_s->mgmt_group_cipher = 0;
 868                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
 869         }
 870         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 871                          wpa_s->mgmt_group_cipher);
 872 #endif /* CONFIG_IEEE80211W */
 873
 874         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
 875                 wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE.");
 876                 return -1;
 877         }
 878
 879         if (ssid->key_mgmt &
 880             (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK | WPA_KEY_MGMT_PSK_SHA256))
 881                 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
 882         else
 883                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
 884
 885         return 0;
 886 }
 887
 888
 889 /**
 890  * wpa_supplicant_associate - Request association
 891  * @wpa_s: Pointer to wpa_supplicant data
 892  * @bss: Scan results for the selected BSS, or %NULL if not available
 893  * @ssid: Configuration data for the selected network
 894  *
 895  * This function is used to request %wpa_supplicant to associate with a BSS.
 896  */
 897 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
 898                               struct wpa_scan_res *bss, struct wpa_ssid *ssid)
 899 {
 900         u8 wpa_ie[80];
 901         size_t wpa_ie_len;
 902         int use_crypt, ret, i;
 903         int algs = AUTH_ALG_OPEN_SYSTEM;
 904         wpa_cipher cipher_pairwise, cipher_group;
 905         struct wpa_driver_associate_params params;
 906         int wep_keys_set = 0;
 907         struct wpa_driver_capa capa;
 908         int assoc_failed = 0;
 909
 910         wpa_s->reassociate = 0;
 911         if (bss) {
 912 #ifdef CONFIG_IEEE80211R
 913                 const u8 *md = NULL;
 914 #endif /* CONFIG_IEEE80211R */
 915                 const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
 916                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
 917                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
 918                         ie ? wpa_ssid_txt(ie + 2, ie[1]) : "", bss->freq);
 919                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
 920                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
 921 #ifdef CONFIG_IEEE80211R
 922                 ie = wpa_scan_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
 923                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
 924                         md = ie + 2;
 925                 wpa_sm_set_ft_params(wpa_s->wpa, md, NULL, 0, NULL);
 926                 if (md) {
 927                         /* Prepare for the next transition */
 928                         wpa_ft_prepare_auth_request(wpa_s->wpa);
 929                 }
 930 #endif /* CONFIG_IEEE80211R */
 931         } else {
 932                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
 933                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
 934                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
 935         }
 936         wpa_supplicant_cancel_scan(wpa_s);
 937
 938         /* Starting new association, so clear the possibly used WPA IE from the
 939          * previous association. */
 940         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 941
 942         if (wpa_drv_set_mode(wpa_s, ssid->mode)) {
 943                 wpa_printf(MSG_WARNING, "Failed to set operating mode");
 944                 assoc_failed = 1;
 945         }
 946
 947 #ifdef IEEE8021X_EAPOL
 948         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 949                 if (ssid->leap) {
 950                         if (ssid->non_leap == 0)
 951                                 algs = AUTH_ALG_LEAP;
 952                         else
 953                                 algs |= AUTH_ALG_LEAP;
 954                 }
 955         }
 956 #endif /* IEEE8021X_EAPOL */
 957         wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
 958         if (ssid->auth_alg) {
 959                 algs = 0;
 960                 if (ssid->auth_alg & WPA_AUTH_ALG_OPEN)
 961                         algs |= AUTH_ALG_OPEN_SYSTEM;
 962                 if (ssid->auth_alg & WPA_AUTH_ALG_SHARED)
 963                         algs |= AUTH_ALG_SHARED_KEY;
 964                 if (ssid->auth_alg & WPA_AUTH_ALG_LEAP)
 965                         algs |= AUTH_ALG_LEAP;
 966                 wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
 967                            algs);
 968         }
 969         wpa_drv_set_auth_alg(wpa_s, algs);
 970
 971         if (bss && (wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
 972                     wpa_scan_get_ie(bss, WLAN_EID_RSN)) &&
 973             (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
 974                                WPA_KEY_MGMT_FT_IEEE8021X |
 975                                WPA_KEY_MGMT_FT_PSK |
 976                                WPA_KEY_MGMT_IEEE8021X_SHA256 |
 977                                WPA_KEY_MGMT_PSK_SHA256))) {
 978                 int try_opportunistic;
 979                 try_opportunistic = ssid->proactive_key_caching &&
 980                         (ssid->proto & WPA_PROTO_RSN);
 981                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
 982                                             wpa_s->current_ssid,
 983                                             try_opportunistic) == 0)
 984                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
 985                 wpa_ie_len = sizeof(wpa_ie);
 986                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
 987                                               wpa_ie, &wpa_ie_len)) {
 988                         wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
 989                                    "management and encryption suites");
 990                         return;
 991                 }
 992         } else if (ssid->key_mgmt &
 993                    (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
 994                     WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
 995                     WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_PSK_SHA256 |
 996                     WPA_KEY_MGMT_IEEE8021X_SHA256)) {
 997                 wpa_ie_len = sizeof(wpa_ie);
 998                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
 999                                               wpa_ie, &wpa_ie_len)) {
1000                         wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
1001                                    "management and encryption suites (no scan "
1002                                    "results)");
1003                         return;
1004                 }
1005         } else {
1006                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1007                 wpa_ie_len = 0;
1008         }
1009
1010         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1011         use_crypt = 1;
1012         cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1013         cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1014         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1015             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1016                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1017                         use_crypt = 0;
1018                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1019                         use_crypt = 1;
1020                         wep_keys_set = 1;
1021                 }
1022         }
1023
1024 #ifdef IEEE8021X_EAPOL
1025         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1026                 if ((ssid->eapol_flags &
1027                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1028                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1029                     !wep_keys_set) {
1030                         use_crypt = 0;
1031                 } else {
1032                         /* Assume that dynamic WEP-104 keys will be used and
1033                          * set cipher suites in order for drivers to expect
1034                          * encryption. */
1035                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1036                 }
1037         }
1038 #endif /* IEEE8021X_EAPOL */
1039
1040         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1041                 /* Set the key before (and later after) association */
1042                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1043         }
1044
1045         wpa_drv_set_drop_unencrypted(wpa_s, use_crypt);
1046         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1047         os_memset(&params, 0, sizeof(params));
1048         if (bss) {
1049                 const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
1050                 params.bssid = bss->bssid;
1051                 params.ssid = ie ? ie + 2 : (u8 *) "";
1052                 params.ssid_len = ie ? ie[1] : 0;
1053                 params.freq = bss->freq;
1054         } else {
1055                 params.ssid = ssid->ssid;
1056                 params.ssid_len = ssid->ssid_len;
1057         }
1058         if (ssid->mode == 1 && ssid->frequency > 0 && params.freq == 0)
1059                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1060         params.wpa_ie = wpa_ie;
1061         params.wpa_ie_len = wpa_ie_len;
1062         params.pairwise_suite = cipher_pairwise;
1063         params.group_suite = cipher_group;
1064         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1065         params.auth_alg = algs;
1066         params.mode = ssid->mode;
1067         for (i = 0; i < NUM_WEP_KEYS; i++) {
1068                 if (ssid->wep_key_len[i])
1069                         params.wep_key[i] = ssid->wep_key[i];
1070                 params.wep_key_len[i] = ssid->wep_key_len[i];
1071         }
1072         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1073
1074         if (wpa_s->driver_4way_handshake &&
1075             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1076              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1077                 params.passphrase = ssid->passphrase;
1078                 if (ssid->psk_set)
1079                         params.psk = ssid->psk;
1080         }
1081
1082 #ifdef CONFIG_IEEE80211W
1083         switch (ssid->ieee80211w) {
1084         case NO_IEEE80211W:
1085                 params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION;
1086                 break;
1087         case IEEE80211W_OPTIONAL:
1088                 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_OPTIONAL;
1089                 break;
1090         case IEEE80211W_REQUIRED:
1091                 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_REQUIRED;
1092                 break;
1093         }
1094 #endif /* CONFIG_IEEE80211W */
1095
1096         if (wpa_s->use_client_mlme)
1097                 ret = ieee80211_sta_associate(wpa_s, &params);
1098         else
1099                 ret = wpa_drv_associate(wpa_s, &params);
1100         if (ret < 0) {
1101                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1102                         "failed");
1103                 /* try to continue anyway; new association will be tried again
1104                  * after timeout */
1105                 assoc_failed = 1;
1106         }
1107
1108         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1109                 /* Set the key after the association just in case association
1110                  * cleared the previously configured key. */
1111                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1112                 /* No need to timeout authentication since there is no key
1113                  * management. */
1114                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1115                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1116         } else {
1117                 /* Timeout for IEEE 802.11 authentication and association */
1118                 int timeout = 60;
1119
1120                 if (assoc_failed) {
1121                         /* give IBSS a bit more time */
1122                         timeout = ssid->mode ? 10 : 5;
1123                 } else if (wpa_s->conf->ap_scan == 1) {
1124                         /* give IBSS a bit more time */
1125                         timeout = ssid->mode ? 20 : 10;
1126                 }
1127                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1128         }
1129
1130         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1131             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1132                 /* Set static WEP keys again */
1133                 wpa_set_wep_keys(wpa_s, ssid);
1134         }
1135
1136         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1137                 /*
1138                  * Do not allow EAP session resumption between different
1139                  * network configurations.
1140                  */
1141                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1142         }
1143         wpa_s->current_ssid = ssid;
1144         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1145         wpa_supplicant_initiate_eapol(wpa_s);
1146 }
1147
1148
1149 /**
1150  * wpa_supplicant_disassociate - Disassociate the current connection
1151  * @wpa_s: Pointer to wpa_supplicant data
1152  * @reason_code: IEEE 802.11 reason code for the disassociate frame
1153  *
1154  * This function is used to request %wpa_supplicant to disassociate with the
1155  * current AP.
1156  */
1157 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1158                                  int reason_code)
1159 {
1160         u8 *addr = NULL;
1161         if (!is_zero_ether_addr(wpa_s->bssid)) {
1162                 if (wpa_s->use_client_mlme)
1163                         ieee80211_sta_disassociate(wpa_s, reason_code);
1164                 else
1165                         wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1166                 addr = wpa_s->bssid;
1167         }
1168         wpa_clear_keys(wpa_s, addr);
1169         wpa_supplicant_mark_disassoc(wpa_s);
1170         wpa_s->current_ssid = NULL;
1171         wpa_sm_set_config(wpa_s->wpa, NULL);
1172         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1173 }
1174
1175
1176 /**
1177  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1178  * @wpa_s: Pointer to wpa_supplicant data
1179  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1180  *
1181  * This function is used to request %wpa_supplicant to disassociate with the
1182  * current AP.
1183  */
1184 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1185                                    int reason_code)
1186 {
1187         u8 *addr = NULL;
1188         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1189         if (!is_zero_ether_addr(wpa_s->bssid)) {
1190                 if (wpa_s->use_client_mlme)
1191                         ieee80211_sta_deauthenticate(wpa_s, reason_code);
1192                 else
1193                         wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1194                                                reason_code);
1195                 addr = wpa_s->bssid;
1196         }
1197         wpa_clear_keys(wpa_s, addr);
1198         wpa_s->current_ssid = NULL;
1199         wpa_sm_set_config(wpa_s->wpa, NULL);
1200         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1201         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1202         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1203 }
1204
1205
1206 static int wpa_supplicant_get_scan_results_old(struct wpa_supplicant *wpa_s)
1207 {
1208 #define SCAN_AP_LIMIT 128
1209         struct wpa_scan_result *results;
1210         int num, i;
1211         struct wpa_scan_results *res;
1212
1213         results = os_malloc(SCAN_AP_LIMIT * sizeof(struct wpa_scan_result));
1214         if (results == NULL) {
1215                 wpa_printf(MSG_WARNING, "Failed to allocate memory for scan "
1216                            "results");
1217                 return -1;
1218         }
1219
1220         num = wpa_drv_get_scan_results(wpa_s, results, SCAN_AP_LIMIT);
1221         wpa_printf(MSG_DEBUG, "Scan results: %d", num);
1222         if (num < 0) {
1223                 wpa_printf(MSG_DEBUG, "Failed to get scan results");
1224                 os_free(results);
1225                 return -1;
1226         }
1227         if (num > SCAN_AP_LIMIT) {
1228                 wpa_printf(MSG_INFO, "Not enough room for all APs (%d < %d)",
1229                            num, SCAN_AP_LIMIT);
1230                 num = SCAN_AP_LIMIT;
1231         }
1232
1233         wpa_scan_results_free(wpa_s->scan_res);
1234         wpa_s->scan_res = NULL;
1235
1236         /* Convert old scan result data structure to the new one */
1237         res = os_zalloc(sizeof(*res));
1238         if (res == NULL) {
1239                 os_free(results);
1240                 return -1;
1241         }
1242         res->res = os_zalloc(num * sizeof(struct wpa_scan_res *));
1243         if (res->res == NULL) {
1244                 os_free(results);
1245                 os_free(res);
1246                 return -1;
1247         }
1248
1249         for (i = 0; i < num; i++) {
1250                 struct wpa_scan_result *bss = &results[i];
1251                 struct wpa_scan_res *r;
1252                 size_t ie_len;
1253                 u8 *pos;
1254
1255                 ie_len = 2 + bss->ssid_len + bss->rsn_ie_len + bss->wpa_ie_len;
1256                 if (bss->maxrate)
1257                         ie_len += 3;
1258                 if (bss->mdie_present)
1259                         ie_len += 5;
1260
1261                 r = os_zalloc(sizeof(*r) + ie_len);
1262                 if (r == NULL)
1263                         break;
1264
1265                 os_memcpy(r->bssid, bss->bssid, ETH_ALEN);
1266                 r->freq = bss->freq;
1267                 r->caps = bss->caps;
1268                 r->qual = bss->qual;
1269                 r->noise = bss->noise;
1270                 r->level = bss->level;
1271                 r->tsf = bss->tsf;
1272                 r->ie_len = ie_len;
1273
1274                 pos = (u8 *) (r + 1);
1275
1276                 /* SSID IE */
1277                 *pos++ = WLAN_EID_SSID;
1278                 *pos++ = bss->ssid_len;
1279                 os_memcpy(pos, bss->ssid, bss->ssid_len);
1280                 pos += bss->ssid_len;
1281
1282                 if (bss->maxrate) {
1283                         /* Fake Supported Rate IE to include max rate */
1284                         *pos++ = WLAN_EID_SUPP_RATES;
1285                         *pos++ = 1;
1286                         *pos++ = bss->maxrate;
1287                 }
1288
1289                 if (bss->rsn_ie_len) {
1290                         os_memcpy(pos, bss->rsn_ie, bss->rsn_ie_len);
1291                         pos += bss->rsn_ie_len;
1292                 }
1293
1294                 if (bss->mdie_present) {
1295                         os_memcpy(pos, bss->mdie, 5);
1296                         pos += 5;
1297                 }
1298
1299                 if (bss->wpa_ie_len) {
1300                         os_memcpy(pos, bss->wpa_ie, bss->wpa_ie_len);
1301                         pos += bss->wpa_ie_len;
1302                 }
1303
1304                 res->res[res->num++] = r;
1305         }
1306
1307         os_free(results);
1308         wpa_s->scan_res = res;
1309
1310         return 0;
1311 }
1312
1313
1314 /**
1315  * wpa_supplicant_get_scan_results - Get scan results
1316  * @wpa_s: Pointer to wpa_supplicant data
1317  * Returns: 0 on success, -1 on failure
1318  *
1319  * This function is request the current scan results from the driver and stores
1320  * a local copy of the results in wpa_s->scan_res.
1321  */
1322 int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s)
1323 {
1324         int ret;
1325
1326         if (wpa_s->use_client_mlme) {
1327                 wpa_scan_results_free(wpa_s->scan_res);
1328                 wpa_s->scan_res = ieee80211_sta_get_scan_results(wpa_s);
1329                 if (wpa_s->scan_res == NULL) {
1330                         wpa_printf(MSG_DEBUG, "Failed to get scan results");
1331                         ret = -1;
1332                 } else
1333                         ret = 0;
1334         } else if (wpa_s->driver->get_scan_results2 == NULL)
1335                 ret = wpa_supplicant_get_scan_results_old(wpa_s);
1336         else {
1337                 wpa_scan_results_free(wpa_s->scan_res);
1338                 wpa_s->scan_res = wpa_drv_get_scan_results2(wpa_s);
1339                 if (wpa_s->scan_res == NULL) {
1340                         wpa_printf(MSG_DEBUG, "Failed to get scan results");
1341                         ret = -1;
1342                 } else
1343                         ret = 0;
1344         }
1345
1346         if (wpa_s->scan_res)
1347                 wpa_scan_sort_results(wpa_s->scan_res);
1348
1349         return ret;
1350 }
1351
1352
1353 /**
1354  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
1355  * @wpa_s: Pointer to wpa_supplicant data
1356  * Returns: A pointer to the current network structure or %NULL on failure
1357  */
1358 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1359 {
1360         struct wpa_ssid *entry;
1361         u8 ssid[MAX_SSID_LEN];
1362         int res;
1363         size_t ssid_len;
1364         u8 bssid[ETH_ALEN];
1365         int wired;
1366
1367         if (wpa_s->use_client_mlme) {
1368                 if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) {
1369                         wpa_printf(MSG_WARNING, "Could not read SSID from "
1370                                    "MLME.");
1371                         return NULL;
1372                 }
1373         } else {
1374                 res = wpa_drv_get_ssid(wpa_s, ssid);
1375                 if (res < 0) {
1376                         wpa_printf(MSG_WARNING, "Could not read SSID from "
1377                                    "driver.");
1378                         return NULL;
1379                 }
1380                 ssid_len = res;
1381         }
1382
1383         if (wpa_s->use_client_mlme)
1384                 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
1385         else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1386                 wpa_printf(MSG_WARNING, "Could not read BSSID from driver.");
1387                 return NULL;
1388         }
1389
1390         wired = wpa_s->conf->ap_scan == 0 && wpa_s->driver &&
1391                 os_strcmp(wpa_s->driver->name, "wired") == 0;
1392
1393         entry = wpa_s->conf->ssid;
1394         while (entry) {
1395                 if (!entry->disabled &&
1396                     ((ssid_len == entry->ssid_len &&
1397                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1398                     (!entry->bssid_set ||
1399                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1400                         return entry;
1401                 entry = entry->next;
1402         }
1403
1404         return NULL;
1405 }
1406
1407
1408 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1409                                      const char *name)
1410 {
1411         int i;
1412
1413         if (wpa_s == NULL)
1414                 return -1;
1415
1416         if (wpa_supplicant_drivers[0] == NULL) {
1417                 wpa_printf(MSG_ERROR, "No driver interfaces build into "
1418                            "wpa_supplicant.");
1419                 return -1;
1420         }
1421
1422         if (name == NULL) {
1423                 /* default to first driver in the list */
1424                 wpa_s->driver = wpa_supplicant_drivers[0];
1425                 return 0;
1426         }
1427
1428         for (i = 0; wpa_supplicant_drivers[i]; i++) {
1429                 if (os_strcmp(name, wpa_supplicant_drivers[i]->name) == 0) {
1430                         wpa_s->driver = wpa_supplicant_drivers[i];
1431                         return 0;
1432                 }
1433         }
1434
1435         wpa_printf(MSG_ERROR, "Unsupported driver '%s'.\n", name);
1436         return -1;
1437 }
1438
1439
1440 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1441                              const u8 *buf, size_t len)
1442 {
1443         struct wpa_supplicant *wpa_s = ctx;
1444
1445         wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1446         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1447
1448         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1449                 wpa_printf(MSG_DEBUG, "Ignored received EAPOL frame since "
1450                            "no key management is configured");
1451                 return;
1452         }
1453
1454         if (wpa_s->eapol_received == 0 &&
1455             (!wpa_s->driver_4way_handshake ||
1456              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1457              wpa_s->wpa_state != WPA_COMPLETED)) {
1458                 /* Timeout for completing IEEE 802.1X and WPA authentication */
1459                 wpa_supplicant_req_auth_timeout(
1460                         wpa_s,
1461                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1462                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) ?
1463                         70 : 10, 0);
1464         }
1465         wpa_s->eapol_received++;
1466
1467         if (wpa_s->countermeasures) {
1468                 wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL "
1469                            "packet");
1470                 return;
1471         }
1472
1473         /* Source address of the incoming EAPOL frame could be compared to the
1474          * current BSSID. However, it is possible that a centralized
1475          * Authenticator could be using another MAC address than the BSSID of
1476          * an AP, so just allow any address to be used for now. The replies are
1477          * still sent to the current BSSID (if available), though. */
1478
1479         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
1480         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
1481             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
1482                 return;
1483         wpa_drv_poll(wpa_s);
1484         if (!wpa_s->driver_4way_handshake)
1485                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
1486         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1487                 /*
1488                  * Set portValid = TRUE here since we are going to skip 4-way
1489                  * handshake processing which would normally set portValid. We
1490                  * need this to allow the EAPOL state machines to be completed
1491                  * without going through EAPOL-Key handshake.
1492                  */
1493                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1494         }
1495 }
1496
1497
1498 void wpa_supplicant_sta_free_hw_features(struct wpa_hw_modes *hw_features,
1499                                          size_t num_hw_features)
1500 {
1501         ieee80211_sta_free_hw_features(hw_features, num_hw_features);
1502 }
1503
1504
1505 void wpa_supplicant_sta_rx(void *ctx, const u8 *buf, size_t len,
1506                            struct ieee80211_rx_status *rx_status)
1507 {
1508         struct wpa_supplicant *wpa_s = ctx;
1509         ieee80211_sta_rx(wpa_s, buf, len, rx_status);
1510 }
1511
1512
1513 /**
1514  * wpa_supplicant_driver_init - Initialize driver interface parameters
1515  * @wpa_s: Pointer to wpa_supplicant data
1516  * Returns: 0 on success, -1 on failure
1517  *
1518  * This function is called to initialize driver interface parameters.
1519  * wpa_drv_init() must have been called before this function to initialize the
1520  * driver interface.
1521  */
1522 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1523 {
1524         static int interface_count = 0;
1525
1526         if (wpa_s->driver->send_eapol) {
1527                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1528                 if (addr)
1529                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1530         } else {
1531                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
1532                                            wpa_drv_get_mac_addr(wpa_s),
1533                                            ETH_P_EAPOL,
1534                                            wpa_supplicant_rx_eapol, wpa_s, 0);
1535                 if (wpa_s->l2 == NULL)
1536                         return -1;
1537         }
1538
1539         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
1540                 wpa_printf(MSG_ERROR, "Failed to get own L2 address");
1541                 return -1;
1542         }
1543
1544         wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR,
1545                    MAC2STR(wpa_s->own_addr));
1546
1547         if (wpa_s->bridge_ifname[0]) {
1548                 wpa_printf(MSG_DEBUG, "Receiving packets from bridge interface"
1549                            " '%s'", wpa_s->bridge_ifname);
1550                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
1551                                               wpa_s->own_addr,
1552                                               ETH_P_EAPOL,
1553                                               wpa_supplicant_rx_eapol, wpa_s,
1554                                               0);
1555                 if (wpa_s->l2_br == NULL) {
1556                         wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1557                                    "connection for the bridge interface '%s'",
1558                                    wpa_s->bridge_ifname);
1559                         return -1;
1560                 }
1561         }
1562
1563         /* Backwards compatibility call to set_wpa() handler. This is called
1564          * only just after init and just before deinit, so these handler can be
1565          * used to implement same functionality. */
1566         if (wpa_drv_set_wpa(wpa_s, 1) < 0) {
1567                 struct wpa_driver_capa capa;
1568                 if (wpa_drv_get_capa(wpa_s, &capa) < 0 ||
1569                     !(capa.flags & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1570                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2))) {
1571                         wpa_printf(MSG_DEBUG, "Driver does not support WPA.");
1572                         /* Continue to allow non-WPA modes to be used. */
1573                 } else {
1574                         wpa_printf(MSG_ERROR, "Failed to enable WPA in the "
1575                                 "driver.");
1576                         return -1;
1577                 }
1578         }
1579
1580         wpa_clear_keys(wpa_s, NULL);
1581
1582         /* Make sure that TKIP countermeasures are not left enabled (could
1583          * happen if wpa_supplicant is killed during countermeasures. */
1584         wpa_drv_set_countermeasures(wpa_s, 0);
1585
1586         wpa_drv_set_drop_unencrypted(wpa_s, 1);
1587
1588         wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
1589         wpa_drv_flush_pmkid(wpa_s);
1590
1591         wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
1592         wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
1593         interface_count++;
1594
1595         return 0;
1596 }
1597
1598
1599 static int wpa_supplicant_daemon(const char *pid_file)
1600 {
1601         wpa_printf(MSG_DEBUG, "Daemonize..");
1602         return os_daemonize(pid_file);
1603 }
1604
1605
1606 static struct wpa_supplicant * wpa_supplicant_alloc(void)
1607 {
1608         struct wpa_supplicant *wpa_s;
1609
1610         wpa_s = os_zalloc(sizeof(*wpa_s));
1611         if (wpa_s == NULL)
1612                 return NULL;
1613         wpa_s->scan_req = 1;
1614
1615         return wpa_s;
1616 }
1617
1618
1619 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
1620                                      struct wpa_interface *iface)
1621 {
1622         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
1623                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
1624                    iface->confname ? iface->confname : "N/A",
1625                    iface->driver ? iface->driver : "default",
1626                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
1627                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
1628
1629         if (wpa_supplicant_set_driver(wpa_s, iface->driver) < 0) {
1630                 return -1;
1631         }
1632
1633         if (iface->confname) {
1634 #ifdef CONFIG_BACKEND_FILE
1635                 wpa_s->confname = os_rel2abs_path(iface->confname);
1636                 if (wpa_s->confname == NULL) {
1637                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
1638                                    "for configuration file '%s'.",
1639                                    iface->confname);
1640                         return -1;
1641                 }
1642                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
1643                            iface->confname, wpa_s->confname);
1644 #else /* CONFIG_BACKEND_FILE */
1645                 wpa_s->confname = os_strdup(iface->confname);
1646 #endif /* CONFIG_BACKEND_FILE */
1647                 wpa_s->conf = wpa_config_read(wpa_s->confname);
1648                 if (wpa_s->conf == NULL) {
1649                         wpa_printf(MSG_ERROR, "Failed to read or parse "
1650                                    "configuration '%s'.", wpa_s->confname);
1651                         return -1;
1652                 }
1653
1654                 /*
1655                  * Override ctrl_interface and driver_param if set on command
1656                  * line.
1657                  */
1658                 if (iface->ctrl_interface) {
1659                         os_free(wpa_s->conf->ctrl_interface);
1660                         wpa_s->conf->ctrl_interface =
1661                                 os_strdup(iface->ctrl_interface);
1662                 }
1663
1664                 if (iface->driver_param) {
1665                         os_free(wpa_s->conf->driver_param);
1666                         wpa_s->conf->driver_param =
1667                                 os_strdup(iface->driver_param);
1668                 }
1669         } else
1670                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
1671                                                      iface->driver_param);
1672
1673         if (wpa_s->conf == NULL) {
1674                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
1675                 return -1;
1676         }
1677
1678         if (iface->ifname == NULL) {
1679                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
1680                 return -1;
1681         }
1682         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
1683                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
1684                            iface->ifname);
1685                 return -1;
1686         }
1687         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
1688
1689         if (iface->bridge_ifname) {
1690                 if (os_strlen(iface->bridge_ifname) >=
1691                     sizeof(wpa_s->bridge_ifname)) {
1692                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
1693                                    "name '%s'.", iface->bridge_ifname);
1694                         return -1;
1695                 }
1696                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
1697                            sizeof(wpa_s->bridge_ifname));
1698         }
1699
1700         return 0;
1701 }
1702
1703
1704 static int wpa_supplicant_init_iface2(struct wpa_supplicant *wpa_s)
1705 {
1706         const char *ifname;
1707         struct wpa_driver_capa capa;
1708
1709         wpa_printf(MSG_DEBUG, "Initializing interface (2) '%s'",
1710                    wpa_s->ifname);
1711
1712         /* RSNA Supplicant Key Management - INITIALIZE */
1713         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1714         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1715
1716         /* Initialize driver interface and register driver event handler before
1717          * L2 receive handler so that association events are processed before
1718          * EAPOL-Key packets if both become available for the same select()
1719          * call. */
1720         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
1721         if (wpa_s->drv_priv == NULL) {
1722                 wpa_printf(MSG_ERROR, "Failed to initialize driver interface");
1723                 return -1;
1724         }
1725         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
1726                 wpa_printf(MSG_ERROR, "Driver interface rejected "
1727                            "driver_param '%s'", wpa_s->conf->driver_param);
1728                 return -1;
1729         }
1730
1731         ifname = wpa_drv_get_ifname(wpa_s);
1732         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
1733                 wpa_printf(MSG_DEBUG, "Driver interface replaced interface "
1734                            "name with '%s'", ifname);
1735                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
1736         }
1737
1738         if (wpa_supplicant_init_wpa(wpa_s) < 0)
1739                 return -1;
1740
1741         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
1742                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
1743                           NULL);
1744         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1745
1746         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
1747             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
1748                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
1749                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1750                            "dot11RSNAConfigPMKLifetime");
1751                 return -1;
1752         }
1753
1754         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
1755             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
1756                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
1757                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1758                         "dot11RSNAConfigPMKReauthThreshold");
1759                 return -1;
1760         }
1761
1762         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
1763             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
1764                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
1765                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1766                            "dot11RSNAConfigSATimeout");
1767                 return -1;
1768         }
1769
1770         if (wpa_supplicant_driver_init(wpa_s) < 0)
1771                 return -1;
1772
1773         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
1774
1775         if (wpa_supplicant_init_eapol(wpa_s) < 0)
1776                 return -1;
1777         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
1778
1779         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1780         if (wpa_s->ctrl_iface == NULL) {
1781                 wpa_printf(MSG_ERROR,
1782                            "Failed to initialize control interface '%s'.\n"
1783                            "You may have another wpa_supplicant process "
1784                            "already running or the file was\n"
1785                            "left by an unclean termination of wpa_supplicant "
1786                            "in which case you will need\n"
1787                            "to manually remove this file before starting "
1788                            "wpa_supplicant again.\n",
1789                            wpa_s->conf->ctrl_interface);
1790                 return -1;
1791         }
1792
1793         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
1794                 if (capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
1795                         wpa_s->use_client_mlme = 1;
1796                         if (ieee80211_sta_init(wpa_s))
1797                                 return -1;
1798                 }
1799                 if (capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)
1800                         wpa_s->driver_4way_handshake = 1;
1801         }
1802
1803         return 0;
1804 }
1805
1806
1807 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s)
1808 {
1809         if (wpa_s->drv_priv) {
1810                 wpa_supplicant_deauthenticate(wpa_s,
1811                                               WLAN_REASON_DEAUTH_LEAVING);
1812
1813                 /* Backwards compatibility call to set_wpa() handler. This is
1814                  * called only just after init and just before deinit, so these
1815                  * handler can be used to implement same functionality. */
1816                 if (wpa_drv_set_wpa(wpa_s, 0) < 0) {
1817                         wpa_printf(MSG_ERROR, "Failed to disable WPA in the "
1818                                    "driver.");
1819                 }
1820
1821                 wpa_drv_set_drop_unencrypted(wpa_s, 0);
1822                 wpa_drv_set_countermeasures(wpa_s, 0);
1823                 wpa_clear_keys(wpa_s, NULL);
1824         }
1825
1826         wpas_dbus_unregister_iface(wpa_s);
1827
1828         wpa_supplicant_cleanup(wpa_s);
1829
1830         if (wpa_s->drv_priv)
1831                 wpa_drv_deinit(wpa_s);
1832 }
1833
1834
1835 /**
1836  * wpa_supplicant_add_iface - Add a new network interface
1837  * @global: Pointer to global data from wpa_supplicant_init()
1838  * @iface: Interface configuration options
1839  * Returns: Pointer to the created interface or %NULL on failure
1840  *
1841  * This function is used to add new network interfaces for %wpa_supplicant.
1842  * This can be called before wpa_supplicant_run() to add interfaces before the
1843  * main event loop has been started. In addition, new interfaces can be added
1844  * dynamically while %wpa_supplicant is already running. This could happen,
1845  * e.g., when a hotplug network adapter is inserted.
1846  */
1847 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
1848                                                  struct wpa_interface *iface)
1849 {
1850         struct wpa_supplicant *wpa_s;
1851
1852         if (global == NULL || iface == NULL)
1853                 return NULL;
1854
1855         wpa_s = wpa_supplicant_alloc();
1856         if (wpa_s == NULL)
1857                 return NULL;
1858
1859         if (wpa_supplicant_init_iface(wpa_s, iface) ||
1860             wpa_supplicant_init_iface2(wpa_s)) {
1861                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
1862                            iface->ifname);
1863                 wpa_supplicant_deinit_iface(wpa_s);
1864                 os_free(wpa_s);
1865                 return NULL;
1866         }
1867
1868         wpa_s->global = global;
1869
1870         /* Register the interface with the dbus control interface */
1871         if (wpas_dbus_register_iface(wpa_s)) {
1872                 wpa_supplicant_deinit_iface(wpa_s);
1873                 os_free(wpa_s);
1874                 return NULL;
1875         }
1876
1877         wpa_s->next = global->ifaces;
1878         global->ifaces = wpa_s;
1879
1880         wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname);
1881
1882         return wpa_s;
1883 }
1884
1885
1886 /**
1887  * wpa_supplicant_remove_iface - Remove a network interface
1888  * @global: Pointer to global data from wpa_supplicant_init()
1889  * @wpa_s: Pointer to the network interface to be removed
1890  * Returns: 0 if interface was removed, -1 if interface was not found
1891  *
1892  * This function can be used to dynamically remove network interfaces from
1893  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
1894  * addition, this function is used to remove all remaining interfaces when
1895  * %wpa_supplicant is terminated.
1896  */
1897 int wpa_supplicant_remove_iface(struct wpa_global *global,
1898                                 struct wpa_supplicant *wpa_s)
1899 {
1900         struct wpa_supplicant *prev;
1901
1902         /* Remove interface from the global list of interfaces */
1903         prev = global->ifaces;
1904         if (prev == wpa_s) {
1905                 global->ifaces = wpa_s->next;
1906         } else {
1907                 while (prev && prev->next != wpa_s)
1908                         prev = prev->next;
1909                 if (prev == NULL)
1910                         return -1;
1911                 prev->next = wpa_s->next;
1912         }
1913
1914         wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
1915
1916         wpa_supplicant_deinit_iface(wpa_s);
1917         os_free(wpa_s);
1918
1919         return 0;
1920 }
1921
1922
1923 /**
1924  * wpa_supplicant_get_iface - Get a new network interface
1925  * @global: Pointer to global data from wpa_supplicant_init()
1926  * @ifname: Interface name
1927  * Returns: Pointer to the interface or %NULL if not found
1928  */
1929 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
1930                                                  const char *ifname)
1931 {
1932         struct wpa_supplicant *wpa_s;
1933
1934         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1935                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
1936                         return wpa_s;
1937         }
1938         return NULL;
1939 }
1940
1941
1942 /**
1943  * wpa_supplicant_init - Initialize %wpa_supplicant
1944  * @params: Parameters for %wpa_supplicant
1945  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
1946  *
1947  * This function is used to initialize %wpa_supplicant. After successful
1948  * initialization, the returned data pointer can be used to add and remove
1949  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
1950  */
1951 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
1952 {
1953         struct wpa_global *global;
1954         int ret;
1955
1956         if (params == NULL)
1957                 return NULL;
1958
1959         wpa_debug_open_file(params->wpa_debug_file_path);
1960
1961         ret = eap_peer_register_methods();
1962         if (ret) {
1963                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
1964                 if (ret == -2)
1965                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
1966                                    "the same EAP type.");
1967                 return NULL;
1968         }
1969
1970         global = os_zalloc(sizeof(*global));
1971         if (global == NULL)
1972                 return NULL;
1973         global->params.daemonize = params->daemonize;
1974         global->params.wait_for_monitor = params->wait_for_monitor;
1975         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
1976         if (params->pid_file)
1977                 global->params.pid_file = os_strdup(params->pid_file);
1978         if (params->ctrl_interface)
1979                 global->params.ctrl_interface =
1980                         os_strdup(params->ctrl_interface);
1981         wpa_debug_level = global->params.wpa_debug_level =
1982                 params->wpa_debug_level;
1983         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
1984                 params->wpa_debug_show_keys;
1985         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
1986                 params->wpa_debug_timestamp;
1987
1988         if (eloop_init(global)) {
1989                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1990                 wpa_supplicant_deinit(global);
1991                 return NULL;
1992         }
1993
1994         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
1995         if (global->ctrl_iface == NULL) {
1996                 wpa_supplicant_deinit(global);
1997                 return NULL;
1998         }
1999
2000         if (global->params.dbus_ctrl_interface) {
2001                 global->dbus_ctrl_iface =
2002                         wpa_supplicant_dbus_ctrl_iface_init(global);
2003                 if (global->dbus_ctrl_iface == NULL) {
2004                         wpa_supplicant_deinit(global);
2005                         return NULL;
2006                 }
2007         }
2008
2009         return global;
2010 }
2011
2012
2013 /**
2014  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
2015  * @global: Pointer to global data from wpa_supplicant_init()
2016  * Returns: 0 after successful event loop run, -1 on failure
2017  *
2018  * This function starts the main event loop and continues running as long as
2019  * there are any remaining events. In most cases, this function is running as
2020  * long as the %wpa_supplicant process in still in use.
2021  */
2022 int wpa_supplicant_run(struct wpa_global *global)
2023 {
2024         struct wpa_supplicant *wpa_s;
2025
2026         if (global->params.daemonize &&
2027             wpa_supplicant_daemon(global->params.pid_file))
2028                 return -1;
2029
2030         if (global->params.wait_for_monitor) {
2031                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2032                         if (wpa_s->ctrl_iface)
2033                                 wpa_supplicant_ctrl_iface_wait(
2034                                         wpa_s->ctrl_iface);
2035         }
2036
2037         eloop_register_signal_terminate(wpa_supplicant_terminate, NULL);
2038         eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL);
2039
2040         eloop_run();
2041
2042         return 0;
2043 }
2044
2045
2046 /**
2047  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2048  * @global: Pointer to global data from wpa_supplicant_init()
2049  *
2050  * This function is called to deinitialize %wpa_supplicant and to free all
2051  * allocated resources. Remaining network interfaces will also be removed.
2052  */
2053 void wpa_supplicant_deinit(struct wpa_global *global)
2054 {
2055         if (global == NULL)
2056                 return;
2057
2058         while (global->ifaces)
2059                 wpa_supplicant_remove_iface(global, global->ifaces);
2060
2061         if (global->ctrl_iface)
2062                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2063         if (global->dbus_ctrl_iface)
2064                 wpa_supplicant_dbus_ctrl_iface_deinit(global->dbus_ctrl_iface);
2065
2066         eap_peer_unregister_methods();
2067
2068         eloop_destroy();
2069
2070         if (global->params.pid_file) {
2071                 os_daemonize_terminate(global->params.pid_file);
2072                 os_free(global->params.pid_file);
2073         }
2074         os_free(global->params.ctrl_interface);
2075
2076         os_free(global);
2077         wpa_debug_close_file();
2078 }