CHROMIUMOS: wpa_supplicant: add fast reconnect support

wpa_supplicant/events.c

 /*
  * WPA Supplicant - Driver event processing
  * Copyright (c) 2003-2010, Jouni Malinen <j@w1.fi>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * Alternatively, this software may be distributed under the terms of BSD
  * license.
@@ skipping 866 matching lines @@
         return 1;
 }
 
 
 static void wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
                                               union wpa_event_data *data)
 {
         struct wpa_bss *selected;
         struct wpa_ssid *ssid = NULL;
         struct wpa_scan_results *scan_res;
+        int was_fast_reconnect;
 
         wpa_supplicant_notify_scanning(wpa_s, 0);
 
+        was_fast_reconnect = wpa_s->fast_reconnect;
+        wpa_s->fast_reconnect = FALSE;
+
         scan_res = wpa_supplicant_get_scan_results(wpa_s,
                                                    data ? &data->scan_info :
                                                    NULL, 1);
         if (scan_res == NULL) {
                 if (wpa_s->conf->ap_scan == 2)
                         return;
                 wpa_printf(MSG_DEBUG, "Failed to get scan results - try "
                            "scanning again");
                 wpa_supplicant_req_new_scan(wpa_s, 1, 0);
                 return;
@@ skipping 43 matching lines @@
         selected = wpa_supplicant_pick_network(wpa_s, scan_res, &ssid);
 
         if (selected) {
                 int skip;
                 skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid,
                                                     scan_res);
                 wpa_scan_results_free(scan_res);
                 if (skip)
                         return;
                 wpa_supplicant_connect(wpa_s, selected, ssid);
+        } else if (was_fast_reconnect) {
+                /*
+                 * Processed deferred disassoc work on a failed
+                 * fast reconnect.
+                 */
+                wpa_printf(MSG_INFO, "Fast reconnect failed");
+                wpa_scan_results_free(scan_res);
+                wpa_supplicant_mark_disassoc(wpa_s);
         } else {
                 wpa_scan_results_free(scan_res);
                 wpa_printf(MSG_DEBUG, "No suitable network found");
                 ssid = wpa_supplicant_pick_new_network(wpa_s);
                 if (ssid) {
                         wpa_printf(MSG_DEBUG, "Setup a new network");
                         wpa_supplicant_associate(wpa_s, NULL, ssid);
                 } else {
                         int timeout_sec = 5;
                         int timeout_usec = 0;
@@ skipping 275 matching lines @@
         if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
              wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
             wpa_s->current_ssid && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE) {
                 /* Set static WEP keys again */
                 wpa_set_wep_keys(wpa_s, wpa_s->current_ssid);
         }
 }
 
 
+/*
+ * Try to return to the same AP immediately.  Directly scan
+ * on the current channel for the current BSSID and try to
+ * reassociate.  If the station is not present we will clock
+ * the state machine to DISCONNECTED in wpa_supplicant_event_scan_results
+ * which will notify external agents.
+ */
+static int wpa_supplicant_fast_reconnect(struct wpa_supplicant *wpa_s,
+                                         const u8 *bssid)
+{
+        struct wpa_driver_scan_params params;
+        int freqs[2];
+
+        wpa_s->reassociate = 1;
+        wpa_s->fast_reconnect = 1;
+
+        os_memset(&params, 0, sizeof(params));
+        params.num_ssids = 1;
+        params.ssids[0].ssid = wpa_s->current_ssid->ssid;
+        params.ssids[0].ssid_len = wpa_s->current_ssid->ssid_len;
+        freqs[0] = wpa_s->assoc_freq;
+        freqs[1] = 0;
+        params.freqs = freqs;
+
+        wpa_msg(wpa_s, MSG_INFO, "Fast reconnect bssid=" MACSTR
+                " ssid=%.*s freq=%d", MAC2STR(bssid),
+                params.ssids[0].ssid_len, params.ssids[0].ssid,
+                params.freqs[0]);
+
+        bgscan_deinit(wpa_s);

[Paul Stewart, 2011/02/22 21:56:25]

Nit: Any reason why instead of adding these two lines here you don't just move
lines 1365,1366 above the "if (fast_reconnect)" conditional?  Seems a shame to
duplicate.

+        wpa_s->bgscan_ssid = NULL;
+
+        return wpa_supplicant_trigger_scan(wpa_s, &params);
+}
+
+
 static void wpa_supplicant_event_disassoc(struct wpa_supplicant *wpa_s,
                                           u16 reason_code)
 {
         const u8 *bssid;
+        int fast_reconnect;
 #ifdef CONFIG_SME
         int authenticating;
         u8 prev_pending_bssid[ETH_ALEN];
 
         authenticating = wpa_s->wpa_state == WPA_AUTHENTICATING;
         os_memcpy(prev_pending_bssid, wpa_s->pending_bssid, ETH_ALEN);
 #endif /* CONFIG_SME */
 
         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
                 /*
                  * At least Host AP driver and a Prism3 card seemed to be
                  * generating streams of disconnected events when configuring
                  * IBSS for WPA-None. Ignore them for now.
                  */
                 wpa_printf(MSG_DEBUG, "Disconnect event - ignore in "
                            "IBSS/WPA-None mode");
                 return;
         }
 
         if (wpa_s->wpa_state == WPA_4WAY_HANDSHAKE &&
             wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
                 wpa_msg(wpa_s, MSG_INFO, "WPA: 4-Way Handshake failed - "
                         "pre-shared key may be incorrect");
         }
-        if (wpa_s->wpa_state >= WPA_ASSOCIATING)
-                wpa_supplicant_req_scan(wpa_s, 0, 100000);
+        /*
+         * If in a COMPLETED state and we were dropped for a reason
+         * we can directly recover from directly re-join the AP without
+         * clocking the state machine and/or notifying external agents.
+         *
+         * TODO(sleffler) guard against looping (should be only if AP is busted)
+         */
+        fast_reconnect =
+            wpa_s->wpa_state == WPA_COMPLETED &&
+            (reason_code == WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY ||
+             reason_code == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA ||
+             reason_code == WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
         bssid = wpa_s->bssid;
-        if (is_zero_ether_addr(bssid))
+        if (is_zero_ether_addr(bssid)) {
                 bssid = wpa_s->pending_bssid;
-        /*
-         * Don't blacklist the AP on normal/expected disconnects.
-         */
-        if (reason_code != WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY &&
-            reason_code != WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA &&
-            reason_code != WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA)
+                fast_reconnect = FALSE; /* XXX can this happen? */
+                wpa_printf(MSG_DEBUG, "Do not reconnect; pending bssid switch");
+        }
+        if (!fast_reconnect) {
+                if (wpa_s->wpa_state >= WPA_ASSOCIATING)
+                        wpa_supplicant_req_scan(wpa_s, 0, 100000);
                 wpa_blacklist_add(wpa_s, bssid);
+        }
         wpa_sm_notify_disassoc(wpa_s->wpa);
         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "bssid=" MACSTR
                 " reason=%d",
                 MAC2STR(bssid), reason_code);
         if (wpa_supplicant_dynamic_keys(wpa_s)) {
                 wpa_printf(MSG_DEBUG, "Disconnect event - remove keys");
                 wpa_s->keys_cleared = 0;
                 wpa_clear_keys(wpa_s, wpa_s->bssid);
         }
+        if (fast_reconnect) {
+                if (wpa_supplicant_fast_reconnect(wpa_s, bssid) == 0)
+                        return;
+                /* NB: fall through to slow path */
+                wpa_printf(MSG_DEBUG, "Fast reconnect: Failed to trigger scan");
+                wpa_supplicant_req_scan(wpa_s, 0, 100000);
+        }
         wpa_supplicant_mark_disassoc(wpa_s);
         bgscan_deinit(wpa_s);
         wpa_s->bgscan_ssid = NULL;
 #ifdef CONFIG_SME
         if (authenticating &&
             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) {
                 /*
                  * mac80211-workaround to force deauth on failed auth cmd,
                  * requires us to remain in authenticating state to allow the
                  * second authentication attempt to be continued properly.
@@ skipping 421 matching lines @@
                 break;
         case EVENT_CONNECTION_CHANGE:
                 bgscan_notify_connection_change(wpa_s,
                                                 &data->connection_change);
                 break;
         default:
                 wpa_printf(MSG_INFO, "Unknown event %d", event);
                 break;
         }
 }