Changeset 33525


Ignore:
Timestamp:
Oct 16, 2017, 2:40:24 PM (6 years ago)
Author:
brainslayer
Message:

fixes

Location:
src/router/hostapd-2016-09-05
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • src/router/hostapd-2016-09-05/src/ap/ieee802_11.c

    r30765 r33525  
    18551855        struct ieee80211_ht_capabilities ht_cap;
    18561856        struct ieee80211_vht_capabilities vht_cap;
     1857        int set = 1;
    18571858
    18581859        /*
     
    18621863         * skips the authentication flow, or if working with a driver that
    18631864         * does not support full AP client state.
     1865         *
     1866         * Skip this if the STA has already completed FT reassociation and the
     1867         * TK has been configured since the TX/RX PN must not be reset to 0 for
     1868         * the same key.
    18641869         */
    1865         if (!sta->added_unassoc)
     1870        if (!sta->added_unassoc &&
     1871            (!(sta->flags & WLAN_STA_AUTHORIZED) ||
     1872             !wpa_auth_sta_ft_tk_already_set(sta->wpa_sm))) {
    18661873                hostapd_drv_sta_remove(hapd, sta->addr);
     1874                wpa_auth_sm_event(sta->wpa_sm, WPA_DRV_STA_REMOVED);
     1875                set = 0;
     1876        }
    18671877
    18681878#ifdef CONFIG_IEEE80211N
     
    18871897                            sta->flags | WLAN_STA_ASSOC, sta->qosinfo,
    18881898                            sta->vht_opmode, sta->p2p_ie ? 1 : 0,
    1889                             sta->added_unassoc)) {
     1899                            set)) {
    18901900                hostapd_logger(hapd, sta->addr,
    18911901                               HOSTAPD_MODULE_IEEE80211, HOSTAPD_LEVEL_NOTICE,
    18921902                               "Could not %s STA to kernel driver",
    1893                                sta->added_unassoc ? "set" : "add");
     1903                               set ? "set" : "add");
    18941904
    18951905                if (sta->added_unassoc) {
  • src/router/hostapd-2016-09-05/src/ap/wpa_auth.c

    r30765 r33525  
    17461746                break;
    17471747#endif /* CONFIG_IEEE80211R */
     1748        case WPA_DRV_STA_REMOVED:
     1749                sm->tk_already_set = FALSE;
     1750                return 0;
    17481751        }
    17491752
     
    18961899         * INITIALIZE. */
    18971900        sm->TimeoutCtr = 0;
     1901}
     1902
     1903
     1904static int wpa_auth_sm_ptk_update(struct wpa_state_machine *sm)
     1905{
     1906        if (random_get_bytes(sm->ANonce, WPA_NONCE_LEN)) {
     1907                wpa_printf(MSG_ERROR,
     1908                           "WPA: Failed to get random data for ANonce");
     1909                sm->Disconnect = TRUE;
     1910                return -1;
     1911        }
     1912        wpa_hexdump(MSG_DEBUG, "WPA: Assign new ANonce", sm->ANonce,
     1913                    WPA_NONCE_LEN);
     1914        sm->TimeoutCtr = 0;
     1915        return 0;
    18981916}
    18991917
     
    24562474        else if (sm->ReAuthenticationRequest)
    24572475                SM_ENTER(WPA_PTK, AUTHENTICATION2);
    2458         else if (sm->PTKRequest)
    2459                 SM_ENTER(WPA_PTK, PTKSTART);
    2460         else switch (sm->wpa_ptk_state) {
     2476        else if (sm->PTKRequest) {
     2477                if (wpa_auth_sm_ptk_update(sm) < 0)
     2478                        SM_ENTER(WPA_PTK, DISCONNECTED);
     2479                else
     2480                        SM_ENTER(WPA_PTK, PTKSTART);
     2481        } else switch (sm->wpa_ptk_state) {
    24612482        case WPA_PTK_INITIALIZE:
    24622483                break;
     
    32523273
    32533274
     3275int wpa_auth_sta_ft_tk_already_set(struct wpa_state_machine *sm)
     3276{
     3277        if (!sm || !wpa_key_mgmt_ft(sm->wpa_key_mgmt))
     3278                return 0;
     3279        return sm->tk_already_set;
     3280}
     3281
     3282
    32543283int wpa_auth_sta_clear_pmksa(struct wpa_state_machine *sm,
    32553284                             struct rsn_pmksa_cache_entry *entry)
  • src/router/hostapd-2016-09-05/src/ap/wpa_auth.h

    r30765 r33525  
    268268enum wpa_event {
    269269        WPA_AUTH, WPA_ASSOC, WPA_DISASSOC, WPA_DEAUTH, WPA_REAUTH,
    270         WPA_REAUTH_EAPOL, WPA_ASSOC_FT
     270        WPA_REAUTH_EAPOL, WPA_ASSOC_FT, WPA_DRV_STA_REMOVED
    271271};
    272272void wpa_remove_ptk(struct wpa_state_machine *sm);
     
    281281int wpa_auth_sta_key_mgmt(struct wpa_state_machine *sm);
    282282int wpa_auth_sta_wpa_version(struct wpa_state_machine *sm);
     283int wpa_auth_sta_ft_tk_already_set(struct wpa_state_machine *sm);
    283284int wpa_auth_sta_clear_pmksa(struct wpa_state_machine *sm,
    284285                             struct rsn_pmksa_cache_entry *entry);
  • src/router/hostapd-2016-09-05/src/ap/wpa_auth_ft.c

    r30765 r33525  
    781781        }
    782782
     783        if (sm->tk_already_set) {
     784                /* Must avoid TK reconfiguration to prevent clearing of TX/RX
     785                 * PN in the driver */
     786                wpa_printf(MSG_DEBUG,
     787                           "FT: Do not re-install same PTK to the driver");
     788                return;
     789        }
     790
    783791        /* FIX: add STA entry to kernel/driver here? The set_key will fail
    784792         * most likely without this.. At the moment, STA entry is added only
     
    793801        /* FIX: MLME-SetProtection.Request(TA, Tx_Rx) */
    794802        sm->pairwise_set = TRUE;
     803        sm->tk_already_set = TRUE;
    795804}
    796805
     
    899908        sm->pairwise = pairwise;
    900909        sm->PTK_valid = TRUE;
     910        sm->tk_already_set = FALSE;
    901911        wpa_ft_install_ptk(sm);
    902912
  • src/router/hostapd-2016-09-05/src/ap/wpa_auth_i.h

    r30765 r33525  
    6666        Boolean PTK_valid;
    6767        Boolean pairwise_set;
     68        Boolean tk_already_set;
    6869        int keycount;
    6970        Boolean Pair;
  • src/router/hostapd-2016-09-05/src/common/wpa_common.h

    r30765 r33525  
    216216        size_t kek_len;
    217217        size_t tk_len;
    218 };
    219 
     218        int installed; /* 1 if key has already been installed to driver */
     219};
     220
     221struct wpa_gtk {
     222        u8 gtk[WPA_GTK_MAX_LEN];
     223        size_t gtk_len;
     224};
     225
     226#ifdef CONFIG_IEEE80211W
     227struct wpa_igtk {
     228        u8 igtk[WPA_IGTK_MAX_LEN];
     229        size_t igtk_len;
     230};
     231#endif /* CONFIG_IEEE80211W */
    220232
    221233/* WPA IE version 1
  • src/router/hostapd-2016-09-05/src/rsn_supp/tdls.c

    r30765 r33525  
    113113        } tpk;
    114114        int tpk_set;
     115        int tk_set; /* TPK-TK configured to the driver */
    115116        int tpk_success;
    116117        int tpk_in_progress;
     
    193194        enum wpa_alg alg;
    194195
     196        if (peer->tk_set) {
     197                /*
     198                 * This same TPK-TK has already been configured to the driver
     199                 * and this new configuration attempt (likely due to an
     200                 * unexpected retransmitted frame) would result in clearing
     201                 * the TX/RX sequence number which can break security, so must
     202                 * not allow that to happen.
     203                 */
     204                wpa_printf(MSG_INFO, "TDLS: TPK-TK for the peer " MACSTR
     205                           " has already been configured to the driver - do not reconfigure",
     206                           MAC2STR(peer->addr));
     207                return -1;
     208        }
     209
    195210        os_memset(rsc, 0, 6);
    196211
     
    210225        }
    211226
     227        wpa_printf(MSG_DEBUG, "TDLS: Configure pairwise key for peer " MACSTR,
     228                   MAC2STR(peer->addr));
    212229        if (wpa_sm_set_key(sm, alg, peer->addr, -1, 1,
    213230                           rsc, sizeof(rsc), peer->tpk.tk, key_len) < 0) {
     
    216233                return -1;
    217234        }
     235        peer->tk_set = 1;
    218236        return 0;
    219237}
     
    697715        peer->qos_info = 0;
    698716        peer->wmm_capable = 0;
    699         peer->tpk_set = peer->tpk_success = 0;
     717        peer->tk_set = peer->tpk_set = peer->tpk_success = 0;
    700718        peer->chan_switch_enabled = 0;
    701719        os_memset(&peer->tpk, 0, sizeof(peer->tpk));
     
    11601178                return -1;
    11611179        }
     1180        peer->tk_set = 0; /* A new nonce results in a new TK */
    11621181        wpa_hexdump(MSG_DEBUG, "TDLS: Initiator Nonce for TPK handshake",
    11631182                    peer->inonce, WPA_NONCE_LEN);
     
    17491768                                       peer->supp_oper_classes,
    17501769                                       peer->supp_oper_classes_len);
     1770}
     1771
     1772
     1773static int tdls_nonce_set(const u8 *nonce)
     1774{
     1775        int i;
     1776
     1777        for (i = 0; i < WPA_NONCE_LEN; i++) {
     1778                if (nonce[i])
     1779                        return 1;
     1780        }
     1781
     1782        return 0;
    17511783}
    17521784
     
    20052037        peer->cipher = cipher;
    20062038
    2007         if (os_memcmp(peer->inonce, ftie->Snonce, WPA_NONCE_LEN) != 0) {
     2039        if (os_memcmp(peer->inonce, ftie->Snonce, WPA_NONCE_LEN) != 0 ||
     2040            !tdls_nonce_set(peer->inonce)) {
    20082041                /*
    20092042                 * There is no point in updating the RNonce for every obtained
     
    20212054                        goto error;
    20222055                }
     2056                peer->tk_set = 0; /* A new nonce results in a new TK */
    20232057        }
    20242058
  • src/router/hostapd-2016-09-05/src/rsn_supp/wpa.c

    r30765 r33525  
    511511        }
    512512        sm->tptk_set = 1;
    513         sm->tk_to_set = 1;
    514513
    515514        kde = sm->assoc_wpa_ie;
     
    616615        const u8 *key_rsc;
    617616
    618         if (!sm->tk_to_set) {
     617        if (sm->ptk.installed) {
    619618                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
    620619                        "WPA: Do not re-install same PTK to the driver");
     
    660659        /* TK is not needed anymore in supplicant */
    661660        os_memset(sm->ptk.tk, 0, WPA_TK_MAX_LEN);
    662         sm->tk_to_set = 0;
     661        sm->ptk.installed = 1;
    663662
    664663        if (sm->wpa_ptk_rekey) {
     
    710709static int wpa_supplicant_install_gtk(struct wpa_sm *sm,
    711710                                      const struct wpa_gtk_data *gd,
    712                                       const u8 *key_rsc)
     711                                      const u8 *key_rsc, int wnm_sleep)
    713712{
    714713        const u8 *_gtk = gd->gtk;
    715714        u8 gtk_buf[32];
     715
     716        /* Detect possible key reinstallation */
     717        if ((sm->gtk.gtk_len == (size_t) gd->gtk_len &&
     718             os_memcmp(sm->gtk.gtk, gd->gtk, sm->gtk.gtk_len) == 0) ||
     719            (sm->gtk_wnm_sleep.gtk_len == (size_t) gd->gtk_len &&
     720             os_memcmp(sm->gtk_wnm_sleep.gtk, gd->gtk,
     721                       sm->gtk_wnm_sleep.gtk_len) == 0)) {
     722                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     723                        "WPA: Not reinstalling already in-use GTK to the driver (keyidx=%d tx=%d len=%d)",
     724                        gd->keyidx, gd->tx, gd->gtk_len);
     725                return 0;
     726        }
    716727
    717728        wpa_hexdump_key(MSG_DEBUG, "WPA: Group Key", gd->gtk, gd->gtk_len);
     
    748759        }
    749760        os_memset(gtk_buf, 0, sizeof(gtk_buf));
     761
     762        if (wnm_sleep) {
     763                sm->gtk_wnm_sleep.gtk_len = gd->gtk_len;
     764                os_memcpy(sm->gtk_wnm_sleep.gtk, gd->gtk,
     765                          sm->gtk_wnm_sleep.gtk_len);
     766        } else {
     767                sm->gtk.gtk_len = gd->gtk_len;
     768                os_memcpy(sm->gtk.gtk, gd->gtk, sm->gtk.gtk_len);
     769        }
    750770
    751771        return 0;
     
    841861                                               gtk_len, gtk_len,
    842862                                               &gd.key_rsc_len, &gd.alg) ||
    843              wpa_supplicant_install_gtk(sm, &gd, key_rsc))) {
     863             wpa_supplicant_install_gtk(sm, &gd, key_rsc, 0))) {
    844864                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
    845865                        "RSN: Failed to install GTK");
     
    855875
    856876
     877#ifdef CONFIG_IEEE80211W
     878static int wpa_supplicant_install_igtk(struct wpa_sm *sm,
     879                                       const struct wpa_igtk_kde *igtk,
     880                                       int wnm_sleep)
     881{
     882        size_t len = wpa_cipher_key_len(sm->mgmt_group_cipher);
     883        u16 keyidx = WPA_GET_LE16(igtk->keyid);
     884
     885        /* Detect possible key reinstallation */
     886        if ((sm->igtk.igtk_len == len &&
     887             os_memcmp(sm->igtk.igtk, igtk->igtk, sm->igtk.igtk_len) == 0) ||
     888            (sm->igtk_wnm_sleep.igtk_len == len &&
     889             os_memcmp(sm->igtk_wnm_sleep.igtk, igtk->igtk,
     890                       sm->igtk_wnm_sleep.igtk_len) == 0)) {
     891                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     892                        "WPA: Not reinstalling already in-use IGTK to the driver (keyidx=%d)",
     893                        keyidx);
     894                return  0;
     895        }
     896
     897        wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     898                "WPA: IGTK keyid %d pn %02x%02x%02x%02x%02x%02x",
     899                keyidx, MAC2STR(igtk->pn));
     900        wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK", igtk->igtk, len);
     901        if (keyidx > 4095) {
     902                wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
     903                        "WPA: Invalid IGTK KeyID %d", keyidx);
     904                return -1;
     905        }
     906        if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
     907                           broadcast_ether_addr,
     908                           keyidx, 0, igtk->pn, sizeof(igtk->pn),
     909                           igtk->igtk, len) < 0) {
     910                wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
     911                        "WPA: Failed to configure IGTK to the driver");
     912                return -1;
     913        }
     914
     915        if (wnm_sleep) {
     916                sm->igtk_wnm_sleep.igtk_len = len;
     917                os_memcpy(sm->igtk_wnm_sleep.igtk, igtk->igtk,
     918                          sm->igtk_wnm_sleep.igtk_len);
     919        } else {
     920                sm->igtk.igtk_len = len;
     921                os_memcpy(sm->igtk.igtk, igtk->igtk, sm->igtk.igtk_len);
     922        }
     923
     924        return 0;
     925}
     926#endif /* CONFIG_IEEE80211W */
     927
     928
    857929static int ieee80211w_set_keys(struct wpa_sm *sm,
    858930                               struct wpa_eapol_ie_parse *ie)
     
    865937                size_t len;
    866938                const struct wpa_igtk_kde *igtk;
    867                 u16 keyidx;
     939
    868940                len = wpa_cipher_key_len(sm->mgmt_group_cipher);
    869941                if (ie->igtk_len != WPA_IGTK_KDE_PREFIX_LEN + len)
    870942                        return -1;
     943
    871944                igtk = (const struct wpa_igtk_kde *) ie->igtk;
    872                 keyidx = WPA_GET_LE16(igtk->keyid);
    873                 wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG, "WPA: IGTK keyid %d "
    874                         "pn %02x%02x%02x%02x%02x%02x",
    875                         keyidx, MAC2STR(igtk->pn));
    876                 wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK",
    877                                 igtk->igtk, len);
    878                 if (keyidx > 4095) {
    879                         wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
    880                                 "WPA: Invalid IGTK KeyID %d", keyidx);
     945                if (wpa_supplicant_install_igtk(sm, igtk, 0) < 0)
    881946                        return -1;
    882                 }
    883                 if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
    884                                    broadcast_ether_addr,
    885                                    keyidx, 0, igtk->pn, sizeof(igtk->pn),
    886                                    igtk->igtk, len) < 0) {
    887                         wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
    888                                 "WPA: Failed to configure IGTK to the driver");
    889                         return -1;
    890                 }
    891947        }
    892948
     
    15371593                key_rsc = null_rsc;
    15381594
    1539         if (wpa_supplicant_install_gtk(sm, &gd, key_rsc) ||
     1595        if (wpa_supplicant_install_gtk(sm, &gd, key_rsc, 0) ||
    15401596            wpa_supplicant_send_2_of_2(sm, key, ver, key_info) < 0)
    15411597                goto failed;
     
    23112367void wpa_sm_notify_assoc(struct wpa_sm *sm, const u8 *bssid)
    23122368{
    2313         int clear_ptk = 1;
     2369        int clear_keys = 1;
    23142370
    23152371        if (sm == NULL)
     
    23332389                eapol_sm_notify_portValid(sm->eapol, FALSE);
    23342390                wpa_supplicant_key_neg_complete(sm, sm->bssid, 1);
     2391                clear_keys = 0;
    23352392
    23362393                /* Prepare for the next transition */
    23372394                wpa_ft_prepare_auth_request(sm, NULL);
    23382395
    2339                 clear_ptk = 0;
     2396                clear_keys = 0;
    23402397        }
    23412398#endif /* CONFIG_IEEE80211R */
    23422399
    2343         if (clear_ptk) {
     2400        if (clear_keys) {
    23442401                /*
    23452402                 * IEEE 802.11, 8.4.10: Delete PTK SA on (re)association if
     
    23512408                sm->tptk_set = 0;
    23522409                os_memset(&sm->tptk, 0, sizeof(sm->tptk));
     2410                os_memset(&sm->gtk, 0, sizeof(sm->gtk));
     2411                os_memset(&sm->gtk_wnm_sleep, 0, sizeof(sm->gtk_wnm_sleep));
     2412#ifdef CONFIG_IEEE80211W
     2413                os_memset(&sm->igtk, 0, sizeof(sm->igtk));
     2414                os_memset(&sm->igtk_wnm_sleep, 0, sizeof(sm->igtk_wnm_sleep));
     2415#endif /* CONFIG_IEEE80211W */
    23532416        }
    23542417
     
    23822445        wpa_tdls_disassoc(sm);
    23832446#endif /* CONFIG_TDLS */
     2447#ifdef CONFIG_IEEE80211R
     2448        sm->ft_reassoc_completed = 0;
     2449#endif /* CONFIG_IEEE80211R */
    23842450
    23852451        /* Keys are not needed in the WPA state machine anymore */
     
    28812947        os_memset(&sm->ptk, 0, sizeof(sm->ptk));
    28822948        os_memset(&sm->tptk, 0, sizeof(sm->tptk));
     2949        os_memset(&sm->gtk, 0, sizeof(sm->gtk));
     2950        os_memset(&sm->gtk_wnm_sleep, 0, sizeof(sm->gtk_wnm_sleep));
     2951#ifdef CONFIG_IEEE80211W
     2952        os_memset(&sm->igtk, 0, sizeof(sm->igtk));
     2953        os_memset(&sm->igtk_wnm_sleep, 0, sizeof(sm->igtk_wnm_sleep));
     2954#endif /* CONFIG_IEEE80211W */
    28832955#ifdef CONFIG_IEEE80211R
    28842956        os_memset(sm->xxkey, 0, sizeof(sm->xxkey));
     
    29443016                wpa_hexdump_key(MSG_DEBUG, "Install GTK (WNM SLEEP)",
    29453017                                gd.gtk, gd.gtk_len);
    2946                 if (wpa_supplicant_install_gtk(sm, &gd, key_rsc)) {
     3018                if (wpa_supplicant_install_gtk(sm, &gd, key_rsc, 1)) {
    29473019                        os_memset(&gd, 0, sizeof(gd));
    29483020                        wpa_printf(MSG_DEBUG, "Failed to install the GTK in "
     
    29533025#ifdef CONFIG_IEEE80211W
    29543026        } else if (subelem_id == WNM_SLEEP_SUBELEM_IGTK) {
    2955                 struct wpa_igtk_kde igd;
    2956                 u16 keyidx;
    2957 
    2958                 os_memset(&igd, 0, sizeof(igd));
    2959                 keylen = wpa_cipher_key_len(sm->mgmt_group_cipher);
    2960                 os_memcpy(igd.keyid, buf + 2, 2);
    2961                 os_memcpy(igd.pn, buf + 4, 6);
    2962 
    2963                 keyidx = WPA_GET_LE16(igd.keyid);
    2964                 os_memcpy(igd.igtk, buf + 10, keylen);
    2965 
    2966                 wpa_hexdump_key(MSG_DEBUG, "Install IGTK (WNM SLEEP)",
    2967                                 igd.igtk, keylen);
    2968                 if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
    2969                                    broadcast_ether_addr,
    2970                                    keyidx, 0, igd.pn, sizeof(igd.pn),
    2971                                    igd.igtk, keylen) < 0) {
    2972                         wpa_printf(MSG_DEBUG, "Failed to install the IGTK in "
    2973                                    "WNM mode");
    2974                         os_memset(&igd, 0, sizeof(igd));
     3027                const struct wpa_igtk_kde *igtk;
     3028
     3029                igtk = (const struct wpa_igtk_kde *) (buf + 2);
     3030                if (wpa_supplicant_install_igtk(sm, igtk, 1) < 0)
    29753031                        return -1;
    2976                 }
    2977                 os_memset(&igd, 0, sizeof(igd));
    29783032#endif /* CONFIG_IEEE80211W */
    29793033        } else {
  • src/router/hostapd-2016-09-05/src/rsn_supp/wpa_ft.c

    r30765 r33525  
    154154
    155155        sm->ft_completed = 0;
     156        sm->ft_reassoc_completed = 0;
    156157
    157158        buf_len = 2 + sizeof(struct rsn_mdie) + 2 + sizeof(struct rsn_ftie) +
     
    682683        }
    683684
     685        if (sm->ft_reassoc_completed) {
     686                wpa_printf(MSG_DEBUG, "FT: Reassociation has already been completed for this FT protocol instance - ignore unexpected retransmission");
     687                return 0;
     688        }
     689
    684690        if (wpa_ft_parse_ies(ies, ies_len, &parse) < 0) {
    685691                wpa_printf(MSG_DEBUG, "FT: Failed to parse IEs");
     
    782788        }
    783789
     790        sm->ft_reassoc_completed = 1;
     791
    784792        if (wpa_ft_process_gtk_subelem(sm, parse.gtk, parse.gtk_len) < 0)
    785793                return -1;
  • src/router/hostapd-2016-09-05/src/rsn_supp/wpa_i.h

    r30765 r33525  
    2525        int ptk_set, tptk_set;
    2626        unsigned int msg_3_of_4_ok:1;
    27         unsigned int tk_to_set:1;
    2827        u8 snonce[WPA_NONCE_LEN];
    2928        u8 anonce[WPA_NONCE_LEN]; /* ANonce from the last 1/4 msg */
     
    3231        int rx_replay_counter_set;
    3332        u8 request_counter[WPA_REPLAY_COUNTER_LEN];
     33        struct wpa_gtk gtk;
     34        struct wpa_gtk gtk_wnm_sleep;
     35#ifdef CONFIG_IEEE80211W
     36        struct wpa_igtk igtk;
     37        struct wpa_igtk igtk_wnm_sleep;
     38#endif /* CONFIG_IEEE80211W */
    3439
    3540        struct eapol_sm *eapol; /* EAPOL state machine from upper level code */
     
    124129        u8 r1kh_id[FT_R1KH_ID_LEN];
    125130        int ft_completed;
     131        int ft_reassoc_completed;
    126132        int over_the_ds_in_progress;
    127133        u8 target_ap[ETH_ALEN]; /* over-the-DS target AP */
  • src/router/hostapd-2016-09-05/wpa_supplicant/wnm_sta.c

    r30765 r33525  
    261261        if (!wpa_s->wnmsleep_used) {
    262262                wpa_printf(MSG_DEBUG,
    263                            "WNM: Ignore WNM-Sleep Mode Response frame since WNM-Sleep Mode has not been used in this association");
     263                           "WNM: Ignore WNM-Sleep Mode Response frame since WNM-Sleep Mode operation has not been requested");
    264264                return;
    265265        }
     
    299299                return;
    300300        }
     301
     302        wpa_s->wnmsleep_used = 0;
    301303
    302304        if (wnmsleep_ie->status == WNM_STATUS_SLEEP_ACCEPT ||
Note: See TracChangeset for help on using the changeset viewer.