hostapd.c revision 7f65602d49069f96a7bb44da8bd79ffe8d4c6a98
1/* 2 * hostapd / Initialization and configuration 3 * Copyright (c) 2002-2014, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9#include "utils/includes.h" 10 11#include "utils/common.h" 12#include "utils/eloop.h" 13#include "common/ieee802_11_defs.h" 14#include "common/wpa_ctrl.h" 15#include "radius/radius_client.h" 16#include "radius/radius_das.h" 17#include "eap_server/tncs.h" 18#include "eapol_auth/eapol_auth_sm.h" 19#include "eapol_auth/eapol_auth_sm_i.h" 20#include "hostapd.h" 21#include "authsrv.h" 22#include "sta_info.h" 23#include "accounting.h" 24#include "ap_list.h" 25#include "beacon.h" 26#include "iapp.h" 27#include "ieee802_1x.h" 28#include "ieee802_11_auth.h" 29#include "vlan_init.h" 30#include "wpa_auth.h" 31#include "wps_hostapd.h" 32#include "hw_features.h" 33#include "wpa_auth_glue.h" 34#include "ap_drv_ops.h" 35#include "ap_config.h" 36#include "p2p_hostapd.h" 37#include "gas_serv.h" 38#include "dfs.h" 39#include "ieee802_11.h" 40#include "bss_load.h" 41#include "x_snoop.h" 42#include "dhcp_snoop.h" 43#include "ndisc_snoop.h" 44 45 46static int hostapd_flush_old_stations(struct hostapd_data *hapd, u16 reason); 47static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd); 48static int hostapd_broadcast_wep_clear(struct hostapd_data *hapd); 49static int setup_interface2(struct hostapd_iface *iface); 50static void channel_list_update_timeout(void *eloop_ctx, void *timeout_ctx); 51 52 53int hostapd_for_each_interface(struct hapd_interfaces *interfaces, 54 int (*cb)(struct hostapd_iface *iface, 55 void *ctx), void *ctx) 56{ 57 size_t i; 58 int ret; 59 60 for (i = 0; i < interfaces->count; i++) { 61 ret = cb(interfaces->iface[i], ctx); 62 if (ret) 63 return ret; 64 } 65 66 return 0; 67} 68 69 70static void hostapd_reload_bss(struct hostapd_data *hapd) 71{ 72 struct hostapd_ssid *ssid; 73 74#ifndef CONFIG_NO_RADIUS 75 radius_client_reconfig(hapd->radius, hapd->conf->radius); 76#endif /* CONFIG_NO_RADIUS */ 77 78 ssid = &hapd->conf->ssid; 79 if (!ssid->wpa_psk_set && ssid->wpa_psk && !ssid->wpa_psk->next && 80 ssid->wpa_passphrase_set && ssid->wpa_passphrase) { 81 /* 82 * Force PSK to be derived again since SSID or passphrase may 83 * have changed. 84 */ 85 hostapd_config_clear_wpa_psk(&hapd->conf->ssid.wpa_psk); 86 } 87 if (hostapd_setup_wpa_psk(hapd->conf)) { 88 wpa_printf(MSG_ERROR, "Failed to re-configure WPA PSK " 89 "after reloading configuration"); 90 } 91 92 if (hapd->conf->ieee802_1x || hapd->conf->wpa) 93 hostapd_set_drv_ieee8021x(hapd, hapd->conf->iface, 1); 94 else 95 hostapd_set_drv_ieee8021x(hapd, hapd->conf->iface, 0); 96 97 if ((hapd->conf->wpa || hapd->conf->osen) && hapd->wpa_auth == NULL) { 98 hostapd_setup_wpa(hapd); 99 if (hapd->wpa_auth) 100 wpa_init_keys(hapd->wpa_auth); 101 } else if (hapd->conf->wpa) { 102 const u8 *wpa_ie; 103 size_t wpa_ie_len; 104 hostapd_reconfig_wpa(hapd); 105 wpa_ie = wpa_auth_get_wpa_ie(hapd->wpa_auth, &wpa_ie_len); 106 if (hostapd_set_generic_elem(hapd, wpa_ie, wpa_ie_len)) 107 wpa_printf(MSG_ERROR, "Failed to configure WPA IE for " 108 "the kernel driver."); 109 } else if (hapd->wpa_auth) { 110 wpa_deinit(hapd->wpa_auth); 111 hapd->wpa_auth = NULL; 112 hostapd_set_privacy(hapd, 0); 113 hostapd_setup_encryption(hapd->conf->iface, hapd); 114 hostapd_set_generic_elem(hapd, (u8 *) "", 0); 115 } 116 117 ieee802_11_set_beacon(hapd); 118 hostapd_update_wps(hapd); 119 120 if (hapd->conf->ssid.ssid_set && 121 hostapd_set_ssid(hapd, hapd->conf->ssid.ssid, 122 hapd->conf->ssid.ssid_len)) { 123 wpa_printf(MSG_ERROR, "Could not set SSID for kernel driver"); 124 /* try to continue */ 125 } 126 wpa_printf(MSG_DEBUG, "Reconfigured interface %s", hapd->conf->iface); 127} 128 129 130static void hostapd_clear_old(struct hostapd_iface *iface) 131{ 132 size_t j; 133 134 /* 135 * Deauthenticate all stations since the new configuration may not 136 * allow them to use the BSS anymore. 137 */ 138 for (j = 0; j < iface->num_bss; j++) { 139 hostapd_flush_old_stations(iface->bss[j], 140 WLAN_REASON_PREV_AUTH_NOT_VALID); 141 hostapd_broadcast_wep_clear(iface->bss[j]); 142 143#ifndef CONFIG_NO_RADIUS 144 /* TODO: update dynamic data based on changed configuration 145 * items (e.g., open/close sockets, etc.) */ 146 radius_client_flush(iface->bss[j]->radius, 0); 147#endif /* CONFIG_NO_RADIUS */ 148 } 149} 150 151 152int hostapd_reload_config(struct hostapd_iface *iface) 153{ 154 struct hostapd_data *hapd = iface->bss[0]; 155 struct hostapd_config *newconf, *oldconf; 156 size_t j; 157 158 if (iface->config_fname == NULL) { 159 /* Only in-memory config in use - assume it has been updated */ 160 hostapd_clear_old(iface); 161 for (j = 0; j < iface->num_bss; j++) 162 hostapd_reload_bss(iface->bss[j]); 163 return 0; 164 } 165 166 if (iface->interfaces == NULL || 167 iface->interfaces->config_read_cb == NULL) 168 return -1; 169 newconf = iface->interfaces->config_read_cb(iface->config_fname); 170 if (newconf == NULL) 171 return -1; 172 173 hostapd_clear_old(iface); 174 175 oldconf = hapd->iconf; 176 iface->conf = newconf; 177 178 for (j = 0; j < iface->num_bss; j++) { 179 hapd = iface->bss[j]; 180 hapd->iconf = newconf; 181 hapd->iconf->channel = oldconf->channel; 182 hapd->iconf->secondary_channel = oldconf->secondary_channel; 183 hapd->iconf->ieee80211n = oldconf->ieee80211n; 184 hapd->iconf->ieee80211ac = oldconf->ieee80211ac; 185 hapd->iconf->ht_capab = oldconf->ht_capab; 186 hapd->iconf->vht_capab = oldconf->vht_capab; 187 hapd->iconf->vht_oper_chwidth = oldconf->vht_oper_chwidth; 188 hapd->iconf->vht_oper_centr_freq_seg0_idx = 189 oldconf->vht_oper_centr_freq_seg0_idx; 190 hapd->iconf->vht_oper_centr_freq_seg1_idx = 191 oldconf->vht_oper_centr_freq_seg1_idx; 192 hapd->conf = newconf->bss[j]; 193 hostapd_reload_bss(hapd); 194 } 195 196 hostapd_config_free(oldconf); 197 198 199 return 0; 200} 201 202 203static void hostapd_broadcast_key_clear_iface(struct hostapd_data *hapd, 204 char *ifname) 205{ 206 int i; 207 208 for (i = 0; i < NUM_WEP_KEYS; i++) { 209 if (hostapd_drv_set_key(ifname, hapd, WPA_ALG_NONE, NULL, i, 210 0, NULL, 0, NULL, 0)) { 211 wpa_printf(MSG_DEBUG, "Failed to clear default " 212 "encryption keys (ifname=%s keyidx=%d)", 213 ifname, i); 214 } 215 } 216#ifdef CONFIG_IEEE80211W 217 if (hapd->conf->ieee80211w) { 218 for (i = NUM_WEP_KEYS; i < NUM_WEP_KEYS + 2; i++) { 219 if (hostapd_drv_set_key(ifname, hapd, WPA_ALG_NONE, 220 NULL, i, 0, NULL, 221 0, NULL, 0)) { 222 wpa_printf(MSG_DEBUG, "Failed to clear " 223 "default mgmt encryption keys " 224 "(ifname=%s keyidx=%d)", ifname, i); 225 } 226 } 227 } 228#endif /* CONFIG_IEEE80211W */ 229} 230 231 232static int hostapd_broadcast_wep_clear(struct hostapd_data *hapd) 233{ 234 hostapd_broadcast_key_clear_iface(hapd, hapd->conf->iface); 235 return 0; 236} 237 238 239static int hostapd_broadcast_wep_set(struct hostapd_data *hapd) 240{ 241 int errors = 0, idx; 242 struct hostapd_ssid *ssid = &hapd->conf->ssid; 243 244 idx = ssid->wep.idx; 245 if (ssid->wep.default_len && 246 hostapd_drv_set_key(hapd->conf->iface, 247 hapd, WPA_ALG_WEP, broadcast_ether_addr, idx, 248 1, NULL, 0, ssid->wep.key[idx], 249 ssid->wep.len[idx])) { 250 wpa_printf(MSG_WARNING, "Could not set WEP encryption."); 251 errors++; 252 } 253 254 return errors; 255} 256 257 258static void hostapd_free_hapd_data(struct hostapd_data *hapd) 259{ 260 os_free(hapd->probereq_cb); 261 hapd->probereq_cb = NULL; 262 263#ifdef CONFIG_P2P 264 wpabuf_free(hapd->p2p_beacon_ie); 265 hapd->p2p_beacon_ie = NULL; 266 wpabuf_free(hapd->p2p_probe_resp_ie); 267 hapd->p2p_probe_resp_ie = NULL; 268#endif /* CONFIG_P2P */ 269 270 if (!hapd->started) { 271 wpa_printf(MSG_ERROR, "%s: Interface %s wasn't started", 272 __func__, hapd->conf->iface); 273 return; 274 } 275 hapd->started = 0; 276 277 wpa_printf(MSG_DEBUG, "%s(%s)", __func__, hapd->conf->iface); 278 iapp_deinit(hapd->iapp); 279 hapd->iapp = NULL; 280 accounting_deinit(hapd); 281 hostapd_deinit_wpa(hapd); 282 vlan_deinit(hapd); 283 hostapd_acl_deinit(hapd); 284#ifndef CONFIG_NO_RADIUS 285 radius_client_deinit(hapd->radius); 286 hapd->radius = NULL; 287 radius_das_deinit(hapd->radius_das); 288 hapd->radius_das = NULL; 289#endif /* CONFIG_NO_RADIUS */ 290 291 hostapd_deinit_wps(hapd); 292 293 authsrv_deinit(hapd); 294 295 if (hapd->interface_added) { 296 hapd->interface_added = 0; 297 if (hostapd_if_remove(hapd, WPA_IF_AP_BSS, hapd->conf->iface)) { 298 wpa_printf(MSG_WARNING, 299 "Failed to remove BSS interface %s", 300 hapd->conf->iface); 301 hapd->interface_added = 1; 302 } else { 303 /* 304 * Since this was a dynamically added interface, the 305 * driver wrapper may have removed its internal instance 306 * and hapd->drv_priv is not valid anymore. 307 */ 308 hapd->drv_priv = NULL; 309 } 310 } 311 312 wpabuf_free(hapd->time_adv); 313 314#ifdef CONFIG_INTERWORKING 315 gas_serv_deinit(hapd); 316#endif /* CONFIG_INTERWORKING */ 317 318 bss_load_update_deinit(hapd); 319 ndisc_snoop_deinit(hapd); 320 dhcp_snoop_deinit(hapd); 321 x_snoop_deinit(hapd); 322 323#ifdef CONFIG_SQLITE 324 bin_clear_free(hapd->tmp_eap_user.identity, 325 hapd->tmp_eap_user.identity_len); 326 bin_clear_free(hapd->tmp_eap_user.password, 327 hapd->tmp_eap_user.password_len); 328#endif /* CONFIG_SQLITE */ 329 330#ifdef CONFIG_MESH 331 wpabuf_free(hapd->mesh_pending_auth); 332 hapd->mesh_pending_auth = NULL; 333#endif /* CONFIG_MESH */ 334} 335 336 337/** 338 * hostapd_cleanup - Per-BSS cleanup (deinitialization) 339 * @hapd: Pointer to BSS data 340 * 341 * This function is used to free all per-BSS data structures and resources. 342 * Most of the modules that are initialized in hostapd_setup_bss() are 343 * deinitialized here. 344 */ 345static void hostapd_cleanup(struct hostapd_data *hapd) 346{ 347 wpa_printf(MSG_DEBUG, "%s(hapd=%p (%s))", __func__, hapd, 348 hapd->conf->iface); 349 if (hapd->iface->interfaces && 350 hapd->iface->interfaces->ctrl_iface_deinit) 351 hapd->iface->interfaces->ctrl_iface_deinit(hapd); 352 hostapd_free_hapd_data(hapd); 353} 354 355 356static void hostapd_cleanup_iface_partial(struct hostapd_iface *iface) 357{ 358 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 359#ifdef CONFIG_IEEE80211N 360#ifdef NEED_AP_MLME 361 hostapd_stop_setup_timers(iface); 362#endif /* NEED_AP_MLME */ 363#endif /* CONFIG_IEEE80211N */ 364 hostapd_free_hw_features(iface->hw_features, iface->num_hw_features); 365 iface->hw_features = NULL; 366 os_free(iface->current_rates); 367 iface->current_rates = NULL; 368 os_free(iface->basic_rates); 369 iface->basic_rates = NULL; 370 ap_list_deinit(iface); 371} 372 373 374/** 375 * hostapd_cleanup_iface - Complete per-interface cleanup 376 * @iface: Pointer to interface data 377 * 378 * This function is called after per-BSS data structures are deinitialized 379 * with hostapd_cleanup(). 380 */ 381static void hostapd_cleanup_iface(struct hostapd_iface *iface) 382{ 383 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 384 eloop_cancel_timeout(channel_list_update_timeout, iface, NULL); 385 386 hostapd_cleanup_iface_partial(iface); 387 hostapd_config_free(iface->conf); 388 iface->conf = NULL; 389 390 os_free(iface->config_fname); 391 os_free(iface->bss); 392 wpa_printf(MSG_DEBUG, "%s: free iface=%p", __func__, iface); 393 os_free(iface); 394} 395 396 397static void hostapd_clear_wep(struct hostapd_data *hapd) 398{ 399 if (hapd->drv_priv && !hapd->iface->driver_ap_teardown) { 400 hostapd_set_privacy(hapd, 0); 401 hostapd_broadcast_wep_clear(hapd); 402 } 403} 404 405 406static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd) 407{ 408 int i; 409 410 hostapd_broadcast_wep_set(hapd); 411 412 if (hapd->conf->ssid.wep.default_len) { 413 hostapd_set_privacy(hapd, 1); 414 return 0; 415 } 416 417 /* 418 * When IEEE 802.1X is not enabled, the driver may need to know how to 419 * set authentication algorithms for static WEP. 420 */ 421 hostapd_drv_set_authmode(hapd, hapd->conf->auth_algs); 422 423 for (i = 0; i < 4; i++) { 424 if (hapd->conf->ssid.wep.key[i] && 425 hostapd_drv_set_key(iface, hapd, WPA_ALG_WEP, NULL, i, 426 i == hapd->conf->ssid.wep.idx, NULL, 0, 427 hapd->conf->ssid.wep.key[i], 428 hapd->conf->ssid.wep.len[i])) { 429 wpa_printf(MSG_WARNING, "Could not set WEP " 430 "encryption."); 431 return -1; 432 } 433 if (hapd->conf->ssid.wep.key[i] && 434 i == hapd->conf->ssid.wep.idx) 435 hostapd_set_privacy(hapd, 1); 436 } 437 438 return 0; 439} 440 441 442static int hostapd_flush_old_stations(struct hostapd_data *hapd, u16 reason) 443{ 444 int ret = 0; 445 u8 addr[ETH_ALEN]; 446 447 if (hostapd_drv_none(hapd) || hapd->drv_priv == NULL) 448 return 0; 449 450 if (!hapd->iface->driver_ap_teardown) { 451 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, 452 "Flushing old station entries"); 453 454 if (hostapd_flush(hapd)) { 455 wpa_msg(hapd->msg_ctx, MSG_WARNING, 456 "Could not connect to kernel driver"); 457 ret = -1; 458 } 459 } 460 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "Deauthenticate all stations"); 461 os_memset(addr, 0xff, ETH_ALEN); 462 hostapd_drv_sta_deauth(hapd, addr, reason); 463 hostapd_free_stas(hapd); 464 465 return ret; 466} 467 468 469static void hostapd_bss_deinit_no_free(struct hostapd_data *hapd) 470{ 471 hostapd_free_stas(hapd); 472 hostapd_flush_old_stations(hapd, WLAN_REASON_DEAUTH_LEAVING); 473 hostapd_clear_wep(hapd); 474} 475 476 477/** 478 * hostapd_validate_bssid_configuration - Validate BSSID configuration 479 * @iface: Pointer to interface data 480 * Returns: 0 on success, -1 on failure 481 * 482 * This function is used to validate that the configured BSSIDs are valid. 483 */ 484static int hostapd_validate_bssid_configuration(struct hostapd_iface *iface) 485{ 486 u8 mask[ETH_ALEN] = { 0 }; 487 struct hostapd_data *hapd = iface->bss[0]; 488 unsigned int i = iface->conf->num_bss, bits = 0, j; 489 int auto_addr = 0; 490 491 if (hostapd_drv_none(hapd)) 492 return 0; 493 494 /* Generate BSSID mask that is large enough to cover the BSSIDs. */ 495 496 /* Determine the bits necessary to cover the number of BSSIDs. */ 497 for (i--; i; i >>= 1) 498 bits++; 499 500 /* Determine the bits necessary to any configured BSSIDs, 501 if they are higher than the number of BSSIDs. */ 502 for (j = 0; j < iface->conf->num_bss; j++) { 503 if (hostapd_mac_comp_empty(iface->conf->bss[j]->bssid) == 0) { 504 if (j) 505 auto_addr++; 506 continue; 507 } 508 509 for (i = 0; i < ETH_ALEN; i++) { 510 mask[i] |= 511 iface->conf->bss[j]->bssid[i] ^ 512 hapd->own_addr[i]; 513 } 514 } 515 516 if (!auto_addr) 517 goto skip_mask_ext; 518 519 for (i = 0; i < ETH_ALEN && mask[i] == 0; i++) 520 ; 521 j = 0; 522 if (i < ETH_ALEN) { 523 j = (5 - i) * 8; 524 525 while (mask[i] != 0) { 526 mask[i] >>= 1; 527 j++; 528 } 529 } 530 531 if (bits < j) 532 bits = j; 533 534 if (bits > 40) { 535 wpa_printf(MSG_ERROR, "Too many bits in the BSSID mask (%u)", 536 bits); 537 return -1; 538 } 539 540 os_memset(mask, 0xff, ETH_ALEN); 541 j = bits / 8; 542 for (i = 5; i > 5 - j; i--) 543 mask[i] = 0; 544 j = bits % 8; 545 while (j--) 546 mask[i] <<= 1; 547 548skip_mask_ext: 549 wpa_printf(MSG_DEBUG, "BSS count %lu, BSSID mask " MACSTR " (%d bits)", 550 (unsigned long) iface->conf->num_bss, MAC2STR(mask), bits); 551 552 if (!auto_addr) 553 return 0; 554 555 for (i = 0; i < ETH_ALEN; i++) { 556 if ((hapd->own_addr[i] & mask[i]) != hapd->own_addr[i]) { 557 wpa_printf(MSG_ERROR, "Invalid BSSID mask " MACSTR 558 " for start address " MACSTR ".", 559 MAC2STR(mask), MAC2STR(hapd->own_addr)); 560 wpa_printf(MSG_ERROR, "Start address must be the " 561 "first address in the block (i.e., addr " 562 "AND mask == addr)."); 563 return -1; 564 } 565 } 566 567 return 0; 568} 569 570 571static int mac_in_conf(struct hostapd_config *conf, const void *a) 572{ 573 size_t i; 574 575 for (i = 0; i < conf->num_bss; i++) { 576 if (hostapd_mac_comp(conf->bss[i]->bssid, a) == 0) { 577 return 1; 578 } 579 } 580 581 return 0; 582} 583 584 585#ifndef CONFIG_NO_RADIUS 586 587static int hostapd_das_nas_mismatch(struct hostapd_data *hapd, 588 struct radius_das_attrs *attr) 589{ 590 if (attr->nas_identifier && 591 (!hapd->conf->nas_identifier || 592 os_strlen(hapd->conf->nas_identifier) != 593 attr->nas_identifier_len || 594 os_memcmp(hapd->conf->nas_identifier, attr->nas_identifier, 595 attr->nas_identifier_len) != 0)) { 596 wpa_printf(MSG_DEBUG, "RADIUS DAS: NAS-Identifier mismatch"); 597 return 1; 598 } 599 600 if (attr->nas_ip_addr && 601 (hapd->conf->own_ip_addr.af != AF_INET || 602 os_memcmp(&hapd->conf->own_ip_addr.u.v4, attr->nas_ip_addr, 4) != 603 0)) { 604 wpa_printf(MSG_DEBUG, "RADIUS DAS: NAS-IP-Address mismatch"); 605 return 1; 606 } 607 608#ifdef CONFIG_IPV6 609 if (attr->nas_ipv6_addr && 610 (hapd->conf->own_ip_addr.af != AF_INET6 || 611 os_memcmp(&hapd->conf->own_ip_addr.u.v6, attr->nas_ipv6_addr, 16) 612 != 0)) { 613 wpa_printf(MSG_DEBUG, "RADIUS DAS: NAS-IPv6-Address mismatch"); 614 return 1; 615 } 616#endif /* CONFIG_IPV6 */ 617 618 return 0; 619} 620 621 622static struct sta_info * hostapd_das_find_sta(struct hostapd_data *hapd, 623 struct radius_das_attrs *attr, 624 int *multi) 625{ 626 struct sta_info *selected, *sta; 627 char buf[128]; 628 int num_attr = 0; 629 int count; 630 631 *multi = 0; 632 633 for (sta = hapd->sta_list; sta; sta = sta->next) 634 sta->radius_das_match = 1; 635 636 if (attr->sta_addr) { 637 num_attr++; 638 sta = ap_get_sta(hapd, attr->sta_addr); 639 if (!sta) { 640 wpa_printf(MSG_DEBUG, 641 "RADIUS DAS: No Calling-Station-Id match"); 642 return NULL; 643 } 644 645 selected = sta; 646 for (sta = hapd->sta_list; sta; sta = sta->next) { 647 if (sta != selected) 648 sta->radius_das_match = 0; 649 } 650 wpa_printf(MSG_DEBUG, "RADIUS DAS: Calling-Station-Id match"); 651 } 652 653 if (attr->acct_session_id) { 654 num_attr++; 655 if (attr->acct_session_id_len != 17) { 656 wpa_printf(MSG_DEBUG, 657 "RADIUS DAS: Acct-Session-Id cannot match"); 658 return NULL; 659 } 660 count = 0; 661 662 for (sta = hapd->sta_list; sta; sta = sta->next) { 663 if (!sta->radius_das_match) 664 continue; 665 os_snprintf(buf, sizeof(buf), "%08X-%08X", 666 sta->acct_session_id_hi, 667 sta->acct_session_id_lo); 668 if (os_memcmp(attr->acct_session_id, buf, 17) != 0) 669 sta->radius_das_match = 0; 670 else 671 count++; 672 } 673 674 if (count == 0) { 675 wpa_printf(MSG_DEBUG, 676 "RADIUS DAS: No matches remaining after Acct-Session-Id check"); 677 return NULL; 678 } 679 wpa_printf(MSG_DEBUG, "RADIUS DAS: Acct-Session-Id match"); 680 } 681 682 if (attr->acct_multi_session_id) { 683 num_attr++; 684 if (attr->acct_multi_session_id_len != 17) { 685 wpa_printf(MSG_DEBUG, 686 "RADIUS DAS: Acct-Multi-Session-Id cannot match"); 687 return NULL; 688 } 689 count = 0; 690 691 for (sta = hapd->sta_list; sta; sta = sta->next) { 692 if (!sta->radius_das_match) 693 continue; 694 if (!sta->eapol_sm || 695 !sta->eapol_sm->acct_multi_session_id_hi) { 696 sta->radius_das_match = 0; 697 continue; 698 } 699 os_snprintf(buf, sizeof(buf), "%08X+%08X", 700 sta->eapol_sm->acct_multi_session_id_hi, 701 sta->eapol_sm->acct_multi_session_id_lo); 702 if (os_memcmp(attr->acct_multi_session_id, buf, 17) != 703 0) 704 sta->radius_das_match = 0; 705 else 706 count++; 707 } 708 709 if (count == 0) { 710 wpa_printf(MSG_DEBUG, 711 "RADIUS DAS: No matches remaining after Acct-Multi-Session-Id check"); 712 return NULL; 713 } 714 wpa_printf(MSG_DEBUG, 715 "RADIUS DAS: Acct-Multi-Session-Id match"); 716 } 717 718 if (attr->cui) { 719 num_attr++; 720 count = 0; 721 722 for (sta = hapd->sta_list; sta; sta = sta->next) { 723 struct wpabuf *cui; 724 725 if (!sta->radius_das_match) 726 continue; 727 cui = ieee802_1x_get_radius_cui(sta->eapol_sm); 728 if (!cui || wpabuf_len(cui) != attr->cui_len || 729 os_memcmp(wpabuf_head(cui), attr->cui, 730 attr->cui_len) != 0) 731 sta->radius_das_match = 0; 732 else 733 count++; 734 } 735 736 if (count == 0) { 737 wpa_printf(MSG_DEBUG, 738 "RADIUS DAS: No matches remaining after Chargeable-User-Identity check"); 739 return NULL; 740 } 741 wpa_printf(MSG_DEBUG, 742 "RADIUS DAS: Chargeable-User-Identity match"); 743 } 744 745 if (attr->user_name) { 746 num_attr++; 747 count = 0; 748 749 for (sta = hapd->sta_list; sta; sta = sta->next) { 750 u8 *identity; 751 size_t identity_len; 752 753 if (!sta->radius_das_match) 754 continue; 755 identity = ieee802_1x_get_identity(sta->eapol_sm, 756 &identity_len); 757 if (!identity || 758 identity_len != attr->user_name_len || 759 os_memcmp(identity, attr->user_name, identity_len) 760 != 0) 761 sta->radius_das_match = 0; 762 else 763 count++; 764 } 765 766 if (count == 0) { 767 wpa_printf(MSG_DEBUG, 768 "RADIUS DAS: No matches remaining after User-Name check"); 769 return NULL; 770 } 771 wpa_printf(MSG_DEBUG, 772 "RADIUS DAS: User-Name match"); 773 } 774 775 if (num_attr == 0) { 776 /* 777 * In theory, we could match all current associations, but it 778 * seems safer to just reject requests that do not include any 779 * session identification attributes. 780 */ 781 wpa_printf(MSG_DEBUG, 782 "RADIUS DAS: No session identification attributes included"); 783 return NULL; 784 } 785 786 selected = NULL; 787 for (sta = hapd->sta_list; sta; sta = sta->next) { 788 if (sta->radius_das_match) { 789 if (selected) { 790 *multi = 1; 791 return NULL; 792 } 793 selected = sta; 794 } 795 } 796 797 return selected; 798} 799 800 801static int hostapd_das_disconnect_pmksa(struct hostapd_data *hapd, 802 struct radius_das_attrs *attr) 803{ 804 if (!hapd->wpa_auth) 805 return -1; 806 return wpa_auth_radius_das_disconnect_pmksa(hapd->wpa_auth, attr); 807} 808 809 810static enum radius_das_res 811hostapd_das_disconnect(void *ctx, struct radius_das_attrs *attr) 812{ 813 struct hostapd_data *hapd = ctx; 814 struct sta_info *sta; 815 int multi; 816 817 if (hostapd_das_nas_mismatch(hapd, attr)) 818 return RADIUS_DAS_NAS_MISMATCH; 819 820 sta = hostapd_das_find_sta(hapd, attr, &multi); 821 if (sta == NULL) { 822 if (multi) { 823 wpa_printf(MSG_DEBUG, 824 "RADIUS DAS: Multiple sessions match - not supported"); 825 return RADIUS_DAS_MULTI_SESSION_MATCH; 826 } 827 if (hostapd_das_disconnect_pmksa(hapd, attr) == 0) { 828 wpa_printf(MSG_DEBUG, 829 "RADIUS DAS: PMKSA cache entry matched"); 830 return RADIUS_DAS_SUCCESS; 831 } 832 wpa_printf(MSG_DEBUG, "RADIUS DAS: No matching session found"); 833 return RADIUS_DAS_SESSION_NOT_FOUND; 834 } 835 836 wpa_printf(MSG_DEBUG, "RADIUS DAS: Found a matching session " MACSTR 837 " - disconnecting", MAC2STR(sta->addr)); 838 wpa_auth_pmksa_remove(hapd->wpa_auth, sta->addr); 839 840 hostapd_drv_sta_deauth(hapd, sta->addr, 841 WLAN_REASON_PREV_AUTH_NOT_VALID); 842 ap_sta_deauthenticate(hapd, sta, WLAN_REASON_PREV_AUTH_NOT_VALID); 843 844 return RADIUS_DAS_SUCCESS; 845} 846 847#endif /* CONFIG_NO_RADIUS */ 848 849 850/** 851 * hostapd_setup_bss - Per-BSS setup (initialization) 852 * @hapd: Pointer to BSS data 853 * @first: Whether this BSS is the first BSS of an interface; -1 = not first, 854 * but interface may exist 855 * 856 * This function is used to initialize all per-BSS data structures and 857 * resources. This gets called in a loop for each BSS when an interface is 858 * initialized. Most of the modules that are initialized here will be 859 * deinitialized in hostapd_cleanup(). 860 */ 861static int hostapd_setup_bss(struct hostapd_data *hapd, int first) 862{ 863 struct hostapd_bss_config *conf = hapd->conf; 864 u8 ssid[HOSTAPD_MAX_SSID_LEN + 1]; 865 int ssid_len, set_ssid; 866 char force_ifname[IFNAMSIZ]; 867 u8 if_addr[ETH_ALEN]; 868 int flush_old_stations = 1; 869 870 wpa_printf(MSG_DEBUG, "%s(hapd=%p (%s), first=%d)", 871 __func__, hapd, conf->iface, first); 872 873#ifdef EAP_SERVER_TNC 874 if (conf->tnc && tncs_global_init() < 0) { 875 wpa_printf(MSG_ERROR, "Failed to initialize TNCS"); 876 return -1; 877 } 878#endif /* EAP_SERVER_TNC */ 879 880 if (hapd->started) { 881 wpa_printf(MSG_ERROR, "%s: Interface %s was already started", 882 __func__, conf->iface); 883 return -1; 884 } 885 hapd->started = 1; 886 887 if (!first || first == -1) { 888 if (hostapd_mac_comp_empty(conf->bssid) == 0) { 889 /* Allocate the next available BSSID. */ 890 do { 891 inc_byte_array(hapd->own_addr, ETH_ALEN); 892 } while (mac_in_conf(hapd->iconf, hapd->own_addr)); 893 } else { 894 /* Allocate the configured BSSID. */ 895 os_memcpy(hapd->own_addr, conf->bssid, ETH_ALEN); 896 897 if (hostapd_mac_comp(hapd->own_addr, 898 hapd->iface->bss[0]->own_addr) == 899 0) { 900 wpa_printf(MSG_ERROR, "BSS '%s' may not have " 901 "BSSID set to the MAC address of " 902 "the radio", conf->iface); 903 return -1; 904 } 905 } 906 907 hapd->interface_added = 1; 908 if (hostapd_if_add(hapd->iface->bss[0], WPA_IF_AP_BSS, 909 conf->iface, hapd->own_addr, hapd, 910 &hapd->drv_priv, force_ifname, if_addr, 911 conf->bridge[0] ? conf->bridge : NULL, 912 first == -1)) { 913 wpa_printf(MSG_ERROR, "Failed to add BSS (BSSID=" 914 MACSTR ")", MAC2STR(hapd->own_addr)); 915 hapd->interface_added = 0; 916 return -1; 917 } 918 } 919 920 if (conf->wmm_enabled < 0) 921 conf->wmm_enabled = hapd->iconf->ieee80211n; 922 923#ifdef CONFIG_MESH 924 if (hapd->iface->mconf == NULL) 925 flush_old_stations = 0; 926#endif /* CONFIG_MESH */ 927 928 if (flush_old_stations) 929 hostapd_flush_old_stations(hapd, 930 WLAN_REASON_PREV_AUTH_NOT_VALID); 931 hostapd_set_privacy(hapd, 0); 932 933 hostapd_broadcast_wep_clear(hapd); 934 if (hostapd_setup_encryption(conf->iface, hapd)) 935 return -1; 936 937 /* 938 * Fetch the SSID from the system and use it or, 939 * if one was specified in the config file, verify they 940 * match. 941 */ 942 ssid_len = hostapd_get_ssid(hapd, ssid, sizeof(ssid)); 943 if (ssid_len < 0) { 944 wpa_printf(MSG_ERROR, "Could not read SSID from system"); 945 return -1; 946 } 947 if (conf->ssid.ssid_set) { 948 /* 949 * If SSID is specified in the config file and it differs 950 * from what is being used then force installation of the 951 * new SSID. 952 */ 953 set_ssid = (conf->ssid.ssid_len != (size_t) ssid_len || 954 os_memcmp(conf->ssid.ssid, ssid, ssid_len) != 0); 955 } else { 956 /* 957 * No SSID in the config file; just use the one we got 958 * from the system. 959 */ 960 set_ssid = 0; 961 conf->ssid.ssid_len = ssid_len; 962 os_memcpy(conf->ssid.ssid, ssid, conf->ssid.ssid_len); 963 } 964 965 if (!hostapd_drv_none(hapd)) { 966 wpa_printf(MSG_ERROR, "Using interface %s with hwaddr " MACSTR 967 " and ssid \"%s\"", 968 conf->iface, MAC2STR(hapd->own_addr), 969 wpa_ssid_txt(conf->ssid.ssid, conf->ssid.ssid_len)); 970 } 971 972 if (hostapd_setup_wpa_psk(conf)) { 973 wpa_printf(MSG_ERROR, "WPA-PSK setup failed."); 974 return -1; 975 } 976 977 /* Set SSID for the kernel driver (to be used in beacon and probe 978 * response frames) */ 979 if (set_ssid && hostapd_set_ssid(hapd, conf->ssid.ssid, 980 conf->ssid.ssid_len)) { 981 wpa_printf(MSG_ERROR, "Could not set SSID for kernel driver"); 982 return -1; 983 } 984 985 if (wpa_debug_level <= MSG_MSGDUMP) 986 conf->radius->msg_dumps = 1; 987#ifndef CONFIG_NO_RADIUS 988 hapd->radius = radius_client_init(hapd, conf->radius); 989 if (hapd->radius == NULL) { 990 wpa_printf(MSG_ERROR, "RADIUS client initialization failed."); 991 return -1; 992 } 993 994 if (conf->radius_das_port) { 995 struct radius_das_conf das_conf; 996 os_memset(&das_conf, 0, sizeof(das_conf)); 997 das_conf.port = conf->radius_das_port; 998 das_conf.shared_secret = conf->radius_das_shared_secret; 999 das_conf.shared_secret_len = 1000 conf->radius_das_shared_secret_len; 1001 das_conf.client_addr = &conf->radius_das_client_addr; 1002 das_conf.time_window = conf->radius_das_time_window; 1003 das_conf.require_event_timestamp = 1004 conf->radius_das_require_event_timestamp; 1005 das_conf.ctx = hapd; 1006 das_conf.disconnect = hostapd_das_disconnect; 1007 hapd->radius_das = radius_das_init(&das_conf); 1008 if (hapd->radius_das == NULL) { 1009 wpa_printf(MSG_ERROR, "RADIUS DAS initialization " 1010 "failed."); 1011 return -1; 1012 } 1013 } 1014#endif /* CONFIG_NO_RADIUS */ 1015 1016 if (hostapd_acl_init(hapd)) { 1017 wpa_printf(MSG_ERROR, "ACL initialization failed."); 1018 return -1; 1019 } 1020 if (hostapd_init_wps(hapd, conf)) 1021 return -1; 1022 1023 if (authsrv_init(hapd) < 0) 1024 return -1; 1025 1026 if (ieee802_1x_init(hapd)) { 1027 wpa_printf(MSG_ERROR, "IEEE 802.1X initialization failed."); 1028 return -1; 1029 } 1030 1031 if ((conf->wpa || conf->osen) && hostapd_setup_wpa(hapd)) 1032 return -1; 1033 1034 if (accounting_init(hapd)) { 1035 wpa_printf(MSG_ERROR, "Accounting initialization failed."); 1036 return -1; 1037 } 1038 1039 if (conf->ieee802_11f && 1040 (hapd->iapp = iapp_init(hapd, conf->iapp_iface)) == NULL) { 1041 wpa_printf(MSG_ERROR, "IEEE 802.11F (IAPP) initialization " 1042 "failed."); 1043 return -1; 1044 } 1045 1046#ifdef CONFIG_INTERWORKING 1047 if (gas_serv_init(hapd)) { 1048 wpa_printf(MSG_ERROR, "GAS server initialization failed"); 1049 return -1; 1050 } 1051 1052 if (conf->qos_map_set_len && 1053 hostapd_drv_set_qos_map(hapd, conf->qos_map_set, 1054 conf->qos_map_set_len)) { 1055 wpa_printf(MSG_ERROR, "Failed to initialize QoS Map"); 1056 return -1; 1057 } 1058#endif /* CONFIG_INTERWORKING */ 1059 1060 if (conf->bss_load_update_period && bss_load_update_init(hapd)) { 1061 wpa_printf(MSG_ERROR, "BSS Load initialization failed"); 1062 return -1; 1063 } 1064 1065 if (conf->proxy_arp) { 1066 if (x_snoop_init(hapd)) { 1067 wpa_printf(MSG_ERROR, 1068 "Generic snooping infrastructure initialization failed"); 1069 return -1; 1070 } 1071 1072 if (dhcp_snoop_init(hapd)) { 1073 wpa_printf(MSG_ERROR, 1074 "DHCP snooping initialization failed"); 1075 return -1; 1076 } 1077 1078 if (ndisc_snoop_init(hapd)) { 1079 wpa_printf(MSG_ERROR, 1080 "Neighbor Discovery snooping initialization failed"); 1081 return -1; 1082 } 1083 } 1084 1085 if (!hostapd_drv_none(hapd) && vlan_init(hapd)) { 1086 wpa_printf(MSG_ERROR, "VLAN initialization failed."); 1087 return -1; 1088 } 1089 1090 if (!conf->start_disabled && ieee802_11_set_beacon(hapd) < 0) 1091 return -1; 1092 1093 if (hapd->wpa_auth && wpa_init_keys(hapd->wpa_auth) < 0) 1094 return -1; 1095 1096 if (hapd->driver && hapd->driver->set_operstate) 1097 hapd->driver->set_operstate(hapd->drv_priv, 1); 1098 1099 return 0; 1100} 1101 1102 1103static void hostapd_tx_queue_params(struct hostapd_iface *iface) 1104{ 1105 struct hostapd_data *hapd = iface->bss[0]; 1106 int i; 1107 struct hostapd_tx_queue_params *p; 1108 1109#ifdef CONFIG_MESH 1110 if (iface->mconf == NULL) 1111 return; 1112#endif /* CONFIG_MESH */ 1113 1114 for (i = 0; i < NUM_TX_QUEUES; i++) { 1115 p = &iface->conf->tx_queue[i]; 1116 1117 if (hostapd_set_tx_queue_params(hapd, i, p->aifs, p->cwmin, 1118 p->cwmax, p->burst)) { 1119 wpa_printf(MSG_DEBUG, "Failed to set TX queue " 1120 "parameters for queue %d.", i); 1121 /* Continue anyway */ 1122 } 1123 } 1124} 1125 1126 1127static int hostapd_set_acl_list(struct hostapd_data *hapd, 1128 struct mac_acl_entry *mac_acl, 1129 int n_entries, u8 accept_acl) 1130{ 1131 struct hostapd_acl_params *acl_params; 1132 int i, err; 1133 1134 acl_params = os_zalloc(sizeof(*acl_params) + 1135 (n_entries * sizeof(acl_params->mac_acl[0]))); 1136 if (!acl_params) 1137 return -ENOMEM; 1138 1139 for (i = 0; i < n_entries; i++) 1140 os_memcpy(acl_params->mac_acl[i].addr, mac_acl[i].addr, 1141 ETH_ALEN); 1142 1143 acl_params->acl_policy = accept_acl; 1144 acl_params->num_mac_acl = n_entries; 1145 1146 err = hostapd_drv_set_acl(hapd, acl_params); 1147 1148 os_free(acl_params); 1149 1150 return err; 1151} 1152 1153 1154static void hostapd_set_acl(struct hostapd_data *hapd) 1155{ 1156 struct hostapd_config *conf = hapd->iconf; 1157 int err; 1158 u8 accept_acl; 1159 1160 if (hapd->iface->drv_max_acl_mac_addrs == 0) 1161 return; 1162 1163 if (conf->bss[0]->macaddr_acl == DENY_UNLESS_ACCEPTED) { 1164 accept_acl = 1; 1165 err = hostapd_set_acl_list(hapd, conf->bss[0]->accept_mac, 1166 conf->bss[0]->num_accept_mac, 1167 accept_acl); 1168 if (err) { 1169 wpa_printf(MSG_DEBUG, "Failed to set accept acl"); 1170 return; 1171 } 1172 } else if (conf->bss[0]->macaddr_acl == ACCEPT_UNLESS_DENIED) { 1173 accept_acl = 0; 1174 err = hostapd_set_acl_list(hapd, conf->bss[0]->deny_mac, 1175 conf->bss[0]->num_deny_mac, 1176 accept_acl); 1177 if (err) { 1178 wpa_printf(MSG_DEBUG, "Failed to set deny acl"); 1179 return; 1180 } 1181 } 1182} 1183 1184 1185static int start_ctrl_iface_bss(struct hostapd_data *hapd) 1186{ 1187 if (!hapd->iface->interfaces || 1188 !hapd->iface->interfaces->ctrl_iface_init) 1189 return 0; 1190 1191 if (hapd->iface->interfaces->ctrl_iface_init(hapd)) { 1192 wpa_printf(MSG_ERROR, 1193 "Failed to setup control interface for %s", 1194 hapd->conf->iface); 1195 return -1; 1196 } 1197 1198 return 0; 1199} 1200 1201 1202static int start_ctrl_iface(struct hostapd_iface *iface) 1203{ 1204 size_t i; 1205 1206 if (!iface->interfaces || !iface->interfaces->ctrl_iface_init) 1207 return 0; 1208 1209 for (i = 0; i < iface->num_bss; i++) { 1210 struct hostapd_data *hapd = iface->bss[i]; 1211 if (iface->interfaces->ctrl_iface_init(hapd)) { 1212 wpa_printf(MSG_ERROR, 1213 "Failed to setup control interface for %s", 1214 hapd->conf->iface); 1215 return -1; 1216 } 1217 } 1218 1219 return 0; 1220} 1221 1222 1223static void channel_list_update_timeout(void *eloop_ctx, void *timeout_ctx) 1224{ 1225 struct hostapd_iface *iface = eloop_ctx; 1226 1227 if (!iface->wait_channel_update) { 1228 wpa_printf(MSG_INFO, "Channel list update timeout, but interface was not waiting for it"); 1229 return; 1230 } 1231 1232 /* 1233 * It is possible that the existing channel list is acceptable, so try 1234 * to proceed. 1235 */ 1236 wpa_printf(MSG_DEBUG, "Channel list update timeout - try to continue anyway"); 1237 setup_interface2(iface); 1238} 1239 1240 1241void hostapd_channel_list_updated(struct hostapd_iface *iface, int initiator) 1242{ 1243 if (!iface->wait_channel_update || initiator != REGDOM_SET_BY_USER) 1244 return; 1245 1246 wpa_printf(MSG_DEBUG, "Channel list updated - continue setup"); 1247 eloop_cancel_timeout(channel_list_update_timeout, iface, NULL); 1248 setup_interface2(iface); 1249} 1250 1251 1252static int setup_interface(struct hostapd_iface *iface) 1253{ 1254 struct hostapd_data *hapd = iface->bss[0]; 1255 size_t i; 1256 1257 /* 1258 * It is possible that setup_interface() is called after the interface 1259 * was disabled etc., in which case driver_ap_teardown is possibly set 1260 * to 1. Clear it here so any other key/station deletion, which is not 1261 * part of a teardown flow, would also call the relevant driver 1262 * callbacks. 1263 */ 1264 iface->driver_ap_teardown = 0; 1265 1266 if (!iface->phy[0]) { 1267 const char *phy = hostapd_drv_get_radio_name(hapd); 1268 if (phy) { 1269 wpa_printf(MSG_DEBUG, "phy: %s", phy); 1270 os_strlcpy(iface->phy, phy, sizeof(iface->phy)); 1271 } 1272 } 1273 1274 /* 1275 * Make sure that all BSSes get configured with a pointer to the same 1276 * driver interface. 1277 */ 1278 for (i = 1; i < iface->num_bss; i++) { 1279 iface->bss[i]->driver = hapd->driver; 1280 iface->bss[i]->drv_priv = hapd->drv_priv; 1281 } 1282 1283 if (hostapd_validate_bssid_configuration(iface)) 1284 return -1; 1285 1286 /* 1287 * Initialize control interfaces early to allow external monitoring of 1288 * channel setup operations that may take considerable amount of time 1289 * especially for DFS cases. 1290 */ 1291 if (start_ctrl_iface(iface)) 1292 return -1; 1293 1294 if (hapd->iconf->country[0] && hapd->iconf->country[1]) { 1295 char country[4], previous_country[4]; 1296 1297 hostapd_set_state(iface, HAPD_IFACE_COUNTRY_UPDATE); 1298 if (hostapd_get_country(hapd, previous_country) < 0) 1299 previous_country[0] = '\0'; 1300 1301 os_memcpy(country, hapd->iconf->country, 3); 1302 country[3] = '\0'; 1303 if (hostapd_set_country(hapd, country) < 0) { 1304 wpa_printf(MSG_ERROR, "Failed to set country code"); 1305 return -1; 1306 } 1307 1308 wpa_printf(MSG_DEBUG, "Previous country code %s, new country code %s", 1309 previous_country, country); 1310 1311 if (os_strncmp(previous_country, country, 2) != 0) { 1312 wpa_printf(MSG_DEBUG, "Continue interface setup after channel list update"); 1313 iface->wait_channel_update = 1; 1314 eloop_register_timeout(5, 0, 1315 channel_list_update_timeout, 1316 iface, NULL); 1317 return 0; 1318 } 1319 } 1320 1321 return setup_interface2(iface); 1322} 1323 1324 1325static int setup_interface2(struct hostapd_iface *iface) 1326{ 1327 iface->wait_channel_update = 0; 1328 1329 if (hostapd_get_hw_features(iface)) { 1330 /* Not all drivers support this yet, so continue without hw 1331 * feature data. */ 1332 } else { 1333 int ret = hostapd_select_hw_mode(iface); 1334 if (ret < 0) { 1335 wpa_printf(MSG_ERROR, "Could not select hw_mode and " 1336 "channel. (%d)", ret); 1337 goto fail; 1338 } 1339 if (ret == 1) { 1340 wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback (ACS)"); 1341 return 0; 1342 } 1343 ret = hostapd_check_ht_capab(iface); 1344 if (ret < 0) 1345 goto fail; 1346 if (ret == 1) { 1347 wpa_printf(MSG_DEBUG, "Interface initialization will " 1348 "be completed in a callback"); 1349 return 0; 1350 } 1351 1352 if (iface->conf->ieee80211h) 1353 wpa_printf(MSG_DEBUG, "DFS support is enabled"); 1354 } 1355 return hostapd_setup_interface_complete(iface, 0); 1356 1357fail: 1358 hostapd_set_state(iface, HAPD_IFACE_DISABLED); 1359 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, AP_EVENT_DISABLED); 1360 if (iface->interfaces && iface->interfaces->terminate_on_error) 1361 eloop_terminate(); 1362 return -1; 1363} 1364 1365 1366/** 1367 * hostapd_setup_interface_complete - Complete interface setup 1368 * 1369 * This function is called when previous steps in the interface setup has been 1370 * completed. This can also start operations, e.g., DFS, that will require 1371 * additional processing before interface is ready to be enabled. Such 1372 * operations will call this function from eloop callbacks when finished. 1373 */ 1374int hostapd_setup_interface_complete(struct hostapd_iface *iface, int err) 1375{ 1376 struct hostapd_data *hapd = iface->bss[0]; 1377 size_t j; 1378 u8 *prev_addr; 1379 int delay_apply_cfg = 0; 1380 1381 if (err) 1382 goto fail; 1383 1384 wpa_printf(MSG_DEBUG, "Completing interface initialization"); 1385 if (iface->conf->channel) { 1386#ifdef NEED_AP_MLME 1387 int res; 1388#endif /* NEED_AP_MLME */ 1389 1390 iface->freq = hostapd_hw_get_freq(hapd, iface->conf->channel); 1391 wpa_printf(MSG_DEBUG, "Mode: %s Channel: %d " 1392 "Frequency: %d MHz", 1393 hostapd_hw_mode_txt(iface->conf->hw_mode), 1394 iface->conf->channel, iface->freq); 1395 1396#ifdef NEED_AP_MLME 1397 /* Handle DFS only if it is not offloaded to the driver */ 1398 if (!(iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD)) { 1399 /* Check DFS */ 1400 res = hostapd_handle_dfs(iface); 1401 if (res <= 0) { 1402 if (res < 0) 1403 goto fail; 1404 return res; 1405 } 1406 } 1407#endif /* NEED_AP_MLME */ 1408 1409#ifdef CONFIG_MESH 1410 if (iface->mconf != NULL) { 1411 wpa_printf(MSG_DEBUG, 1412 "%s: Mesh configuration will be applied while joining the mesh network", 1413 iface->bss[0]->conf->iface); 1414 delay_apply_cfg = 1; 1415 } 1416#endif /* CONFIG_MESH */ 1417 1418 if (!delay_apply_cfg && 1419 hostapd_set_freq(hapd, hapd->iconf->hw_mode, iface->freq, 1420 hapd->iconf->channel, 1421 hapd->iconf->ieee80211n, 1422 hapd->iconf->ieee80211ac, 1423 hapd->iconf->secondary_channel, 1424 hapd->iconf->vht_oper_chwidth, 1425 hapd->iconf->vht_oper_centr_freq_seg0_idx, 1426 hapd->iconf->vht_oper_centr_freq_seg1_idx)) { 1427 wpa_printf(MSG_ERROR, "Could not set channel for " 1428 "kernel driver"); 1429 goto fail; 1430 } 1431 } 1432 1433 if (iface->current_mode) { 1434 if (hostapd_prepare_rates(iface, iface->current_mode)) { 1435 wpa_printf(MSG_ERROR, "Failed to prepare rates " 1436 "table."); 1437 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 1438 HOSTAPD_LEVEL_WARNING, 1439 "Failed to prepare rates table."); 1440 goto fail; 1441 } 1442 } 1443 1444 if (hapd->iconf->rts_threshold > -1 && 1445 hostapd_set_rts(hapd, hapd->iconf->rts_threshold)) { 1446 wpa_printf(MSG_ERROR, "Could not set RTS threshold for " 1447 "kernel driver"); 1448 goto fail; 1449 } 1450 1451 if (hapd->iconf->fragm_threshold > -1 && 1452 hostapd_set_frag(hapd, hapd->iconf->fragm_threshold)) { 1453 wpa_printf(MSG_ERROR, "Could not set fragmentation threshold " 1454 "for kernel driver"); 1455 goto fail; 1456 } 1457 1458 prev_addr = hapd->own_addr; 1459 1460 for (j = 0; j < iface->num_bss; j++) { 1461 hapd = iface->bss[j]; 1462 if (j) 1463 os_memcpy(hapd->own_addr, prev_addr, ETH_ALEN); 1464 if (hostapd_setup_bss(hapd, j == 0)) { 1465 do { 1466 hapd = iface->bss[j]; 1467 hostapd_bss_deinit_no_free(hapd); 1468 hostapd_free_hapd_data(hapd); 1469 } while (j-- > 0); 1470 goto fail; 1471 } 1472 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0) 1473 prev_addr = hapd->own_addr; 1474 } 1475 hapd = iface->bss[0]; 1476 1477 hostapd_tx_queue_params(iface); 1478 1479 ap_list_init(iface); 1480 1481 hostapd_set_acl(hapd); 1482 1483 if (hostapd_driver_commit(hapd) < 0) { 1484 wpa_printf(MSG_ERROR, "%s: Failed to commit driver " 1485 "configuration", __func__); 1486 goto fail; 1487 } 1488 1489 /* 1490 * WPS UPnP module can be initialized only when the "upnp_iface" is up. 1491 * If "interface" and "upnp_iface" are the same (e.g., non-bridge 1492 * mode), the interface is up only after driver_commit, so initialize 1493 * WPS after driver_commit. 1494 */ 1495 for (j = 0; j < iface->num_bss; j++) { 1496 if (hostapd_init_wps_complete(iface->bss[j])) 1497 goto fail; 1498 } 1499 1500 hostapd_set_state(iface, HAPD_IFACE_ENABLED); 1501 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, AP_EVENT_ENABLED); 1502 if (hapd->setup_complete_cb) 1503 hapd->setup_complete_cb(hapd->setup_complete_cb_ctx); 1504 1505 wpa_printf(MSG_DEBUG, "%s: Setup of interface done.", 1506 iface->bss[0]->conf->iface); 1507 if (iface->interfaces && iface->interfaces->terminate_on_error > 0) 1508 iface->interfaces->terminate_on_error--; 1509 1510 return 0; 1511 1512fail: 1513 wpa_printf(MSG_ERROR, "Interface initialization failed"); 1514 hostapd_set_state(iface, HAPD_IFACE_DISABLED); 1515 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_EVENT_DISABLED); 1516 if (iface->interfaces && iface->interfaces->terminate_on_error) 1517 eloop_terminate(); 1518 return -1; 1519} 1520 1521 1522/** 1523 * hostapd_setup_interface - Setup of an interface 1524 * @iface: Pointer to interface data. 1525 * Returns: 0 on success, -1 on failure 1526 * 1527 * Initializes the driver interface, validates the configuration, 1528 * and sets driver parameters based on the configuration. 1529 * Flushes old stations, sets the channel, encryption, 1530 * beacons, and WDS links based on the configuration. 1531 * 1532 * If interface setup requires more time, e.g., to perform HT co-ex scans, ACS, 1533 * or DFS operations, this function returns 0 before such operations have been 1534 * completed. The pending operations are registered into eloop and will be 1535 * completed from eloop callbacks. Those callbacks end up calling 1536 * hostapd_setup_interface_complete() once setup has been completed. 1537 */ 1538int hostapd_setup_interface(struct hostapd_iface *iface) 1539{ 1540 int ret; 1541 1542 ret = setup_interface(iface); 1543 if (ret) { 1544 wpa_printf(MSG_ERROR, "%s: Unable to setup interface.", 1545 iface->bss[0]->conf->iface); 1546 return -1; 1547 } 1548 1549 return 0; 1550} 1551 1552 1553/** 1554 * hostapd_alloc_bss_data - Allocate and initialize per-BSS data 1555 * @hapd_iface: Pointer to interface data 1556 * @conf: Pointer to per-interface configuration 1557 * @bss: Pointer to per-BSS configuration for this BSS 1558 * Returns: Pointer to allocated BSS data 1559 * 1560 * This function is used to allocate per-BSS data structure. This data will be 1561 * freed after hostapd_cleanup() is called for it during interface 1562 * deinitialization. 1563 */ 1564struct hostapd_data * 1565hostapd_alloc_bss_data(struct hostapd_iface *hapd_iface, 1566 struct hostapd_config *conf, 1567 struct hostapd_bss_config *bss) 1568{ 1569 struct hostapd_data *hapd; 1570 1571 hapd = os_zalloc(sizeof(*hapd)); 1572 if (hapd == NULL) 1573 return NULL; 1574 1575 hapd->new_assoc_sta_cb = hostapd_new_assoc_sta; 1576 hapd->iconf = conf; 1577 hapd->conf = bss; 1578 hapd->iface = hapd_iface; 1579 hapd->driver = hapd->iconf->driver; 1580 hapd->ctrl_sock = -1; 1581 1582 return hapd; 1583} 1584 1585 1586static void hostapd_bss_deinit(struct hostapd_data *hapd) 1587{ 1588 wpa_printf(MSG_DEBUG, "%s: deinit bss %s", __func__, 1589 hapd->conf->iface); 1590 hostapd_bss_deinit_no_free(hapd); 1591 hostapd_cleanup(hapd); 1592} 1593 1594 1595void hostapd_interface_deinit(struct hostapd_iface *iface) 1596{ 1597 int j; 1598 1599 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1600 if (iface == NULL) 1601 return; 1602 1603#ifdef CONFIG_IEEE80211N 1604#ifdef NEED_AP_MLME 1605 hostapd_stop_setup_timers(iface); 1606 eloop_cancel_timeout(ap_ht2040_timeout, iface, NULL); 1607#endif /* NEED_AP_MLME */ 1608#endif /* CONFIG_IEEE80211N */ 1609 eloop_cancel_timeout(channel_list_update_timeout, iface, NULL); 1610 iface->wait_channel_update = 0; 1611 1612 for (j = iface->num_bss - 1; j >= 0; j--) 1613 hostapd_bss_deinit(iface->bss[j]); 1614} 1615 1616 1617void hostapd_interface_free(struct hostapd_iface *iface) 1618{ 1619 size_t j; 1620 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1621 for (j = 0; j < iface->num_bss; j++) { 1622 wpa_printf(MSG_DEBUG, "%s: free hapd %p", 1623 __func__, iface->bss[j]); 1624 os_free(iface->bss[j]); 1625 } 1626 hostapd_cleanup_iface(iface); 1627} 1628 1629 1630/** 1631 * hostapd_init - Allocate and initialize per-interface data 1632 * @config_file: Path to the configuration file 1633 * Returns: Pointer to the allocated interface data or %NULL on failure 1634 * 1635 * This function is used to allocate main data structures for per-interface 1636 * data. The allocated data buffer will be freed by calling 1637 * hostapd_cleanup_iface(). 1638 */ 1639struct hostapd_iface * hostapd_init(struct hapd_interfaces *interfaces, 1640 const char *config_file) 1641{ 1642 struct hostapd_iface *hapd_iface = NULL; 1643 struct hostapd_config *conf = NULL; 1644 struct hostapd_data *hapd; 1645 size_t i; 1646 1647 hapd_iface = os_zalloc(sizeof(*hapd_iface)); 1648 if (hapd_iface == NULL) 1649 goto fail; 1650 1651 hapd_iface->config_fname = os_strdup(config_file); 1652 if (hapd_iface->config_fname == NULL) 1653 goto fail; 1654 1655 conf = interfaces->config_read_cb(hapd_iface->config_fname); 1656 if (conf == NULL) 1657 goto fail; 1658 hapd_iface->conf = conf; 1659 1660 hapd_iface->num_bss = conf->num_bss; 1661 hapd_iface->bss = os_calloc(conf->num_bss, 1662 sizeof(struct hostapd_data *)); 1663 if (hapd_iface->bss == NULL) 1664 goto fail; 1665 1666 for (i = 0; i < conf->num_bss; i++) { 1667 hapd = hapd_iface->bss[i] = 1668 hostapd_alloc_bss_data(hapd_iface, conf, 1669 conf->bss[i]); 1670 if (hapd == NULL) 1671 goto fail; 1672 hapd->msg_ctx = hapd; 1673 } 1674 1675 return hapd_iface; 1676 1677fail: 1678 wpa_printf(MSG_ERROR, "Failed to set up interface with %s", 1679 config_file); 1680 if (conf) 1681 hostapd_config_free(conf); 1682 if (hapd_iface) { 1683 os_free(hapd_iface->config_fname); 1684 os_free(hapd_iface->bss); 1685 wpa_printf(MSG_DEBUG, "%s: free iface %p", 1686 __func__, hapd_iface); 1687 os_free(hapd_iface); 1688 } 1689 return NULL; 1690} 1691 1692 1693static int ifname_in_use(struct hapd_interfaces *interfaces, const char *ifname) 1694{ 1695 size_t i, j; 1696 1697 for (i = 0; i < interfaces->count; i++) { 1698 struct hostapd_iface *iface = interfaces->iface[i]; 1699 for (j = 0; j < iface->num_bss; j++) { 1700 struct hostapd_data *hapd = iface->bss[j]; 1701 if (os_strcmp(ifname, hapd->conf->iface) == 0) 1702 return 1; 1703 } 1704 } 1705 1706 return 0; 1707} 1708 1709 1710/** 1711 * hostapd_interface_init_bss - Read configuration file and init BSS data 1712 * 1713 * This function is used to parse configuration file for a BSS. This BSS is 1714 * added to an existing interface sharing the same radio (if any) or a new 1715 * interface is created if this is the first interface on a radio. This 1716 * allocate memory for the BSS. No actual driver operations are started. 1717 * 1718 * This is similar to hostapd_interface_init(), but for a case where the 1719 * configuration is used to add a single BSS instead of all BSSes for a radio. 1720 */ 1721struct hostapd_iface * 1722hostapd_interface_init_bss(struct hapd_interfaces *interfaces, const char *phy, 1723 const char *config_fname, int debug) 1724{ 1725 struct hostapd_iface *new_iface = NULL, *iface = NULL; 1726 struct hostapd_data *hapd; 1727 int k; 1728 size_t i, bss_idx; 1729 1730 if (!phy || !*phy) 1731 return NULL; 1732 1733 for (i = 0; i < interfaces->count; i++) { 1734 if (os_strcmp(interfaces->iface[i]->phy, phy) == 0) { 1735 iface = interfaces->iface[i]; 1736 break; 1737 } 1738 } 1739 1740 wpa_printf(MSG_INFO, "Configuration file: %s (phy %s)%s", 1741 config_fname, phy, iface ? "" : " --> new PHY"); 1742 if (iface) { 1743 struct hostapd_config *conf; 1744 struct hostapd_bss_config **tmp_conf; 1745 struct hostapd_data **tmp_bss; 1746 struct hostapd_bss_config *bss; 1747 const char *ifname; 1748 1749 /* Add new BSS to existing iface */ 1750 conf = interfaces->config_read_cb(config_fname); 1751 if (conf == NULL) 1752 return NULL; 1753 if (conf->num_bss > 1) { 1754 wpa_printf(MSG_ERROR, "Multiple BSSes specified in BSS-config"); 1755 hostapd_config_free(conf); 1756 return NULL; 1757 } 1758 1759 ifname = conf->bss[0]->iface; 1760 if (ifname[0] != '\0' && ifname_in_use(interfaces, ifname)) { 1761 wpa_printf(MSG_ERROR, 1762 "Interface name %s already in use", ifname); 1763 hostapd_config_free(conf); 1764 return NULL; 1765 } 1766 1767 tmp_conf = os_realloc_array( 1768 iface->conf->bss, iface->conf->num_bss + 1, 1769 sizeof(struct hostapd_bss_config *)); 1770 tmp_bss = os_realloc_array(iface->bss, iface->num_bss + 1, 1771 sizeof(struct hostapd_data *)); 1772 if (tmp_bss) 1773 iface->bss = tmp_bss; 1774 if (tmp_conf) { 1775 iface->conf->bss = tmp_conf; 1776 iface->conf->last_bss = tmp_conf[0]; 1777 } 1778 if (tmp_bss == NULL || tmp_conf == NULL) { 1779 hostapd_config_free(conf); 1780 return NULL; 1781 } 1782 bss = iface->conf->bss[iface->conf->num_bss] = conf->bss[0]; 1783 iface->conf->num_bss++; 1784 1785 hapd = hostapd_alloc_bss_data(iface, iface->conf, bss); 1786 if (hapd == NULL) { 1787 iface->conf->num_bss--; 1788 hostapd_config_free(conf); 1789 return NULL; 1790 } 1791 iface->conf->last_bss = bss; 1792 iface->bss[iface->num_bss] = hapd; 1793 hapd->msg_ctx = hapd; 1794 1795 bss_idx = iface->num_bss++; 1796 conf->num_bss--; 1797 conf->bss[0] = NULL; 1798 hostapd_config_free(conf); 1799 } else { 1800 /* Add a new iface with the first BSS */ 1801 new_iface = iface = hostapd_init(interfaces, config_fname); 1802 if (!iface) 1803 return NULL; 1804 os_strlcpy(iface->phy, phy, sizeof(iface->phy)); 1805 iface->interfaces = interfaces; 1806 bss_idx = 0; 1807 } 1808 1809 for (k = 0; k < debug; k++) { 1810 if (iface->bss[bss_idx]->conf->logger_stdout_level > 0) 1811 iface->bss[bss_idx]->conf->logger_stdout_level--; 1812 } 1813 1814 if (iface->conf->bss[bss_idx]->iface[0] == '\0' && 1815 !hostapd_drv_none(iface->bss[bss_idx])) { 1816 wpa_printf(MSG_ERROR, "Interface name not specified in %s", 1817 config_fname); 1818 if (new_iface) 1819 hostapd_interface_deinit_free(new_iface); 1820 return NULL; 1821 } 1822 1823 return iface; 1824} 1825 1826 1827void hostapd_interface_deinit_free(struct hostapd_iface *iface) 1828{ 1829 const struct wpa_driver_ops *driver; 1830 void *drv_priv; 1831 1832 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1833 if (iface == NULL) 1834 return; 1835 wpa_printf(MSG_DEBUG, "%s: num_bss=%u conf->num_bss=%u", 1836 __func__, (unsigned int) iface->num_bss, 1837 (unsigned int) iface->conf->num_bss); 1838 driver = iface->bss[0]->driver; 1839 drv_priv = iface->bss[0]->drv_priv; 1840 hostapd_interface_deinit(iface); 1841 wpa_printf(MSG_DEBUG, "%s: driver=%p drv_priv=%p -> hapd_deinit", 1842 __func__, driver, drv_priv); 1843 if (driver && driver->hapd_deinit && drv_priv) { 1844 driver->hapd_deinit(drv_priv); 1845 iface->bss[0]->drv_priv = NULL; 1846 } 1847 hostapd_interface_free(iface); 1848} 1849 1850 1851static void hostapd_deinit_driver(const struct wpa_driver_ops *driver, 1852 void *drv_priv, 1853 struct hostapd_iface *hapd_iface) 1854{ 1855 size_t j; 1856 1857 wpa_printf(MSG_DEBUG, "%s: driver=%p drv_priv=%p -> hapd_deinit", 1858 __func__, driver, drv_priv); 1859 if (driver && driver->hapd_deinit && drv_priv) { 1860 driver->hapd_deinit(drv_priv); 1861 for (j = 0; j < hapd_iface->num_bss; j++) { 1862 wpa_printf(MSG_DEBUG, "%s:bss[%d]->drv_priv=%p", 1863 __func__, (int) j, 1864 hapd_iface->bss[j]->drv_priv); 1865 if (hapd_iface->bss[j]->drv_priv == drv_priv) 1866 hapd_iface->bss[j]->drv_priv = NULL; 1867 } 1868 } 1869} 1870 1871 1872int hostapd_enable_iface(struct hostapd_iface *hapd_iface) 1873{ 1874 size_t j; 1875 1876 if (hapd_iface->bss[0]->drv_priv != NULL) { 1877 wpa_printf(MSG_ERROR, "Interface %s already enabled", 1878 hapd_iface->conf->bss[0]->iface); 1879 return -1; 1880 } 1881 1882 wpa_printf(MSG_DEBUG, "Enable interface %s", 1883 hapd_iface->conf->bss[0]->iface); 1884 1885 for (j = 0; j < hapd_iface->num_bss; j++) 1886 hostapd_set_security_params(hapd_iface->conf->bss[j], 1); 1887 if (hostapd_config_check(hapd_iface->conf, 1) < 0) { 1888 wpa_printf(MSG_INFO, "Invalid configuration - cannot enable"); 1889 return -1; 1890 } 1891 1892 if (hapd_iface->interfaces == NULL || 1893 hapd_iface->interfaces->driver_init == NULL || 1894 hapd_iface->interfaces->driver_init(hapd_iface)) 1895 return -1; 1896 1897 if (hostapd_setup_interface(hapd_iface)) { 1898 hostapd_deinit_driver(hapd_iface->bss[0]->driver, 1899 hapd_iface->bss[0]->drv_priv, 1900 hapd_iface); 1901 return -1; 1902 } 1903 1904 return 0; 1905} 1906 1907 1908int hostapd_reload_iface(struct hostapd_iface *hapd_iface) 1909{ 1910 size_t j; 1911 1912 wpa_printf(MSG_DEBUG, "Reload interface %s", 1913 hapd_iface->conf->bss[0]->iface); 1914 for (j = 0; j < hapd_iface->num_bss; j++) 1915 hostapd_set_security_params(hapd_iface->conf->bss[j], 1); 1916 if (hostapd_config_check(hapd_iface->conf, 1) < 0) { 1917 wpa_printf(MSG_ERROR, "Updated configuration is invalid"); 1918 return -1; 1919 } 1920 hostapd_clear_old(hapd_iface); 1921 for (j = 0; j < hapd_iface->num_bss; j++) 1922 hostapd_reload_bss(hapd_iface->bss[j]); 1923 1924 return 0; 1925} 1926 1927 1928int hostapd_disable_iface(struct hostapd_iface *hapd_iface) 1929{ 1930 size_t j; 1931 const struct wpa_driver_ops *driver; 1932 void *drv_priv; 1933 1934 if (hapd_iface == NULL) 1935 return -1; 1936 1937 if (hapd_iface->bss[0]->drv_priv == NULL) { 1938 wpa_printf(MSG_INFO, "Interface %s already disabled", 1939 hapd_iface->conf->bss[0]->iface); 1940 return -1; 1941 } 1942 1943 wpa_msg(hapd_iface->bss[0]->msg_ctx, MSG_INFO, AP_EVENT_DISABLED); 1944 driver = hapd_iface->bss[0]->driver; 1945 drv_priv = hapd_iface->bss[0]->drv_priv; 1946 1947 hapd_iface->driver_ap_teardown = 1948 !!(hapd_iface->drv_flags & 1949 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 1950 1951 /* same as hostapd_interface_deinit without deinitializing ctrl-iface */ 1952 for (j = 0; j < hapd_iface->num_bss; j++) { 1953 struct hostapd_data *hapd = hapd_iface->bss[j]; 1954 hostapd_bss_deinit_no_free(hapd); 1955 hostapd_free_hapd_data(hapd); 1956 } 1957 1958 hostapd_deinit_driver(driver, drv_priv, hapd_iface); 1959 1960 /* From hostapd_cleanup_iface: These were initialized in 1961 * hostapd_setup_interface and hostapd_setup_interface_complete 1962 */ 1963 hostapd_cleanup_iface_partial(hapd_iface); 1964 1965 wpa_printf(MSG_DEBUG, "Interface %s disabled", 1966 hapd_iface->bss[0]->conf->iface); 1967 hostapd_set_state(hapd_iface, HAPD_IFACE_DISABLED); 1968 return 0; 1969} 1970 1971 1972static struct hostapd_iface * 1973hostapd_iface_alloc(struct hapd_interfaces *interfaces) 1974{ 1975 struct hostapd_iface **iface, *hapd_iface; 1976 1977 iface = os_realloc_array(interfaces->iface, interfaces->count + 1, 1978 sizeof(struct hostapd_iface *)); 1979 if (iface == NULL) 1980 return NULL; 1981 interfaces->iface = iface; 1982 hapd_iface = interfaces->iface[interfaces->count] = 1983 os_zalloc(sizeof(*hapd_iface)); 1984 if (hapd_iface == NULL) { 1985 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 1986 "the interface", __func__); 1987 return NULL; 1988 } 1989 interfaces->count++; 1990 hapd_iface->interfaces = interfaces; 1991 1992 return hapd_iface; 1993} 1994 1995 1996static struct hostapd_config * 1997hostapd_config_alloc(struct hapd_interfaces *interfaces, const char *ifname, 1998 const char *ctrl_iface) 1999{ 2000 struct hostapd_bss_config *bss; 2001 struct hostapd_config *conf; 2002 2003 /* Allocates memory for bss and conf */ 2004 conf = hostapd_config_defaults(); 2005 if (conf == NULL) { 2006 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 2007 "configuration", __func__); 2008 return NULL; 2009 } 2010 2011 conf->driver = wpa_drivers[0]; 2012 if (conf->driver == NULL) { 2013 wpa_printf(MSG_ERROR, "No driver wrappers registered!"); 2014 hostapd_config_free(conf); 2015 return NULL; 2016 } 2017 2018 bss = conf->last_bss = conf->bss[0]; 2019 2020 os_strlcpy(bss->iface, ifname, sizeof(bss->iface)); 2021 bss->ctrl_interface = os_strdup(ctrl_iface); 2022 if (bss->ctrl_interface == NULL) { 2023 hostapd_config_free(conf); 2024 return NULL; 2025 } 2026 2027 /* Reading configuration file skipped, will be done in SET! 2028 * From reading the configuration till the end has to be done in 2029 * SET 2030 */ 2031 return conf; 2032} 2033 2034 2035static int hostapd_data_alloc(struct hostapd_iface *hapd_iface, 2036 struct hostapd_config *conf) 2037{ 2038 size_t i; 2039 struct hostapd_data *hapd; 2040 2041 hapd_iface->bss = os_calloc(conf->num_bss, 2042 sizeof(struct hostapd_data *)); 2043 if (hapd_iface->bss == NULL) 2044 return -1; 2045 2046 for (i = 0; i < conf->num_bss; i++) { 2047 hapd = hapd_iface->bss[i] = 2048 hostapd_alloc_bss_data(hapd_iface, conf, conf->bss[i]); 2049 if (hapd == NULL) { 2050 while (i > 0) { 2051 i--; 2052 os_free(hapd_iface->bss[i]); 2053 hapd_iface->bss[i] = NULL; 2054 } 2055 os_free(hapd_iface->bss); 2056 hapd_iface->bss = NULL; 2057 return -1; 2058 } 2059 hapd->msg_ctx = hapd; 2060 } 2061 2062 hapd_iface->conf = conf; 2063 hapd_iface->num_bss = conf->num_bss; 2064 2065 return 0; 2066} 2067 2068 2069int hostapd_add_iface(struct hapd_interfaces *interfaces, char *buf) 2070{ 2071 struct hostapd_config *conf = NULL; 2072 struct hostapd_iface *hapd_iface = NULL, *new_iface = NULL; 2073 struct hostapd_data *hapd; 2074 char *ptr; 2075 size_t i, j; 2076 const char *conf_file = NULL, *phy_name = NULL; 2077 2078 if (os_strncmp(buf, "bss_config=", 11) == 0) { 2079 char *pos; 2080 phy_name = buf + 11; 2081 pos = os_strchr(phy_name, ':'); 2082 if (!pos) 2083 return -1; 2084 *pos++ = '\0'; 2085 conf_file = pos; 2086 if (!os_strlen(conf_file)) 2087 return -1; 2088 2089 hapd_iface = hostapd_interface_init_bss(interfaces, phy_name, 2090 conf_file, 0); 2091 if (!hapd_iface) 2092 return -1; 2093 for (j = 0; j < interfaces->count; j++) { 2094 if (interfaces->iface[j] == hapd_iface) 2095 break; 2096 } 2097 if (j == interfaces->count) { 2098 struct hostapd_iface **tmp; 2099 tmp = os_realloc_array(interfaces->iface, 2100 interfaces->count + 1, 2101 sizeof(struct hostapd_iface *)); 2102 if (!tmp) { 2103 hostapd_interface_deinit_free(hapd_iface); 2104 return -1; 2105 } 2106 interfaces->iface = tmp; 2107 interfaces->iface[interfaces->count++] = hapd_iface; 2108 new_iface = hapd_iface; 2109 } 2110 2111 if (new_iface) { 2112 if (interfaces->driver_init(hapd_iface)) 2113 goto fail; 2114 2115 if (hostapd_setup_interface(hapd_iface)) { 2116 hostapd_deinit_driver( 2117 hapd_iface->bss[0]->driver, 2118 hapd_iface->bss[0]->drv_priv, 2119 hapd_iface); 2120 goto fail; 2121 } 2122 } else { 2123 /* Assign new BSS with bss[0]'s driver info */ 2124 hapd = hapd_iface->bss[hapd_iface->num_bss - 1]; 2125 hapd->driver = hapd_iface->bss[0]->driver; 2126 hapd->drv_priv = hapd_iface->bss[0]->drv_priv; 2127 os_memcpy(hapd->own_addr, hapd_iface->bss[0]->own_addr, 2128 ETH_ALEN); 2129 2130 if (start_ctrl_iface_bss(hapd) < 0 || 2131 (hapd_iface->state == HAPD_IFACE_ENABLED && 2132 hostapd_setup_bss(hapd, -1))) { 2133 hostapd_cleanup(hapd); 2134 hapd_iface->bss[hapd_iface->num_bss - 1] = NULL; 2135 hapd_iface->conf->num_bss--; 2136 hapd_iface->num_bss--; 2137 wpa_printf(MSG_DEBUG, "%s: free hapd %p %s", 2138 __func__, hapd, hapd->conf->iface); 2139 hostapd_config_free_bss(hapd->conf); 2140 hapd->conf = NULL; 2141 os_free(hapd); 2142 return -1; 2143 } 2144 } 2145 return 0; 2146 } 2147 2148 ptr = os_strchr(buf, ' '); 2149 if (ptr == NULL) 2150 return -1; 2151 *ptr++ = '\0'; 2152 2153 if (os_strncmp(ptr, "config=", 7) == 0) 2154 conf_file = ptr + 7; 2155 2156 for (i = 0; i < interfaces->count; i++) { 2157 if (!os_strcmp(interfaces->iface[i]->conf->bss[0]->iface, 2158 buf)) { 2159 wpa_printf(MSG_INFO, "Cannot add interface - it " 2160 "already exists"); 2161 return -1; 2162 } 2163 } 2164 2165 hapd_iface = hostapd_iface_alloc(interfaces); 2166 if (hapd_iface == NULL) { 2167 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2168 "for interface", __func__); 2169 goto fail; 2170 } 2171 new_iface = hapd_iface; 2172 2173 if (conf_file && interfaces->config_read_cb) { 2174 conf = interfaces->config_read_cb(conf_file); 2175 if (conf && conf->bss) 2176 os_strlcpy(conf->bss[0]->iface, buf, 2177 sizeof(conf->bss[0]->iface)); 2178 } else 2179 conf = hostapd_config_alloc(interfaces, buf, ptr); 2180 if (conf == NULL || conf->bss == NULL) { 2181 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2182 "for configuration", __func__); 2183 goto fail; 2184 } 2185 2186 if (hostapd_data_alloc(hapd_iface, conf) < 0) { 2187 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2188 "for hostapd", __func__); 2189 goto fail; 2190 } 2191 conf = NULL; 2192 2193 if (start_ctrl_iface(hapd_iface) < 0) 2194 goto fail; 2195 2196 wpa_printf(MSG_INFO, "Add interface '%s'", 2197 hapd_iface->conf->bss[0]->iface); 2198 2199 return 0; 2200 2201fail: 2202 if (conf) 2203 hostapd_config_free(conf); 2204 if (hapd_iface) { 2205 if (hapd_iface->bss) { 2206 for (i = 0; i < hapd_iface->num_bss; i++) { 2207 hapd = hapd_iface->bss[i]; 2208 if (!hapd) 2209 continue; 2210 if (hapd_iface->interfaces && 2211 hapd_iface->interfaces->ctrl_iface_deinit) 2212 hapd_iface->interfaces-> 2213 ctrl_iface_deinit(hapd); 2214 wpa_printf(MSG_DEBUG, "%s: free hapd %p (%s)", 2215 __func__, hapd_iface->bss[i], 2216 hapd->conf->iface); 2217 hostapd_cleanup(hapd); 2218 os_free(hapd); 2219 hapd_iface->bss[i] = NULL; 2220 } 2221 os_free(hapd_iface->bss); 2222 hapd_iface->bss = NULL; 2223 } 2224 if (new_iface) { 2225 interfaces->count--; 2226 interfaces->iface[interfaces->count] = NULL; 2227 } 2228 hostapd_cleanup_iface(hapd_iface); 2229 } 2230 return -1; 2231} 2232 2233 2234static int hostapd_remove_bss(struct hostapd_iface *iface, unsigned int idx) 2235{ 2236 size_t i; 2237 2238 wpa_printf(MSG_INFO, "Remove BSS '%s'", iface->conf->bss[idx]->iface); 2239 2240 /* Remove hostapd_data only if it has already been initialized */ 2241 if (idx < iface->num_bss) { 2242 struct hostapd_data *hapd = iface->bss[idx]; 2243 2244 hostapd_bss_deinit(hapd); 2245 wpa_printf(MSG_DEBUG, "%s: free hapd %p (%s)", 2246 __func__, hapd, hapd->conf->iface); 2247 hostapd_config_free_bss(hapd->conf); 2248 hapd->conf = NULL; 2249 os_free(hapd); 2250 2251 iface->num_bss--; 2252 2253 for (i = idx; i < iface->num_bss; i++) 2254 iface->bss[i] = iface->bss[i + 1]; 2255 } else { 2256 hostapd_config_free_bss(iface->conf->bss[idx]); 2257 iface->conf->bss[idx] = NULL; 2258 } 2259 2260 iface->conf->num_bss--; 2261 for (i = idx; i < iface->conf->num_bss; i++) 2262 iface->conf->bss[i] = iface->conf->bss[i + 1]; 2263 2264 return 0; 2265} 2266 2267 2268int hostapd_remove_iface(struct hapd_interfaces *interfaces, char *buf) 2269{ 2270 struct hostapd_iface *hapd_iface; 2271 size_t i, j, k = 0; 2272 2273 for (i = 0; i < interfaces->count; i++) { 2274 hapd_iface = interfaces->iface[i]; 2275 if (hapd_iface == NULL) 2276 return -1; 2277 if (!os_strcmp(hapd_iface->conf->bss[0]->iface, buf)) { 2278 wpa_printf(MSG_INFO, "Remove interface '%s'", buf); 2279 hapd_iface->driver_ap_teardown = 2280 !!(hapd_iface->drv_flags & 2281 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 2282 2283 hostapd_interface_deinit_free(hapd_iface); 2284 k = i; 2285 while (k < (interfaces->count - 1)) { 2286 interfaces->iface[k] = 2287 interfaces->iface[k + 1]; 2288 k++; 2289 } 2290 interfaces->count--; 2291 return 0; 2292 } 2293 2294 for (j = 0; j < hapd_iface->conf->num_bss; j++) { 2295 if (!os_strcmp(hapd_iface->conf->bss[j]->iface, buf)) { 2296 hapd_iface->driver_ap_teardown = 2297 !(hapd_iface->drv_flags & 2298 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 2299 return hostapd_remove_bss(hapd_iface, j); 2300 } 2301 } 2302 } 2303 return -1; 2304} 2305 2306 2307/** 2308 * hostapd_new_assoc_sta - Notify that a new station associated with the AP 2309 * @hapd: Pointer to BSS data 2310 * @sta: Pointer to the associated STA data 2311 * @reassoc: 1 to indicate this was a re-association; 0 = first association 2312 * 2313 * This function will be called whenever a station associates with the AP. It 2314 * can be called from ieee802_11.c for drivers that export MLME to hostapd and 2315 * from drv_callbacks.c based on driver events for drivers that take care of 2316 * management frames (IEEE 802.11 authentication and association) internally. 2317 */ 2318void hostapd_new_assoc_sta(struct hostapd_data *hapd, struct sta_info *sta, 2319 int reassoc) 2320{ 2321 if (hapd->tkip_countermeasures) { 2322 hostapd_drv_sta_deauth(hapd, sta->addr, 2323 WLAN_REASON_MICHAEL_MIC_FAILURE); 2324 return; 2325 } 2326 2327 hostapd_prune_associations(hapd, sta->addr); 2328 2329 /* IEEE 802.11F (IAPP) */ 2330 if (hapd->conf->ieee802_11f) 2331 iapp_new_station(hapd->iapp, sta); 2332 2333#ifdef CONFIG_P2P 2334 if (sta->p2p_ie == NULL && !sta->no_p2p_set) { 2335 sta->no_p2p_set = 1; 2336 hapd->num_sta_no_p2p++; 2337 if (hapd->num_sta_no_p2p == 1) 2338 hostapd_p2p_non_p2p_sta_connected(hapd); 2339 } 2340#endif /* CONFIG_P2P */ 2341 2342 /* Start accounting here, if IEEE 802.1X and WPA are not used. 2343 * IEEE 802.1X/WPA code will start accounting after the station has 2344 * been authorized. */ 2345 if (!hapd->conf->ieee802_1x && !hapd->conf->wpa && !hapd->conf->osen) { 2346 ap_sta_set_authorized(hapd, sta, 1); 2347 os_get_reltime(&sta->connected_time); 2348 accounting_sta_start(hapd, sta); 2349 } 2350 2351 /* Start IEEE 802.1X authentication process for new stations */ 2352 ieee802_1x_new_station(hapd, sta); 2353 if (reassoc) { 2354 if (sta->auth_alg != WLAN_AUTH_FT && 2355 !(sta->flags & (WLAN_STA_WPS | WLAN_STA_MAYBE_WPS))) 2356 wpa_auth_sm_event(sta->wpa_sm, WPA_REAUTH); 2357 } else 2358 wpa_auth_sta_associated(hapd->wpa_auth, sta->wpa_sm); 2359 2360 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER)) { 2361 wpa_printf(MSG_DEBUG, "%s: reschedule ap_handle_timer timeout " 2362 "for " MACSTR " (%d seconds - ap_max_inactivity)", 2363 __func__, MAC2STR(sta->addr), 2364 hapd->conf->ap_max_inactivity); 2365 eloop_cancel_timeout(ap_handle_timer, hapd, sta); 2366 eloop_register_timeout(hapd->conf->ap_max_inactivity, 0, 2367 ap_handle_timer, hapd, sta); 2368 } 2369} 2370 2371 2372const char * hostapd_state_text(enum hostapd_iface_state s) 2373{ 2374 switch (s) { 2375 case HAPD_IFACE_UNINITIALIZED: 2376 return "UNINITIALIZED"; 2377 case HAPD_IFACE_DISABLED: 2378 return "DISABLED"; 2379 case HAPD_IFACE_COUNTRY_UPDATE: 2380 return "COUNTRY_UPDATE"; 2381 case HAPD_IFACE_ACS: 2382 return "ACS"; 2383 case HAPD_IFACE_HT_SCAN: 2384 return "HT_SCAN"; 2385 case HAPD_IFACE_DFS: 2386 return "DFS"; 2387 case HAPD_IFACE_ENABLED: 2388 return "ENABLED"; 2389 } 2390 2391 return "UNKNOWN"; 2392} 2393 2394 2395void hostapd_set_state(struct hostapd_iface *iface, enum hostapd_iface_state s) 2396{ 2397 wpa_printf(MSG_INFO, "%s: interface state %s->%s", 2398 iface->conf->bss[0]->iface, hostapd_state_text(iface->state), 2399 hostapd_state_text(s)); 2400 iface->state = s; 2401} 2402 2403 2404#ifdef NEED_AP_MLME 2405 2406static void free_beacon_data(struct beacon_data *beacon) 2407{ 2408 os_free(beacon->head); 2409 beacon->head = NULL; 2410 os_free(beacon->tail); 2411 beacon->tail = NULL; 2412 os_free(beacon->probe_resp); 2413 beacon->probe_resp = NULL; 2414 os_free(beacon->beacon_ies); 2415 beacon->beacon_ies = NULL; 2416 os_free(beacon->proberesp_ies); 2417 beacon->proberesp_ies = NULL; 2418 os_free(beacon->assocresp_ies); 2419 beacon->assocresp_ies = NULL; 2420} 2421 2422 2423static int hostapd_build_beacon_data(struct hostapd_data *hapd, 2424 struct beacon_data *beacon) 2425{ 2426 struct wpabuf *beacon_extra, *proberesp_extra, *assocresp_extra; 2427 struct wpa_driver_ap_params params; 2428 int ret; 2429 2430 os_memset(beacon, 0, sizeof(*beacon)); 2431 ret = ieee802_11_build_ap_params(hapd, ¶ms); 2432 if (ret < 0) 2433 return ret; 2434 2435 ret = hostapd_build_ap_extra_ies(hapd, &beacon_extra, 2436 &proberesp_extra, 2437 &assocresp_extra); 2438 if (ret) 2439 goto free_ap_params; 2440 2441 ret = -1; 2442 beacon->head = os_malloc(params.head_len); 2443 if (!beacon->head) 2444 goto free_ap_extra_ies; 2445 2446 os_memcpy(beacon->head, params.head, params.head_len); 2447 beacon->head_len = params.head_len; 2448 2449 beacon->tail = os_malloc(params.tail_len); 2450 if (!beacon->tail) 2451 goto free_beacon; 2452 2453 os_memcpy(beacon->tail, params.tail, params.tail_len); 2454 beacon->tail_len = params.tail_len; 2455 2456 if (params.proberesp != NULL) { 2457 beacon->probe_resp = os_malloc(params.proberesp_len); 2458 if (!beacon->probe_resp) 2459 goto free_beacon; 2460 2461 os_memcpy(beacon->probe_resp, params.proberesp, 2462 params.proberesp_len); 2463 beacon->probe_resp_len = params.proberesp_len; 2464 } 2465 2466 /* copy the extra ies */ 2467 if (beacon_extra) { 2468 beacon->beacon_ies = os_malloc(wpabuf_len(beacon_extra)); 2469 if (!beacon->beacon_ies) 2470 goto free_beacon; 2471 2472 os_memcpy(beacon->beacon_ies, 2473 beacon_extra->buf, wpabuf_len(beacon_extra)); 2474 beacon->beacon_ies_len = wpabuf_len(beacon_extra); 2475 } 2476 2477 if (proberesp_extra) { 2478 beacon->proberesp_ies = 2479 os_malloc(wpabuf_len(proberesp_extra)); 2480 if (!beacon->proberesp_ies) 2481 goto free_beacon; 2482 2483 os_memcpy(beacon->proberesp_ies, proberesp_extra->buf, 2484 wpabuf_len(proberesp_extra)); 2485 beacon->proberesp_ies_len = wpabuf_len(proberesp_extra); 2486 } 2487 2488 if (assocresp_extra) { 2489 beacon->assocresp_ies = 2490 os_malloc(wpabuf_len(assocresp_extra)); 2491 if (!beacon->assocresp_ies) 2492 goto free_beacon; 2493 2494 os_memcpy(beacon->assocresp_ies, assocresp_extra->buf, 2495 wpabuf_len(assocresp_extra)); 2496 beacon->assocresp_ies_len = wpabuf_len(assocresp_extra); 2497 } 2498 2499 ret = 0; 2500free_beacon: 2501 /* if the function fails, the caller should not free beacon data */ 2502 if (ret) 2503 free_beacon_data(beacon); 2504 2505free_ap_extra_ies: 2506 hostapd_free_ap_extra_ies(hapd, beacon_extra, proberesp_extra, 2507 assocresp_extra); 2508free_ap_params: 2509 ieee802_11_free_ap_params(¶ms); 2510 return ret; 2511} 2512 2513 2514/* 2515 * TODO: This flow currently supports only changing frequency within the 2516 * same hw_mode. Any other changes to MAC parameters or provided settings (even 2517 * width) are not supported. 2518 */ 2519static int hostapd_change_config_freq(struct hostapd_data *hapd, 2520 struct hostapd_config *conf, 2521 struct hostapd_freq_params *params, 2522 struct hostapd_freq_params *old_params) 2523{ 2524 int channel; 2525 2526 if (!params->channel) { 2527 /* check if the new channel is supported by hw */ 2528 params->channel = hostapd_hw_get_channel(hapd, params->freq); 2529 } 2530 2531 channel = params->channel; 2532 if (!channel) 2533 return -1; 2534 2535 /* if a pointer to old_params is provided we save previous state */ 2536 if (old_params) { 2537 old_params->channel = conf->channel; 2538 old_params->ht_enabled = conf->ieee80211n; 2539 old_params->sec_channel_offset = conf->secondary_channel; 2540 } 2541 2542 conf->channel = channel; 2543 conf->ieee80211n = params->ht_enabled; 2544 conf->secondary_channel = params->sec_channel_offset; 2545 2546 /* TODO: maybe call here hostapd_config_check here? */ 2547 2548 return 0; 2549} 2550 2551 2552static int hostapd_fill_csa_settings(struct hostapd_data *hapd, 2553 struct csa_settings *settings) 2554{ 2555 struct hostapd_iface *iface = hapd->iface; 2556 struct hostapd_freq_params old_freq; 2557 int ret; 2558 2559 os_memset(&old_freq, 0, sizeof(old_freq)); 2560 if (!iface || !iface->freq || hapd->csa_in_progress) 2561 return -1; 2562 2563 ret = hostapd_change_config_freq(iface->bss[0], iface->conf, 2564 &settings->freq_params, 2565 &old_freq); 2566 if (ret) 2567 return ret; 2568 2569 ret = hostapd_build_beacon_data(hapd, &settings->beacon_after); 2570 2571 /* change back the configuration */ 2572 hostapd_change_config_freq(iface->bss[0], iface->conf, 2573 &old_freq, NULL); 2574 2575 if (ret) 2576 return ret; 2577 2578 /* set channel switch parameters for csa ie */ 2579 hapd->cs_freq_params = settings->freq_params; 2580 hapd->cs_count = settings->cs_count; 2581 hapd->cs_block_tx = settings->block_tx; 2582 2583 ret = hostapd_build_beacon_data(hapd, &settings->beacon_csa); 2584 if (ret) { 2585 free_beacon_data(&settings->beacon_after); 2586 return ret; 2587 } 2588 2589 settings->counter_offset_beacon = hapd->cs_c_off_beacon; 2590 settings->counter_offset_presp = hapd->cs_c_off_proberesp; 2591 2592 return 0; 2593} 2594 2595 2596void hostapd_cleanup_cs_params(struct hostapd_data *hapd) 2597{ 2598 os_memset(&hapd->cs_freq_params, 0, sizeof(hapd->cs_freq_params)); 2599 hapd->cs_count = 0; 2600 hapd->cs_block_tx = 0; 2601 hapd->cs_c_off_beacon = 0; 2602 hapd->cs_c_off_proberesp = 0; 2603 hapd->csa_in_progress = 0; 2604} 2605 2606 2607int hostapd_switch_channel(struct hostapd_data *hapd, 2608 struct csa_settings *settings) 2609{ 2610 int ret; 2611 2612 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_AP_CSA)) { 2613 wpa_printf(MSG_INFO, "CSA is not supported"); 2614 return -1; 2615 } 2616 2617 ret = hostapd_fill_csa_settings(hapd, settings); 2618 if (ret) 2619 return ret; 2620 2621 ret = hostapd_drv_switch_channel(hapd, settings); 2622 free_beacon_data(&settings->beacon_csa); 2623 free_beacon_data(&settings->beacon_after); 2624 2625 if (ret) { 2626 /* if we failed, clean cs parameters */ 2627 hostapd_cleanup_cs_params(hapd); 2628 return ret; 2629 } 2630 2631 hapd->csa_in_progress = 1; 2632 return 0; 2633} 2634 2635 2636void 2637hostapd_switch_channel_fallback(struct hostapd_iface *iface, 2638 const struct hostapd_freq_params *freq_params) 2639{ 2640 int vht_seg0_idx = 0, vht_seg1_idx = 0, vht_bw = VHT_CHANWIDTH_USE_HT; 2641 unsigned int i; 2642 2643 wpa_printf(MSG_DEBUG, "Restarting all CSA-related BSSes"); 2644 2645 if (freq_params->center_freq1) 2646 vht_seg0_idx = 36 + (freq_params->center_freq1 - 5180) / 5; 2647 if (freq_params->center_freq2) 2648 vht_seg1_idx = 36 + (freq_params->center_freq2 - 5180) / 5; 2649 2650 switch (freq_params->bandwidth) { 2651 case 0: 2652 case 20: 2653 case 40: 2654 vht_bw = VHT_CHANWIDTH_USE_HT; 2655 break; 2656 case 80: 2657 if (freq_params->center_freq2) 2658 vht_bw = VHT_CHANWIDTH_80P80MHZ; 2659 else 2660 vht_bw = VHT_CHANWIDTH_80MHZ; 2661 break; 2662 case 160: 2663 vht_bw = VHT_CHANWIDTH_160MHZ; 2664 break; 2665 default: 2666 wpa_printf(MSG_WARNING, "Unknown CSA bandwidth: %d", 2667 freq_params->bandwidth); 2668 break; 2669 } 2670 2671 iface->freq = freq_params->freq; 2672 iface->conf->channel = freq_params->channel; 2673 iface->conf->secondary_channel = freq_params->sec_channel_offset; 2674 iface->conf->vht_oper_centr_freq_seg0_idx = vht_seg0_idx; 2675 iface->conf->vht_oper_centr_freq_seg1_idx = vht_seg1_idx; 2676 iface->conf->vht_oper_chwidth = vht_bw; 2677 iface->conf->ieee80211n = freq_params->ht_enabled; 2678 iface->conf->ieee80211ac = freq_params->vht_enabled; 2679 2680 /* 2681 * cs_params must not be cleared earlier because the freq_params 2682 * argument may actually point to one of these. 2683 */ 2684 for (i = 0; i < iface->num_bss; i++) 2685 hostapd_cleanup_cs_params(iface->bss[i]); 2686 2687 hostapd_disable_iface(iface); 2688 hostapd_enable_iface(iface); 2689} 2690 2691#endif /* NEED_AP_MLME */ 2692