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 static 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
 133 int 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
 173 static 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
 202 static 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
 209 static 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
 228 static 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  */
 286 static 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  */
 302 static void hostapd_cleanup_iface_pre(struct hostapd_iface *iface)
 303 {
 304 }
 305
 306
 307 static 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  */
 326 static 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
 338 static 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
 347 static 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
 383 static 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  */
 413 static 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
 477 skip_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
 500 static 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
 516 static int hostapd_das_nas_mismatch(struct hostapd_data *hapd,
 517                                     struct radius_das_attrs *attr)
 518 {
 519         /* TODO */
 520         return 0;
 521 }
 522
 523
 524 static 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
 573 static enum radius_das_res
 574 hostapd_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  */
 606 static 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
 798 static 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
 817 static 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
 844 static 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
 885 static 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
 939 int 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  */
1053 int 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  */
1079 struct hostapd_data *
1080 hostapd_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
1101 void 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
1119 void 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
1130 void 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
1145 int 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
1167 int 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
1189 int 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
1221         wpa_printf(MSG_DEBUG, "Interface %s disabled", bss->iface);
1222         return 0;
1223 }
1224
1225
1226 static struct hostapd_iface *
1227 hostapd_iface_alloc(struct hapd_interfaces *interfaces)
1228 {
1229         struct hostapd_iface **iface, *hapd_iface;
1230
1231         iface = os_realloc_array(interfaces->iface, interfaces->count + 1,
1232                                  sizeof(struct hostapd_iface *));
1233         if (iface == NULL)
1234                 return NULL;
1235         interfaces->iface = iface;
1236         hapd_iface = interfaces->iface[interfaces->count] =
1237                 os_zalloc(sizeof(*hapd_iface));
1238         if (hapd_iface == NULL) {
1239                 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for "
1240                            "the interface", __func__);
1241                 return NULL;
1242         }
1243         interfaces->count++;
1244         hapd_iface->interfaces = interfaces;
1245
1246         return hapd_iface;
1247 }
1248
1249
1250 static struct hostapd_config *
1251 hostapd_config_alloc(struct hapd_interfaces *interfaces, const char *ifname,
1252                      const char *ctrl_iface)
1253 {
1254         struct hostapd_bss_config *bss;
1255         struct hostapd_config *conf;
1256
1257         /* Allocates memory for bss and conf */
1258         conf = hostapd_config_defaults();
1259         if (conf == NULL) {
1260                  wpa_printf(MSG_ERROR, "%s: Failed to allocate memory for "
1261                                 "configuration", __func__);
1262                 return NULL;
1263         }
1264
1265         conf->driver = wpa_drivers[0];
1266         if (conf->driver == NULL) {
1267                 wpa_printf(MSG_ERROR, "No driver wrappers registered!");
1268                 hostapd_config_free(conf);
1269                 return NULL;
1270         }
1271
1272         bss = conf->last_bss = conf->bss;
1273
1274         os_strlcpy(bss->iface, ifname, sizeof(bss->iface));
1275         bss->ctrl_interface = os_strdup(ctrl_iface);
1276         if (bss->ctrl_interface == NULL) {
1277                 hostapd_config_free(conf);
1278                 return NULL;
1279         }
1280
1281         /* Reading configuration file skipped, will be done in SET!
1282          * From reading the configuration till the end has to be done in
1283          * SET
1284          */
1285         return conf;
1286 }
1287
1288
1289 static struct hostapd_iface * hostapd_data_alloc(
1290         struct hapd_interfaces *interfaces, struct hostapd_config *conf)
1291 {
1292         size_t i;
1293         struct hostapd_iface *hapd_iface =
1294                 interfaces->iface[interfaces->count - 1];
1295         struct hostapd_data *hapd;
1296
1297         hapd_iface->conf = conf;
1298         hapd_iface->num_bss = conf->num_bss;
1299
1300         hapd_iface->bss = os_zalloc(conf->num_bss *
1301                                     sizeof(struct hostapd_data *));
1302         if (hapd_iface->bss == NULL)
1303                 return NULL;
1304
1305         for (i = 0; i < conf->num_bss; i++) {
1306                 hapd = hapd_iface->bss[i] =
1307                         hostapd_alloc_bss_data(hapd_iface, conf,
1308                                                &conf->bss[i]);
1309                 if (hapd == NULL)
1310                         return NULL;
1311                 hapd->msg_ctx = hapd;
1312         }
1313
1314         hapd_iface->interfaces = interfaces;
1315
1316         return hapd_iface;
1317 }
1318
1319
1320 int hostapd_add_iface(struct hapd_interfaces *interfaces, char *buf)
1321 {
1322         struct hostapd_config *conf = NULL;
1323         struct hostapd_iface *hapd_iface = NULL;
1324         char *ptr;
1325         size_t i;
1326
1327         ptr = os_strchr(buf, ' ');
1328         if (ptr == NULL)
1329                 return -1;
1330         *ptr++ = '\0';
1331
1332         for (i = 0; i < interfaces->count; i++) {
1333                 if (!os_strcmp(interfaces->iface[i]->conf->bss[0].iface,
1334                                buf)) {
1335                         wpa_printf(MSG_INFO, "Cannot add interface - it "
1336                                    "already exists");
1337                         return -1;
1338                 }
1339         }
1340
1341         hapd_iface = hostapd_iface_alloc(interfaces);
1342         if (hapd_iface == NULL) {
1343                 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory "
1344                            "for interface", __func__);
1345                 goto fail;
1346         }
1347
1348         conf = hostapd_config_alloc(interfaces, buf, ptr);
1349         if (conf == NULL) {
1350                 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory "
1351                            "for configuration", __func__);
1352                 goto fail;
1353         }
1354
1355         hapd_iface = hostapd_data_alloc(interfaces, conf);
1356         if (hapd_iface == NULL) {
1357                 wpa_printf(MSG_ERROR, "%s: Failed to allocate memory "
1358                            "for hostapd", __func__);
1359                 goto fail;
1360         }
1361
1362         if (hapd_iface->interfaces &&
1363             hapd_iface->interfaces->ctrl_iface_init &&
1364             hapd_iface->interfaces->ctrl_iface_init(hapd_iface->bss[0])) {
1365                 wpa_printf(MSG_ERROR, "%s: Failed to setup control "
1366                            "interface", __func__);
1367                 goto fail;
1368         }
1369         wpa_printf(MSG_INFO, "Add interface '%s'", conf->bss[0].iface);
1370
1371         return 0;
1372
1373 fail:
1374         if (conf)
1375                 hostapd_config_free(conf);
1376         if (hapd_iface) {
1377                 os_free(hapd_iface->bss[interfaces->count]);
1378                 os_free(hapd_iface);
1379         }
1380         return -1;
1381 }
1382
1383
1384 int hostapd_remove_iface(struct hapd_interfaces *interfaces, char *buf)
1385 {
1386         struct hostapd_iface *hapd_iface;
1387         size_t i, k = 0;
1388
1389         for (i = 0; i < interfaces->count; i++) {
1390                 hapd_iface = interfaces->iface[i];
1391                 if (hapd_iface == NULL)
1392                         return -1;
1393                 if (!os_strcmp(hapd_iface->conf->bss[0].iface, buf)) {
1394                         wpa_printf(MSG_INFO, "Remove interface '%s'", buf);
1395                         hostapd_interface_deinit_free(hapd_iface);
1396                         k = i;
1397                         while (k < (interfaces->count - 1)) {
1398                                 interfaces->iface[k] =
1399                                         interfaces->iface[k + 1];
1400                                 k++;
1401                         }
1402                         interfaces->count--;
1403                         return 0;
1404                 }
1405         }
1406         return -1;
1407 }
1408
1409 #endif /* HOSTAPD */
1410
1411
1412 /**
1413  * hostapd_new_assoc_sta - Notify that a new station associated with the AP
1414  * @hapd: Pointer to BSS data
1415  * @sta: Pointer to the associated STA data
1416  * @reassoc: 1 to indicate this was a re-association; 0 = first association
1417  *
1418  * This function will be called whenever a station associates with the AP. It
1419  * can be called from ieee802_11.c for drivers that export MLME to hostapd and
1420  * from drv_callbacks.c based on driver events for drivers that take care of
1421  * management frames (IEEE 802.11 authentication and association) internally.
1422  */
1423 void hostapd_new_assoc_sta(struct hostapd_data *hapd, struct sta_info *sta,
1424                            int reassoc)
1425 {
1426         if (hapd->tkip_countermeasures) {
1427                 hostapd_drv_sta_deauth(hapd, sta->addr,
1428                                        WLAN_REASON_MICHAEL_MIC_FAILURE);
1429                 return;
1430         }
1431
1432         hostapd_prune_associations(hapd, sta->addr);
1433
1434         /* IEEE 802.11F (IAPP) */
1435         if (hapd->conf->ieee802_11f)
1436                 iapp_new_station(hapd->iapp, sta);
1437
1438 #ifdef CONFIG_P2P
1439         if (sta->p2p_ie == NULL && !sta->no_p2p_set) {
1440                 sta->no_p2p_set = 1;
1441                 hapd->num_sta_no_p2p++;
1442                 if (hapd->num_sta_no_p2p == 1)
1443                         hostapd_p2p_non_p2p_sta_connected(hapd);
1444         }
1445 #endif /* CONFIG_P2P */
1446
1447         /* Start accounting here, if IEEE 802.1X and WPA are not used.
1448          * IEEE 802.1X/WPA code will start accounting after the station has
1449          * been authorized. */
1450         if (!hapd->conf->ieee802_1x && !hapd->conf->wpa) {
1451                 os_get_time(&sta->connected_time);
1452                 accounting_sta_start(hapd, sta);
1453         }
1454
1455         /* Start IEEE 802.1X authentication process for new stations */
1456         ieee802_1x_new_station(hapd, sta);
1457         if (reassoc) {
1458                 if (sta->auth_alg != WLAN_AUTH_FT &&
1459                     !(sta->flags & (WLAN_STA_WPS | WLAN_STA_MAYBE_WPS)))
1460                         wpa_auth_sm_event(sta->wpa_sm, WPA_REAUTH);
1461         } else
1462                 wpa_auth_sta_associated(hapd->wpa_auth, sta->wpa_sm);
1463
1464         wpa_printf(MSG_DEBUG, "%s: reschedule ap_handle_timer timeout "
1465                    "for " MACSTR " (%d seconds - ap_max_inactivity)",
1466                    __func__, MAC2STR(sta->addr),
1467                    hapd->conf->ap_max_inactivity);
1468         eloop_cancel_timeout(ap_handle_timer, hapd, sta);
1469         eloop_register_timeout(hapd->conf->ap_max_inactivity, 0,
1470                                ap_handle_timer, hapd, sta);
1471 }