src/ap/hostapd.c

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