wpa_supplicant/sme.c

   1 /*
   2  * wpa_supplicant - SME
   3  * Copyright (c) 2009-2010, 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
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "common/ieee802_11_defs.h"
  19 #include "common/ieee802_11_common.h"
  20 #include "eapol_supp/eapol_supp_sm.h"
  21 #include "common/wpa_common.h"
  22 #include "rsn_supp/wpa.h"
  23 #include "rsn_supp/pmksa_cache.h"
  24 #include "config.h"
  25 #include "wpa_supplicant_i.h"
  26 #include "driver_i.h"
  27 #include "wpas_glue.h"
  28 #include "wps_supplicant.h"
  29 #include "p2p_supplicant.h"
  30 #include "notify.h"
  31 #include "blacklist.h"
  32 #include "bss.h"
  33 #include "scan.h"
  34 #include "sme.h"
  35
  36 void sme_authenticate(struct wpa_supplicant *wpa_s,
  37                       struct wpa_bss *bss, struct wpa_ssid *ssid)
  38 {
  39         struct wpa_driver_auth_params params;
  40         struct wpa_ssid *old_ssid;
  41 #ifdef CONFIG_IEEE80211R
  42         const u8 *ie;
  43 #endif /* CONFIG_IEEE80211R */
  44 #ifdef CONFIG_IEEE80211R
  45         const u8 *md = NULL;
  46 #endif /* CONFIG_IEEE80211R */
  47         int i, bssid_changed;
  48
  49         if (bss == NULL) {
  50                 wpa_printf(MSG_ERROR, "SME: No scan result available for the "
  51                            "network");
  52                 return;
  53         }
  54
  55         wpa_s->current_bss = bss;
  56
  57         os_memset(&params, 0, sizeof(params));
  58         wpa_s->reassociate = 0;
  59
  60         params.freq = bss->freq;
  61         params.bssid = bss->bssid;
  62         params.ssid = bss->ssid;
  63         params.ssid_len = bss->ssid_len;
  64
  65         if (wpa_s->sme.ssid_len != params.ssid_len ||
  66             os_memcmp(wpa_s->sme.ssid, params.ssid, params.ssid_len) != 0)
  67                 wpa_s->sme.prev_bssid_set = 0;
  68
  69         wpa_s->sme.freq = params.freq;
  70         os_memcpy(wpa_s->sme.ssid, params.ssid, params.ssid_len);
  71         wpa_s->sme.ssid_len = params.ssid_len;
  72
  73         params.auth_alg = WPA_AUTH_ALG_OPEN;
  74 #ifdef IEEE8021X_EAPOL
  75         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
  76                 if (ssid->leap) {
  77                         if (ssid->non_leap == 0)
  78                                 params.auth_alg = WPA_AUTH_ALG_LEAP;
  79                         else
  80                                 params.auth_alg |= WPA_AUTH_ALG_LEAP;
  81                 }
  82         }
  83 #endif /* IEEE8021X_EAPOL */
  84         wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x",
  85                    params.auth_alg);
  86         if (ssid->auth_alg) {
  87                 params.auth_alg = ssid->auth_alg;
  88                 wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
  89                            params.auth_alg);
  90         }
  91
  92         for (i = 0; i < NUM_WEP_KEYS; i++) {
  93                 if (ssid->wep_key_len[i])
  94                         params.wep_key[i] = ssid->wep_key[i];
  95                 params.wep_key_len[i] = ssid->wep_key_len[i];
  96         }
  97         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
  98
  99         bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
 100         os_memset(wpa_s->bssid, 0, ETH_ALEN);
 101         os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
 102         if (bssid_changed)
 103                 wpas_notify_bssid_changed(wpa_s);
 104
 105         if ((wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
 106              wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
 107             (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
 108                                WPA_KEY_MGMT_FT_IEEE8021X |
 109                                WPA_KEY_MGMT_FT_PSK |
 110                                WPA_KEY_MGMT_IEEE8021X_SHA256 |
 111                                WPA_KEY_MGMT_PSK_SHA256))) {
 112                 int try_opportunistic;
 113                 try_opportunistic = ssid->proactive_key_caching &&
 114                         (ssid->proto & WPA_PROTO_RSN);
 115                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
 116                                             wpa_s->current_ssid,
 117                                             try_opportunistic) == 0)
 118                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
 119                 wpa_s->sme.assoc_req_ie_len = sizeof(wpa_s->sme.assoc_req_ie);
 120                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
 121                                               wpa_s->sme.assoc_req_ie,
 122                                               &wpa_s->sme.assoc_req_ie_len)) {
 123                         wpa_printf(MSG_WARNING, "SME: Failed to set WPA key "
 124                                    "management and encryption suites");
 125                         return;
 126                 }
 127         } else if (ssid->key_mgmt &
 128                    (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
 129                     WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
 130                     WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_PSK_SHA256 |
 131                     WPA_KEY_MGMT_IEEE8021X_SHA256)) {
 132                 wpa_s->sme.assoc_req_ie_len = sizeof(wpa_s->sme.assoc_req_ie);
 133                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
 134                                               wpa_s->sme.assoc_req_ie,
 135                                               &wpa_s->sme.assoc_req_ie_len)) {
 136                         wpa_printf(MSG_WARNING, "SME: Failed to set WPA key "
 137                                    "management and encryption suites (no scan "
 138                                    "results)");
 139                         return;
 140                 }
 141 #ifdef CONFIG_WPS
 142         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
 143                 struct wpabuf *wps_ie;
 144                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
 145                 if (wps_ie && wpabuf_len(wps_ie) <=
 146                     sizeof(wpa_s->sme.assoc_req_ie)) {
 147                         wpa_s->sme.assoc_req_ie_len = wpabuf_len(wps_ie);
 148                         os_memcpy(wpa_s->sme.assoc_req_ie, wpabuf_head(wps_ie),
 149                                   wpa_s->sme.assoc_req_ie_len);
 150                 } else
 151                         wpa_s->sme.assoc_req_ie_len = 0;
 152                 wpabuf_free(wps_ie);
 153                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
 154 #endif /* CONFIG_WPS */
 155         } else {
 156                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
 157                 wpa_s->sme.assoc_req_ie_len = 0;
 158         }
 159
 160 #ifdef CONFIG_IEEE80211R
 161         ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
 162         if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
 163                 md = ie + 2;
 164         wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
 165         if (md) {
 166                 /* Prepare for the next transition */
 167                 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
 168         }
 169
 170         if (md && ssid->key_mgmt & (WPA_KEY_MGMT_FT_PSK |
 171                                     WPA_KEY_MGMT_FT_IEEE8021X)) {
 172                 if (wpa_s->sme.assoc_req_ie_len + 5 <
 173                     sizeof(wpa_s->sme.assoc_req_ie)) {
 174                         struct rsn_mdie *mdie;
 175                         u8 *pos = wpa_s->sme.assoc_req_ie +
 176                                 wpa_s->sme.assoc_req_ie_len;
 177                         *pos++ = WLAN_EID_MOBILITY_DOMAIN;
 178                         *pos++ = sizeof(*mdie);
 179                         mdie = (struct rsn_mdie *) pos;
 180                         os_memcpy(mdie->mobility_domain, md,
 181                                   MOBILITY_DOMAIN_ID_LEN);
 182                         mdie->ft_capab = md[MOBILITY_DOMAIN_ID_LEN];
 183                         wpa_s->sme.assoc_req_ie_len += 5;
 184                 }
 185
 186                 if (wpa_s->sme.ft_used &&
 187                     os_memcmp(md, wpa_s->sme.mobility_domain, 2) == 0 &&
 188                     wpa_sm_has_ptk(wpa_s->wpa)) {
 189                         wpa_printf(MSG_DEBUG, "SME: Trying to use FT "
 190                                    "over-the-air");
 191                         params.auth_alg = WPA_AUTH_ALG_FT;
 192                         params.ie = wpa_s->sme.ft_ies;
 193                         params.ie_len = wpa_s->sme.ft_ies_len;
 194                 }
 195         }
 196 #endif /* CONFIG_IEEE80211R */
 197
 198 #ifdef CONFIG_IEEE80211W
 199         wpa_s->sme.mfp = ssid->ieee80211w;
 200         if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
 201                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 202                 struct wpa_ie_data _ie;
 203                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &_ie) == 0 &&
 204                     _ie.capabilities &
 205                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
 206                         wpa_printf(MSG_DEBUG, "WPA: Selected AP supports MFP: "
 207                                    "require MFP");
 208                         wpa_s->sme.mfp = MGMT_FRAME_PROTECTION_REQUIRED;
 209                 }
 210         }
 211 #endif /* CONFIG_IEEE80211W */
 212
 213 #ifdef CONFIG_P2P
 214         if (wpa_s->global->p2p) {
 215                 u8 *pos;
 216                 size_t len;
 217                 int res;
 218                 int p2p_group;
 219                 p2p_group = wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE;
 220                 pos = wpa_s->sme.assoc_req_ie + wpa_s->sme.assoc_req_ie_len;
 221                 len = sizeof(wpa_s->sme.assoc_req_ie) -
 222                         wpa_s->sme.assoc_req_ie_len;
 223                 res = wpas_p2p_assoc_req_ie(wpa_s, bss->bssid, pos, len,
 224                                             p2p_group);
 225                 if (res >= 0)
 226                         wpa_s->sme.assoc_req_ie_len += res;
 227         }
 228 #endif /* CONFIG_P2P */
 229
 230         wpa_supplicant_cancel_scan(wpa_s);
 231
 232         wpa_msg(wpa_s, MSG_INFO, "Trying to authenticate with " MACSTR
 233                 " (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),
 234                 wpa_ssid_txt(params.ssid, params.ssid_len), params.freq);
 235
 236         wpa_clear_keys(wpa_s, bss->bssid);
 237         wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);
 238         old_ssid = wpa_s->current_ssid;
 239         wpa_s->current_ssid = ssid;
 240         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
 241         wpa_supplicant_initiate_eapol(wpa_s);
 242         if (old_ssid != wpa_s->current_ssid)
 243                 wpas_notify_network_changed(wpa_s);
 244
 245         wpa_s->sme.auth_alg = params.auth_alg;
 246         if (wpa_drv_authenticate(wpa_s, &params) < 0) {
 247                 wpa_msg(wpa_s, MSG_INFO, "Authentication request to the "
 248                         "driver failed");
 249                 wpa_supplicant_req_scan(wpa_s, 1, 0);
 250                 return;
 251         }
 252
 253         /* TODO: add timeout on authentication */
 254
 255         /*
 256          * Association will be started based on the authentication event from
 257          * the driver.
 258          */
 259 }
 260
 261
 262 void sme_event_auth(struct wpa_supplicant *wpa_s, union wpa_event_data *data)
 263 {
 264         struct wpa_ssid *ssid = wpa_s->current_ssid;
 265
 266         if (ssid == NULL) {
 267                 wpa_printf(MSG_DEBUG, "SME: Ignore authentication event when "
 268                            "network is not selected");
 269                 return;
 270         }
 271
 272         if (wpa_s->wpa_state != WPA_AUTHENTICATING) {
 273                 wpa_printf(MSG_DEBUG, "SME: Ignore authentication event when "
 274                            "not in authenticating state");
 275                 return;
 276         }
 277
 278         if (os_memcmp(wpa_s->pending_bssid, data->auth.peer, ETH_ALEN) != 0) {
 279                 wpa_printf(MSG_DEBUG, "SME: Ignore authentication with "
 280                            "unexpected peer " MACSTR,
 281                            MAC2STR(data->auth.peer));
 282                 return;
 283         }
 284
 285         wpa_printf(MSG_DEBUG, "SME: Authentication response: peer=" MACSTR
 286                    " auth_type=%d status_code=%d",
 287                    MAC2STR(data->auth.peer), data->auth.auth_type,
 288                    data->auth.status_code);
 289         wpa_hexdump(MSG_MSGDUMP, "SME: Authentication response IEs",
 290                     data->auth.ies, data->auth.ies_len);
 291
 292         if (data->auth.status_code != WLAN_STATUS_SUCCESS) {
 293                 wpa_printf(MSG_DEBUG, "SME: Authentication failed (status "
 294                            "code %d)", data->auth.status_code);
 295
 296                 if (data->auth.status_code !=
 297                     WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG ||
 298                     wpa_s->sme.auth_alg == data->auth.auth_type ||
 299                     wpa_s->current_ssid->auth_alg == WPA_AUTH_ALG_LEAP)
 300                         return;
 301
 302                 switch (data->auth.auth_type) {
 303                 case WLAN_AUTH_OPEN:
 304                         wpa_s->current_ssid->auth_alg = WPA_AUTH_ALG_SHARED;
 305
 306                         wpa_printf(MSG_DEBUG, "SME: Trying SHARED auth");
 307                         wpa_supplicant_associate(wpa_s, wpa_s->current_bss,
 308                                                  wpa_s->current_ssid);
 309                         return;
 310
 311                 case WLAN_AUTH_SHARED_KEY:
 312                         wpa_s->current_ssid->auth_alg = WPA_AUTH_ALG_LEAP;
 313
 314                         wpa_printf(MSG_DEBUG, "SME: Trying LEAP auth");
 315                         wpa_supplicant_associate(wpa_s, wpa_s->current_bss,
 316                                                  wpa_s->current_ssid);
 317                         return;
 318
 319                 default:
 320                         return;
 321                 }
 322         }
 323
 324 #ifdef CONFIG_IEEE80211R
 325         if (data->auth.auth_type == WLAN_AUTH_FT) {
 326                 union wpa_event_data edata;
 327                 os_memset(&edata, 0, sizeof(edata));
 328                 edata.ft_ies.ies = data->auth.ies;
 329                 edata.ft_ies.ies_len = data->auth.ies_len;
 330                 os_memcpy(edata.ft_ies.target_ap, data->auth.peer, ETH_ALEN);
 331                 wpa_supplicant_event(wpa_s, EVENT_FT_RESPONSE, &edata);
 332         }
 333 #endif /* CONFIG_IEEE80211R */
 334
 335         sme_associate(wpa_s, ssid->mode, data->auth.peer,
 336                       data->auth.auth_type);
 337 }
 338
 339
 340 void sme_associate(struct wpa_supplicant *wpa_s, enum wpas_mode mode,
 341                    const u8 *bssid, u16 auth_type)
 342 {
 343         struct wpa_driver_associate_params params;
 344         struct ieee802_11_elems elems;
 345
 346         os_memset(&params, 0, sizeof(params));
 347         params.bssid = bssid;
 348         params.ssid = wpa_s->sme.ssid;
 349         params.ssid_len = wpa_s->sme.ssid_len;
 350         params.freq = wpa_s->sme.freq;
 351         params.wpa_ie = wpa_s->sme.assoc_req_ie_len ?
 352                 wpa_s->sme.assoc_req_ie : NULL;
 353         params.wpa_ie_len = wpa_s->sme.assoc_req_ie_len;
 354 #ifdef CONFIG_IEEE80211R
 355         if (auth_type == WLAN_AUTH_FT && wpa_s->sme.ft_ies) {
 356                 params.wpa_ie = wpa_s->sme.ft_ies;
 357                 params.wpa_ie_len = wpa_s->sme.ft_ies_len;
 358         }
 359 #endif /* CONFIG_IEEE80211R */
 360         params.mode = mode;
 361         params.mgmt_frame_protection = wpa_s->sme.mfp;
 362         if (wpa_s->sme.prev_bssid_set)
 363                 params.prev_bssid = wpa_s->sme.prev_bssid;
 364
 365         wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
 366                 " (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),
 367                 params.ssid ? wpa_ssid_txt(params.ssid, params.ssid_len) : "",
 368                 params.freq);
 369
 370         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
 371
 372         if (params.wpa_ie == NULL ||
 373             ieee802_11_parse_elems(params.wpa_ie, params.wpa_ie_len, &elems, 0)
 374             < 0) {
 375                 wpa_printf(MSG_DEBUG, "SME: Could not parse own IEs?!");
 376                 os_memset(&elems, 0, sizeof(elems));
 377         }
 378         if (elems.rsn_ie)
 379                 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.rsn_ie - 2,
 380                                         elems.rsn_ie_len + 2);
 381         else if (elems.wpa_ie)
 382                 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.wpa_ie - 2,
 383                                         elems.wpa_ie_len + 2);
 384         else
 385                 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 386         if (elems.p2p &&
 387             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
 388                 params.p2p = 1;
 389
 390         if (wpa_drv_associate(wpa_s, &params) < 0) {
 391                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
 392                         "failed");
 393                 wpa_supplicant_req_scan(wpa_s, 5, 0);
 394                 return;
 395         }
 396
 397         /* TODO: add timeout on association */
 398 }
 399
 400
 401 int sme_update_ft_ies(struct wpa_supplicant *wpa_s, const u8 *md,
 402                       const u8 *ies, size_t ies_len)
 403 {
 404         if (md == NULL || ies == NULL) {
 405                 wpa_printf(MSG_DEBUG, "SME: Remove mobility domain");
 406                 os_free(wpa_s->sme.ft_ies);
 407                 wpa_s->sme.ft_ies = NULL;
 408                 wpa_s->sme.ft_ies_len = 0;
 409                 wpa_s->sme.ft_used = 0;
 410                 return 0;
 411         }
 412
 413         os_memcpy(wpa_s->sme.mobility_domain, md, MOBILITY_DOMAIN_ID_LEN);
 414         wpa_hexdump(MSG_DEBUG, "SME: FT IEs", ies, ies_len);
 415         os_free(wpa_s->sme.ft_ies);
 416         wpa_s->sme.ft_ies = os_malloc(ies_len);
 417         if (wpa_s->sme.ft_ies == NULL)
 418                 return -1;
 419         os_memcpy(wpa_s->sme.ft_ies, ies, ies_len);
 420         wpa_s->sme.ft_ies_len = ies_len;
 421         return 0;
 422 }
 423
 424
 425 void sme_event_assoc_reject(struct wpa_supplicant *wpa_s,
 426                             union wpa_event_data *data)
 427 {
 428         int bssid_changed;
 429         int timeout = 5000;
 430
 431         wpa_printf(MSG_DEBUG, "SME: Association with " MACSTR " failed: "
 432                    "status code %d", MAC2STR(wpa_s->pending_bssid),
 433                    data->assoc_reject.status_code);
 434
 435         bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
 436
 437         /*
 438          * For now, unconditionally terminate the previous authentication. In
 439          * theory, this should not be needed, but mac80211 gets quite confused
 440          * if the authentication is left pending.. Some roaming cases might
 441          * benefit from using the previous authentication, so this could be
 442          * optimized in the future.
 443          */
 444         if (wpa_drv_deauthenticate(wpa_s, wpa_s->pending_bssid,
 445                                    WLAN_REASON_DEAUTH_LEAVING) < 0) {
 446                 wpa_msg(wpa_s, MSG_INFO,
 447                         "Deauth request to the driver failed");
 448         }
 449         wpa_s->sme.prev_bssid_set = 0;
 450
 451         if (wpa_blacklist_add(wpa_s, wpa_s->pending_bssid) == 0) {
 452                 struct wpa_blacklist *b;
 453                 b = wpa_blacklist_get(wpa_s, wpa_s->pending_bssid);
 454                 if (b && b->count < 3) {
 455                         /*
 456                          * Speed up next attempt if there could be other APs
 457                          * that could accept association.
 458                          */
 459                         timeout = 100;
 460                 }
 461         }
 462         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
 463         os_memset(wpa_s->bssid, 0, ETH_ALEN);
 464         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
 465         if (bssid_changed)
 466                 wpas_notify_bssid_changed(wpa_s);
 467
 468         /*
 469          * TODO: if more than one possible AP is available in scan results,
 470          * could try the other ones before requesting a new scan.
 471          */
 472         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
 473                                 1000 * (timeout % 1000));
 474 }
 475
 476
 477 void sme_event_auth_timed_out(struct wpa_supplicant *wpa_s,
 478                               union wpa_event_data *data)
 479 {
 480         wpa_printf(MSG_DEBUG, "SME: Authentication timed out");
 481         wpa_supplicant_req_scan(wpa_s, 5, 0);
 482 }
 483
 484
 485 void sme_event_assoc_timed_out(struct wpa_supplicant *wpa_s,
 486                                union wpa_event_data *data)
 487 {
 488         wpa_printf(MSG_DEBUG, "SME: Association timed out");
 489         wpa_supplicant_mark_disassoc(wpa_s);
 490         wpa_supplicant_req_scan(wpa_s, 5, 0);
 491 }
 492
 493
 494 void sme_event_disassoc(struct wpa_supplicant *wpa_s,
 495                         union wpa_event_data *data)
 496 {
 497         wpa_printf(MSG_DEBUG, "SME: Disassociation event received");
 498         if (wpa_s->sme.prev_bssid_set &&
 499             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)) {
 500                 /*
 501                  * cfg80211/mac80211 can get into somewhat confused state if
 502                  * the AP only disassociates us and leaves us in authenticated
 503                  * state. For now, force the state to be cleared to avoid
 504                  * confusing errors if we try to associate with the AP again.
 505                  */
 506                 wpa_printf(MSG_DEBUG, "SME: Deauthenticate to clear driver "
 507                            "state");
 508                 wpa_drv_deauthenticate(wpa_s, wpa_s->sme.prev_bssid,
 509                                        WLAN_REASON_DEAUTH_LEAVING);
 510         }
 511 }