hostapd.c revision 391c59f0632df8db1c325da1d31d479b2eedce45
1/* 2 * hostapd / Initialization and configuration 3 * Copyright (c) 2002-2012, 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 "radius/radius_client.h" 15#include "radius/radius_das.h" 16#include "drivers/driver.h" 17#include "hostapd.h" 18#include "authsrv.h" 19#include "sta_info.h" 20#include "accounting.h" 21#include "ap_list.h" 22#include "beacon.h" 23#include "iapp.h" 24#include "ieee802_1x.h" 25#include "ieee802_11_auth.h" 26#include "vlan_init.h" 27#include "wpa_auth.h" 28#include "wps_hostapd.h" 29#include "hw_features.h" 30#include "wpa_auth_glue.h" 31#include "ap_drv_ops.h" 32#include "ap_config.h" 33#include "p2p_hostapd.h" 34#include "gas_serv.h" 35 36 37static int hostapd_flush_old_stations(struct hostapd_data *hapd, u16 reason); 38static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd); 39static int hostapd_broadcast_wep_clear(struct hostapd_data *hapd); 40 41extern int wpa_debug_level; 42extern struct wpa_driver_ops *wpa_drivers[]; 43 44 45int hostapd_for_each_interface(struct hapd_interfaces *interfaces, 46 int (*cb)(struct hostapd_iface *iface, 47 void *ctx), void *ctx) 48{ 49 size_t i; 50 int ret; 51 52 for (i = 0; i < interfaces->count; i++) { 53 ret = cb(interfaces->iface[i], ctx); 54 if (ret) 55 return ret; 56 } 57 58 return 0; 59} 60 61 62static void hostapd_reload_bss(struct hostapd_data *hapd) 63{ 64#ifndef CONFIG_NO_RADIUS 65 radius_client_reconfig(hapd->radius, hapd->conf->radius); 66#endif /* CONFIG_NO_RADIUS */ 67 68 if (hostapd_setup_wpa_psk(hapd->conf)) { 69 wpa_printf(MSG_ERROR, "Failed to re-configure WPA PSK " 70 "after reloading configuration"); 71 } 72 73 if (hapd->conf->ieee802_1x || hapd->conf->wpa) 74 hostapd_set_drv_ieee8021x(hapd, hapd->conf->iface, 1); 75 else 76 hostapd_set_drv_ieee8021x(hapd, hapd->conf->iface, 0); 77 78 if (hapd->conf->wpa && hapd->wpa_auth == NULL) { 79 hostapd_setup_wpa(hapd); 80 if (hapd->wpa_auth) 81 wpa_init_keys(hapd->wpa_auth); 82 } else if (hapd->conf->wpa) { 83 const u8 *wpa_ie; 84 size_t wpa_ie_len; 85 hostapd_reconfig_wpa(hapd); 86 wpa_ie = wpa_auth_get_wpa_ie(hapd->wpa_auth, &wpa_ie_len); 87 if (hostapd_set_generic_elem(hapd, wpa_ie, wpa_ie_len)) 88 wpa_printf(MSG_ERROR, "Failed to configure WPA IE for " 89 "the kernel driver."); 90 } else if (hapd->wpa_auth) { 91 wpa_deinit(hapd->wpa_auth); 92 hapd->wpa_auth = NULL; 93 hostapd_set_privacy(hapd, 0); 94 hostapd_setup_encryption(hapd->conf->iface, hapd); 95 hostapd_set_generic_elem(hapd, (u8 *) "", 0); 96 } 97 98 ieee802_11_set_beacon(hapd); 99 hostapd_update_wps(hapd); 100 101 if (hapd->conf->ssid.ssid_set && 102 hostapd_set_ssid(hapd, hapd->conf->ssid.ssid, 103 hapd->conf->ssid.ssid_len)) { 104 wpa_printf(MSG_ERROR, "Could not set SSID for kernel driver"); 105 /* try to continue */ 106 } 107 wpa_printf(MSG_DEBUG, "Reconfigured interface %s", hapd->conf->iface); 108} 109 110 111static void hostapd_clear_old(struct hostapd_iface *iface) 112{ 113 size_t j; 114 115 /* 116 * Deauthenticate all stations since the new configuration may not 117 * allow them to use the BSS anymore. 118 */ 119 for (j = 0; j < iface->num_bss; j++) { 120 hostapd_flush_old_stations(iface->bss[j], 121 WLAN_REASON_PREV_AUTH_NOT_VALID); 122 hostapd_broadcast_wep_clear(iface->bss[j]); 123 124#ifndef CONFIG_NO_RADIUS 125 /* TODO: update dynamic data based on changed configuration 126 * items (e.g., open/close sockets, etc.) */ 127 radius_client_flush(iface->bss[j]->radius, 0); 128#endif /* CONFIG_NO_RADIUS */ 129 } 130} 131 132 133int hostapd_reload_config(struct hostapd_iface *iface) 134{ 135 struct hostapd_data *hapd = iface->bss[0]; 136 struct hostapd_config *newconf, *oldconf; 137 size_t j; 138 139 if (iface->config_fname == NULL) { 140 /* Only in-memory config in use - assume it has been updated */ 141 hostapd_clear_old(iface); 142 for (j = 0; j < iface->num_bss; j++) 143 hostapd_reload_bss(iface->bss[j]); 144 return 0; 145 } 146 147 if (iface->interfaces == NULL || 148 iface->interfaces->config_read_cb == NULL) 149 return -1; 150 newconf = iface->interfaces->config_read_cb(iface->config_fname); 151 if (newconf == NULL) 152 return -1; 153 154 hostapd_clear_old(iface); 155 156 oldconf = hapd->iconf; 157 iface->conf = newconf; 158 159 for (j = 0; j < iface->num_bss; j++) { 160 hapd = iface->bss[j]; 161 hapd->iconf = newconf; 162 hapd->conf = &newconf->bss[j]; 163 hostapd_reload_bss(hapd); 164 } 165 166 hostapd_config_free(oldconf); 167 168 169 return 0; 170} 171 172 173static void hostapd_broadcast_key_clear_iface(struct hostapd_data *hapd, 174 char *ifname) 175{ 176 int i; 177 178 for (i = 0; i < NUM_WEP_KEYS; i++) { 179 if (hostapd_drv_set_key(ifname, hapd, WPA_ALG_NONE, NULL, i, 180 0, NULL, 0, NULL, 0)) { 181 wpa_printf(MSG_DEBUG, "Failed to clear default " 182 "encryption keys (ifname=%s keyidx=%d)", 183 ifname, i); 184 } 185 } 186#ifdef CONFIG_IEEE80211W 187 if (hapd->conf->ieee80211w) { 188 for (i = NUM_WEP_KEYS; i < NUM_WEP_KEYS + 2; i++) { 189 if (hostapd_drv_set_key(ifname, hapd, WPA_ALG_NONE, 190 NULL, i, 0, NULL, 191 0, NULL, 0)) { 192 wpa_printf(MSG_DEBUG, "Failed to clear " 193 "default mgmt encryption keys " 194 "(ifname=%s keyidx=%d)", ifname, i); 195 } 196 } 197 } 198#endif /* CONFIG_IEEE80211W */ 199} 200 201 202static int hostapd_broadcast_wep_clear(struct hostapd_data *hapd) 203{ 204 hostapd_broadcast_key_clear_iface(hapd, hapd->conf->iface); 205 return 0; 206} 207 208 209static int hostapd_broadcast_wep_set(struct hostapd_data *hapd) 210{ 211 int errors = 0, idx; 212 struct hostapd_ssid *ssid = &hapd->conf->ssid; 213 214 idx = ssid->wep.idx; 215 if (ssid->wep.default_len && 216 hostapd_drv_set_key(hapd->conf->iface, 217 hapd, WPA_ALG_WEP, broadcast_ether_addr, idx, 218 1, NULL, 0, ssid->wep.key[idx], 219 ssid->wep.len[idx])) { 220 wpa_printf(MSG_WARNING, "Could not set WEP encryption."); 221 errors++; 222 } 223 224 return errors; 225} 226 227 228static void hostapd_free_hapd_data(struct hostapd_data *hapd) 229{ 230 iapp_deinit(hapd->iapp); 231 hapd->iapp = NULL; 232 accounting_deinit(hapd); 233 hostapd_deinit_wpa(hapd); 234 vlan_deinit(hapd); 235 hostapd_acl_deinit(hapd); 236#ifndef CONFIG_NO_RADIUS 237 radius_client_deinit(hapd->radius); 238 hapd->radius = NULL; 239 radius_das_deinit(hapd->radius_das); 240 hapd->radius_das = NULL; 241#endif /* CONFIG_NO_RADIUS */ 242 243 hostapd_deinit_wps(hapd); 244 245 authsrv_deinit(hapd); 246 247 if (hapd->interface_added && 248 hostapd_if_remove(hapd, WPA_IF_AP_BSS, hapd->conf->iface)) { 249 wpa_printf(MSG_WARNING, "Failed to remove BSS interface %s", 250 hapd->conf->iface); 251 } 252 253 os_free(hapd->probereq_cb); 254 hapd->probereq_cb = NULL; 255 256#ifdef CONFIG_P2P 257 wpabuf_free(hapd->p2p_beacon_ie); 258 hapd->p2p_beacon_ie = NULL; 259 wpabuf_free(hapd->p2p_probe_resp_ie); 260 hapd->p2p_probe_resp_ie = NULL; 261#endif /* CONFIG_P2P */ 262 263 wpabuf_free(hapd->time_adv); 264 265#ifdef CONFIG_INTERWORKING 266 gas_serv_deinit(hapd); 267#endif /* CONFIG_INTERWORKING */ 268 269#ifdef CONFIG_SQLITE 270 os_free(hapd->tmp_eap_user.identity); 271 os_free(hapd->tmp_eap_user.password); 272#endif /* CONFIG_SQLITE */ 273} 274 275 276/** 277 * hostapd_cleanup - Per-BSS cleanup (deinitialization) 278 * @hapd: Pointer to BSS data 279 * 280 * This function is used to free all per-BSS data structures and resources. 281 * This gets called in a loop for each BSS between calls to 282 * hostapd_cleanup_iface_pre() and hostapd_cleanup_iface() when an interface 283 * is deinitialized. Most of the modules that are initialized in 284 * hostapd_setup_bss() are deinitialized here. 285 */ 286static void hostapd_cleanup(struct hostapd_data *hapd) 287{ 288 if (hapd->iface->interfaces && 289 hapd->iface->interfaces->ctrl_iface_deinit) 290 hapd->iface->interfaces->ctrl_iface_deinit(hapd); 291 hostapd_free_hapd_data(hapd); 292} 293 294 295/** 296 * hostapd_cleanup_iface_pre - Preliminary per-interface cleanup 297 * @iface: Pointer to interface data 298 * 299 * This function is called before per-BSS data structures are deinitialized 300 * with hostapd_cleanup(). 301 */ 302static void hostapd_cleanup_iface_pre(struct hostapd_iface *iface) 303{ 304} 305 306 307static void hostapd_cleanup_iface_partial(struct hostapd_iface *iface) 308{ 309 hostapd_free_hw_features(iface->hw_features, iface->num_hw_features); 310 iface->hw_features = NULL; 311 os_free(iface->current_rates); 312 iface->current_rates = NULL; 313 os_free(iface->basic_rates); 314 iface->basic_rates = NULL; 315 ap_list_deinit(iface); 316} 317 318 319/** 320 * hostapd_cleanup_iface - Complete per-interface cleanup 321 * @iface: Pointer to interface data 322 * 323 * This function is called after per-BSS data structures are deinitialized 324 * with hostapd_cleanup(). 325 */ 326static void hostapd_cleanup_iface(struct hostapd_iface *iface) 327{ 328 hostapd_cleanup_iface_partial(iface); 329 hostapd_config_free(iface->conf); 330 iface->conf = NULL; 331 332 os_free(iface->config_fname); 333 os_free(iface->bss); 334 os_free(iface); 335} 336 337 338static void hostapd_clear_wep(struct hostapd_data *hapd) 339{ 340 if (hapd->drv_priv) { 341 hostapd_set_privacy(hapd, 0); 342 hostapd_broadcast_wep_clear(hapd); 343 } 344} 345 346 347static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd) 348{ 349 int i; 350 351 hostapd_broadcast_wep_set(hapd); 352 353 if (hapd->conf->ssid.wep.default_len) { 354 hostapd_set_privacy(hapd, 1); 355 return 0; 356 } 357 358 /* 359 * When IEEE 802.1X is not enabled, the driver may need to know how to 360 * set authentication algorithms for static WEP. 361 */ 362 hostapd_drv_set_authmode(hapd, hapd->conf->auth_algs); 363 364 for (i = 0; i < 4; i++) { 365 if (hapd->conf->ssid.wep.key[i] && 366 hostapd_drv_set_key(iface, hapd, WPA_ALG_WEP, NULL, i, 367 i == hapd->conf->ssid.wep.idx, NULL, 0, 368 hapd->conf->ssid.wep.key[i], 369 hapd->conf->ssid.wep.len[i])) { 370 wpa_printf(MSG_WARNING, "Could not set WEP " 371 "encryption."); 372 return -1; 373 } 374 if (hapd->conf->ssid.wep.key[i] && 375 i == hapd->conf->ssid.wep.idx) 376 hostapd_set_privacy(hapd, 1); 377 } 378 379 return 0; 380} 381 382 383static int hostapd_flush_old_stations(struct hostapd_data *hapd, u16 reason) 384{ 385 int ret = 0; 386 u8 addr[ETH_ALEN]; 387 388 if (hostapd_drv_none(hapd) || hapd->drv_priv == NULL) 389 return 0; 390 391 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "Flushing old station entries"); 392 if (hostapd_flush(hapd)) { 393 wpa_msg(hapd->msg_ctx, MSG_WARNING, "Could not connect to " 394 "kernel driver"); 395 ret = -1; 396 } 397 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "Deauthenticate all stations"); 398 os_memset(addr, 0xff, ETH_ALEN); 399 hostapd_drv_sta_deauth(hapd, addr, reason); 400 hostapd_free_stas(hapd); 401 402 return ret; 403} 404 405 406/** 407 * hostapd_validate_bssid_configuration - Validate BSSID configuration 408 * @iface: Pointer to interface data 409 * Returns: 0 on success, -1 on failure 410 * 411 * This function is used to validate that the configured BSSIDs are valid. 412 */ 413static int hostapd_validate_bssid_configuration(struct hostapd_iface *iface) 414{ 415 u8 mask[ETH_ALEN] = { 0 }; 416 struct hostapd_data *hapd = iface->bss[0]; 417 unsigned int i = iface->conf->num_bss, bits = 0, j; 418 int auto_addr = 0; 419 420 if (hostapd_drv_none(hapd)) 421 return 0; 422 423 /* Generate BSSID mask that is large enough to cover the BSSIDs. */ 424 425 /* Determine the bits necessary to cover the number of BSSIDs. */ 426 for (i--; i; i >>= 1) 427 bits++; 428 429 /* Determine the bits necessary to any configured BSSIDs, 430 if they are higher than the number of BSSIDs. */ 431 for (j = 0; j < iface->conf->num_bss; j++) { 432 if (hostapd_mac_comp_empty(iface->conf->bss[j].bssid) == 0) { 433 if (j) 434 auto_addr++; 435 continue; 436 } 437 438 for (i = 0; i < ETH_ALEN; i++) { 439 mask[i] |= 440 iface->conf->bss[j].bssid[i] ^ 441 hapd->own_addr[i]; 442 } 443 } 444 445 if (!auto_addr) 446 goto skip_mask_ext; 447 448 for (i = 0; i < ETH_ALEN && mask[i] == 0; i++) 449 ; 450 j = 0; 451 if (i < ETH_ALEN) { 452 j = (5 - i) * 8; 453 454 while (mask[i] != 0) { 455 mask[i] >>= 1; 456 j++; 457 } 458 } 459 460 if (bits < j) 461 bits = j; 462 463 if (bits > 40) { 464 wpa_printf(MSG_ERROR, "Too many bits in the BSSID mask (%u)", 465 bits); 466 return -1; 467 } 468 469 os_memset(mask, 0xff, ETH_ALEN); 470 j = bits / 8; 471 for (i = 5; i > 5 - j; i--) 472 mask[i] = 0; 473 j = bits % 8; 474 while (j--) 475 mask[i] <<= 1; 476 477skip_mask_ext: 478 wpa_printf(MSG_DEBUG, "BSS count %lu, BSSID mask " MACSTR " (%d bits)", 479 (unsigned long) iface->conf->num_bss, MAC2STR(mask), bits); 480 481 if (!auto_addr) 482 return 0; 483 484 for (i = 0; i < ETH_ALEN; i++) { 485 if ((hapd->own_addr[i] & mask[i]) != hapd->own_addr[i]) { 486 wpa_printf(MSG_ERROR, "Invalid BSSID mask " MACSTR 487 " for start address " MACSTR ".", 488 MAC2STR(mask), MAC2STR(hapd->own_addr)); 489 wpa_printf(MSG_ERROR, "Start address must be the " 490 "first address in the block (i.e., addr " 491 "AND mask == addr)."); 492 return -1; 493 } 494 } 495 496 return 0; 497} 498 499 500static int mac_in_conf(struct hostapd_config *conf, const void *a) 501{ 502 size_t i; 503 504 for (i = 0; i < conf->num_bss; i++) { 505 if (hostapd_mac_comp(conf->bss[i].bssid, a) == 0) { 506 return 1; 507 } 508 } 509 510 return 0; 511} 512 513 514#ifndef CONFIG_NO_RADIUS 515 516static int hostapd_das_nas_mismatch(struct hostapd_data *hapd, 517 struct radius_das_attrs *attr) 518{ 519 /* TODO */ 520 return 0; 521} 522 523 524static struct sta_info * hostapd_das_find_sta(struct hostapd_data *hapd, 525 struct radius_das_attrs *attr) 526{ 527 struct sta_info *sta = NULL; 528 char buf[128]; 529 530 if (attr->sta_addr) 531 sta = ap_get_sta(hapd, attr->sta_addr); 532 533 if (sta == NULL && attr->acct_session_id && 534 attr->acct_session_id_len == 17) { 535 for (sta = hapd->sta_list; sta; sta = sta->next) { 536 os_snprintf(buf, sizeof(buf), "%08X-%08X", 537 sta->acct_session_id_hi, 538 sta->acct_session_id_lo); 539 if (os_memcmp(attr->acct_session_id, buf, 17) == 0) 540 break; 541 } 542 } 543 544 if (sta == NULL && attr->cui) { 545 for (sta = hapd->sta_list; sta; sta = sta->next) { 546 struct wpabuf *cui; 547 cui = ieee802_1x_get_radius_cui(sta->eapol_sm); 548 if (cui && wpabuf_len(cui) == attr->cui_len && 549 os_memcmp(wpabuf_head(cui), attr->cui, 550 attr->cui_len) == 0) 551 break; 552 } 553 } 554 555 if (sta == NULL && attr->user_name) { 556 for (sta = hapd->sta_list; sta; sta = sta->next) { 557 u8 *identity; 558 size_t identity_len; 559 identity = ieee802_1x_get_identity(sta->eapol_sm, 560 &identity_len); 561 if (identity && 562 identity_len == attr->user_name_len && 563 os_memcmp(identity, attr->user_name, identity_len) 564 == 0) 565 break; 566 } 567 } 568 569 return sta; 570} 571 572 573static enum radius_das_res 574hostapd_das_disconnect(void *ctx, struct radius_das_attrs *attr) 575{ 576 struct hostapd_data *hapd = ctx; 577 struct sta_info *sta; 578 579 if (hostapd_das_nas_mismatch(hapd, attr)) 580 return RADIUS_DAS_NAS_MISMATCH; 581 582 sta = hostapd_das_find_sta(hapd, attr); 583 if (sta == NULL) 584 return RADIUS_DAS_SESSION_NOT_FOUND; 585 586 hostapd_drv_sta_deauth(hapd, sta->addr, 587 WLAN_REASON_PREV_AUTH_NOT_VALID); 588 ap_sta_deauthenticate(hapd, sta, WLAN_REASON_PREV_AUTH_NOT_VALID); 589 590 return RADIUS_DAS_SUCCESS; 591} 592 593#endif /* CONFIG_NO_RADIUS */ 594 595 596/** 597 * hostapd_setup_bss - Per-BSS setup (initialization) 598 * @hapd: Pointer to BSS data 599 * @first: Whether this BSS is the first BSS of an interface 600 * 601 * This function is used to initialize all per-BSS data structures and 602 * resources. This gets called in a loop for each BSS when an interface is 603 * initialized. Most of the modules that are initialized here will be 604 * deinitialized in hostapd_cleanup(). 605 */ 606static int hostapd_setup_bss(struct hostapd_data *hapd, int first) 607{ 608 struct hostapd_bss_config *conf = hapd->conf; 609 u8 ssid[HOSTAPD_MAX_SSID_LEN + 1]; 610 int ssid_len, set_ssid; 611 char force_ifname[IFNAMSIZ]; 612 u8 if_addr[ETH_ALEN]; 613 614 if (!first) { 615 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0) { 616 /* Allocate the next available BSSID. */ 617 do { 618 inc_byte_array(hapd->own_addr, ETH_ALEN); 619 } while (mac_in_conf(hapd->iconf, hapd->own_addr)); 620 } else { 621 /* Allocate the configured BSSID. */ 622 os_memcpy(hapd->own_addr, hapd->conf->bssid, ETH_ALEN); 623 624 if (hostapd_mac_comp(hapd->own_addr, 625 hapd->iface->bss[0]->own_addr) == 626 0) { 627 wpa_printf(MSG_ERROR, "BSS '%s' may not have " 628 "BSSID set to the MAC address of " 629 "the radio", hapd->conf->iface); 630 return -1; 631 } 632 } 633 634 hapd->interface_added = 1; 635 if (hostapd_if_add(hapd->iface->bss[0], WPA_IF_AP_BSS, 636 hapd->conf->iface, hapd->own_addr, hapd, 637 &hapd->drv_priv, force_ifname, if_addr, 638 hapd->conf->bridge[0] ? hapd->conf->bridge : 639 NULL)) { 640 wpa_printf(MSG_ERROR, "Failed to add BSS (BSSID=" 641 MACSTR ")", MAC2STR(hapd->own_addr)); 642 return -1; 643 } 644 } 645 646 if (conf->wmm_enabled < 0) 647 conf->wmm_enabled = hapd->iconf->ieee80211n; 648 649 hostapd_flush_old_stations(hapd, WLAN_REASON_PREV_AUTH_NOT_VALID); 650 hostapd_set_privacy(hapd, 0); 651 652 hostapd_broadcast_wep_clear(hapd); 653 if (hostapd_setup_encryption(hapd->conf->iface, hapd)) 654 return -1; 655 656 /* 657 * Fetch the SSID from the system and use it or, 658 * if one was specified in the config file, verify they 659 * match. 660 */ 661 ssid_len = hostapd_get_ssid(hapd, ssid, sizeof(ssid)); 662 if (ssid_len < 0) { 663 wpa_printf(MSG_ERROR, "Could not read SSID from system"); 664 return -1; 665 } 666 if (conf->ssid.ssid_set) { 667 /* 668 * If SSID is specified in the config file and it differs 669 * from what is being used then force installation of the 670 * new SSID. 671 */ 672 set_ssid = (conf->ssid.ssid_len != (size_t) ssid_len || 673 os_memcmp(conf->ssid.ssid, ssid, ssid_len) != 0); 674 } else { 675 /* 676 * No SSID in the config file; just use the one we got 677 * from the system. 678 */ 679 set_ssid = 0; 680 conf->ssid.ssid_len = ssid_len; 681 os_memcpy(conf->ssid.ssid, ssid, conf->ssid.ssid_len); 682 } 683 684 if (!hostapd_drv_none(hapd)) { 685 wpa_printf(MSG_ERROR, "Using interface %s with hwaddr " MACSTR 686 " and ssid \"%s\"", 687 hapd->conf->iface, MAC2STR(hapd->own_addr), 688 wpa_ssid_txt(hapd->conf->ssid.ssid, 689 hapd->conf->ssid.ssid_len)); 690 } 691 692 if (hostapd_setup_wpa_psk(conf)) { 693 wpa_printf(MSG_ERROR, "WPA-PSK setup failed."); 694 return -1; 695 } 696 697 /* Set SSID for the kernel driver (to be used in beacon and probe 698 * response frames) */ 699 if (set_ssid && hostapd_set_ssid(hapd, conf->ssid.ssid, 700 conf->ssid.ssid_len)) { 701 wpa_printf(MSG_ERROR, "Could not set SSID for kernel driver"); 702 return -1; 703 } 704 705 if (wpa_debug_level == MSG_MSGDUMP) 706 conf->radius->msg_dumps = 1; 707#ifndef CONFIG_NO_RADIUS 708 hapd->radius = radius_client_init(hapd, conf->radius); 709 if (hapd->radius == NULL) { 710 wpa_printf(MSG_ERROR, "RADIUS client initialization failed."); 711 return -1; 712 } 713 714 if (hapd->conf->radius_das_port) { 715 struct radius_das_conf das_conf; 716 os_memset(&das_conf, 0, sizeof(das_conf)); 717 das_conf.port = hapd->conf->radius_das_port; 718 das_conf.shared_secret = hapd->conf->radius_das_shared_secret; 719 das_conf.shared_secret_len = 720 hapd->conf->radius_das_shared_secret_len; 721 das_conf.client_addr = &hapd->conf->radius_das_client_addr; 722 das_conf.time_window = hapd->conf->radius_das_time_window; 723 das_conf.require_event_timestamp = 724 hapd->conf->radius_das_require_event_timestamp; 725 das_conf.ctx = hapd; 726 das_conf.disconnect = hostapd_das_disconnect; 727 hapd->radius_das = radius_das_init(&das_conf); 728 if (hapd->radius_das == NULL) { 729 wpa_printf(MSG_ERROR, "RADIUS DAS initialization " 730 "failed."); 731 return -1; 732 } 733 } 734#endif /* CONFIG_NO_RADIUS */ 735 736 if (hostapd_acl_init(hapd)) { 737 wpa_printf(MSG_ERROR, "ACL initialization failed."); 738 return -1; 739 } 740 if (hostapd_init_wps(hapd, conf)) 741 return -1; 742 743 if (authsrv_init(hapd) < 0) 744 return -1; 745 746 if (ieee802_1x_init(hapd)) { 747 wpa_printf(MSG_ERROR, "IEEE 802.1X initialization failed."); 748 return -1; 749 } 750 751 if (hapd->conf->wpa && hostapd_setup_wpa(hapd)) 752 return -1; 753 754 if (accounting_init(hapd)) { 755 wpa_printf(MSG_ERROR, "Accounting initialization failed."); 756 return -1; 757 } 758 759 if (hapd->conf->ieee802_11f && 760 (hapd->iapp = iapp_init(hapd, hapd->conf->iapp_iface)) == NULL) { 761 wpa_printf(MSG_ERROR, "IEEE 802.11F (IAPP) initialization " 762 "failed."); 763 return -1; 764 } 765 766#ifdef CONFIG_INTERWORKING 767 if (gas_serv_init(hapd)) { 768 wpa_printf(MSG_ERROR, "GAS server initialization failed"); 769 return -1; 770 } 771#endif /* CONFIG_INTERWORKING */ 772 773 if (hapd->iface->interfaces && 774 hapd->iface->interfaces->ctrl_iface_init && 775 hapd->iface->interfaces->ctrl_iface_init(hapd)) { 776 wpa_printf(MSG_ERROR, "Failed to setup control interface"); 777 return -1; 778 } 779 780 if (!hostapd_drv_none(hapd) && vlan_init(hapd)) { 781 wpa_printf(MSG_ERROR, "VLAN initialization failed."); 782 return -1; 783 } 784 785 if (!hapd->conf->start_disabled) 786 ieee802_11_set_beacon(hapd); 787 788 if (hapd->wpa_auth && wpa_init_keys(hapd->wpa_auth) < 0) 789 return -1; 790 791 if (hapd->driver && hapd->driver->set_operstate) 792 hapd->driver->set_operstate(hapd->drv_priv, 1); 793 794 return 0; 795} 796 797 798static void hostapd_tx_queue_params(struct hostapd_iface *iface) 799{ 800 struct hostapd_data *hapd = iface->bss[0]; 801 int i; 802 struct hostapd_tx_queue_params *p; 803 804 for (i = 0; i < NUM_TX_QUEUES; i++) { 805 p = &iface->conf->tx_queue[i]; 806 807 if (hostapd_set_tx_queue_params(hapd, i, p->aifs, p->cwmin, 808 p->cwmax, p->burst)) { 809 wpa_printf(MSG_DEBUG, "Failed to set TX queue " 810 "parameters for queue %d.", i); 811 /* Continue anyway */ 812 } 813 } 814} 815 816 817static int hostapd_set_acl_list(struct hostapd_data *hapd, 818 struct mac_acl_entry *mac_acl, 819 int n_entries, u8 accept_acl) 820{ 821 struct hostapd_acl_params *acl_params; 822 int i, err; 823 824 acl_params = os_zalloc(sizeof(*acl_params) + 825 (n_entries * sizeof(acl_params->mac_acl[0]))); 826 if (!acl_params) 827 return -ENOMEM; 828 829 for (i = 0; i < n_entries; i++) 830 os_memcpy(acl_params->mac_acl[i].addr, mac_acl[i].addr, 831 ETH_ALEN); 832 833 acl_params->acl_policy = accept_acl; 834 acl_params->num_mac_acl = n_entries; 835 836 err = hostapd_drv_set_acl(hapd, acl_params); 837 838 os_free(acl_params); 839 840 return err; 841} 842 843 844static void hostapd_set_acl(struct hostapd_data *hapd) 845{ 846 struct hostapd_config *conf = hapd->iconf; 847 int err; 848 u8 accept_acl; 849 850 if (hapd->iface->drv_max_acl_mac_addrs == 0) 851 return; 852 if (!(conf->bss->num_accept_mac || conf->bss->num_deny_mac)) 853 return; 854 855 if (conf->bss->macaddr_acl == DENY_UNLESS_ACCEPTED) { 856 if (conf->bss->num_accept_mac) { 857 accept_acl = 1; 858 err = hostapd_set_acl_list(hapd, conf->bss->accept_mac, 859 conf->bss->num_accept_mac, 860 accept_acl); 861 if (err) { 862 wpa_printf(MSG_DEBUG, "Failed to set accept acl"); 863 return; 864 } 865 } else { 866 wpa_printf(MSG_DEBUG, "Mismatch between ACL Policy & Accept/deny lists file"); 867 } 868 } else if (conf->bss->macaddr_acl == ACCEPT_UNLESS_DENIED) { 869 if (conf->bss->num_deny_mac) { 870 accept_acl = 0; 871 err = hostapd_set_acl_list(hapd, conf->bss->deny_mac, 872 conf->bss->num_deny_mac, 873 accept_acl); 874 if (err) { 875 wpa_printf(MSG_DEBUG, "Failed to set deny acl"); 876 return; 877 } 878 } else { 879 wpa_printf(MSG_DEBUG, "Mismatch between ACL Policy & Accept/deny lists file"); 880 } 881 } 882} 883 884 885static int setup_interface(struct hostapd_iface *iface) 886{ 887 struct hostapd_data *hapd = iface->bss[0]; 888 size_t i; 889 char country[4]; 890 891 /* 892 * Make sure that all BSSes get configured with a pointer to the same 893 * driver interface. 894 */ 895 for (i = 1; i < iface->num_bss; i++) { 896 iface->bss[i]->driver = hapd->driver; 897 iface->bss[i]->drv_priv = hapd->drv_priv; 898 } 899 900 if (hostapd_validate_bssid_configuration(iface)) 901 return -1; 902 903 if (hapd->iconf->country[0] && hapd->iconf->country[1]) { 904 os_memcpy(country, hapd->iconf->country, 3); 905 country[3] = '\0'; 906 if (hostapd_set_country(hapd, country) < 0) { 907 wpa_printf(MSG_ERROR, "Failed to set country code"); 908 return -1; 909 } 910 } 911 912 if (hostapd_get_hw_features(iface)) { 913 /* Not all drivers support this yet, so continue without hw 914 * feature data. */ 915 } else { 916 int ret = hostapd_select_hw_mode(iface); 917 if (ret < 0) { 918 wpa_printf(MSG_ERROR, "Could not select hw_mode and " 919 "channel. (%d)", ret); 920 return -1; 921 } 922 if (ret == 1) { 923 wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback (ACS)"); 924 return 0; 925 } 926 ret = hostapd_check_ht_capab(iface); 927 if (ret < 0) 928 return -1; 929 if (ret == 1) { 930 wpa_printf(MSG_DEBUG, "Interface initialization will " 931 "be completed in a callback"); 932 return 0; 933 } 934 } 935 return hostapd_setup_interface_complete(iface, 0); 936} 937 938 939int hostapd_setup_interface_complete(struct hostapd_iface *iface, int err) 940{ 941 struct hostapd_data *hapd = iface->bss[0]; 942 size_t j; 943 u8 *prev_addr; 944 945 if (err) { 946 wpa_printf(MSG_ERROR, "Interface initialization failed"); 947 eloop_terminate(); 948 return -1; 949 } 950 951 wpa_printf(MSG_DEBUG, "Completing interface initialization"); 952 if (hapd->iconf->channel) { 953 iface->freq = hostapd_hw_get_freq(hapd, hapd->iconf->channel); 954 wpa_printf(MSG_DEBUG, "Mode: %s Channel: %d " 955 "Frequency: %d MHz", 956 hostapd_hw_mode_txt(hapd->iconf->hw_mode), 957 hapd->iconf->channel, iface->freq); 958 959 if (hostapd_set_freq(hapd, hapd->iconf->hw_mode, iface->freq, 960 hapd->iconf->channel, 961 hapd->iconf->ieee80211n, 962 hapd->iconf->ieee80211ac, 963 hapd->iconf->secondary_channel, 964 hapd->iconf->vht_oper_chwidth, 965 hapd->iconf->vht_oper_centr_freq_seg0_idx, 966 hapd->iconf->vht_oper_centr_freq_seg1_idx)) { 967 wpa_printf(MSG_ERROR, "Could not set channel for " 968 "kernel driver"); 969 return -1; 970 } 971 } 972 973 if (iface->current_mode) { 974 if (hostapd_prepare_rates(iface, iface->current_mode)) { 975 wpa_printf(MSG_ERROR, "Failed to prepare rates " 976 "table."); 977 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 978 HOSTAPD_LEVEL_WARNING, 979 "Failed to prepare rates table."); 980 return -1; 981 } 982 } 983 984 if (hapd->iconf->rts_threshold > -1 && 985 hostapd_set_rts(hapd, hapd->iconf->rts_threshold)) { 986 wpa_printf(MSG_ERROR, "Could not set RTS threshold for " 987 "kernel driver"); 988 return -1; 989 } 990 991 if (hapd->iconf->fragm_threshold > -1 && 992 hostapd_set_frag(hapd, hapd->iconf->fragm_threshold)) { 993 wpa_printf(MSG_ERROR, "Could not set fragmentation threshold " 994 "for kernel driver"); 995 return -1; 996 } 997 998 prev_addr = hapd->own_addr; 999 1000 for (j = 0; j < iface->num_bss; j++) { 1001 hapd = iface->bss[j]; 1002 if (j) 1003 os_memcpy(hapd->own_addr, prev_addr, ETH_ALEN); 1004 if (hostapd_setup_bss(hapd, j == 0)) 1005 return -1; 1006 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0) 1007 prev_addr = hapd->own_addr; 1008 } 1009 1010 hostapd_tx_queue_params(iface); 1011 1012 ap_list_init(iface); 1013 1014 hostapd_set_acl(hapd); 1015 1016 if (hostapd_driver_commit(hapd) < 0) { 1017 wpa_printf(MSG_ERROR, "%s: Failed to commit driver " 1018 "configuration", __func__); 1019 return -1; 1020 } 1021 1022 /* 1023 * WPS UPnP module can be initialized only when the "upnp_iface" is up. 1024 * If "interface" and "upnp_iface" are the same (e.g., non-bridge 1025 * mode), the interface is up only after driver_commit, so initialize 1026 * WPS after driver_commit. 1027 */ 1028 for (j = 0; j < iface->num_bss; j++) { 1029 if (hostapd_init_wps_complete(iface->bss[j])) 1030 return -1; 1031 } 1032 1033 if (hapd->setup_complete_cb) 1034 hapd->setup_complete_cb(hapd->setup_complete_cb_ctx); 1035 1036 wpa_printf(MSG_DEBUG, "%s: Setup of interface done.", 1037 iface->bss[0]->conf->iface); 1038 1039 return 0; 1040} 1041 1042 1043/** 1044 * hostapd_setup_interface - Setup of an interface 1045 * @iface: Pointer to interface data. 1046 * Returns: 0 on success, -1 on failure 1047 * 1048 * Initializes the driver interface, validates the configuration, 1049 * and sets driver parameters based on the configuration. 1050 * Flushes old stations, sets the channel, encryption, 1051 * beacons, and WDS links based on the configuration. 1052 */ 1053int hostapd_setup_interface(struct hostapd_iface *iface) 1054{ 1055 int ret; 1056 1057 ret = setup_interface(iface); 1058 if (ret) { 1059 wpa_printf(MSG_ERROR, "%s: Unable to setup interface.", 1060 iface->bss[0]->conf->iface); 1061 return -1; 1062 } 1063 1064 return 0; 1065} 1066 1067 1068/** 1069 * hostapd_alloc_bss_data - Allocate and initialize per-BSS data 1070 * @hapd_iface: Pointer to interface data 1071 * @conf: Pointer to per-interface configuration 1072 * @bss: Pointer to per-BSS configuration for this BSS 1073 * Returns: Pointer to allocated BSS data 1074 * 1075 * This function is used to allocate per-BSS data structure. This data will be 1076 * freed after hostapd_cleanup() is called for it during interface 1077 * deinitialization. 1078 */ 1079struct hostapd_data * 1080hostapd_alloc_bss_data(struct hostapd_iface *hapd_iface, 1081 struct hostapd_config *conf, 1082 struct hostapd_bss_config *bss) 1083{ 1084 struct hostapd_data *hapd; 1085 1086 hapd = os_zalloc(sizeof(*hapd)); 1087 if (hapd == NULL) 1088 return NULL; 1089 1090 hapd->new_assoc_sta_cb = hostapd_new_assoc_sta; 1091 hapd->iconf = conf; 1092 hapd->conf = bss; 1093 hapd->iface = hapd_iface; 1094 hapd->driver = hapd->iconf->driver; 1095 hapd->ctrl_sock = -1; 1096 1097 return hapd; 1098} 1099 1100 1101void hostapd_interface_deinit(struct hostapd_iface *iface) 1102{ 1103 size_t j; 1104 1105 if (iface == NULL) 1106 return; 1107 1108 hostapd_cleanup_iface_pre(iface); 1109 for (j = 0; j < iface->num_bss; j++) { 1110 struct hostapd_data *hapd = iface->bss[j]; 1111 hostapd_free_stas(hapd); 1112 hostapd_flush_old_stations(hapd, WLAN_REASON_DEAUTH_LEAVING); 1113 hostapd_clear_wep(hapd); 1114 hostapd_cleanup(hapd); 1115 } 1116} 1117 1118 1119void hostapd_interface_free(struct hostapd_iface *iface) 1120{ 1121 size_t j; 1122 for (j = 0; j < iface->num_bss; j++) 1123 os_free(iface->bss[j]); 1124 hostapd_cleanup_iface(iface); 1125} 1126 1127 1128#ifdef HOSTAPD 1129 1130void hostapd_interface_deinit_free(struct hostapd_iface *iface) 1131{ 1132 const struct wpa_driver_ops *driver; 1133 void *drv_priv; 1134 if (iface == NULL) 1135 return; 1136 driver = iface->bss[0]->driver; 1137 drv_priv = iface->bss[0]->drv_priv; 1138 hostapd_interface_deinit(iface); 1139 if (driver && driver->hapd_deinit && drv_priv) 1140 driver->hapd_deinit(drv_priv); 1141 hostapd_interface_free(iface); 1142} 1143 1144 1145int hostapd_enable_iface(struct hostapd_iface *hapd_iface) 1146{ 1147 if (hapd_iface->bss[0]->drv_priv != NULL) { 1148 wpa_printf(MSG_ERROR, "Interface %s already enabled", 1149 hapd_iface->conf->bss[0].iface); 1150 return -1; 1151 } 1152 1153 wpa_printf(MSG_DEBUG, "Enable interface %s", 1154 hapd_iface->conf->bss[0].iface); 1155 1156 if (hapd_iface->interfaces == NULL || 1157 hapd_iface->interfaces->driver_init == NULL || 1158 hapd_iface->interfaces->driver_init(hapd_iface) || 1159 hostapd_setup_interface(hapd_iface)) { 1160 hostapd_interface_deinit_free(hapd_iface); 1161 return -1; 1162 } 1163 return 0; 1164} 1165 1166 1167int hostapd_reload_iface(struct hostapd_iface *hapd_iface) 1168{ 1169 size_t j; 1170 1171 wpa_printf(MSG_DEBUG, "Reload interface %s", 1172 hapd_iface->conf->bss[0].iface); 1173 for (j = 0; j < hapd_iface->num_bss; j++) { 1174 hostapd_flush_old_stations(hapd_iface->bss[j], 1175 WLAN_REASON_PREV_AUTH_NOT_VALID); 1176 1177#ifndef CONFIG_NO_RADIUS 1178 /* TODO: update dynamic data based on changed configuration 1179 * items (e.g., open/close sockets, etc.) */ 1180 radius_client_flush(hapd_iface->bss[j]->radius, 0); 1181#endif /* CONFIG_NO_RADIUS */ 1182 1183 hostapd_reload_bss(hapd_iface->bss[j]); 1184 } 1185 return 0; 1186} 1187 1188 1189int hostapd_disable_iface(struct hostapd_iface *hapd_iface) 1190{ 1191 size_t j; 1192 struct hostapd_bss_config *bss; 1193 const struct wpa_driver_ops *driver; 1194 void *drv_priv; 1195 1196 if (hapd_iface == NULL) 1197 return -1; 1198 bss = hapd_iface->bss[0]->conf; 1199 driver = hapd_iface->bss[0]->driver; 1200 drv_priv = hapd_iface->bss[0]->drv_priv; 1201 1202 /* whatever hostapd_interface_deinit does */ 1203 for (j = 0; j < hapd_iface->num_bss; j++) { 1204 struct hostapd_data *hapd = hapd_iface->bss[j]; 1205 hostapd_free_stas(hapd); 1206 hostapd_flush_old_stations(hapd, WLAN_REASON_DEAUTH_LEAVING); 1207 hostapd_clear_wep(hapd); 1208 hostapd_free_hapd_data(hapd); 1209 } 1210 1211 if (driver && driver->hapd_deinit && drv_priv) { 1212 driver->hapd_deinit(drv_priv); 1213 hapd_iface->bss[0]->drv_priv = NULL; 1214 } 1215 1216 /* From hostapd_cleanup_iface: These were initialized in 1217 * hostapd_setup_interface and hostapd_setup_interface_complete 1218 */ 1219 hostapd_cleanup_iface_partial(hapd_iface); 1220 bss->wpa = 0; 1221 bss->wpa_key_mgmt = -1; 1222 bss->wpa_pairwise = -1; 1223 1224 wpa_printf(MSG_DEBUG, "Interface %s disabled", bss->iface); 1225 return 0; 1226} 1227 1228 1229static struct hostapd_iface * 1230hostapd_iface_alloc(struct hapd_interfaces *interfaces) 1231{ 1232 struct hostapd_iface **iface, *hapd_iface; 1233 1234 iface = os_realloc_array(interfaces->iface, interfaces->count + 1, 1235 sizeof(struct hostapd_iface *)); 1236 if (iface == NULL) 1237 return NULL; 1238 interfaces->iface = iface; 1239 hapd_iface = interfaces->iface[interfaces->count] = 1240 os_zalloc(sizeof(*hapd_iface)); 1241 if (hapd_iface == NULL) { 1242 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 1243 "the interface", __func__); 1244 return NULL; 1245 } 1246 interfaces->count++; 1247 hapd_iface->interfaces = interfaces; 1248 1249 return hapd_iface; 1250} 1251 1252 1253static struct hostapd_config * 1254hostapd_config_alloc(struct hapd_interfaces *interfaces, const char *ifname, 1255 const char *ctrl_iface) 1256{ 1257 struct hostapd_bss_config *bss; 1258 struct hostapd_config *conf; 1259 1260 /* Allocates memory for bss and conf */ 1261 conf = hostapd_config_defaults(); 1262 if (conf == NULL) { 1263 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for " 1264 "configuration", __func__); 1265 return NULL; 1266 } 1267 1268 conf->driver = wpa_drivers[0]; 1269 if (conf->driver == NULL) { 1270 wpa_printf(MSG_ERROR, "No driver wrappers registered!"); 1271 hostapd_config_free(conf); 1272 return NULL; 1273 } 1274 1275 bss = conf->last_bss = conf->bss; 1276 1277 os_strlcpy(bss->iface, ifname, sizeof(bss->iface)); 1278 bss->ctrl_interface = os_strdup(ctrl_iface); 1279 if (bss->ctrl_interface == NULL) { 1280 hostapd_config_free(conf); 1281 return NULL; 1282 } 1283 1284 /* Reading configuration file skipped, will be done in SET! 1285 * From reading the configuration till the end has to be done in 1286 * SET 1287 */ 1288 return conf; 1289} 1290 1291 1292static struct hostapd_iface * hostapd_data_alloc( 1293 struct hapd_interfaces *interfaces, struct hostapd_config *conf) 1294{ 1295 size_t i; 1296 struct hostapd_iface *hapd_iface = 1297 interfaces->iface[interfaces->count - 1]; 1298 struct hostapd_data *hapd; 1299 1300 hapd_iface->conf = conf; 1301 hapd_iface->num_bss = conf->num_bss; 1302 1303 hapd_iface->bss = os_zalloc(conf->num_bss * 1304 sizeof(struct hostapd_data *)); 1305 if (hapd_iface->bss == NULL) 1306 return NULL; 1307 1308 for (i = 0; i < conf->num_bss; i++) { 1309 hapd = hapd_iface->bss[i] = 1310 hostapd_alloc_bss_data(hapd_iface, conf, 1311 &conf->bss[i]); 1312 if (hapd == NULL) 1313 return NULL; 1314 hapd->msg_ctx = hapd; 1315 } 1316 1317 hapd_iface->interfaces = interfaces; 1318 1319 return hapd_iface; 1320} 1321 1322 1323int hostapd_add_iface(struct hapd_interfaces *interfaces, char *buf) 1324{ 1325 struct hostapd_config *conf = NULL; 1326 struct hostapd_iface *hapd_iface = NULL; 1327 char *ptr; 1328 size_t i; 1329 1330 ptr = os_strchr(buf, ' '); 1331 if (ptr == NULL) 1332 return -1; 1333 *ptr++ = '\0'; 1334 1335 for (i = 0; i < interfaces->count; i++) { 1336 if (!os_strcmp(interfaces->iface[i]->conf->bss[0].iface, 1337 buf)) { 1338 wpa_printf(MSG_INFO, "Cannot add interface - it " 1339 "already exists"); 1340 return -1; 1341 } 1342 } 1343 1344 hapd_iface = hostapd_iface_alloc(interfaces); 1345 if (hapd_iface == NULL) { 1346 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 1347 "for interface", __func__); 1348 goto fail; 1349 } 1350 1351 conf = hostapd_config_alloc(interfaces, buf, ptr); 1352 if (conf == NULL) { 1353 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 1354 "for configuration", __func__); 1355 goto fail; 1356 } 1357 1358 hapd_iface = hostapd_data_alloc(interfaces, conf); 1359 if (hapd_iface == NULL) { 1360 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory " 1361 "for hostapd", __func__); 1362 goto fail; 1363 } 1364 1365 if (hapd_iface->interfaces && 1366 hapd_iface->interfaces->ctrl_iface_init && 1367 hapd_iface->interfaces->ctrl_iface_init(hapd_iface->bss[0])) { 1368 wpa_printf(MSG_ERROR, "%s: Failed to setup control " 1369 "interface", __func__); 1370 goto fail; 1371 } 1372 wpa_printf(MSG_INFO, "Add interface '%s'", conf->bss[0].iface); 1373 1374 return 0; 1375 1376fail: 1377 if (conf) 1378 hostapd_config_free(conf); 1379 if (hapd_iface) { 1380 os_free(hapd_iface->bss[interfaces->count]); 1381 os_free(hapd_iface); 1382 } 1383 return -1; 1384} 1385 1386 1387int hostapd_remove_iface(struct hapd_interfaces *interfaces, char *buf) 1388{ 1389 struct hostapd_iface *hapd_iface; 1390 size_t i, k = 0; 1391 1392 for (i = 0; i < interfaces->count; i++) { 1393 hapd_iface = interfaces->iface[i]; 1394 if (hapd_iface == NULL) 1395 return -1; 1396 if (!os_strcmp(hapd_iface->conf->bss[0].iface, buf)) { 1397 wpa_printf(MSG_INFO, "Remove interface '%s'", buf); 1398 hostapd_interface_deinit_free(hapd_iface); 1399 k = i; 1400 while (k < (interfaces->count - 1)) { 1401 interfaces->iface[k] = 1402 interfaces->iface[k + 1]; 1403 k++; 1404 } 1405 interfaces->count--; 1406 return 0; 1407 } 1408 } 1409 return -1; 1410} 1411 1412#endif /* HOSTAPD */ 1413 1414 1415/** 1416 * hostapd_new_assoc_sta - Notify that a new station associated with the AP 1417 * @hapd: Pointer to BSS data 1418 * @sta: Pointer to the associated STA data 1419 * @reassoc: 1 to indicate this was a re-association; 0 = first association 1420 * 1421 * This function will be called whenever a station associates with the AP. It 1422 * can be called from ieee802_11.c for drivers that export MLME to hostapd and 1423 * from drv_callbacks.c based on driver events for drivers that take care of 1424 * management frames (IEEE 802.11 authentication and association) internally. 1425 */ 1426void hostapd_new_assoc_sta(struct hostapd_data *hapd, struct sta_info *sta, 1427 int reassoc) 1428{ 1429 if (hapd->tkip_countermeasures) { 1430 hostapd_drv_sta_deauth(hapd, sta->addr, 1431 WLAN_REASON_MICHAEL_MIC_FAILURE); 1432 return; 1433 } 1434 1435 hostapd_prune_associations(hapd, sta->addr); 1436 1437 /* IEEE 802.11F (IAPP) */ 1438 if (hapd->conf->ieee802_11f) 1439 iapp_new_station(hapd->iapp, sta); 1440 1441#ifdef CONFIG_P2P 1442 if (sta->p2p_ie == NULL && !sta->no_p2p_set) { 1443 sta->no_p2p_set = 1; 1444 hapd->num_sta_no_p2p++; 1445 if (hapd->num_sta_no_p2p == 1) 1446 hostapd_p2p_non_p2p_sta_connected(hapd); 1447 } 1448#endif /* CONFIG_P2P */ 1449 1450 /* Start accounting here, if IEEE 802.1X and WPA are not used. 1451 * IEEE 802.1X/WPA code will start accounting after the station has 1452 * been authorized. */ 1453 if (!hapd->conf->ieee802_1x && !hapd->conf->wpa) { 1454 os_get_time(&sta->connected_time); 1455 accounting_sta_start(hapd, sta); 1456 } 1457 1458 /* Start IEEE 802.1X authentication process for new stations */ 1459 ieee802_1x_new_station(hapd, sta); 1460 if (reassoc) { 1461 if (sta->auth_alg != WLAN_AUTH_FT && 1462 !(sta->flags & (WLAN_STA_WPS | WLAN_STA_MAYBE_WPS))) 1463 wpa_auth_sm_event(sta->wpa_sm, WPA_REAUTH); 1464 } else 1465 wpa_auth_sta_associated(hapd->wpa_auth, sta->wpa_sm); 1466 1467 wpa_printf(MSG_DEBUG, "%s: reschedule ap_handle_timer timeout " 1468 "for " MACSTR " (%d seconds - ap_max_inactivity)", 1469 __func__, MAC2STR(sta->addr), 1470 hapd->conf->ap_max_inactivity); 1471 eloop_cancel_timeout(ap_handle_timer, hapd, sta); 1472 eloop_register_timeout(hapd->conf->ap_max_inactivity, 0, 1473 ap_handle_timer, hapd, sta); 1474} 1475