src/ap/drv_callbacks.c

   1 /*
   2  * hostapd / Callback functions for driver wrappers
   3  * Copyright (c) 2002-2009, 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 "radius/radius.h"
  19 #include "drivers/driver.h"
  20 #include "common/ieee802_11_defs.h"
  21 #include "common/ieee802_11_common.h"
  22 #include "common/wpa_ctrl.h"
  23 #include "crypto/random.h"
  24 #include "p2p/p2p.h"
  25 #include "wps/wps.h"
  26 #include "hostapd.h"
  27 #include "ieee802_11.h"
  28 #include "sta_info.h"
  29 #include "accounting.h"
  30 #include "tkip_countermeasures.h"
  31 #include "iapp.h"
  32 #include "ieee802_1x.h"
  33 #include "wpa_auth.h"
  34 #include "wmm.h"
  35 #include "wps_hostapd.h"
  36 #include "ap_drv_ops.h"
  37 #include "ap_config.h"
  38
  39
  40 int hostapd_notif_assoc(struct hostapd_data *hapd, const u8 *addr,
  41                         const u8 *req_ies, size_t req_ies_len, int reassoc)
  42 {
  43         struct sta_info *sta;
  44         int new_assoc, res;
  45         struct ieee802_11_elems elems;
  46         const u8 *ie;
  47         size_t ielen;
  48         u16 reason = WLAN_REASON_UNSPECIFIED;
  49
  50         if (addr == NULL) {
  51                 /*
  52                  * This could potentially happen with unexpected event from the
  53                  * driver wrapper. This was seen at least in one case where the
  54                  * driver ended up being set to station mode while hostapd was
  55                  * running, so better make sure we stop processing such an
  56                  * event here.
  57                  */
  58                 wpa_printf(MSG_DEBUG, "hostapd_notif_assoc: Skip event with "
  59                            "no address");
  60                 return -1;
  61         }
  62         random_add_randomness(addr, ETH_ALEN);
  63
  64         hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
  65                        HOSTAPD_LEVEL_INFO, "associated");
  66
  67         ieee802_11_parse_elems(req_ies, req_ies_len, &elems, 0);
  68         if (elems.wps_ie) {
  69                 ie = elems.wps_ie - 2;
  70                 ielen = elems.wps_ie_len + 2;
  71                 wpa_printf(MSG_DEBUG, "STA included WPS IE in (Re)AssocReq");
  72         } else if (elems.rsn_ie) {
  73                 ie = elems.rsn_ie - 2;
  74                 ielen = elems.rsn_ie_len + 2;
  75                 wpa_printf(MSG_DEBUG, "STA included RSN IE in (Re)AssocReq");
  76         } else if (elems.wpa_ie) {
  77                 ie = elems.wpa_ie - 2;
  78                 ielen = elems.wpa_ie_len + 2;
  79                 wpa_printf(MSG_DEBUG, "STA included WPA IE in (Re)AssocReq");
  80         } else {
  81                 ie = NULL;
  82                 ielen = 0;
  83                 wpa_printf(MSG_DEBUG, "STA did not include WPS/RSN/WPA IE in "
  84                            "(Re)AssocReq");
  85         }
  86
  87         sta = ap_get_sta(hapd, addr);
  88         if (sta) {
  89                 accounting_sta_stop(hapd, sta);
  90         } else {
  91                 sta = ap_sta_add(hapd, addr);
  92                 if (sta == NULL)
  93                         return -1;
  94         }
  95         sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS | WLAN_STA_WPS2);
  96
  97 #ifdef CONFIG_P2P
  98         if (elems.p2p) {
  99                 wpabuf_free(sta->p2p_ie);
 100                 sta->p2p_ie = ieee802_11_vendor_ie_concat(req_ies, req_ies_len,
 101                                                           P2P_IE_VENDOR_TYPE);
 102         }
 103 #endif /* CONFIG_P2P */
 104
 105         if (hapd->conf->wpa) {
 106                 if (ie == NULL || ielen == 0) {
 107 #ifdef CONFIG_WPS
 108                         if (hapd->conf->wps_state) {
 109                                 wpa_printf(MSG_DEBUG, "STA did not include "
 110                                            "WPA/RSN IE in (Re)Association "
 111                                            "Request - possible WPS use");
 112                                 sta->flags |= WLAN_STA_MAYBE_WPS;
 113                                 goto skip_wpa_check;
 114                         }
 115 #endif /* CONFIG_WPS */
 116
 117                         wpa_printf(MSG_DEBUG, "No WPA/RSN IE from STA");
 118                         return -1;
 119                 }
 120 #ifdef CONFIG_WPS
 121                 if (hapd->conf->wps_state && ie[0] == 0xdd && ie[1] >= 4 &&
 122                     os_memcmp(ie + 2, "\x00\x50\xf2\x04", 4) == 0) {
 123                         struct wpabuf *wps;
 124                         sta->flags |= WLAN_STA_WPS;
 125                         wps = ieee802_11_vendor_ie_concat(ie, ielen,
 126                                                           WPS_IE_VENDOR_TYPE);
 127                         if (wps) {
 128                                 if (wps_is_20(wps)) {
 129                                         wpa_printf(MSG_DEBUG, "WPS: STA "
 130                                                    "supports WPS 2.0");
 131                                         sta->flags |= WLAN_STA_WPS2;
 132                                 }
 133                                 wpabuf_free(wps);
 134                         }
 135                         goto skip_wpa_check;
 136                 }
 137 #endif /* CONFIG_WPS */
 138
 139                 if (sta->wpa_sm == NULL)
 140                         sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth,
 141                                                         sta->addr);
 142                 if (sta->wpa_sm == NULL) {
 143                         wpa_printf(MSG_ERROR, "Failed to initialize WPA state "
 144                                    "machine");
 145                         return -1;
 146                 }
 147                 res = wpa_validate_wpa_ie(hapd->wpa_auth, sta->wpa_sm,
 148                                           ie, ielen, NULL, 0);
 149                 if (res != WPA_IE_OK) {
 150                         wpa_printf(MSG_DEBUG, "WPA/RSN information element "
 151                                    "rejected? (res %u)", res);
 152                         wpa_hexdump(MSG_DEBUG, "IE", ie, ielen);
 153                         if (res == WPA_INVALID_GROUP)
 154                                 reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID;
 155                         else if (res == WPA_INVALID_PAIRWISE)
 156                                 reason = WLAN_REASON_PAIRWISE_CIPHER_NOT_VALID;
 157                         else if (res == WPA_INVALID_AKMP)
 158                                 reason = WLAN_REASON_AKMP_NOT_VALID;
 159 #ifdef CONFIG_IEEE80211W
 160                         else if (res == WPA_MGMT_FRAME_PROTECTION_VIOLATION)
 161                                 reason = WLAN_REASON_INVALID_IE;
 162                         else if (res == WPA_INVALID_MGMT_GROUP_CIPHER)
 163                                 reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID;
 164 #endif /* CONFIG_IEEE80211W */
 165                         else
 166                                 reason = WLAN_REASON_INVALID_IE;
 167                         goto fail;
 168                 }
 169         } else if (hapd->conf->wps_state) {
 170 #ifdef CONFIG_WPS
 171                 struct wpabuf *wps;
 172                 if (req_ies)
 173                         wps = ieee802_11_vendor_ie_concat(req_ies, req_ies_len,
 174                                                           WPS_IE_VENDOR_TYPE);
 175                 else
 176                         wps = NULL;
 177 #ifdef CONFIG_WPS_STRICT
 178                 if (wps && wps_validate_assoc_req(wps) < 0) {
 179                         reason = WLAN_REASON_INVALID_IE;
 180                         wpabuf_free(wps);
 181                         goto fail;
 182                 }
 183 #endif /* CONFIG_WPS_STRICT */
 184                 if (wps) {
 185                         sta->flags |= WLAN_STA_WPS;
 186                         if (wps_is_20(wps)) {
 187                                 wpa_printf(MSG_DEBUG, "WPS: STA supports "
 188                                            "WPS 2.0");
 189                                 sta->flags |= WLAN_STA_WPS2;
 190                         }
 191                 } else
 192                         sta->flags |= WLAN_STA_MAYBE_WPS;
 193                 wpabuf_free(wps);
 194 #endif /* CONFIG_WPS */
 195         }
 196 #ifdef CONFIG_WPS
 197 skip_wpa_check:
 198 #endif /* CONFIG_WPS */
 199
 200         new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0;
 201         sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC;
 202         wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC);
 203
 204         hostapd_new_assoc_sta(hapd, sta, !new_assoc);
 205
 206         ieee802_1x_notify_port_enabled(sta->eapol_sm, 1);
 207
 208 #ifdef CONFIG_P2P
 209         p2p_group_notif_assoc(hapd->p2p_group, sta->addr,
 210                               req_ies, req_ies_len);
 211 #endif /* CONFIG_P2P */
 212
 213         return 0;
 214
 215 fail:
 216         hostapd_drv_sta_disassoc(hapd, sta->addr, reason);
 217         ap_free_sta(hapd, sta);
 218         return -1;
 219 }
 220
 221
 222 void hostapd_notif_disassoc(struct hostapd_data *hapd, const u8 *addr)
 223 {
 224         struct sta_info *sta;
 225
 226         if (addr == NULL) {
 227                 /*
 228                  * This could potentially happen with unexpected event from the
 229                  * driver wrapper. This was seen at least in one case where the
 230                  * driver ended up reporting a station mode event while hostapd
 231                  * was running, so better make sure we stop processing such an
 232                  * event here.
 233                  */
 234                 wpa_printf(MSG_DEBUG, "hostapd_notif_disassoc: Skip event "
 235                            "with no address");
 236                 return;
 237         }
 238
 239         hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
 240                        HOSTAPD_LEVEL_INFO, "disassociated");
 241
 242         sta = ap_get_sta(hapd, addr);
 243         if (sta == NULL) {
 244                 wpa_printf(MSG_DEBUG, "Disassociation notification for "
 245                            "unknown STA " MACSTR, MAC2STR(addr));
 246                 return;
 247         }
 248
 249         sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
 250         wpa_msg(hapd->msg_ctx, MSG_INFO, AP_STA_DISCONNECTED MACSTR,
 251                 MAC2STR(sta->addr));
 252         wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC);
 253         sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST;
 254         ieee802_1x_notify_port_enabled(sta->eapol_sm, 0);
 255         ap_free_sta(hapd, sta);
 256 }
 257
 258
 259 void hostapd_event_sta_low_ack(struct hostapd_data *hapd, const u8 *addr)
 260 {
 261         struct sta_info *sta = ap_get_sta(hapd, addr);
 262
 263         if (!sta || !hapd->conf->disassoc_low_ack)
 264                 return;
 265
 266         hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
 267                        HOSTAPD_LEVEL_INFO, "disconnected due to excessive "
 268                        "missing ACKs");
 269         hostapd_drv_sta_disassoc(hapd, addr, WLAN_REASON_DISASSOC_LOW_ACK);
 270         if (sta)
 271                 ap_sta_disassociate(hapd, sta, WLAN_REASON_DISASSOC_LOW_ACK);
 272 }
 273
 274
 275 int hostapd_probe_req_rx(struct hostapd_data *hapd, const u8 *sa, const u8 *da,
 276                          const u8 *bssid, const u8 *ie, size_t ie_len)
 277 {
 278         size_t i;
 279         int ret = 0;
 280
 281         if (sa == NULL || ie == NULL)
 282                 return -1;
 283
 284         random_add_randomness(sa, ETH_ALEN);
 285         for (i = 0; hapd->probereq_cb && i < hapd->num_probereq_cb; i++) {
 286                 if (hapd->probereq_cb[i].cb(hapd->probereq_cb[i].ctx,
 287                                             sa, da, bssid, ie, ie_len) > 0) {
 288                         ret = 1;
 289                         break;
 290                 }
 291         }
 292         return ret;
 293 }
 294
 295
 296 #ifdef HOSTAPD
 297
 298 #ifdef NEED_AP_MLME
 299
 300 #define HAPD_BROADCAST ((struct hostapd_data *) -1)
 301
 302 static struct hostapd_data * get_hapd_bssid(struct hostapd_iface *iface,
 303                                             const u8 *bssid)
 304 {
 305         size_t i;
 306
 307         if (bssid == NULL)
 308                 return NULL;
 309         if (bssid[0] == 0xff && bssid[1] == 0xff && bssid[2] == 0xff &&
 310             bssid[3] == 0xff && bssid[4] == 0xff && bssid[5] == 0xff)
 311                 return HAPD_BROADCAST;
 312
 313         for (i = 0; i < iface->num_bss; i++) {
 314                 if (os_memcmp(bssid, iface->bss[i]->own_addr, ETH_ALEN) == 0)
 315                         return iface->bss[i];
 316         }
 317
 318         return NULL;
 319 }
 320
 321
 322 static void hostapd_rx_from_unknown_sta(struct hostapd_data *hapd,
 323                                         const u8 *bssid, const u8 *addr,
 324                                         int wds)
 325 {
 326         hapd = get_hapd_bssid(hapd->iface, bssid);
 327         if (hapd == NULL || hapd == HAPD_BROADCAST)
 328                 return;
 329
 330         ieee802_11_rx_from_unknown(hapd, addr, wds);
 331 }
 332
 333
 334 static void hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt)
 335 {
 336         struct hostapd_iface *iface = hapd->iface;
 337         const struct ieee80211_hdr *hdr;
 338         const u8 *bssid;
 339         struct hostapd_frame_info fi;
 340
 341         hdr = (const struct ieee80211_hdr *) rx_mgmt->frame;
 342         bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len);
 343         if (bssid == NULL)
 344                 return;
 345
 346         hapd = get_hapd_bssid(iface, bssid);
 347         if (hapd == NULL) {
 348                 u16 fc;
 349                 fc = le_to_host16(hdr->frame_control);
 350
 351                 /*
 352                  * Drop frames to unknown BSSIDs except for Beacon frames which
 353                  * could be used to update neighbor information.
 354                  */
 355                 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
 356                     WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
 357                         hapd = iface->bss[0];
 358                 else
 359                         return;
 360         }
 361
 362         os_memset(&fi, 0, sizeof(fi));
 363         fi.datarate = rx_mgmt->datarate;
 364         fi.ssi_signal = rx_mgmt->ssi_signal;
 365
 366         if (hapd == HAPD_BROADCAST) {
 367                 size_t i;
 368                 for (i = 0; i < iface->num_bss; i++)
 369                         ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame,
 370                                         rx_mgmt->frame_len, &fi);
 371         } else
 372                 ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len, &fi);
 373
 374         random_add_randomness(&fi, sizeof(fi));
 375 }
 376
 377
 378 static void hostapd_rx_action(struct hostapd_data *hapd,
 379                               struct rx_action *rx_action)
 380 {
 381         struct rx_mgmt rx_mgmt;
 382         u8 *buf;
 383         struct ieee80211_hdr *hdr;
 384
 385         wpa_printf(MSG_DEBUG, "EVENT_RX_ACTION DA=" MACSTR " SA=" MACSTR
 386                    " BSSID=" MACSTR " category=%u",
 387                    MAC2STR(rx_action->da), MAC2STR(rx_action->sa),
 388                    MAC2STR(rx_action->bssid), rx_action->category);
 389         wpa_hexdump(MSG_MSGDUMP, "Received action frame contents",
 390                     rx_action->data, rx_action->len);
 391
 392         buf = os_zalloc(24 + 1 + rx_action->len);
 393         if (buf == NULL)
 394                 return;
 395         hdr = (struct ieee80211_hdr *) buf;
 396         hdr->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 397                                           WLAN_FC_STYPE_ACTION);
 398         if (rx_action->category == WLAN_ACTION_SA_QUERY) {
 399                 /*
 400                  * Assume frame was protected; it would have been dropped if
 401                  * not.
 402                  */
 403                 hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
 404         }
 405         os_memcpy(hdr->addr1, rx_action->da, ETH_ALEN);
 406         os_memcpy(hdr->addr2, rx_action->sa, ETH_ALEN);
 407         os_memcpy(hdr->addr3, rx_action->bssid, ETH_ALEN);
 408         buf[24] = rx_action->category;
 409         os_memcpy(buf + 24 + 1, rx_action->data, rx_action->len);
 410         os_memset(&rx_mgmt, 0, sizeof(rx_mgmt));
 411         rx_mgmt.frame = buf;
 412         rx_mgmt.frame_len = 24 + 1 + rx_action->len;
 413         hostapd_mgmt_rx(hapd, &rx_mgmt);
 414         os_free(buf);
 415 }
 416
 417
 418 static void hostapd_mgmt_tx_cb(struct hostapd_data *hapd, const u8 *buf,
 419                                size_t len, u16 stype, int ok)
 420 {
 421         struct ieee80211_hdr *hdr;
 422         hdr = (struct ieee80211_hdr *) buf;
 423         hapd = get_hapd_bssid(hapd->iface, get_hdr_bssid(hdr, len));
 424         if (hapd == NULL || hapd == HAPD_BROADCAST)
 425                 return;
 426         ieee802_11_mgmt_cb(hapd, buf, len, stype, ok);
 427 }
 428
 429 #endif /* NEED_AP_MLME */
 430
 431
 432 static int hostapd_event_new_sta(struct hostapd_data *hapd, const u8 *addr)
 433 {
 434         struct sta_info *sta = ap_get_sta(hapd, addr);
 435         if (sta)
 436                 return 0;
 437
 438         wpa_printf(MSG_DEBUG, "Data frame from unknown STA " MACSTR
 439                    " - adding a new STA", MAC2STR(addr));
 440         sta = ap_sta_add(hapd, addr);
 441         if (sta) {
 442                 hostapd_new_assoc_sta(hapd, sta, 0);
 443         } else {
 444                 wpa_printf(MSG_DEBUG, "Failed to add STA entry for " MACSTR,
 445                            MAC2STR(addr));
 446                 return -1;
 447         }
 448
 449         return 0;
 450 }
 451
 452
 453 static void hostapd_event_eapol_rx(struct hostapd_data *hapd, const u8 *src,
 454                                    const u8 *data, size_t data_len)
 455 {
 456         struct hostapd_iface *iface = hapd->iface;
 457         size_t j;
 458
 459         for (j = 0; j < iface->num_bss; j++) {
 460                 if (ap_get_sta(iface->bss[j], src)) {
 461                         hapd = iface->bss[j];
 462                         break;
 463                 }
 464         }
 465
 466         ieee802_1x_receive(hapd, src, data, data_len);
 467 }
 468
 469
 470 void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
 471                           union wpa_event_data *data)
 472 {
 473         struct hostapd_data *hapd = ctx;
 474
 475         switch (event) {
 476         case EVENT_MICHAEL_MIC_FAILURE:
 477                 michael_mic_failure(hapd, data->michael_mic_failure.src, 1);
 478                 break;
 479         case EVENT_SCAN_RESULTS:
 480                 if (hapd->iface->scan_cb)
 481                         hapd->iface->scan_cb(hapd->iface);
 482                 break;
 483 #ifdef CONFIG_IEEE80211R
 484         case EVENT_FT_RRB_RX:
 485                 wpa_ft_rrb_rx(hapd->wpa_auth, data->ft_rrb_rx.src,
 486                               data->ft_rrb_rx.data, data->ft_rrb_rx.data_len);
 487                 break;
 488 #endif /* CONFIG_IEEE80211R */
 489         case EVENT_WPS_BUTTON_PUSHED:
 490                 hostapd_wps_button_pushed(hapd, NULL);
 491                 break;
 492 #ifdef NEED_AP_MLME
 493         case EVENT_TX_STATUS:
 494                 switch (data->tx_status.type) {
 495                 case WLAN_FC_TYPE_MGMT:
 496                         hostapd_mgmt_tx_cb(hapd, data->tx_status.data,
 497                                            data->tx_status.data_len,
 498                                            data->tx_status.stype,
 499                                            data->tx_status.ack);
 500                         break;
 501                 case WLAN_FC_TYPE_DATA:
 502                         hostapd_tx_status(hapd, data->tx_status.dst,
 503                                           data->tx_status.data,
 504                                           data->tx_status.data_len,
 505                                           data->tx_status.ack);
 506                         break;
 507                 }
 508                 break;
 509         case EVENT_DRIVER_CLIENT_POLL_OK:
 510                 hostapd_client_poll_ok(hapd, data->client_poll.addr);
 511                 break;
 512         case EVENT_RX_FROM_UNKNOWN:
 513                 hostapd_rx_from_unknown_sta(hapd, data->rx_from_unknown.bssid,
 514                                             data->rx_from_unknown.addr,
 515                                             data->rx_from_unknown.wds);
 516                 break;
 517         case EVENT_RX_MGMT:
 518                 hostapd_mgmt_rx(hapd, &data->rx_mgmt);
 519                 break;
 520 #endif /* NEED_AP_MLME */
 521         case EVENT_RX_PROBE_REQ:
 522                 if (data->rx_probe_req.sa == NULL ||
 523                     data->rx_probe_req.ie == NULL)
 524                         break;
 525                 hostapd_probe_req_rx(hapd, data->rx_probe_req.sa,
 526                                      data->rx_probe_req.da,
 527                                      data->rx_probe_req.bssid,
 528                                      data->rx_probe_req.ie,
 529                                      data->rx_probe_req.ie_len);
 530                 break;
 531         case EVENT_NEW_STA:
 532                 hostapd_event_new_sta(hapd, data->new_sta.addr);
 533                 break;
 534         case EVENT_EAPOL_RX:
 535                 hostapd_event_eapol_rx(hapd, data->eapol_rx.src,
 536                                        data->eapol_rx.data,
 537                                        data->eapol_rx.data_len);
 538                 break;
 539         case EVENT_ASSOC:
 540                 hostapd_notif_assoc(hapd, data->assoc_info.addr,
 541                                     data->assoc_info.req_ies,
 542                                     data->assoc_info.req_ies_len,
 543                                     data->assoc_info.reassoc);
 544                 break;
 545         case EVENT_DISASSOC:
 546                 if (data)
 547                         hostapd_notif_disassoc(hapd, data->disassoc_info.addr);
 548                 break;
 549         case EVENT_DEAUTH:
 550                 if (data)
 551                         hostapd_notif_disassoc(hapd, data->deauth_info.addr);
 552                 break;
 553         case EVENT_STATION_LOW_ACK:
 554                 if (!data)
 555                         break;
 556                 hostapd_event_sta_low_ack(hapd, data->low_ack.addr);
 557                 break;
 558 #ifdef NEED_AP_MLME
 559         case EVENT_RX_ACTION:
 560                 if (data->rx_action.da == NULL || data->rx_action.sa == NULL ||
 561                     data->rx_action.bssid == NULL)
 562                         break;
 563                 hostapd_rx_action(hapd, &data->rx_action);
 564                 break;
 565 #endif /* NEED_AP_MLME */
 566         default:
 567                 wpa_printf(MSG_DEBUG, "Unknown event %d", event);
 568                 break;
 569         }
 570 }
 571
 572 #endif /* HOSTAPD */