hostapd.c revision 203eadb9eda41a1dde4a583edb4684319e3f399e
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 int res_dfs_offload = 0; 1381 1382 if (err) 1383 goto fail; 1384 1385 wpa_printf(MSG_DEBUG, "Completing interface initialization"); 1386 if (iface->conf->channel) { 1387#ifdef NEED_AP_MLME 1388 int res; 1389#endif /* NEED_AP_MLME */ 1390 1391 iface->freq = hostapd_hw_get_freq(hapd, iface->conf->channel); 1392 wpa_printf(MSG_DEBUG, "Mode: %s Channel: %d " 1393 "Frequency: %d MHz", 1394 hostapd_hw_mode_txt(iface->conf->hw_mode), 1395 iface->conf->channel, iface->freq); 1396 1397#ifdef NEED_AP_MLME 1398 /* Handle DFS only if it is not offloaded to the driver */ 1399 if (!(iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD)) { 1400 /* Check DFS */ 1401 res = hostapd_handle_dfs(iface); 1402 if (res <= 0) { 1403 if (res < 0) 1404 goto fail; 1405 return res; 1406 } 1407 } else { 1408 /* If DFS is offloaded to the driver */ 1409 res_dfs_offload = hostapd_handle_dfs_offload(iface); 1410 if (res_dfs_offload <= 0) { 1411 if (res_dfs_offload < 0) 1412 goto fail; 1413 } else { 1414 wpa_printf(MSG_DEBUG, 1415 "Proceed with AP/channel setup"); 1416 /* 1417 * If this is a DFS channel, move to completing 1418 * AP setup. 1419 */ 1420 if (res_dfs_offload == 1) 1421 goto dfs_offload; 1422 /* Otherwise fall through. */ 1423 } 1424 } 1425#endif /* NEED_AP_MLME */ 1426 1427#ifdef CONFIG_MESH 1428 if (iface->mconf != NULL) { 1429 wpa_printf(MSG_DEBUG, 1430 "%s: Mesh configuration will be applied while joining the mesh network", 1431 iface->bss[0]->conf->iface); 1432 delay_apply_cfg = 1; 1433 } 1434#endif /* CONFIG_MESH */ 1435 1436 if (!delay_apply_cfg && 1437 hostapd_set_freq(hapd, hapd->iconf->hw_mode, iface->freq, 1438 hapd->iconf->channel, 1439 hapd->iconf->ieee80211n, 1440 hapd->iconf->ieee80211ac, 1441 hapd->iconf->secondary_channel, 1442 hapd->iconf->vht_oper_chwidth, 1443 hapd->iconf->vht_oper_centr_freq_seg0_idx, 1444 hapd->iconf->vht_oper_centr_freq_seg1_idx)) { 1445 wpa_printf(MSG_ERROR, "Could not set channel for " 1446 "kernel driver"); 1447 goto fail; 1448 } 1449 } 1450 1451 if (iface->current_mode) { 1452 if (hostapd_prepare_rates(iface, iface->current_mode)) { 1453 wpa_printf(MSG_ERROR, "Failed to prepare rates " 1454 "table."); 1455 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 1456 HOSTAPD_LEVEL_WARNING, 1457 "Failed to prepare rates table."); 1458 goto fail; 1459 } 1460 } 1461 1462 if (hapd->iconf->rts_threshold > -1 && 1463 hostapd_set_rts(hapd, hapd->iconf->rts_threshold)) { 1464 wpa_printf(MSG_ERROR, "Could not set RTS threshold for " 1465 "kernel driver"); 1466 goto fail; 1467 } 1468 1469 if (hapd->iconf->fragm_threshold > -1 && 1470 hostapd_set_frag(hapd, hapd->iconf->fragm_threshold)) { 1471 wpa_printf(MSG_ERROR, "Could not set fragmentation threshold " 1472 "for kernel driver"); 1473 goto fail; 1474 } 1475 1476 prev_addr = hapd->own_addr; 1477 1478 for (j = 0; j < iface->num_bss; j++) { 1479 hapd = iface->bss[j]; 1480 if (j) 1481 os_memcpy(hapd->own_addr, prev_addr, ETH_ALEN); 1482 if (hostapd_setup_bss(hapd, j == 0)) { 1483 do { 1484 hapd = iface->bss[j]; 1485 hostapd_bss_deinit_no_free(hapd); 1486 hostapd_free_hapd_data(hapd); 1487 } while (j-- > 0); 1488 goto fail; 1489 } 1490 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0) 1491 prev_addr = hapd->own_addr; 1492 } 1493 hapd = iface->bss[0]; 1494 1495 hostapd_tx_queue_params(iface); 1496 1497 ap_list_init(iface); 1498 1499 hostapd_set_acl(hapd); 1500 1501 if (hostapd_driver_commit(hapd) < 0) { 1502 wpa_printf(MSG_ERROR, "%s: Failed to commit driver " 1503 "configuration", __func__); 1504 goto fail; 1505 } 1506 1507 /* 1508 * WPS UPnP module can be initialized only when the "upnp_iface" is up. 1509 * If "interface" and "upnp_iface" are the same (e.g., non-bridge 1510 * mode), the interface is up only after driver_commit, so initialize 1511 * WPS after driver_commit. 1512 */ 1513 for (j = 0; j < iface->num_bss; j++) { 1514 if (hostapd_init_wps_complete(iface->bss[j])) 1515 goto fail; 1516 } 1517 1518 if ((iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) && 1519 !res_dfs_offload) { 1520 /* 1521 * If freq is DFS, and DFS is offloaded to the driver, then wait 1522 * for CAC to complete. 1523 */ 1524 wpa_printf(MSG_DEBUG, "%s: Wait for CAC to complete", __func__); 1525 return res_dfs_offload; 1526 } 1527 1528#ifdef NEED_AP_MLME 1529dfs_offload: 1530#endif /* NEED_AP_MLME */ 1531 hostapd_set_state(iface, HAPD_IFACE_ENABLED); 1532 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, AP_EVENT_ENABLED); 1533 if (hapd->setup_complete_cb) 1534 hapd->setup_complete_cb(hapd->setup_complete_cb_ctx); 1535 1536 wpa_printf(MSG_DEBUG, "%s: Setup of interface done.", 1537 iface->bss[0]->conf->iface); 1538 if (iface->interfaces && iface->interfaces->terminate_on_error > 0) 1539 iface->interfaces->terminate_on_error--; 1540 1541 return 0; 1542 1543fail: 1544 wpa_printf(MSG_ERROR, "Interface initialization failed"); 1545 hostapd_set_state(iface, HAPD_IFACE_DISABLED); 1546 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_EVENT_DISABLED); 1547 if (iface->interfaces && iface->interfaces->terminate_on_error) 1548 eloop_terminate(); 1549 return -1; 1550} 1551 1552 1553/** 1554 * hostapd_setup_interface - Setup of an interface 1555 * @iface: Pointer to interface data. 1556 * Returns: 0 on success, -1 on failure 1557 * 1558 * Initializes the driver interface, validates the configuration, 1559 * and sets driver parameters based on the configuration. 1560 * Flushes old stations, sets the channel, encryption, 1561 * beacons, and WDS links based on the configuration. 1562 * 1563 * If interface setup requires more time, e.g., to perform HT co-ex scans, ACS, 1564 * or DFS operations, this function returns 0 before such operations have been 1565 * completed. The pending operations are registered into eloop and will be 1566 * completed from eloop callbacks. Those callbacks end up calling 1567 * hostapd_setup_interface_complete() once setup has been completed. 1568 */ 1569int hostapd_setup_interface(struct hostapd_iface *iface) 1570{ 1571 int ret; 1572 1573 ret = setup_interface(iface); 1574 if (ret) { 1575 wpa_printf(MSG_ERROR, "%s: Unable to setup interface.", 1576 iface->bss[0]->conf->iface); 1577 return -1; 1578 } 1579 1580 return 0; 1581} 1582 1583 1584/** 1585 * hostapd_alloc_bss_data - Allocate and initialize per-BSS data 1586 * @hapd_iface: Pointer to interface data 1587 * @conf: Pointer to per-interface configuration 1588 * @bss: Pointer to per-BSS configuration for this BSS 1589 * Returns: Pointer to allocated BSS data 1590 * 1591 * This function is used to allocate per-BSS data structure. This data will be 1592 * freed after hostapd_cleanup() is called for it during interface 1593 * deinitialization. 1594 */ 1595struct hostapd_data * 1596hostapd_alloc_bss_data(struct hostapd_iface *hapd_iface, 1597 struct hostapd_config *conf, 1598 struct hostapd_bss_config *bss) 1599{ 1600 struct hostapd_data *hapd; 1601 1602 hapd = os_zalloc(sizeof(*hapd)); 1603 if (hapd == NULL) 1604 return NULL; 1605 1606 hapd->new_assoc_sta_cb = hostapd_new_assoc_sta; 1607 hapd->iconf = conf; 1608 hapd->conf = bss; 1609 hapd->iface = hapd_iface; 1610 hapd->driver = hapd->iconf->driver; 1611 hapd->ctrl_sock = -1; 1612 1613 return hapd; 1614} 1615 1616 1617static void hostapd_bss_deinit(struct hostapd_data *hapd) 1618{ 1619 wpa_printf(MSG_DEBUG, "%s: deinit bss %s", __func__, 1620 hapd->conf->iface); 1621 hostapd_bss_deinit_no_free(hapd); 1622 hostapd_cleanup(hapd); 1623} 1624 1625 1626void hostapd_interface_deinit(struct hostapd_iface *iface) 1627{ 1628 int j; 1629 1630 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1631 if (iface == NULL) 1632 return; 1633 1634#ifdef CONFIG_IEEE80211N 1635#ifdef NEED_AP_MLME 1636 hostapd_stop_setup_timers(iface); 1637 eloop_cancel_timeout(ap_ht2040_timeout, iface, NULL); 1638#endif /* NEED_AP_MLME */ 1639#endif /* CONFIG_IEEE80211N */ 1640 eloop_cancel_timeout(channel_list_update_timeout, iface, NULL); 1641 iface->wait_channel_update = 0; 1642 1643 for (j = iface->num_bss - 1; j >= 0; j--) 1644 hostapd_bss_deinit(iface->bss[j]); 1645} 1646 1647 1648void hostapd_interface_free(struct hostapd_iface *iface) 1649{ 1650 size_t j; 1651 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1652 for (j = 0; j < iface->num_bss; j++) { 1653 wpa_printf(MSG_DEBUG, "%s: free hapd %p", 1654 __func__, iface->bss[j]); 1655 os_free(iface->bss[j]); 1656 } 1657 hostapd_cleanup_iface(iface); 1658} 1659 1660 1661/** 1662 * hostapd_init - Allocate and initialize per-interface data 1663 * @config_file: Path to the configuration file 1664 * Returns: Pointer to the allocated interface data or %NULL on failure 1665 * 1666 * This function is used to allocate main data structures for per-interface 1667 * data. The allocated data buffer will be freed by calling 1668 * hostapd_cleanup_iface(). 1669 */ 1670struct hostapd_iface * hostapd_init(struct hapd_interfaces *interfaces, 1671 const char *config_file) 1672{ 1673 struct hostapd_iface *hapd_iface = NULL; 1674 struct hostapd_config *conf = NULL; 1675 struct hostapd_data *hapd; 1676 size_t i; 1677 1678 hapd_iface = os_zalloc(sizeof(*hapd_iface)); 1679 if (hapd_iface == NULL) 1680 goto fail; 1681 1682 hapd_iface->config_fname = os_strdup(config_file); 1683 if (hapd_iface->config_fname == NULL) 1684 goto fail; 1685 1686 conf = interfaces->config_read_cb(hapd_iface->config_fname); 1687 if (conf == NULL) 1688 goto fail; 1689 hapd_iface->conf = conf; 1690 1691 hapd_iface->num_bss = conf->num_bss; 1692 hapd_iface->bss = os_calloc(conf->num_bss, 1693 sizeof(struct hostapd_data *)); 1694 if (hapd_iface->bss == NULL) 1695 goto fail; 1696 1697 for (i = 0; i < conf->num_bss; i++) { 1698 hapd = hapd_iface->bss[i] = 1699 hostapd_alloc_bss_data(hapd_iface, conf, 1700 conf->bss[i]); 1701 if (hapd == NULL) 1702 goto fail; 1703 hapd->msg_ctx = hapd; 1704 } 1705 1706 return hapd_iface; 1707 1708fail: 1709 wpa_printf(MSG_ERROR, "Failed to set up interface with %s", 1710 config_file); 1711 if (conf) 1712 hostapd_config_free(conf); 1713 if (hapd_iface) { 1714 os_free(hapd_iface->config_fname); 1715 os_free(hapd_iface->bss); 1716 wpa_printf(MSG_DEBUG, "%s: free iface %p", 1717 __func__, hapd_iface); 1718 os_free(hapd_iface); 1719 } 1720 return NULL; 1721} 1722 1723 1724static int ifname_in_use(struct hapd_interfaces *interfaces, const char *ifname) 1725{ 1726 size_t i, j; 1727 1728 for (i = 0; i < interfaces->count; i++) { 1729 struct hostapd_iface *iface = interfaces->iface[i]; 1730 for (j = 0; j < iface->num_bss; j++) { 1731 struct hostapd_data *hapd = iface->bss[j]; 1732 if (os_strcmp(ifname, hapd->conf->iface) == 0) 1733 return 1; 1734 } 1735 } 1736 1737 return 0; 1738} 1739 1740 1741/** 1742 * hostapd_interface_init_bss - Read configuration file and init BSS data 1743 * 1744 * This function is used to parse configuration file for a BSS. This BSS is 1745 * added to an existing interface sharing the same radio (if any) or a new 1746 * interface is created if this is the first interface on a radio. This 1747 * allocate memory for the BSS. No actual driver operations are started. 1748 * 1749 * This is similar to hostapd_interface_init(), but for a case where the 1750 * configuration is used to add a single BSS instead of all BSSes for a radio. 1751 */ 1752struct hostapd_iface * 1753hostapd_interface_init_bss(struct hapd_interfaces *interfaces, const char *phy, 1754 const char *config_fname, int debug) 1755{ 1756 struct hostapd_iface *new_iface = NULL, *iface = NULL; 1757 struct hostapd_data *hapd; 1758 int k; 1759 size_t i, bss_idx; 1760 1761 if (!phy || !*phy) 1762 return NULL; 1763 1764 for (i = 0; i < interfaces->count; i++) { 1765 if (os_strcmp(interfaces->iface[i]->phy, phy) == 0) { 1766 iface = interfaces->iface[i]; 1767 break; 1768 } 1769 } 1770 1771 wpa_printf(MSG_INFO, "Configuration file: %s (phy %s)%s", 1772 config_fname, phy, iface ? "" : " --> new PHY"); 1773 if (iface) { 1774 struct hostapd_config *conf; 1775 struct hostapd_bss_config **tmp_conf; 1776 struct hostapd_data **tmp_bss; 1777 struct hostapd_bss_config *bss; 1778 const char *ifname; 1779 1780 /* Add new BSS to existing iface */ 1781 conf = interfaces->config_read_cb(config_fname); 1782 if (conf == NULL) 1783 return NULL; 1784 if (conf->num_bss > 1) { 1785 wpa_printf(MSG_ERROR, "Multiple BSSes specified in BSS-config"); 1786 hostapd_config_free(conf); 1787 return NULL; 1788 } 1789 1790 ifname = conf->bss[0]->iface; 1791 if (ifname[0] != '\0' && ifname_in_use(interfaces, ifname)) { 1792 wpa_printf(MSG_ERROR, 1793 "Interface name %s already in use", ifname); 1794 hostapd_config_free(conf); 1795 return NULL; 1796 } 1797 1798 tmp_conf = os_realloc_array( 1799 iface->conf->bss, iface->conf->num_bss + 1, 1800 sizeof(struct hostapd_bss_config *)); 1801 tmp_bss = os_realloc_array(iface->bss, iface->num_bss + 1, 1802 sizeof(struct hostapd_data *)); 1803 if (tmp_bss) 1804 iface->bss = tmp_bss; 1805 if (tmp_conf) { 1806 iface->conf->bss = tmp_conf; 1807 iface->conf->last_bss = tmp_conf[0]; 1808 } 1809 if (tmp_bss == NULL || tmp_conf == NULL) { 1810 hostapd_config_free(conf); 1811 return NULL; 1812 } 1813 bss = iface->conf->bss[iface->conf->num_bss] = conf->bss[0]; 1814 iface->conf->num_bss++; 1815 1816 hapd = hostapd_alloc_bss_data(iface, iface->conf, bss); 1817 if (hapd == NULL) { 1818 iface->conf->num_bss--; 1819 hostapd_config_free(conf); 1820 return NULL; 1821 } 1822 iface->conf->last_bss = bss; 1823 iface->bss[iface->num_bss] = hapd; 1824 hapd->msg_ctx = hapd; 1825 1826 bss_idx = iface->num_bss++; 1827 conf->num_bss--; 1828 conf->bss[0] = NULL; 1829 hostapd_config_free(conf); 1830 } else { 1831 /* Add a new iface with the first BSS */ 1832 new_iface = iface = hostapd_init(interfaces, config_fname); 1833 if (!iface) 1834 return NULL; 1835 os_strlcpy(iface->phy, phy, sizeof(iface->phy)); 1836 iface->interfaces = interfaces; 1837 bss_idx = 0; 1838 } 1839 1840 for (k = 0; k < debug; k++) { 1841 if (iface->bss[bss_idx]->conf->logger_stdout_level > 0) 1842 iface->bss[bss_idx]->conf->logger_stdout_level--; 1843 } 1844 1845 if (iface->conf->bss[bss_idx]->iface[0] == '\0' && 1846 !hostapd_drv_none(iface->bss[bss_idx])) { 1847 wpa_printf(MSG_ERROR, "Interface name not specified in %s", 1848 config_fname); 1849 if (new_iface) 1850 hostapd_interface_deinit_free(new_iface); 1851 return NULL; 1852 } 1853 1854 return iface; 1855} 1856 1857 1858void hostapd_interface_deinit_free(struct hostapd_iface *iface) 1859{ 1860 const struct wpa_driver_ops *driver; 1861 void *drv_priv; 1862 1863 wpa_printf(MSG_DEBUG, "%s(%p)", __func__, iface); 1864 if (iface == NULL) 1865 return; 1866 wpa_printf(MSG_DEBUG, "%s: num_bss=%u conf->num_bss=%u", 1867 __func__, (unsigned int) iface->num_bss, 1868 (unsigned int) iface->conf->num_bss); 1869 driver = iface->bss[0]->driver; 1870 drv_priv = iface->bss[0]->drv_priv; 1871 hostapd_interface_deinit(iface); 1872 wpa_printf(MSG_DEBUG, "%s: driver=%p drv_priv=%p -> hapd_deinit", 1873 __func__, driver, drv_priv); 1874 if (driver && driver->hapd_deinit && drv_priv) { 1875 driver->hapd_deinit(drv_priv); 1876 iface->bss[0]->drv_priv = NULL; 1877 } 1878 hostapd_interface_free(iface); 1879} 1880 1881 1882static void hostapd_deinit_driver(const struct wpa_driver_ops *driver, 1883 void *drv_priv, 1884 struct hostapd_iface *hapd_iface) 1885{ 1886 size_t j; 1887 1888 wpa_printf(MSG_DEBUG, "%s: driver=%p drv_priv=%p -> hapd_deinit", 1889 __func__, driver, drv_priv); 1890 if (driver && driver->hapd_deinit && drv_priv) { 1891 driver->hapd_deinit(drv_priv); 1892 for (j = 0; j < hapd_iface->num_bss; j++) { 1893 wpa_printf(MSG_DEBUG, "%s:bss[%d]->drv_priv=%p", 1894 __func__, (int) j, 1895 hapd_iface->bss[j]->drv_priv); 1896 if (hapd_iface->bss[j]->drv_priv == drv_priv) 1897 hapd_iface->bss[j]->drv_priv = NULL; 1898 } 1899 } 1900} 1901 1902 1903int hostapd_enable_iface(struct hostapd_iface *hapd_iface) 1904{ 1905 size_t j; 1906 1907 if (hapd_iface->bss[0]->drv_priv != NULL) { 1908 wpa_printf(MSG_ERROR, "Interface %s already enabled", 1909 hapd_iface->conf->bss[0]->iface); 1910 return -1; 1911 } 1912 1913 wpa_printf(MSG_DEBUG, "Enable interface %s", 1914 hapd_iface->conf->bss[0]->iface); 1915 1916 for (j = 0; j < hapd_iface->num_bss; j++) 1917 hostapd_set_security_params(hapd_iface->conf->bss[j], 1); 1918 if (hostapd_config_check(hapd_iface->conf, 1) < 0) { 1919 wpa_printf(MSG_INFO, "Invalid configuration - cannot enable"); 1920 return -1; 1921 } 1922 1923 if (hapd_iface->interfaces == NULL || 1924 hapd_iface->interfaces->driver_init == NULL || 1925 hapd_iface->interfaces->driver_init(hapd_iface)) 1926 return -1; 1927 1928 if (hostapd_setup_interface(hapd_iface)) { 1929 hostapd_deinit_driver(hapd_iface->bss[0]->driver, 1930 hapd_iface->bss[0]->drv_priv, 1931 hapd_iface); 1932 return -1; 1933 } 1934 1935 return 0; 1936} 1937 1938 1939int hostapd_reload_iface(struct hostapd_iface *hapd_iface) 1940{ 1941 size_t j; 1942 1943 wpa_printf(MSG_DEBUG, "Reload interface %s", 1944 hapd_iface->conf->bss[0]->iface); 1945 for (j = 0; j < hapd_iface->num_bss; j++) 1946 hostapd_set_security_params(hapd_iface->conf->bss[j], 1); 1947 if (hostapd_config_check(hapd_iface->conf, 1) < 0) { 1948 wpa_printf(MSG_ERROR, "Updated configuration is invalid"); 1949 return -1; 1950 } 1951 hostapd_clear_old(hapd_iface); 1952 for (j = 0; j < hapd_iface->num_bss; j++) 1953 hostapd_reload_bss(hapd_iface->bss[j]); 1954 1955 return 0; 1956} 1957 1958 1959int hostapd_disable_iface(struct hostapd_iface *hapd_iface) 1960{ 1961 size_t j; 1962 const struct wpa_driver_ops *driver; 1963 void *drv_priv; 1964 1965 if (hapd_iface == NULL) 1966 return -1; 1967 1968 if (hapd_iface->bss[0]->drv_priv == NULL) { 1969 wpa_printf(MSG_INFO, "Interface %s already disabled", 1970 hapd_iface->conf->bss[0]->iface); 1971 return -1; 1972 } 1973 1974 wpa_msg(hapd_iface->bss[0]->msg_ctx, MSG_INFO, AP_EVENT_DISABLED); 1975 driver = hapd_iface->bss[0]->driver; 1976 drv_priv = hapd_iface->bss[0]->drv_priv; 1977 1978 hapd_iface->driver_ap_teardown = 1979 !!(hapd_iface->drv_flags & 1980 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 1981 1982 /* same as hostapd_interface_deinit without deinitializing ctrl-iface */ 1983 for (j = 0; j < hapd_iface->num_bss; j++) { 1984 struct hostapd_data *hapd = hapd_iface->bss[j]; 1985 hostapd_bss_deinit_no_free(hapd); 1986 hostapd_free_hapd_data(hapd); 1987 } 1988 1989 hostapd_deinit_driver(driver, drv_priv, hapd_iface); 1990 1991 /* From hostapd_cleanup_iface: These were initialized in 1992 * hostapd_setup_interface and hostapd_setup_interface_complete 1993 */ 1994 hostapd_cleanup_iface_partial(hapd_iface); 1995 1996 wpa_printf(MSG_DEBUG, "Interface %s disabled", 1997 hapd_iface->bss[0]->conf->iface); 1998 hostapd_set_state(hapd_iface, HAPD_IFACE_DISABLED); 1999 return 0; 2000} 2001 2002 2003static struct hostapd_iface * 2004hostapd_iface_alloc(struct hapd_interfaces *interfaces) 2005{ 2006 struct hostapd_iface **iface, *hapd_iface; 2007 2008 iface = os_realloc_array(interfaces->iface, interfaces->count + 1, 2009 sizeof(struct hostapd_iface *)); 2010 if (iface == NULL) 2011 return NULL; 2012 interfaces->iface = iface; 2013 hapd_iface = interfaces->iface[interfaces->count] = 2014 os_zalloc(sizeof(*hapd_iface)); 2015 if (hapd_iface == NULL) { 2016 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 2017 "the interface", __func__); 2018 return NULL; 2019 } 2020 interfaces->count++; 2021 hapd_iface->interfaces = interfaces; 2022 2023 return hapd_iface; 2024} 2025 2026 2027static struct hostapd_config * 2028hostapd_config_alloc(struct hapd_interfaces *interfaces, const char *ifname, 2029 const char *ctrl_iface) 2030{ 2031 struct hostapd_bss_config *bss; 2032 struct hostapd_config *conf; 2033 2034 /* Allocates memory for bss and conf */ 2035 conf = hostapd_config_defaults(); 2036 if (conf == NULL) { 2037 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 2038 "configuration", __func__); 2039 return NULL; 2040 } 2041 2042 conf->driver = wpa_drivers[0]; 2043 if (conf->driver == NULL) { 2044 wpa_printf(MSG_ERROR, "No driver wrappers registered!"); 2045 hostapd_config_free(conf); 2046 return NULL; 2047 } 2048 2049 bss = conf->last_bss = conf->bss[0]; 2050 2051 os_strlcpy(bss->iface, ifname, sizeof(bss->iface)); 2052 bss->ctrl_interface = os_strdup(ctrl_iface); 2053 if (bss->ctrl_interface == NULL) { 2054 hostapd_config_free(conf); 2055 return NULL; 2056 } 2057 2058 /* Reading configuration file skipped, will be done in SET! 2059 * From reading the configuration till the end has to be done in 2060 * SET 2061 */ 2062 return conf; 2063} 2064 2065 2066static int hostapd_data_alloc(struct hostapd_iface *hapd_iface, 2067 struct hostapd_config *conf) 2068{ 2069 size_t i; 2070 struct hostapd_data *hapd; 2071 2072 hapd_iface->bss = os_calloc(conf->num_bss, 2073 sizeof(struct hostapd_data *)); 2074 if (hapd_iface->bss == NULL) 2075 return -1; 2076 2077 for (i = 0; i < conf->num_bss; i++) { 2078 hapd = hapd_iface->bss[i] = 2079 hostapd_alloc_bss_data(hapd_iface, conf, conf->bss[i]); 2080 if (hapd == NULL) { 2081 while (i > 0) { 2082 i--; 2083 os_free(hapd_iface->bss[i]); 2084 hapd_iface->bss[i] = NULL; 2085 } 2086 os_free(hapd_iface->bss); 2087 hapd_iface->bss = NULL; 2088 return -1; 2089 } 2090 hapd->msg_ctx = hapd; 2091 } 2092 2093 hapd_iface->conf = conf; 2094 hapd_iface->num_bss = conf->num_bss; 2095 2096 return 0; 2097} 2098 2099 2100int hostapd_add_iface(struct hapd_interfaces *interfaces, char *buf) 2101{ 2102 struct hostapd_config *conf = NULL; 2103 struct hostapd_iface *hapd_iface = NULL, *new_iface = NULL; 2104 struct hostapd_data *hapd; 2105 char *ptr; 2106 size_t i, j; 2107 const char *conf_file = NULL, *phy_name = NULL; 2108 2109 if (os_strncmp(buf, "bss_config=", 11) == 0) { 2110 char *pos; 2111 phy_name = buf + 11; 2112 pos = os_strchr(phy_name, ':'); 2113 if (!pos) 2114 return -1; 2115 *pos++ = '\0'; 2116 conf_file = pos; 2117 if (!os_strlen(conf_file)) 2118 return -1; 2119 2120 hapd_iface = hostapd_interface_init_bss(interfaces, phy_name, 2121 conf_file, 0); 2122 if (!hapd_iface) 2123 return -1; 2124 for (j = 0; j < interfaces->count; j++) { 2125 if (interfaces->iface[j] == hapd_iface) 2126 break; 2127 } 2128 if (j == interfaces->count) { 2129 struct hostapd_iface **tmp; 2130 tmp = os_realloc_array(interfaces->iface, 2131 interfaces->count + 1, 2132 sizeof(struct hostapd_iface *)); 2133 if (!tmp) { 2134 hostapd_interface_deinit_free(hapd_iface); 2135 return -1; 2136 } 2137 interfaces->iface = tmp; 2138 interfaces->iface[interfaces->count++] = hapd_iface; 2139 new_iface = hapd_iface; 2140 } 2141 2142 if (new_iface) { 2143 if (interfaces->driver_init(hapd_iface)) 2144 goto fail; 2145 2146 if (hostapd_setup_interface(hapd_iface)) { 2147 hostapd_deinit_driver( 2148 hapd_iface->bss[0]->driver, 2149 hapd_iface->bss[0]->drv_priv, 2150 hapd_iface); 2151 goto fail; 2152 } 2153 } else { 2154 /* Assign new BSS with bss[0]'s driver info */ 2155 hapd = hapd_iface->bss[hapd_iface->num_bss - 1]; 2156 hapd->driver = hapd_iface->bss[0]->driver; 2157 hapd->drv_priv = hapd_iface->bss[0]->drv_priv; 2158 os_memcpy(hapd->own_addr, hapd_iface->bss[0]->own_addr, 2159 ETH_ALEN); 2160 2161 if (start_ctrl_iface_bss(hapd) < 0 || 2162 (hapd_iface->state == HAPD_IFACE_ENABLED && 2163 hostapd_setup_bss(hapd, -1))) { 2164 hostapd_cleanup(hapd); 2165 hapd_iface->bss[hapd_iface->num_bss - 1] = NULL; 2166 hapd_iface->conf->num_bss--; 2167 hapd_iface->num_bss--; 2168 wpa_printf(MSG_DEBUG, "%s: free hapd %p %s", 2169 __func__, hapd, hapd->conf->iface); 2170 hostapd_config_free_bss(hapd->conf); 2171 hapd->conf = NULL; 2172 os_free(hapd); 2173 return -1; 2174 } 2175 } 2176 return 0; 2177 } 2178 2179 ptr = os_strchr(buf, ' '); 2180 if (ptr == NULL) 2181 return -1; 2182 *ptr++ = '\0'; 2183 2184 if (os_strncmp(ptr, "config=", 7) == 0) 2185 conf_file = ptr + 7; 2186 2187 for (i = 0; i < interfaces->count; i++) { 2188 if (!os_strcmp(interfaces->iface[i]->conf->bss[0]->iface, 2189 buf)) { 2190 wpa_printf(MSG_INFO, "Cannot add interface - it " 2191 "already exists"); 2192 return -1; 2193 } 2194 } 2195 2196 hapd_iface = hostapd_iface_alloc(interfaces); 2197 if (hapd_iface == NULL) { 2198 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2199 "for interface", __func__); 2200 goto fail; 2201 } 2202 new_iface = hapd_iface; 2203 2204 if (conf_file && interfaces->config_read_cb) { 2205 conf = interfaces->config_read_cb(conf_file); 2206 if (conf && conf->bss) 2207 os_strlcpy(conf->bss[0]->iface, buf, 2208 sizeof(conf->bss[0]->iface)); 2209 } else 2210 conf = hostapd_config_alloc(interfaces, buf, ptr); 2211 if (conf == NULL || conf->bss == NULL) { 2212 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2213 "for configuration", __func__); 2214 goto fail; 2215 } 2216 2217 if (hostapd_data_alloc(hapd_iface, conf) < 0) { 2218 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 2219 "for hostapd", __func__); 2220 goto fail; 2221 } 2222 conf = NULL; 2223 2224 if (start_ctrl_iface(hapd_iface) < 0) 2225 goto fail; 2226 2227 wpa_printf(MSG_INFO, "Add interface '%s'", 2228 hapd_iface->conf->bss[0]->iface); 2229 2230 return 0; 2231 2232fail: 2233 if (conf) 2234 hostapd_config_free(conf); 2235 if (hapd_iface) { 2236 if (hapd_iface->bss) { 2237 for (i = 0; i < hapd_iface->num_bss; i++) { 2238 hapd = hapd_iface->bss[i]; 2239 if (!hapd) 2240 continue; 2241 if (hapd_iface->interfaces && 2242 hapd_iface->interfaces->ctrl_iface_deinit) 2243 hapd_iface->interfaces-> 2244 ctrl_iface_deinit(hapd); 2245 wpa_printf(MSG_DEBUG, "%s: free hapd %p (%s)", 2246 __func__, hapd_iface->bss[i], 2247 hapd->conf->iface); 2248 hostapd_cleanup(hapd); 2249 os_free(hapd); 2250 hapd_iface->bss[i] = NULL; 2251 } 2252 os_free(hapd_iface->bss); 2253 hapd_iface->bss = NULL; 2254 } 2255 if (new_iface) { 2256 interfaces->count--; 2257 interfaces->iface[interfaces->count] = NULL; 2258 } 2259 hostapd_cleanup_iface(hapd_iface); 2260 } 2261 return -1; 2262} 2263 2264 2265static int hostapd_remove_bss(struct hostapd_iface *iface, unsigned int idx) 2266{ 2267 size_t i; 2268 2269 wpa_printf(MSG_INFO, "Remove BSS '%s'", iface->conf->bss[idx]->iface); 2270 2271 /* Remove hostapd_data only if it has already been initialized */ 2272 if (idx < iface->num_bss) { 2273 struct hostapd_data *hapd = iface->bss[idx]; 2274 2275 hostapd_bss_deinit(hapd); 2276 wpa_printf(MSG_DEBUG, "%s: free hapd %p (%s)", 2277 __func__, hapd, hapd->conf->iface); 2278 hostapd_config_free_bss(hapd->conf); 2279 hapd->conf = NULL; 2280 os_free(hapd); 2281 2282 iface->num_bss--; 2283 2284 for (i = idx; i < iface->num_bss; i++) 2285 iface->bss[i] = iface->bss[i + 1]; 2286 } else { 2287 hostapd_config_free_bss(iface->conf->bss[idx]); 2288 iface->conf->bss[idx] = NULL; 2289 } 2290 2291 iface->conf->num_bss--; 2292 for (i = idx; i < iface->conf->num_bss; i++) 2293 iface->conf->bss[i] = iface->conf->bss[i + 1]; 2294 2295 return 0; 2296} 2297 2298 2299int hostapd_remove_iface(struct hapd_interfaces *interfaces, char *buf) 2300{ 2301 struct hostapd_iface *hapd_iface; 2302 size_t i, j, k = 0; 2303 2304 for (i = 0; i < interfaces->count; i++) { 2305 hapd_iface = interfaces->iface[i]; 2306 if (hapd_iface == NULL) 2307 return -1; 2308 if (!os_strcmp(hapd_iface->conf->bss[0]->iface, buf)) { 2309 wpa_printf(MSG_INFO, "Remove interface '%s'", buf); 2310 hapd_iface->driver_ap_teardown = 2311 !!(hapd_iface->drv_flags & 2312 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 2313 2314 hostapd_interface_deinit_free(hapd_iface); 2315 k = i; 2316 while (k < (interfaces->count - 1)) { 2317 interfaces->iface[k] = 2318 interfaces->iface[k + 1]; 2319 k++; 2320 } 2321 interfaces->count--; 2322 return 0; 2323 } 2324 2325 for (j = 0; j < hapd_iface->conf->num_bss; j++) { 2326 if (!os_strcmp(hapd_iface->conf->bss[j]->iface, buf)) { 2327 hapd_iface->driver_ap_teardown = 2328 !(hapd_iface->drv_flags & 2329 WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT); 2330 return hostapd_remove_bss(hapd_iface, j); 2331 } 2332 } 2333 } 2334 return -1; 2335} 2336 2337 2338/** 2339 * hostapd_new_assoc_sta - Notify that a new station associated with the AP 2340 * @hapd: Pointer to BSS data 2341 * @sta: Pointer to the associated STA data 2342 * @reassoc: 1 to indicate this was a re-association; 0 = first association 2343 * 2344 * This function will be called whenever a station associates with the AP. It 2345 * can be called from ieee802_11.c for drivers that export MLME to hostapd and 2346 * from drv_callbacks.c based on driver events for drivers that take care of 2347 * management frames (IEEE 802.11 authentication and association) internally. 2348 */ 2349void hostapd_new_assoc_sta(struct hostapd_data *hapd, struct sta_info *sta, 2350 int reassoc) 2351{ 2352 if (hapd->tkip_countermeasures) { 2353 hostapd_drv_sta_deauth(hapd, sta->addr, 2354 WLAN_REASON_MICHAEL_MIC_FAILURE); 2355 return; 2356 } 2357 2358 hostapd_prune_associations(hapd, sta->addr); 2359 2360 /* IEEE 802.11F (IAPP) */ 2361 if (hapd->conf->ieee802_11f) 2362 iapp_new_station(hapd->iapp, sta); 2363 2364#ifdef CONFIG_P2P 2365 if (sta->p2p_ie == NULL && !sta->no_p2p_set) { 2366 sta->no_p2p_set = 1; 2367 hapd->num_sta_no_p2p++; 2368 if (hapd->num_sta_no_p2p == 1) 2369 hostapd_p2p_non_p2p_sta_connected(hapd); 2370 } 2371#endif /* CONFIG_P2P */ 2372 2373 /* Start accounting here, if IEEE 802.1X and WPA are not used. 2374 * IEEE 802.1X/WPA code will start accounting after the station has 2375 * been authorized. */ 2376 if (!hapd->conf->ieee802_1x && !hapd->conf->wpa && !hapd->conf->osen) { 2377 ap_sta_set_authorized(hapd, sta, 1); 2378 os_get_reltime(&sta->connected_time); 2379 accounting_sta_start(hapd, sta); 2380 } 2381 2382 /* Start IEEE 802.1X authentication process for new stations */ 2383 ieee802_1x_new_station(hapd, sta); 2384 if (reassoc) { 2385 if (sta->auth_alg != WLAN_AUTH_FT && 2386 !(sta->flags & (WLAN_STA_WPS | WLAN_STA_MAYBE_WPS))) 2387 wpa_auth_sm_event(sta->wpa_sm, WPA_REAUTH); 2388 } else 2389 wpa_auth_sta_associated(hapd->wpa_auth, sta->wpa_sm); 2390 2391 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER)) { 2392 wpa_printf(MSG_DEBUG, "%s: reschedule ap_handle_timer timeout " 2393 "for " MACSTR " (%d seconds - ap_max_inactivity)", 2394 __func__, MAC2STR(sta->addr), 2395 hapd->conf->ap_max_inactivity); 2396 eloop_cancel_timeout(ap_handle_timer, hapd, sta); 2397 eloop_register_timeout(hapd->conf->ap_max_inactivity, 0, 2398 ap_handle_timer, hapd, sta); 2399 } 2400} 2401 2402 2403const char * hostapd_state_text(enum hostapd_iface_state s) 2404{ 2405 switch (s) { 2406 case HAPD_IFACE_UNINITIALIZED: 2407 return "UNINITIALIZED"; 2408 case HAPD_IFACE_DISABLED: 2409 return "DISABLED"; 2410 case HAPD_IFACE_COUNTRY_UPDATE: 2411 return "COUNTRY_UPDATE"; 2412 case HAPD_IFACE_ACS: 2413 return "ACS"; 2414 case HAPD_IFACE_HT_SCAN: 2415 return "HT_SCAN"; 2416 case HAPD_IFACE_DFS: 2417 return "DFS"; 2418 case HAPD_IFACE_ENABLED: 2419 return "ENABLED"; 2420 } 2421 2422 return "UNKNOWN"; 2423} 2424 2425 2426void hostapd_set_state(struct hostapd_iface *iface, enum hostapd_iface_state s) 2427{ 2428 wpa_printf(MSG_INFO, "%s: interface state %s->%s", 2429 iface->conf->bss[0]->iface, hostapd_state_text(iface->state), 2430 hostapd_state_text(s)); 2431 iface->state = s; 2432} 2433 2434 2435#ifdef NEED_AP_MLME 2436 2437static void free_beacon_data(struct beacon_data *beacon) 2438{ 2439 os_free(beacon->head); 2440 beacon->head = NULL; 2441 os_free(beacon->tail); 2442 beacon->tail = NULL; 2443 os_free(beacon->probe_resp); 2444 beacon->probe_resp = NULL; 2445 os_free(beacon->beacon_ies); 2446 beacon->beacon_ies = NULL; 2447 os_free(beacon->proberesp_ies); 2448 beacon->proberesp_ies = NULL; 2449 os_free(beacon->assocresp_ies); 2450 beacon->assocresp_ies = NULL; 2451} 2452 2453 2454static int hostapd_build_beacon_data(struct hostapd_data *hapd, 2455 struct beacon_data *beacon) 2456{ 2457 struct wpabuf *beacon_extra, *proberesp_extra, *assocresp_extra; 2458 struct wpa_driver_ap_params params; 2459 int ret; 2460 2461 os_memset(beacon, 0, sizeof(*beacon)); 2462 ret = ieee802_11_build_ap_params(hapd, ¶ms); 2463 if (ret < 0) 2464 return ret; 2465 2466 ret = hostapd_build_ap_extra_ies(hapd, &beacon_extra, 2467 &proberesp_extra, 2468 &assocresp_extra); 2469 if (ret) 2470 goto free_ap_params; 2471 2472 ret = -1; 2473 beacon->head = os_malloc(params.head_len); 2474 if (!beacon->head) 2475 goto free_ap_extra_ies; 2476 2477 os_memcpy(beacon->head, params.head, params.head_len); 2478 beacon->head_len = params.head_len; 2479 2480 beacon->tail = os_malloc(params.tail_len); 2481 if (!beacon->tail) 2482 goto free_beacon; 2483 2484 os_memcpy(beacon->tail, params.tail, params.tail_len); 2485 beacon->tail_len = params.tail_len; 2486 2487 if (params.proberesp != NULL) { 2488 beacon->probe_resp = os_malloc(params.proberesp_len); 2489 if (!beacon->probe_resp) 2490 goto free_beacon; 2491 2492 os_memcpy(beacon->probe_resp, params.proberesp, 2493 params.proberesp_len); 2494 beacon->probe_resp_len = params.proberesp_len; 2495 } 2496 2497 /* copy the extra ies */ 2498 if (beacon_extra) { 2499 beacon->beacon_ies = os_malloc(wpabuf_len(beacon_extra)); 2500 if (!beacon->beacon_ies) 2501 goto free_beacon; 2502 2503 os_memcpy(beacon->beacon_ies, 2504 beacon_extra->buf, wpabuf_len(beacon_extra)); 2505 beacon->beacon_ies_len = wpabuf_len(beacon_extra); 2506 } 2507 2508 if (proberesp_extra) { 2509 beacon->proberesp_ies = 2510 os_malloc(wpabuf_len(proberesp_extra)); 2511 if (!beacon->proberesp_ies) 2512 goto free_beacon; 2513 2514 os_memcpy(beacon->proberesp_ies, proberesp_extra->buf, 2515 wpabuf_len(proberesp_extra)); 2516 beacon->proberesp_ies_len = wpabuf_len(proberesp_extra); 2517 } 2518 2519 if (assocresp_extra) { 2520 beacon->assocresp_ies = 2521 os_malloc(wpabuf_len(assocresp_extra)); 2522 if (!beacon->assocresp_ies) 2523 goto free_beacon; 2524 2525 os_memcpy(beacon->assocresp_ies, assocresp_extra->buf, 2526 wpabuf_len(assocresp_extra)); 2527 beacon->assocresp_ies_len = wpabuf_len(assocresp_extra); 2528 } 2529 2530 ret = 0; 2531free_beacon: 2532 /* if the function fails, the caller should not free beacon data */ 2533 if (ret) 2534 free_beacon_data(beacon); 2535 2536free_ap_extra_ies: 2537 hostapd_free_ap_extra_ies(hapd, beacon_extra, proberesp_extra, 2538 assocresp_extra); 2539free_ap_params: 2540 ieee802_11_free_ap_params(¶ms); 2541 return ret; 2542} 2543 2544 2545/* 2546 * TODO: This flow currently supports only changing frequency within the 2547 * same hw_mode. Any other changes to MAC parameters or provided settings (even 2548 * width) are not supported. 2549 */ 2550static int hostapd_change_config_freq(struct hostapd_data *hapd, 2551 struct hostapd_config *conf, 2552 struct hostapd_freq_params *params, 2553 struct hostapd_freq_params *old_params) 2554{ 2555 int channel; 2556 2557 if (!params->channel) { 2558 /* check if the new channel is supported by hw */ 2559 params->channel = hostapd_hw_get_channel(hapd, params->freq); 2560 } 2561 2562 channel = params->channel; 2563 if (!channel) 2564 return -1; 2565 2566 /* if a pointer to old_params is provided we save previous state */ 2567 if (old_params) { 2568 old_params->channel = conf->channel; 2569 old_params->ht_enabled = conf->ieee80211n; 2570 old_params->sec_channel_offset = conf->secondary_channel; 2571 } 2572 2573 conf->channel = channel; 2574 conf->ieee80211n = params->ht_enabled; 2575 conf->secondary_channel = params->sec_channel_offset; 2576 2577 /* TODO: maybe call here hostapd_config_check here? */ 2578 2579 return 0; 2580} 2581 2582 2583static int hostapd_fill_csa_settings(struct hostapd_data *hapd, 2584 struct csa_settings *settings) 2585{ 2586 struct hostapd_iface *iface = hapd->iface; 2587 struct hostapd_freq_params old_freq; 2588 int ret; 2589 2590 os_memset(&old_freq, 0, sizeof(old_freq)); 2591 if (!iface || !iface->freq || hapd->csa_in_progress) 2592 return -1; 2593 2594 ret = hostapd_change_config_freq(iface->bss[0], iface->conf, 2595 &settings->freq_params, 2596 &old_freq); 2597 if (ret) 2598 return ret; 2599 2600 ret = hostapd_build_beacon_data(hapd, &settings->beacon_after); 2601 2602 /* change back the configuration */ 2603 hostapd_change_config_freq(iface->bss[0], iface->conf, 2604 &old_freq, NULL); 2605 2606 if (ret) 2607 return ret; 2608 2609 /* set channel switch parameters for csa ie */ 2610 hapd->cs_freq_params = settings->freq_params; 2611 hapd->cs_count = settings->cs_count; 2612 hapd->cs_block_tx = settings->block_tx; 2613 2614 ret = hostapd_build_beacon_data(hapd, &settings->beacon_csa); 2615 if (ret) { 2616 free_beacon_data(&settings->beacon_after); 2617 return ret; 2618 } 2619 2620 settings->counter_offset_beacon = hapd->cs_c_off_beacon; 2621 settings->counter_offset_presp = hapd->cs_c_off_proberesp; 2622 2623 return 0; 2624} 2625 2626 2627void hostapd_cleanup_cs_params(struct hostapd_data *hapd) 2628{ 2629 os_memset(&hapd->cs_freq_params, 0, sizeof(hapd->cs_freq_params)); 2630 hapd->cs_count = 0; 2631 hapd->cs_block_tx = 0; 2632 hapd->cs_c_off_beacon = 0; 2633 hapd->cs_c_off_proberesp = 0; 2634 hapd->csa_in_progress = 0; 2635} 2636 2637 2638int hostapd_switch_channel(struct hostapd_data *hapd, 2639 struct csa_settings *settings) 2640{ 2641 int ret; 2642 2643 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_AP_CSA)) { 2644 wpa_printf(MSG_INFO, "CSA is not supported"); 2645 return -1; 2646 } 2647 2648 ret = hostapd_fill_csa_settings(hapd, settings); 2649 if (ret) 2650 return ret; 2651 2652 ret = hostapd_drv_switch_channel(hapd, settings); 2653 free_beacon_data(&settings->beacon_csa); 2654 free_beacon_data(&settings->beacon_after); 2655 2656 if (ret) { 2657 /* if we failed, clean cs parameters */ 2658 hostapd_cleanup_cs_params(hapd); 2659 return ret; 2660 } 2661 2662 hapd->csa_in_progress = 1; 2663 return 0; 2664} 2665 2666 2667void 2668hostapd_switch_channel_fallback(struct hostapd_iface *iface, 2669 const struct hostapd_freq_params *freq_params) 2670{ 2671 int vht_seg0_idx = 0, vht_seg1_idx = 0, vht_bw = VHT_CHANWIDTH_USE_HT; 2672 unsigned int i; 2673 2674 wpa_printf(MSG_DEBUG, "Restarting all CSA-related BSSes"); 2675 2676 if (freq_params->center_freq1) 2677 vht_seg0_idx = 36 + (freq_params->center_freq1 - 5180) / 5; 2678 if (freq_params->center_freq2) 2679 vht_seg1_idx = 36 + (freq_params->center_freq2 - 5180) / 5; 2680 2681 switch (freq_params->bandwidth) { 2682 case 0: 2683 case 20: 2684 case 40: 2685 vht_bw = VHT_CHANWIDTH_USE_HT; 2686 break; 2687 case 80: 2688 if (freq_params->center_freq2) 2689 vht_bw = VHT_CHANWIDTH_80P80MHZ; 2690 else 2691 vht_bw = VHT_CHANWIDTH_80MHZ; 2692 break; 2693 case 160: 2694 vht_bw = VHT_CHANWIDTH_160MHZ; 2695 break; 2696 default: 2697 wpa_printf(MSG_WARNING, "Unknown CSA bandwidth: %d", 2698 freq_params->bandwidth); 2699 break; 2700 } 2701 2702 iface->freq = freq_params->freq; 2703 iface->conf->channel = freq_params->channel; 2704 iface->conf->secondary_channel = freq_params->sec_channel_offset; 2705 iface->conf->vht_oper_centr_freq_seg0_idx = vht_seg0_idx; 2706 iface->conf->vht_oper_centr_freq_seg1_idx = vht_seg1_idx; 2707 iface->conf->vht_oper_chwidth = vht_bw; 2708 iface->conf->ieee80211n = freq_params->ht_enabled; 2709 iface->conf->ieee80211ac = freq_params->vht_enabled; 2710 2711 /* 2712 * cs_params must not be cleared earlier because the freq_params 2713 * argument may actually point to one of these. 2714 */ 2715 for (i = 0; i < iface->num_bss; i++) 2716 hostapd_cleanup_cs_params(iface->bss[i]); 2717 2718 hostapd_disable_iface(iface); 2719 hostapd_enable_iface(iface); 2720} 2721 2722#endif /* NEED_AP_MLME */ 2723