wlantest/rx_mgmt.c

   1 /*
   2  * Received Management frame processing
   3  * Copyright (c) 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 "utils/includes.h"
  16
  17 #include "utils/common.h"
  18 #include "common/ieee802_11_defs.h"
  19 #include "common/ieee802_11_common.h"
  20 #include "crypto/aes_wrap.h"
  21 #include "wlantest.h"
  22
  23
  24 static const char * mgmt_stype(u16 stype)
  25 {
  26         switch (stype) {
  27         case WLAN_FC_STYPE_ASSOC_REQ:
  28                 return "ASSOC-REQ";
  29         case WLAN_FC_STYPE_ASSOC_RESP:
  30                 return "ASSOC-RESP";
  31         case WLAN_FC_STYPE_REASSOC_REQ:
  32                 return "REASSOC-REQ";
  33         case WLAN_FC_STYPE_REASSOC_RESP:
  34                 return "REASSOC-RESP";
  35         case WLAN_FC_STYPE_PROBE_REQ:
  36                 return "PROBE-REQ";
  37         case WLAN_FC_STYPE_PROBE_RESP:
  38                 return "PROBE-RESP";
  39         case WLAN_FC_STYPE_BEACON:
  40                 return "BEACON";
  41         case WLAN_FC_STYPE_ATIM:
  42                 return "ATIM";
  43         case WLAN_FC_STYPE_DISASSOC:
  44                 return "DISASSOC";
  45         case WLAN_FC_STYPE_AUTH:
  46                 return "AUTH";
  47         case WLAN_FC_STYPE_DEAUTH:
  48                 return "DEAUTH";
  49         case WLAN_FC_STYPE_ACTION:
  50                 return "ACTION";
  51         }
  52         return "??";
  53 }
  54
  55
  56 static void rx_mgmt_beacon(struct wlantest *wt, const u8 *data, size_t len)
  57 {
  58         const struct ieee80211_mgmt *mgmt;
  59         struct wlantest_bss *bss;
  60         struct ieee802_11_elems elems;
  61
  62         mgmt = (const struct ieee80211_mgmt *) data;
  63         bss = bss_get(wt, mgmt->bssid);
  64         if (bss == NULL)
  65                 return;
  66         if (bss->proberesp_seen)
  67                 return; /* do not override with Beacon data */
  68         bss->capab_info = le_to_host16(mgmt->u.beacon.capab_info);
  69         if (ieee802_11_parse_elems(mgmt->u.beacon.variable,
  70                                    len - (mgmt->u.beacon.variable - data),
  71                                    &elems, 0) == ParseFailed) {
  72                 if (bss->parse_error_reported)
  73                         return;
  74                 wpa_printf(MSG_INFO, "Invalid IEs in a Beacon frame from "
  75                            MACSTR, MAC2STR(mgmt->sa));
  76                 bss->parse_error_reported = 1;
  77                 return;
  78         }
  79
  80         bss_update(wt, bss, &elems);
  81 }
  82
  83
  84 static void rx_mgmt_probe_resp(struct wlantest *wt, const u8 *data, size_t len)
  85 {
  86         const struct ieee80211_mgmt *mgmt;
  87         struct wlantest_bss *bss;
  88         struct ieee802_11_elems elems;
  89
  90         mgmt = (const struct ieee80211_mgmt *) data;
  91         bss = bss_get(wt, mgmt->bssid);
  92         if (bss == NULL)
  93                 return;
  94
  95         bss->capab_info = le_to_host16(mgmt->u.probe_resp.capab_info);
  96         if (ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
  97                                    len - (mgmt->u.probe_resp.variable - data),
  98                                    &elems, 0) == ParseFailed) {
  99                 if (bss->parse_error_reported)
 100                         return;
 101                 wpa_printf(MSG_INFO, "Invalid IEs in a Probe Response frame "
 102                            "from " MACSTR, MAC2STR(mgmt->sa));
 103                 bss->parse_error_reported = 1;
 104                 return;
 105         }
 106
 107         bss_update(wt, bss, &elems);
 108 }
 109
 110
 111 static void rx_mgmt_auth(struct wlantest *wt, const u8 *data, size_t len)
 112 {
 113         const struct ieee80211_mgmt *mgmt;
 114         struct wlantest_bss *bss;
 115         struct wlantest_sta *sta;
 116         u16 alg, trans, status;
 117
 118         mgmt = (const struct ieee80211_mgmt *) data;
 119         bss = bss_get(wt, mgmt->bssid);
 120         if (bss == NULL)
 121                 return;
 122         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 123                 sta = sta_get(bss, mgmt->da);
 124         else
 125                 sta = sta_get(bss, mgmt->sa);
 126         if (sta == NULL)
 127                 return;
 128
 129         if (len < 24 + 6) {
 130                 wpa_printf(MSG_INFO, "Too short Authentication frame from "
 131                            MACSTR, MAC2STR(mgmt->sa));
 132                 return;
 133         }
 134
 135         alg = le_to_host16(mgmt->u.auth.auth_alg);
 136         trans = le_to_host16(mgmt->u.auth.auth_transaction);
 137         status = le_to_host16(mgmt->u.auth.status_code);
 138
 139         wpa_printf(MSG_DEBUG, "AUTH " MACSTR " -> " MACSTR
 140                    " (alg=%u trans=%u status=%u)",
 141                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), alg, trans, status);
 142
 143         if (alg == 0 && trans == 2 && status == 0) {
 144                 if (sta->state == STATE1) {
 145                         wpa_printf(MSG_DEBUG, "STA " MACSTR
 146                                    " moved to State 2 with " MACSTR,
 147                                    MAC2STR(sta->addr), MAC2STR(bss->bssid));
 148                         sta->state = STATE2;
 149                 }
 150         }
 151 }
 152
 153
 154 static void rx_mgmt_deauth(struct wlantest *wt, const u8 *data, size_t len)
 155 {
 156         const struct ieee80211_mgmt *mgmt;
 157         struct wlantest_bss *bss;
 158         struct wlantest_sta *sta;
 159
 160         mgmt = (const struct ieee80211_mgmt *) data;
 161         bss = bss_get(wt, mgmt->bssid);
 162         if (bss == NULL)
 163                 return;
 164         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 165                 sta = sta_get(bss, mgmt->da);
 166         else
 167                 sta = sta_get(bss, mgmt->sa);
 168         if (sta == NULL)
 169                 return;
 170
 171         if (len < 24 + 2) {
 172                 wpa_printf(MSG_INFO, "Too short Deauthentication frame from "
 173                            MACSTR, MAC2STR(mgmt->sa));
 174                 return;
 175         }
 176
 177         wpa_printf(MSG_DEBUG, "DEAUTH " MACSTR " -> " MACSTR
 178                    " (reason=%u)",
 179                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 180                    le_to_host16(mgmt->u.deauth.reason_code));
 181
 182         if (sta->state != STATE1) {
 183                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 184                            " moved to State 1 with " MACSTR,
 185                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 186                 sta->state = STATE1;
 187         }
 188 }
 189
 190
 191 static void rx_mgmt_assoc_req(struct wlantest *wt, const u8 *data, size_t len)
 192 {
 193         const struct ieee80211_mgmt *mgmt;
 194         struct wlantest_bss *bss;
 195         struct wlantest_sta *sta;
 196         struct ieee802_11_elems elems;
 197
 198         mgmt = (const struct ieee80211_mgmt *) data;
 199         bss = bss_get(wt, mgmt->bssid);
 200         if (bss == NULL)
 201                 return;
 202         sta = sta_get(bss, mgmt->sa);
 203         if (sta == NULL)
 204                 return;
 205
 206         if (len < 24 + 4) {
 207                 wpa_printf(MSG_INFO, "Too short Association Request frame "
 208                            "from " MACSTR, MAC2STR(mgmt->sa));
 209                 return;
 210         }
 211
 212         wpa_printf(MSG_DEBUG, "ASSOCREQ " MACSTR " -> " MACSTR
 213                    " (capab=0x%x listen_int=%u)",
 214                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 215                    le_to_host16(mgmt->u.assoc_req.capab_info),
 216                    le_to_host16(mgmt->u.assoc_req.listen_interval));
 217
 218         if (ieee802_11_parse_elems(mgmt->u.assoc_req.variable,
 219                                    len - (mgmt->u.assoc_req.variable - data),
 220                                    &elems, 0) == ParseFailed) {
 221                 wpa_printf(MSG_INFO, "Invalid IEs in Association Request "
 222                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 223                 return;
 224         }
 225
 226         sta_update_assoc(sta, &elems);
 227 }
 228
 229
 230 static void rx_mgmt_assoc_resp(struct wlantest *wt, const u8 *data, size_t len)
 231 {
 232         const struct ieee80211_mgmt *mgmt;
 233         struct wlantest_bss *bss;
 234         struct wlantest_sta *sta;
 235         u16 capab, status, aid;
 236
 237         mgmt = (const struct ieee80211_mgmt *) data;
 238         bss = bss_get(wt, mgmt->bssid);
 239         if (bss == NULL)
 240                 return;
 241         sta = sta_get(bss, mgmt->da);
 242         if (sta == NULL)
 243                 return;
 244
 245         if (len < 24 + 6) {
 246                 wpa_printf(MSG_INFO, "Too short Association Response frame "
 247                            "from " MACSTR, MAC2STR(mgmt->sa));
 248                 return;
 249         }
 250
 251         capab = le_to_host16(mgmt->u.assoc_resp.capab_info);
 252         status = le_to_host16(mgmt->u.assoc_resp.status_code);
 253         aid = le_to_host16(mgmt->u.assoc_resp.aid);
 254
 255         wpa_printf(MSG_DEBUG, "ASSOCRESP " MACSTR " -> " MACSTR
 256                    " (capab=0x%x status=%u aid=%u)",
 257                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 258                    aid & 0x3fff);
 259
 260         if (status)
 261                 return;
 262
 263         if ((aid & 0xc000) != 0xc000) {
 264                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 265                            "in Association Response from " MACSTR,
 266                            MAC2STR(mgmt->sa));
 267         }
 268         sta->aid = aid & 0xc000;
 269
 270         if (sta->state < STATE2) {
 271                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 272                            "getting associated", MAC2STR(sta->addr));
 273         }
 274
 275         if (sta->state < STATE3) {
 276                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 277                            " moved to State 3 with " MACSTR,
 278                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 279                 sta->state = STATE3;
 280         }
 281 }
 282
 283
 284 static void rx_mgmt_reassoc_req(struct wlantest *wt, const u8 *data,
 285                                 size_t len)
 286 {
 287         const struct ieee80211_mgmt *mgmt;
 288         struct wlantest_bss *bss;
 289         struct wlantest_sta *sta;
 290         struct ieee802_11_elems elems;
 291
 292         mgmt = (const struct ieee80211_mgmt *) data;
 293         bss = bss_get(wt, mgmt->bssid);
 294         if (bss == NULL)
 295                 return;
 296         sta = sta_get(bss, mgmt->sa);
 297         if (sta == NULL)
 298                 return;
 299
 300         if (len < 24 + 4 + ETH_ALEN) {
 301                 wpa_printf(MSG_INFO, "Too short Reassociation Request frame "
 302                            "from " MACSTR, MAC2STR(mgmt->sa));
 303                 return;
 304         }
 305
 306         wpa_printf(MSG_DEBUG, "REASSOCREQ " MACSTR " -> " MACSTR
 307                    " (capab=0x%x listen_int=%u current_ap=" MACSTR ")",
 308                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 309                    le_to_host16(mgmt->u.reassoc_req.capab_info),
 310                    le_to_host16(mgmt->u.reassoc_req.listen_interval),
 311                    MAC2STR(mgmt->u.reassoc_req.current_ap));
 312
 313         if (ieee802_11_parse_elems(mgmt->u.reassoc_req.variable,
 314                                    len - (mgmt->u.reassoc_req.variable - data),
 315                                    &elems, 0) == ParseFailed) {
 316                 wpa_printf(MSG_INFO, "Invalid IEs in Reassociation Request "
 317                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 318                 return;
 319         }
 320
 321         sta_update_assoc(sta, &elems);
 322 }
 323
 324
 325 static void rx_mgmt_reassoc_resp(struct wlantest *wt, const u8 *data,
 326                                  size_t len)
 327 {
 328         const struct ieee80211_mgmt *mgmt;
 329         struct wlantest_bss *bss;
 330         struct wlantest_sta *sta;
 331         u16 capab, status, aid;
 332
 333         mgmt = (const struct ieee80211_mgmt *) data;
 334         bss = bss_get(wt, mgmt->bssid);
 335         if (bss == NULL)
 336                 return;
 337         sta = sta_get(bss, mgmt->da);
 338         if (sta == NULL)
 339                 return;
 340
 341         if (len < 24 + 6) {
 342                 wpa_printf(MSG_INFO, "Too short Reassociation Response frame "
 343                            "from " MACSTR, MAC2STR(mgmt->sa));
 344                 return;
 345         }
 346
 347         capab = le_to_host16(mgmt->u.reassoc_resp.capab_info);
 348         status = le_to_host16(mgmt->u.reassoc_resp.status_code);
 349         aid = le_to_host16(mgmt->u.reassoc_resp.aid);
 350
 351         wpa_printf(MSG_DEBUG, "REASSOCRESP " MACSTR " -> " MACSTR
 352                    " (capab=0x%x status=%u aid=%u)",
 353                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 354                    aid & 0x3fff);
 355
 356         if (status)
 357                 return;
 358
 359         if ((aid & 0xc000) != 0xc000) {
 360                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 361                            "in Reassociation Response from " MACSTR,
 362                            MAC2STR(mgmt->sa));
 363         }
 364         sta->aid = aid & 0xc000;
 365
 366         if (sta->state < STATE2) {
 367                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 368                            "getting associated", MAC2STR(sta->addr));
 369         }
 370
 371         if (sta->state < STATE3) {
 372                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 373                            " moved to State 3 with " MACSTR,
 374                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 375                 sta->state = STATE3;
 376         }
 377 }
 378
 379
 380 static void rx_mgmt_disassoc(struct wlantest *wt, const u8 *data, size_t len)
 381 {
 382         const struct ieee80211_mgmt *mgmt;
 383         struct wlantest_bss *bss;
 384         struct wlantest_sta *sta;
 385
 386         mgmt = (const struct ieee80211_mgmt *) data;
 387         bss = bss_get(wt, mgmt->bssid);
 388         if (bss == NULL)
 389                 return;
 390         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 391                 sta = sta_get(bss, mgmt->da);
 392         else
 393                 sta = sta_get(bss, mgmt->sa);
 394         if (sta == NULL)
 395                 return;
 396
 397         if (len < 24 + 2) {
 398                 wpa_printf(MSG_INFO, "Too short Disassociation frame from "
 399                            MACSTR, MAC2STR(mgmt->sa));
 400                 return;
 401         }
 402
 403         wpa_printf(MSG_DEBUG, "DISASSOC " MACSTR " -> " MACSTR
 404                    " (reason=%u)",
 405                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 406                    le_to_host16(mgmt->u.disassoc.reason_code));
 407
 408         if (sta->state < STATE2) {
 409                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 or 3 "
 410                            "when getting disassociated", MAC2STR(sta->addr));
 411         }
 412
 413         if (sta->state > STATE2) {
 414                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 415                            " moved to State 2 with " MACSTR,
 416                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 417                 sta->state = STATE2;
 418         }
 419 }
 420
 421
 422 static int check_mmie_mic(const u8 *igtk, const u8 *data, size_t len)
 423 {
 424         u8 *buf;
 425         u8 mic[16];
 426         u16 fc;
 427         const struct ieee80211_hdr *hdr;
 428
 429         buf = os_malloc(len + 20 - 24);
 430         if (buf == NULL)
 431                 return -1;
 432
 433         /* BIP AAD: FC(masked) A1 A2 A3 */
 434         hdr = (const struct ieee80211_hdr *) data;
 435         fc = le_to_host16(hdr->frame_control);
 436         fc &= ~(WLAN_FC_RETRY | WLAN_FC_PWRMGT | WLAN_FC_MOREDATA);
 437         WPA_PUT_LE16(buf, fc);
 438         os_memcpy(buf + 2, hdr->addr1, 3 * ETH_ALEN);
 439
 440         /* Frame body with MMIE MIC masked to zero */
 441         os_memcpy(buf + 20, data + 24, len - 24 - 8);
 442         os_memset(buf + 20 + len - 24 - 8, 0, 8);
 443
 444         wpa_hexdump(MSG_MSGDUMP, "BIP: AAD|Body(masked)", buf, len + 20 - 24);
 445         /* MIC = L(AES-128-CMAC(AAD || Frame Body(masked)), 0, 64) */
 446         if (omac1_aes_128(igtk, buf, len + 20 - 24, mic) < 0) {
 447                 os_free(buf);
 448                 return -1;
 449         }
 450
 451         os_free(buf);
 452
 453         if (os_memcmp(data + len - 8, mic, 8) != 0)
 454                 return -1;
 455
 456         return 0;
 457 }
 458
 459
 460 static int check_bip(struct wlantest *wt, const u8 *data, size_t len)
 461 {
 462         const struct ieee80211_mgmt *mgmt;
 463         u16 fc, stype;
 464         const u8 *mmie;
 465         int keyid;
 466         struct wlantest_bss *bss;
 467
 468         mgmt = (const struct ieee80211_mgmt *) data;
 469         fc = le_to_host16(mgmt->frame_control);
 470         stype = WLAN_FC_GET_STYPE(fc);
 471
 472         if (stype == WLAN_FC_STYPE_ACTION) {
 473                 if (len < 24 + 1)
 474                         return 0;
 475                 if (mgmt->u.action.category == WLAN_ACTION_PUBLIC)
 476                         return 0; /* Not a robust management frame */
 477         }
 478
 479         bss = bss_get(wt, mgmt->bssid);
 480         if (bss == NULL)
 481                 return 0; /* No key known yet */
 482
 483         if (len < 24 + 18 || data[len - 18] != WLAN_EID_MMIE ||
 484             data[len - 17] != 16) {
 485                 /* No MMIE */
 486                 /* TODO: use MFPC flag in RSN IE instead of IGTK flags */
 487                 if (bss->igtk_set[4] || bss->igtk_set[5]) {
 488                         wpa_printf(MSG_INFO, "Robust group-addressed "
 489                                    "management frame sent without BIP by "
 490                                    MACSTR, MAC2STR(mgmt->sa));
 491                         return -1;
 492                 }
 493                 return 0;
 494         }
 495
 496         mmie = data + len - 16;
 497         keyid = WPA_GET_LE16(mmie);
 498         if (keyid < 4 || keyid > 5) {
 499                 wpa_printf(MSG_INFO, "Unexpected MMIE KeyID %u from " MACSTR,
 500                            keyid, MAC2STR(mgmt->sa));
 501                 return 0;
 502         }
 503         wpa_printf(MSG_DEBUG, "MMIE KeyID %u", keyid);
 504         wpa_hexdump(MSG_MSGDUMP, "MMIE IPN", mmie + 2, 6);
 505         wpa_hexdump(MSG_MSGDUMP, "MMIE MIC", mmie + 8, 8);
 506
 507         if (!bss->igtk_set[keyid]) {
 508                 wpa_printf(MSG_DEBUG, "No IGTK known to validate BIP frame");
 509                 return 0;
 510         }
 511
 512         if (os_memcmp(mmie + 2, bss->ipn[keyid], 6) <= 0) {
 513                 wpa_printf(MSG_INFO, "BIP replay detected: SA=" MACSTR,
 514                            MAC2STR(mgmt->sa));
 515                 wpa_hexdump(MSG_INFO, "RX IPN", mmie + 2, 6);
 516                 wpa_hexdump(MSG_INFO, "Last RX IPN", bss->ipn[keyid], 6);
 517         }
 518
 519         if (check_mmie_mic(bss->igtk[keyid], data, len) < 0) {
 520                 wpa_printf(MSG_INFO, "Invalid MMIE MIC in a frame from "
 521                            MACSTR, MAC2STR(mgmt->sa));
 522                 return -1;
 523         }
 524
 525         wpa_printf(MSG_DEBUG, "Valid MMIE MIC");
 526         os_memcpy(bss->ipn[keyid], mmie + 2, 6);
 527
 528         return 0;
 529 }
 530
 531
 532 void rx_mgmt(struct wlantest *wt, const u8 *data, size_t len)
 533 {
 534         const struct ieee80211_hdr *hdr;
 535         u16 fc, stype;
 536
 537         if (len < 24)
 538                 return;
 539
 540         hdr = (const struct ieee80211_hdr *) data;
 541         fc = le_to_host16(hdr->frame_control);
 542         wt->rx_mgmt++;
 543         stype = WLAN_FC_GET_STYPE(fc);
 544
 545         if ((hdr->addr1[0] & 0x01) &&
 546             (stype == WLAN_FC_STYPE_DEAUTH ||
 547              stype == WLAN_FC_STYPE_DISASSOC ||
 548              stype == WLAN_FC_STYPE_ACTION))
 549                 check_bip(wt, data, len);
 550
 551         wpa_printf((stype == WLAN_FC_STYPE_BEACON ||
 552                     stype == WLAN_FC_STYPE_PROBE_RESP ||
 553                     stype == WLAN_FC_STYPE_PROBE_REQ) ?
 554                    MSG_EXCESSIVE : MSG_MSGDUMP,
 555                    "MGMT %s%s%s DA=" MACSTR " SA=" MACSTR " BSSID=" MACSTR,
 556                    mgmt_stype(stype),
 557                    fc & WLAN_FC_PWRMGT ? " PwrMgt" : "",
 558                    fc & WLAN_FC_ISWEP ? " Prot" : "",
 559                    MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
 560                    MAC2STR(hdr->addr3));
 561
 562         switch (stype) {
 563         case WLAN_FC_STYPE_BEACON:
 564                 rx_mgmt_beacon(wt, data, len);
 565                 break;
 566         case WLAN_FC_STYPE_PROBE_RESP:
 567                 rx_mgmt_probe_resp(wt, data, len);
 568                 break;
 569         case WLAN_FC_STYPE_AUTH:
 570                 rx_mgmt_auth(wt, data, len);
 571                 break;
 572         case WLAN_FC_STYPE_DEAUTH:
 573                 rx_mgmt_deauth(wt, data, len);
 574                 break;
 575         case WLAN_FC_STYPE_ASSOC_REQ:
 576                 rx_mgmt_assoc_req(wt, data, len);
 577                 break;
 578         case WLAN_FC_STYPE_ASSOC_RESP:
 579                 rx_mgmt_assoc_resp(wt, data, len);
 580                 break;
 581         case WLAN_FC_STYPE_REASSOC_REQ:
 582                 rx_mgmt_reassoc_req(wt, data, len);
 583                 break;
 584         case WLAN_FC_STYPE_REASSOC_RESP:
 585                 rx_mgmt_reassoc_resp(wt, data, len);
 586                 break;
 587         case WLAN_FC_STYPE_DISASSOC:
 588                 rx_mgmt_disassoc(wt, data, len);
 589                 break;
 590         }
 591 }