hostapd/hostapd.c

   1 /*
   2  * hostapd / Initialization and configuration
   3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16 #ifndef CONFIG_NATIVE_WINDOWS
  17 #include <syslog.h>
  18 #endif /* CONFIG_NATIVE_WINDOWS */
  19
  20 #include "eloop.h"
  21 #include "hostapd.h"
  22 #include "ieee802_1x.h"
  23 #include "beacon.h"
  24 #include "hw_features.h"
  25 #include "accounting.h"
  26 #include "eapol_sm.h"
  27 #include "iapp.h"
  28 #include "ap.h"
  29 #include "ieee802_11_defs.h"
  30 #include "ieee802_11_auth.h"
  31 #include "ap_list.h"
  32 #include "sta_info.h"
  33 #include "driver_i.h"
  34 #include "radius/radius_client.h"
  35 #include "radius/radius_server.h"
  36 #include "wpa.h"
  37 #include "preauth.h"
  38 #include "vlan_init.h"
  39 #include "ctrl_iface.h"
  40 #include "tls.h"
  41 #include "eap_server/eap_sim_db.h"
  42 #include "eap_server/eap.h"
  43 #include "eap_server/tncs.h"
  44 #include "version.h"
  45 #include "l2_packet/l2_packet.h"
  46 #include "wps_hostapd.h"
  47 #include "tkip_countermeasures.h"
  48
  49
  50 static int hostapd_radius_get_eap_user(void *ctx, const u8 *identity,
  51                                        size_t identity_len, int phase2,
  52                                        struct eap_user *user);
  53 static int hostapd_flush_old_stations(struct hostapd_data *hapd);
  54 static int hostapd_setup_wpa(struct hostapd_data *hapd);
  55 static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd);
  56
  57 struct hapd_interfaces {
  58         size_t count;
  59         struct hostapd_iface **iface;
  60 };
  61
  62
  63 extern int wpa_debug_level;
  64 extern int wpa_debug_show_keys;
  65 extern int wpa_debug_timestamp;
  66
  67
  68 int hostapd_for_each_interface(int (*cb)(struct hostapd_iface *iface,
  69                                          void *ctx), void *ctx)
  70 {
  71         struct hapd_interfaces *interfaces = eloop_get_user_data();
  72         size_t i;
  73         int ret;
  74
  75         for (i = 0; i < interfaces->count; i++) {
  76                 ret = cb(interfaces->iface[i], ctx);
  77                 if (ret)
  78                         return ret;
  79         }
  80
  81         return 0;
  82 }
  83
  84
  85 static void hostapd_logger_cb(void *ctx, const u8 *addr, unsigned int module,
  86                               int level, const char *txt, size_t len)
  87 {
  88         struct hostapd_data *hapd = ctx;
  89         char *format, *module_str;
  90         int maxlen;
  91         int conf_syslog_level, conf_stdout_level;
  92         unsigned int conf_syslog, conf_stdout;
  93
  94         maxlen = len + 100;
  95         format = os_malloc(maxlen);
  96         if (!format)
  97                 return;
  98
  99         if (hapd && hapd->conf) {
 100                 conf_syslog_level = hapd->conf->logger_syslog_level;
 101                 conf_stdout_level = hapd->conf->logger_stdout_level;
 102                 conf_syslog = hapd->conf->logger_syslog;
 103                 conf_stdout = hapd->conf->logger_stdout;
 104         } else {
 105                 conf_syslog_level = conf_stdout_level = 0;
 106                 conf_syslog = conf_stdout = (unsigned int) -1;
 107         }
 108
 109         switch (module) {
 110         case HOSTAPD_MODULE_IEEE80211:
 111                 module_str = "IEEE 802.11";
 112                 break;
 113         case HOSTAPD_MODULE_IEEE8021X:
 114                 module_str = "IEEE 802.1X";
 115                 break;
 116         case HOSTAPD_MODULE_RADIUS:
 117                 module_str = "RADIUS";
 118                 break;
 119         case HOSTAPD_MODULE_WPA:
 120                 module_str = "WPA";
 121                 break;
 122         case HOSTAPD_MODULE_DRIVER:
 123                 module_str = "DRIVER";
 124                 break;
 125         case HOSTAPD_MODULE_IAPP:
 126                 module_str = "IAPP";
 127                 break;
 128         case HOSTAPD_MODULE_MLME:
 129                 module_str = "MLME";
 130                 break;
 131         default:
 132                 module_str = NULL;
 133                 break;
 134         }
 135
 136         if (hapd && hapd->conf && addr)
 137                 os_snprintf(format, maxlen, "%s: STA " MACSTR "%s%s: %s",
 138                             hapd->conf->iface, MAC2STR(addr),
 139                             module_str ? " " : "", module_str, txt);
 140         else if (hapd && hapd->conf)
 141                 os_snprintf(format, maxlen, "%s:%s%s %s",
 142                             hapd->conf->iface, module_str ? " " : "",
 143                             module_str, txt);
 144         else if (addr)
 145                 os_snprintf(format, maxlen, "STA " MACSTR "%s%s: %s",
 146                             MAC2STR(addr), module_str ? " " : "",
 147                             module_str, txt);
 148         else
 149                 os_snprintf(format, maxlen, "%s%s%s",
 150                             module_str, module_str ? ": " : "", txt);
 151
 152         if ((conf_stdout & module) && level >= conf_stdout_level) {
 153                 wpa_debug_print_timestamp();
 154                 printf("%s\n", format);
 155         }
 156
 157 #ifndef CONFIG_NATIVE_WINDOWS
 158         if ((conf_syslog & module) && level >= conf_syslog_level) {
 159                 int priority;
 160                 switch (level) {
 161                 case HOSTAPD_LEVEL_DEBUG_VERBOSE:
 162                 case HOSTAPD_LEVEL_DEBUG:
 163                         priority = LOG_DEBUG;
 164                         break;
 165                 case HOSTAPD_LEVEL_INFO:
 166                         priority = LOG_INFO;
 167                         break;
 168                 case HOSTAPD_LEVEL_NOTICE:
 169                         priority = LOG_NOTICE;
 170                         break;
 171                 case HOSTAPD_LEVEL_WARNING:
 172                         priority = LOG_WARNING;
 173                         break;
 174                 default:
 175                         priority = LOG_INFO;
 176                         break;
 177                 }
 178                 syslog(priority, "%s", format);
 179         }
 180 #endif /* CONFIG_NATIVE_WINDOWS */
 181
 182         os_free(format);
 183 }
 184
 185
 186 #ifdef EAP_SERVER
 187 static int hostapd_sim_db_cb_sta(struct hostapd_data *hapd,
 188                                  struct sta_info *sta, void *ctx)
 189 {
 190         if (eapol_auth_eap_pending_cb(sta->eapol_sm, ctx) == 0)
 191                 return 1;
 192         return 0;
 193 }
 194
 195
 196 static void hostapd_sim_db_cb(void *ctx, void *session_ctx)
 197 {
 198         struct hostapd_data *hapd = ctx;
 199         if (ap_for_each_sta(hapd, hostapd_sim_db_cb_sta, session_ctx) == 0)
 200                 radius_server_eap_pending_cb(hapd->radius_srv, session_ctx);
 201 }
 202 #endif /* EAP_SERVER */
 203
 204
 205 /**
 206  * handle_term - SIGINT and SIGTERM handler to terminate hostapd process
 207  */
 208 static void handle_term(int sig, void *eloop_ctx, void *signal_ctx)
 209 {
 210         wpa_printf(MSG_DEBUG, "Signal %d received - terminating", sig);
 211         eloop_terminate();
 212 }
 213
 214
 215 static void hostapd_wpa_auth_conf(struct hostapd_bss_config *conf,
 216                                   struct wpa_auth_config *wconf)
 217 {
 218         wconf->wpa = conf->wpa;
 219         wconf->wpa_key_mgmt = conf->wpa_key_mgmt;
 220         wconf->wpa_pairwise = conf->wpa_pairwise;
 221         wconf->wpa_group = conf->wpa_group;
 222         wconf->wpa_group_rekey = conf->wpa_group_rekey;
 223         wconf->wpa_strict_rekey = conf->wpa_strict_rekey;
 224         wconf->wpa_gmk_rekey = conf->wpa_gmk_rekey;
 225         wconf->wpa_ptk_rekey = conf->wpa_ptk_rekey;
 226         wconf->rsn_pairwise = conf->rsn_pairwise;
 227         wconf->rsn_preauth = conf->rsn_preauth;
 228         wconf->eapol_version = conf->eapol_version;
 229         wconf->peerkey = conf->peerkey;
 230         wconf->wme_enabled = conf->wme_enabled;
 231         wconf->okc = conf->okc;
 232 #ifdef CONFIG_IEEE80211W
 233         wconf->ieee80211w = conf->ieee80211w;
 234 #endif /* CONFIG_IEEE80211W */
 235 #ifdef CONFIG_IEEE80211R
 236         wconf->ssid_len = conf->ssid.ssid_len;
 237         if (wconf->ssid_len > SSID_LEN)
 238                 wconf->ssid_len = SSID_LEN;
 239         os_memcpy(wconf->ssid, conf->ssid.ssid, wconf->ssid_len);
 240         os_memcpy(wconf->mobility_domain, conf->mobility_domain,
 241                   MOBILITY_DOMAIN_ID_LEN);
 242         if (conf->nas_identifier &&
 243             os_strlen(conf->nas_identifier) <= FT_R0KH_ID_MAX_LEN) {
 244                 wconf->r0_key_holder_len = os_strlen(conf->nas_identifier);
 245                 os_memcpy(wconf->r0_key_holder, conf->nas_identifier,
 246                           wconf->r0_key_holder_len);
 247         }
 248         os_memcpy(wconf->r1_key_holder, conf->r1_key_holder, FT_R1KH_ID_LEN);
 249         wconf->r0_key_lifetime = conf->r0_key_lifetime;
 250         wconf->reassociation_deadline = conf->reassociation_deadline;
 251         wconf->r0kh_list = conf->r0kh_list;
 252         wconf->r1kh_list = conf->r1kh_list;
 253         wconf->pmk_r1_push = conf->pmk_r1_push;
 254 #endif /* CONFIG_IEEE80211R */
 255 }
 256
 257
 258 int hostapd_reload_config(struct hostapd_iface *iface)
 259 {
 260         struct hostapd_data *hapd = iface->bss[0];
 261         struct hostapd_config *newconf, *oldconf;
 262         struct wpa_auth_config wpa_auth_conf;
 263
 264         newconf = hostapd_config_read(iface->config_fname);
 265         if (newconf == NULL)
 266                 return -1;
 267
 268         /*
 269          * Deauthenticate all stations since the new configuration may not
 270          * allow them to use the BSS anymore.
 271          */
 272         hostapd_flush_old_stations(hapd);
 273
 274         /* TODO: update dynamic data based on changed configuration
 275          * items (e.g., open/close sockets, etc.) */
 276         radius_client_flush(hapd->radius, 0);
 277
 278         oldconf = hapd->iconf;
 279         hapd->iconf = newconf;
 280         hapd->conf = &newconf->bss[0];
 281         iface->conf = newconf;
 282
 283         if (hostapd_setup_wpa_psk(hapd->conf)) {
 284                 wpa_printf(MSG_ERROR, "Failed to re-configure WPA PSK "
 285                            "after reloading configuration");
 286         }
 287
 288         if (hapd->conf->wpa && hapd->wpa_auth == NULL)
 289                 hostapd_setup_wpa(hapd);
 290         else if (hapd->conf->wpa) {
 291                 hostapd_wpa_auth_conf(&newconf->bss[0], &wpa_auth_conf);
 292                 wpa_reconfig(hapd->wpa_auth, &wpa_auth_conf);
 293         } else if (hapd->wpa_auth) {
 294                 wpa_deinit(hapd->wpa_auth);
 295                 hapd->wpa_auth = NULL;
 296                 hostapd_set_privacy(hapd, 0);
 297                 hostapd_setup_encryption(hapd->conf->iface, hapd);
 298         }
 299
 300         ieee802_11_set_beacon(hapd);
 301
 302         hostapd_config_free(oldconf);
 303
 304         wpa_printf(MSG_DEBUG, "Reconfigured interface %s", hapd->conf->iface);
 305
 306         return 0;
 307 }
 308
 309
 310 #ifndef CONFIG_NATIVE_WINDOWS
 311 /**
 312  * handle_reload - SIGHUP handler to reload configuration
 313  */
 314 static void handle_reload(int sig, void *eloop_ctx, void *signal_ctx)
 315 {
 316         struct hapd_interfaces *hapds = (struct hapd_interfaces *) eloop_ctx;
 317         size_t i;
 318
 319         wpa_printf(MSG_DEBUG, "Signal %d received - reloading configuration",
 320                    sig);
 321
 322         for (i = 0; i < hapds->count; i++) {
 323                 if (hostapd_reload_config(hapds->iface[i]) < 0) {
 324                         wpa_printf(MSG_WARNING, "Failed to read new "
 325                                    "configuration file - continuing with "
 326                                    "old.");
 327                         continue;
 328                 }
 329         }
 330 }
 331
 332
 333 #ifdef HOSTAPD_DUMP_STATE
 334 /**
 335  * hostapd_dump_state - SIGUSR1 handler to dump hostapd state to a text file
 336  */
 337 static void hostapd_dump_state(struct hostapd_data *hapd)
 338 {
 339         FILE *f;
 340         time_t now;
 341         struct sta_info *sta;
 342         int i;
 343         char *buf;
 344
 345         if (!hapd->conf->dump_log_name) {
 346                 wpa_printf(MSG_DEBUG, "Dump file not defined - ignoring dump "
 347                            "request");
 348                 return;
 349         }
 350
 351         wpa_printf(MSG_DEBUG, "Dumping hostapd state to '%s'",
 352                    hapd->conf->dump_log_name);
 353         f = fopen(hapd->conf->dump_log_name, "w");
 354         if (f == NULL) {
 355                 wpa_printf(MSG_WARNING, "Could not open dump file '%s' for "
 356                            "writing.", hapd->conf->dump_log_name);
 357                 return;
 358         }
 359
 360         time(&now);
 361         fprintf(f, "hostapd state dump - %s", ctime(&now));
 362         fprintf(f, "num_sta=%d num_sta_non_erp=%d "
 363                 "num_sta_no_short_slot_time=%d\n"
 364                 "num_sta_no_short_preamble=%d\n",
 365                 hapd->num_sta, hapd->iface->num_sta_non_erp,
 366                 hapd->iface->num_sta_no_short_slot_time,
 367                 hapd->iface->num_sta_no_short_preamble);
 368
 369         for (sta = hapd->sta_list; sta != NULL; sta = sta->next) {
 370                 fprintf(f, "\nSTA=" MACSTR "\n", MAC2STR(sta->addr));
 371
 372                 fprintf(f,
 373                         "  AID=%d flags=0x%x %s%s%s%s%s%s%s%s%s%s%s%s%s%s\n"
 374                         "  capability=0x%x listen_interval=%d\n",
 375                         sta->aid,
 376                         sta->flags,
 377                         (sta->flags & WLAN_STA_AUTH ? "[AUTH]" : ""),
 378                         (sta->flags & WLAN_STA_ASSOC ? "[ASSOC]" : ""),
 379                         (sta->flags & WLAN_STA_PS ? "[PS]" : ""),
 380                         (sta->flags & WLAN_STA_TIM ? "[TIM]" : ""),
 381                         (sta->flags & WLAN_STA_PERM ? "[PERM]" : ""),
 382                         (sta->flags & WLAN_STA_AUTHORIZED ? "[AUTHORIZED]" :
 383                          ""),
 384                         (sta->flags & WLAN_STA_PENDING_POLL ? "[PENDING_POLL" :
 385                          ""),
 386                         (sta->flags & WLAN_STA_SHORT_PREAMBLE ?
 387                          "[SHORT_PREAMBLE]" : ""),
 388                         (sta->flags & WLAN_STA_PREAUTH ? "[PREAUTH]" : ""),
 389                         (sta->flags & WLAN_STA_WME ? "[WME]" : ""),
 390                         (sta->flags & WLAN_STA_MFP ? "[MFP]" : ""),
 391                         (sta->flags & WLAN_STA_WPS ? "[WPS]" : ""),
 392                         (sta->flags & WLAN_STA_MAYBE_WPS ? "[MAYBE_WPS]" : ""),
 393                         (sta->flags & WLAN_STA_NONERP ? "[NonERP]" : ""),
 394                         sta->capability,
 395                         sta->listen_interval);
 396
 397                 fprintf(f, "  supported_rates=");
 398                 for (i = 0; i < sta->supported_rates_len; i++)
 399                         fprintf(f, "%02x ", sta->supported_rates[i]);
 400                 fprintf(f, "\n");
 401
 402                 fprintf(f,
 403                         "  timeout_next=%s\n",
 404                         (sta->timeout_next == STA_NULLFUNC ? "NULLFUNC POLL" :
 405                          (sta->timeout_next == STA_DISASSOC ? "DISASSOC" :
 406                           "DEAUTH")));
 407
 408                 ieee802_1x_dump_state(f, "  ", sta);
 409         }
 410
 411         buf = os_malloc(4096);
 412         if (buf) {
 413                 int count = radius_client_get_mib(hapd->radius, buf, 4096);
 414                 if (count < 0)
 415                         count = 0;
 416                 else if (count > 4095)
 417                         count = 4095;
 418                 buf[count] = '\0';
 419                 fprintf(f, "%s", buf);
 420
 421                 count = radius_server_get_mib(hapd->radius_srv, buf, 4096);
 422                 if (count < 0)
 423                         count = 0;
 424                 else if (count > 4095)
 425                         count = 4095;
 426                 buf[count] = '\0';
 427                 fprintf(f, "%s", buf);
 428                 os_free(buf);
 429         }
 430         fclose(f);
 431 }
 432 #endif /* HOSTAPD_DUMP_STATE */
 433
 434
 435 static void handle_dump_state(int sig, void *eloop_ctx, void *signal_ctx)
 436 {
 437 #ifdef HOSTAPD_DUMP_STATE
 438         struct hapd_interfaces *hapds = (struct hapd_interfaces *) eloop_ctx;
 439         size_t i, j;
 440
 441         for (i = 0; i < hapds->count; i++) {
 442                 struct hostapd_iface *hapd_iface = hapds->iface[i];
 443                 for (j = 0; j < hapd_iface->num_bss; j++)
 444                         hostapd_dump_state(hapd_iface->bss[j]);
 445         }
 446 #endif /* HOSTAPD_DUMP_STATE */
 447 }
 448 #endif /* CONFIG_NATIVE_WINDOWS */
 449
 450 static void hostapd_broadcast_key_clear_iface(struct hostapd_data *hapd,
 451                                               char *ifname)
 452 {
 453         int i;
 454
 455         for (i = 0; i < NUM_WEP_KEYS; i++) {
 456                 if (hostapd_set_encryption(ifname, hapd, "none", NULL, i, NULL,
 457                                            0, i == 0 ? 1 : 0)) {
 458                         wpa_printf(MSG_DEBUG, "Failed to clear default "
 459                                    "encryption keys (ifname=%s keyidx=%d)",
 460                                    ifname, i);
 461                 }
 462         }
 463 #ifdef CONFIG_IEEE80211W
 464         if (hapd->conf->ieee80211w) {
 465                 for (i = NUM_WEP_KEYS; i < NUM_WEP_KEYS + 2; i++) {
 466                         if (hostapd_set_encryption(ifname, hapd, "none", NULL,
 467                                                    i, NULL, 0,
 468                                                    i == 0 ? 1 : 0)) {
 469                                 wpa_printf(MSG_DEBUG, "Failed to clear "
 470                                            "default mgmt encryption keys "
 471                                            "(ifname=%s keyidx=%d)", ifname, i);
 472                         }
 473                 }
 474         }
 475 #endif /* CONFIG_IEEE80211W */
 476 }
 477
 478
 479 static int hostapd_broadcast_wep_clear(struct hostapd_data *hapd)
 480 {
 481         hostapd_broadcast_key_clear_iface(hapd, hapd->conf->iface);
 482         return 0;
 483 }
 484
 485
 486 static int hostapd_broadcast_wep_set(struct hostapd_data *hapd)
 487 {
 488         int errors = 0, idx;
 489         struct hostapd_ssid *ssid = &hapd->conf->ssid;
 490
 491         idx = ssid->wep.idx;
 492         if (ssid->wep.default_len &&
 493             hostapd_set_encryption(hapd->conf->iface,
 494                                    hapd, "WEP", NULL, idx,
 495                                    ssid->wep.key[idx],
 496                                    ssid->wep.len[idx],
 497                                    idx == ssid->wep.idx)) {
 498                 wpa_printf(MSG_WARNING, "Could not set WEP encryption.");
 499                 errors++;
 500         }
 501
 502         if (ssid->dyn_vlan_keys) {
 503                 size_t i;
 504                 for (i = 0; i <= ssid->max_dyn_vlan_keys; i++) {
 505                         const char *ifname;
 506                         struct hostapd_wep_keys *key = ssid->dyn_vlan_keys[i];
 507                         if (key == NULL)
 508                                 continue;
 509                         ifname = hostapd_get_vlan_id_ifname(hapd->conf->vlan,
 510                                                             i);
 511                         if (ifname == NULL)
 512                                 continue;
 513
 514                         idx = key->idx;
 515                         if (hostapd_set_encryption(ifname, hapd, "WEP", NULL,
 516                                                    idx, key->key[idx],
 517                                                    key->len[idx],
 518                                                    idx == key->idx)) {
 519                                 wpa_printf(MSG_WARNING, "Could not set "
 520                                            "dynamic VLAN WEP encryption.");
 521                                 errors++;
 522                         }
 523                 }
 524         }
 525
 526         return errors;
 527 }
 528
 529 /**
 530  * hostapd_cleanup - Per-BSS cleanup (deinitialization)
 531  * @hapd: Pointer to BSS data
 532  *
 533  * This function is used to free all per-BSS data structures and resources.
 534  * This gets called in a loop for each BSS between calls to
 535  * hostapd_cleanup_iface_pre() and hostapd_cleanup_iface() when an interface
 536  * is deinitialized. Most of the modules that are initialized in
 537  * hostapd_setup_bss() are deinitialized here.
 538  */
 539 static void hostapd_cleanup(struct hostapd_data *hapd)
 540 {
 541         hostapd_ctrl_iface_deinit(hapd);
 542
 543         os_free(hapd->default_wep_key);
 544         hapd->default_wep_key = NULL;
 545         iapp_deinit(hapd->iapp);
 546         hapd->iapp = NULL;
 547         accounting_deinit(hapd);
 548         rsn_preauth_iface_deinit(hapd);
 549         if (hapd->wpa_auth) {
 550                 wpa_deinit(hapd->wpa_auth);
 551                 hapd->wpa_auth = NULL;
 552
 553                 if (hostapd_set_privacy(hapd, 0)) {
 554                         wpa_printf(MSG_DEBUG, "Could not disable "
 555                                    "PrivacyInvoked for interface %s",
 556                                    hapd->conf->iface);
 557                 }
 558
 559                 if (hostapd_set_generic_elem(hapd, (u8 *) "", 0)) {
 560                         wpa_printf(MSG_DEBUG, "Could not remove generic "
 561                                    "information element from interface %s",
 562                                    hapd->conf->iface);
 563                 }
 564         }
 565         ieee802_1x_deinit(hapd);
 566         vlan_deinit(hapd);
 567         hostapd_acl_deinit(hapd);
 568         radius_client_deinit(hapd->radius);
 569         hapd->radius = NULL;
 570         radius_server_deinit(hapd->radius_srv);
 571         hapd->radius_srv = NULL;
 572
 573 #ifdef CONFIG_IEEE80211R
 574         l2_packet_deinit(hapd->l2);
 575 #endif /* CONFIG_IEEE80211R */
 576
 577         hostapd_deinit_wps(hapd);
 578
 579         hostapd_wireless_event_deinit(hapd);
 580
 581 #ifdef EAP_TLS_FUNCS
 582         if (hapd->ssl_ctx) {
 583                 tls_deinit(hapd->ssl_ctx);
 584                 hapd->ssl_ctx = NULL;
 585         }
 586 #endif /* EAP_TLS_FUNCS */
 587
 588 #ifdef EAP_SERVER
 589         if (hapd->eap_sim_db_priv) {
 590                 eap_sim_db_deinit(hapd->eap_sim_db_priv);
 591                 hapd->eap_sim_db_priv = NULL;
 592         }
 593 #endif /* EAP_SERVER */
 594
 595         if (hapd->interface_added &&
 596             hostapd_bss_remove(hapd, hapd->conf->iface)) {
 597                 wpa_printf(MSG_WARNING, "Failed to remove BSS interface %s",
 598                            hapd->conf->iface);
 599         }
 600 }
 601
 602
 603 /**
 604  * hostapd_cleanup_iface_pre - Preliminary per-interface cleanup
 605  * @iface: Pointer to interface data
 606  *
 607  * This function is called before per-BSS data structures are deinitialized
 608  * with hostapd_cleanup().
 609  */
 610 static void hostapd_cleanup_iface_pre(struct hostapd_iface *iface)
 611 {
 612 }
 613
 614
 615 /**
 616  * hostapd_cleanup_iface - Complete per-interface cleanup
 617  * @iface: Pointer to interface data
 618  *
 619  * This function is called after per-BSS data structures are deinitialized
 620  * with hostapd_cleanup().
 621  */
 622 static void hostapd_cleanup_iface(struct hostapd_iface *iface)
 623 {
 624         hostapd_free_hw_features(iface->hw_features, iface->num_hw_features);
 625         iface->hw_features = NULL;
 626         os_free(iface->current_rates);
 627         iface->current_rates = NULL;
 628         ap_list_deinit(iface);
 629         hostapd_config_free(iface->conf);
 630         iface->conf = NULL;
 631
 632         os_free(iface->config_fname);
 633         os_free(iface->bss);
 634         os_free(iface);
 635 }
 636
 637
 638 static int hostapd_setup_encryption(char *iface, struct hostapd_data *hapd)
 639 {
 640         int i;
 641
 642         hostapd_broadcast_wep_set(hapd);
 643
 644         if (hapd->conf->ssid.wep.default_len)
 645                 return 0;
 646
 647         for (i = 0; i < 4; i++) {
 648                 if (hapd->conf->ssid.wep.key[i] &&
 649                     hostapd_set_encryption(iface, hapd, "WEP", NULL,
 650                                            i, hapd->conf->ssid.wep.key[i],
 651                                            hapd->conf->ssid.wep.len[i],
 652                                            i == hapd->conf->ssid.wep.idx)) {
 653                         wpa_printf(MSG_WARNING, "Could not set WEP "
 654                                    "encryption.");
 655                         return -1;
 656                 }
 657                 if (hapd->conf->ssid.wep.key[i] &&
 658                     i == hapd->conf->ssid.wep.idx)
 659                         hostapd_set_privacy(hapd, 1);
 660         }
 661
 662         return 0;
 663 }
 664
 665
 666 static int hostapd_flush_old_stations(struct hostapd_data *hapd)
 667 {
 668         int ret = 0;
 669
 670         if (hostapd_drv_none(hapd))
 671                 return 0;
 672
 673         wpa_printf(MSG_DEBUG, "Flushing old station entries");
 674         if (hostapd_flush(hapd)) {
 675                 wpa_printf(MSG_WARNING, "Could not connect to kernel driver.");
 676                 ret = -1;
 677         }
 678         wpa_printf(MSG_DEBUG, "Deauthenticate all stations");
 679
 680         /* New Prism2.5/3 STA firmware versions seem to have issues with this
 681          * broadcast deauth frame. This gets the firmware in odd state where
 682          * nothing works correctly, so let's skip sending this for the hostap
 683          * driver. */
 684         if (hapd->driver && os_strcmp(hapd->driver->name, "hostap") != 0) {
 685                 u8 addr[ETH_ALEN];
 686                 os_memset(addr, 0xff, ETH_ALEN);
 687                 hostapd_sta_deauth(hapd, addr,
 688                                    WLAN_REASON_PREV_AUTH_NOT_VALID);
 689         }
 690
 691         return ret;
 692 }
 693
 694
 695 static void hostapd_wpa_auth_logger(void *ctx, const u8 *addr,
 696                                     logger_level level, const char *txt)
 697 {
 698         struct hostapd_data *hapd = ctx;
 699         int hlevel;
 700
 701         switch (level) {
 702         case LOGGER_WARNING:
 703                 hlevel = HOSTAPD_LEVEL_WARNING;
 704                 break;
 705         case LOGGER_INFO:
 706                 hlevel = HOSTAPD_LEVEL_INFO;
 707                 break;
 708         case LOGGER_DEBUG:
 709         default:
 710                 hlevel = HOSTAPD_LEVEL_DEBUG;
 711                 break;
 712         }
 713
 714         hostapd_logger(hapd, addr, HOSTAPD_MODULE_WPA, hlevel, "%s", txt);
 715 }
 716
 717
 718 static void hostapd_wpa_auth_disconnect(void *ctx, const u8 *addr,
 719                                         u16 reason)
 720 {
 721         struct hostapd_data *hapd = ctx;
 722         struct sta_info *sta;
 723
 724         wpa_printf(MSG_DEBUG, "%s: WPA authenticator requests disconnect: "
 725                    "STA " MACSTR " reason %d",
 726                    __func__, MAC2STR(addr), reason);
 727
 728         sta = ap_get_sta(hapd, addr);
 729         hostapd_sta_deauth(hapd, addr, reason);
 730         if (sta == NULL)
 731                 return;
 732         sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_AUTHORIZED);
 733         eloop_cancel_timeout(ap_handle_timer, hapd, sta);
 734         eloop_register_timeout(0, 0, ap_handle_timer, hapd, sta);
 735         sta->timeout_next = STA_REMOVE;
 736 }
 737
 738
 739 static void hostapd_wpa_auth_mic_failure_report(void *ctx, const u8 *addr)
 740 {
 741         struct hostapd_data *hapd = ctx;
 742         michael_mic_failure(hapd, addr, 0);
 743 }
 744
 745
 746 static void hostapd_wpa_auth_set_eapol(void *ctx, const u8 *addr,
 747                                        wpa_eapol_variable var, int value)
 748 {
 749         struct hostapd_data *hapd = ctx;
 750         struct sta_info *sta = ap_get_sta(hapd, addr);
 751         if (sta == NULL)
 752                 return;
 753         switch (var) {
 754         case WPA_EAPOL_portEnabled:
 755                 ieee802_1x_notify_port_enabled(sta->eapol_sm, value);
 756                 break;
 757         case WPA_EAPOL_portValid:
 758                 ieee802_1x_notify_port_valid(sta->eapol_sm, value);
 759                 break;
 760         case WPA_EAPOL_authorized:
 761                 ieee802_1x_set_sta_authorized(hapd, sta, value);
 762                 break;
 763         case WPA_EAPOL_portControl_Auto:
 764                 if (sta->eapol_sm)
 765                         sta->eapol_sm->portControl = Auto;
 766                 break;
 767         case WPA_EAPOL_keyRun:
 768                 if (sta->eapol_sm)
 769                         sta->eapol_sm->keyRun = value ? TRUE : FALSE;
 770                 break;
 771         case WPA_EAPOL_keyAvailable:
 772                 if (sta->eapol_sm)
 773                         sta->eapol_sm->eap_if->eapKeyAvailable =
 774                                 value ? TRUE : FALSE;
 775                 break;
 776         case WPA_EAPOL_keyDone:
 777                 if (sta->eapol_sm)
 778                         sta->eapol_sm->keyDone = value ? TRUE : FALSE;
 779                 break;
 780         case WPA_EAPOL_inc_EapolFramesTx:
 781                 if (sta->eapol_sm)
 782                         sta->eapol_sm->dot1xAuthEapolFramesTx++;
 783                 break;
 784         }
 785 }
 786
 787
 788 static int hostapd_wpa_auth_get_eapol(void *ctx, const u8 *addr,
 789                                       wpa_eapol_variable var)
 790 {
 791         struct hostapd_data *hapd = ctx;
 792         struct sta_info *sta = ap_get_sta(hapd, addr);
 793         if (sta == NULL || sta->eapol_sm == NULL)
 794                 return -1;
 795         switch (var) {
 796         case WPA_EAPOL_keyRun:
 797                 return sta->eapol_sm->keyRun;
 798         case WPA_EAPOL_keyAvailable:
 799                 return sta->eapol_sm->eap_if->eapKeyAvailable;
 800         default:
 801                 return -1;
 802         }
 803 }
 804
 805
 806 static const u8 * hostapd_wpa_auth_get_psk(void *ctx, const u8 *addr,
 807                                            const u8 *prev_psk)
 808 {
 809         struct hostapd_data *hapd = ctx;
 810         return hostapd_get_psk(hapd->conf, addr, prev_psk);
 811 }
 812
 813
 814 static int hostapd_wpa_auth_get_msk(void *ctx, const u8 *addr, u8 *msk,
 815                                     size_t *len)
 816 {
 817         struct hostapd_data *hapd = ctx;
 818         const u8 *key;
 819         size_t keylen;
 820         struct sta_info *sta;
 821
 822         sta = ap_get_sta(hapd, addr);
 823         if (sta == NULL)
 824                 return -1;
 825
 826         key = ieee802_1x_get_key(sta->eapol_sm, &keylen);
 827         if (key == NULL)
 828                 return -1;
 829
 830         if (keylen > *len)
 831                 keylen = *len;
 832         os_memcpy(msk, key, keylen);
 833         *len = keylen;
 834
 835         return 0;
 836 }
 837
 838
 839 static int hostapd_wpa_auth_set_key(void *ctx, int vlan_id, const char *alg,
 840                                     const u8 *addr, int idx, u8 *key,
 841                                     size_t key_len)
 842 {
 843         struct hostapd_data *hapd = ctx;
 844         const char *ifname = hapd->conf->iface;
 845
 846         if (vlan_id > 0) {
 847                 ifname = hostapd_get_vlan_id_ifname(hapd->conf->vlan, vlan_id);
 848                 if (ifname == NULL)
 849                         return -1;
 850         }
 851
 852         return hostapd_set_encryption(ifname, hapd, alg, addr, idx,
 853                                       key, key_len, 1);
 854 }
 855
 856
 857 static int hostapd_wpa_auth_get_seqnum(void *ctx, const u8 *addr, int idx,
 858                                        u8 *seq)
 859 {
 860         struct hostapd_data *hapd = ctx;
 861         return hostapd_get_seqnum(hapd->conf->iface, hapd, addr, idx, seq);
 862 }
 863
 864
 865 static int hostapd_wpa_auth_get_seqnum_igtk(void *ctx, const u8 *addr, int idx,
 866                                             u8 *seq)
 867 {
 868         struct hostapd_data *hapd = ctx;
 869         return hostapd_get_seqnum_igtk(hapd->conf->iface, hapd, addr, idx,
 870                                        seq);
 871 }
 872
 873
 874 static int hostapd_wpa_auth_send_eapol(void *ctx, const u8 *addr,
 875                                        const u8 *data, size_t data_len,
 876                                        int encrypt)
 877 {
 878         struct hostapd_data *hapd = ctx;
 879         return hostapd_send_eapol(hapd, addr, data, data_len, encrypt);
 880 }
 881
 882
 883 static int hostapd_wpa_auth_for_each_sta(
 884         void *ctx, int (*cb)(struct wpa_state_machine *sm, void *ctx),
 885         void *cb_ctx)
 886 {
 887         struct hostapd_data *hapd = ctx;
 888         struct sta_info *sta;
 889
 890         for (sta = hapd->sta_list; sta; sta = sta->next) {
 891                 if (sta->wpa_sm && cb(sta->wpa_sm, cb_ctx))
 892                         return 1;
 893         }
 894         return 0;
 895 }
 896
 897
 898 static int hostapd_wpa_auth_for_each_auth(
 899         void *ctx, int (*cb)(struct wpa_authenticator *sm, void *ctx),
 900         void *cb_ctx)
 901 {
 902         struct hostapd_data *ohapd;
 903         size_t i, j;
 904         struct hapd_interfaces *interfaces = eloop_get_user_data();
 905
 906         for (i = 0; i < interfaces->count; i++) {
 907                 for (j = 0; j < interfaces->iface[i]->num_bss; j++) {
 908                         ohapd = interfaces->iface[i]->bss[j];
 909                         if (cb(ohapd->wpa_auth, cb_ctx))
 910                                 return 1;
 911                 }
 912         }
 913
 914         return 0;
 915 }
 916
 917
 918 static int hostapd_wpa_auth_send_ether(void *ctx, const u8 *dst, u16 proto,
 919                                        const u8 *data, size_t data_len)
 920 {
 921         struct hostapd_data *hapd = ctx;
 922
 923         if (hapd->driver && hapd->driver->send_ether)
 924                 return hapd->driver->send_ether(hapd->drv_priv, dst,
 925                                                 hapd->own_addr, proto,
 926                                                 data, data_len);
 927         if (hapd->l2 == NULL)
 928                 return -1;
 929         return l2_packet_send(hapd->l2, dst, proto, data, data_len);
 930 }
 931
 932
 933 #ifdef CONFIG_IEEE80211R
 934
 935 static int hostapd_wpa_auth_send_ft_action(void *ctx, const u8 *dst,
 936                                            const u8 *data, size_t data_len)
 937 {
 938         struct hostapd_data *hapd = ctx;
 939         int res;
 940         struct ieee80211_mgmt *m;
 941         size_t mlen;
 942         struct sta_info *sta;
 943
 944         sta = ap_get_sta(hapd, dst);
 945         if (sta == NULL || sta->wpa_sm == NULL)
 946                 return -1;
 947
 948         m = os_zalloc(sizeof(*m) + data_len);
 949         if (m == NULL)
 950                 return -1;
 951         mlen = ((u8 *) &m->u - (u8 *) m) + data_len;
 952         m->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 953                                         WLAN_FC_STYPE_ACTION);
 954         os_memcpy(m->da, dst, ETH_ALEN);
 955         os_memcpy(m->sa, hapd->own_addr, ETH_ALEN);
 956         os_memcpy(m->bssid, hapd->own_addr, ETH_ALEN);
 957         os_memcpy(&m->u, data, data_len);
 958
 959         res = hostapd_send_mgmt_frame(hapd, (u8 *) m, mlen, 0);
 960         os_free(m);
 961         return res;
 962 }
 963
 964
 965 static struct wpa_state_machine *
 966 hostapd_wpa_auth_add_sta(void *ctx, const u8 *sta_addr)
 967 {
 968         struct hostapd_data *hapd = ctx;
 969         struct sta_info *sta;
 970
 971         sta = ap_sta_add(hapd, sta_addr);
 972         if (sta == NULL)
 973                 return NULL;
 974         if (sta->wpa_sm)
 975                 return sta->wpa_sm;
 976
 977         sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, sta->addr);
 978         if (sta->wpa_sm == NULL) {
 979                 ap_free_sta(hapd, sta);
 980                 return NULL;
 981         }
 982         sta->auth_alg = WLAN_AUTH_FT;
 983
 984         return sta->wpa_sm;
 985 }
 986
 987
 988 static void hostapd_rrb_receive(void *ctx, const u8 *src_addr, const u8 *buf,
 989                                 size_t len)
 990 {
 991         struct hostapd_data *hapd = ctx;
 992         wpa_ft_rrb_rx(hapd->wpa_auth, src_addr, buf, len);
 993 }
 994
 995 #endif /* CONFIG_IEEE80211R */
 996
 997
 998 /**
 999  * hostapd_validate_bssid_configuration - Validate BSSID configuration
1000  * @iface: Pointer to interface data
1001  * Returns: 0 on success, -1 on failure
1002  *
1003  * This function is used to validate that the configured BSSIDs are valid.
1004  */
1005 static int hostapd_validate_bssid_configuration(struct hostapd_iface *iface)
1006 {
1007         u8 mask[ETH_ALEN] = { 0 };
1008         struct hostapd_data *hapd = iface->bss[0];
1009         unsigned int i = iface->conf->num_bss, bits = 0, j;
1010         int res;
1011
1012         if (hostapd_drv_none(hapd))
1013                 return 0;
1014
1015         /* Generate BSSID mask that is large enough to cover the BSSIDs. */
1016
1017         /* Determine the bits necessary to cover the number of BSSIDs. */
1018         for (i--; i; i >>= 1)
1019                 bits++;
1020
1021         /* Determine the bits necessary to any configured BSSIDs,
1022            if they are higher than the number of BSSIDs. */
1023         for (j = 0; j < iface->conf->num_bss; j++) {
1024                 if (hostapd_mac_comp_empty(iface->conf->bss[j].bssid) == 0)
1025                         continue;
1026
1027                 for (i = 0; i < ETH_ALEN; i++) {
1028                         mask[i] |=
1029                                 iface->conf->bss[j].bssid[i] ^
1030                                 hapd->own_addr[i];
1031                 }
1032         }
1033
1034         for (i = 0; i < ETH_ALEN && mask[i] == 0; i++)
1035                 ;
1036         j = 0;
1037         if (i < ETH_ALEN) {
1038                 j = (5 - i) * 8;
1039
1040                 while (mask[i] != 0) {
1041                         mask[i] >>= 1;
1042                         j++;
1043                 }
1044         }
1045
1046         if (bits < j)
1047                 bits = j;
1048
1049         if (bits > 40)
1050                 return -1;
1051
1052         os_memset(mask, 0xff, ETH_ALEN);
1053         j = bits / 8;
1054         for (i = 5; i > 5 - j; i--)
1055                 mask[i] = 0;
1056         j = bits % 8;
1057         while (j--)
1058                 mask[i] <<= 1;
1059
1060         wpa_printf(MSG_DEBUG, "BSS count %lu, BSSID mask " MACSTR " (%d bits)",
1061                    (unsigned long) iface->conf->num_bss, MAC2STR(mask), bits);
1062
1063         res = hostapd_valid_bss_mask(hapd, hapd->own_addr, mask);
1064         if (res == 0)
1065                 return 0;
1066
1067         if (res < 0) {
1068                 wpa_printf(MSG_ERROR, "Driver did not accept BSSID mask "
1069                            MACSTR " for start address " MACSTR ".",
1070                            MAC2STR(mask), MAC2STR(hapd->own_addr));
1071                 return -1;
1072         }
1073
1074         for (i = 0; i < ETH_ALEN; i++) {
1075                 if ((hapd->own_addr[i] & mask[i]) != hapd->own_addr[i]) {
1076                         wpa_printf(MSG_ERROR, "Invalid BSSID mask " MACSTR
1077                                    " for start address " MACSTR ".",
1078                                    MAC2STR(mask), MAC2STR(hapd->own_addr));
1079                         wpa_printf(MSG_ERROR, "Start address must be the "
1080                                    "first address in the block (i.e., addr "
1081                                    "AND mask == addr).");
1082                         return -1;
1083                 }
1084         }
1085
1086         return 0;
1087 }
1088
1089
1090 static int mac_in_conf(struct hostapd_config *conf, const void *a)
1091 {
1092         size_t i;
1093
1094         for (i = 0; i < conf->num_bss; i++) {
1095                 if (hostapd_mac_comp(conf->bss[i].bssid, a) == 0) {
1096                         return 1;
1097                 }
1098         }
1099
1100         return 0;
1101 }
1102
1103
1104 static int hostapd_setup_wpa(struct hostapd_data *hapd)
1105 {
1106         struct wpa_auth_config _conf;
1107         struct wpa_auth_callbacks cb;
1108         const u8 *wpa_ie;
1109         size_t wpa_ie_len;
1110
1111         hostapd_wpa_auth_conf(hapd->conf, &_conf);
1112         os_memset(&cb, 0, sizeof(cb));
1113         cb.ctx = hapd;
1114         cb.logger = hostapd_wpa_auth_logger;
1115         cb.disconnect = hostapd_wpa_auth_disconnect;
1116         cb.mic_failure_report = hostapd_wpa_auth_mic_failure_report;
1117         cb.set_eapol = hostapd_wpa_auth_set_eapol;
1118         cb.get_eapol = hostapd_wpa_auth_get_eapol;
1119         cb.get_psk = hostapd_wpa_auth_get_psk;
1120         cb.get_msk = hostapd_wpa_auth_get_msk;
1121         cb.set_key = hostapd_wpa_auth_set_key;
1122         cb.get_seqnum = hostapd_wpa_auth_get_seqnum;
1123         cb.get_seqnum_igtk = hostapd_wpa_auth_get_seqnum_igtk;
1124         cb.send_eapol = hostapd_wpa_auth_send_eapol;
1125         cb.for_each_sta = hostapd_wpa_auth_for_each_sta;
1126         cb.for_each_auth = hostapd_wpa_auth_for_each_auth;
1127         cb.send_ether = hostapd_wpa_auth_send_ether;
1128 #ifdef CONFIG_IEEE80211R
1129         cb.send_ft_action = hostapd_wpa_auth_send_ft_action;
1130         cb.add_sta = hostapd_wpa_auth_add_sta;
1131 #endif /* CONFIG_IEEE80211R */
1132         hapd->wpa_auth = wpa_init(hapd->own_addr, &_conf, &cb);
1133         if (hapd->wpa_auth == NULL) {
1134                 wpa_printf(MSG_ERROR, "WPA initialization failed.");
1135                 return -1;
1136         }
1137
1138         if (hostapd_set_privacy(hapd, 1)) {
1139                 wpa_printf(MSG_ERROR, "Could not set PrivacyInvoked "
1140                            "for interface %s", hapd->conf->iface);
1141                 return -1;
1142         }
1143
1144         wpa_ie = wpa_auth_get_wpa_ie(hapd->wpa_auth, &wpa_ie_len);
1145         if (hostapd_set_generic_elem(hapd, wpa_ie, wpa_ie_len)) {
1146                 wpa_printf(MSG_ERROR, "Failed to configure WPA IE for "
1147                            "the kernel driver.");
1148                 return -1;
1149         }
1150
1151         if (rsn_preauth_iface_init(hapd)) {
1152                 wpa_printf(MSG_ERROR, "Initialization of RSN "
1153                            "pre-authentication failed.");
1154                 return -1;
1155         }
1156
1157         return 0;
1158
1159 }
1160
1161
1162 static int hostapd_setup_radius_srv(struct hostapd_data *hapd,
1163                                     struct hostapd_bss_config *conf)
1164 {
1165         struct radius_server_conf srv;
1166         os_memset(&srv, 0, sizeof(srv));
1167         srv.client_file = conf->radius_server_clients;
1168         srv.auth_port = conf->radius_server_auth_port;
1169         srv.conf_ctx = conf;
1170         srv.eap_sim_db_priv = hapd->eap_sim_db_priv;
1171         srv.ssl_ctx = hapd->ssl_ctx;
1172         srv.pac_opaque_encr_key = conf->pac_opaque_encr_key;
1173         srv.eap_fast_a_id = conf->eap_fast_a_id;
1174         srv.eap_fast_a_id_len = conf->eap_fast_a_id_len;
1175         srv.eap_fast_a_id_info = conf->eap_fast_a_id_info;
1176         srv.eap_fast_prov = conf->eap_fast_prov;
1177         srv.pac_key_lifetime = conf->pac_key_lifetime;
1178         srv.pac_key_refresh_time = conf->pac_key_refresh_time;
1179         srv.eap_sim_aka_result_ind = conf->eap_sim_aka_result_ind;
1180         srv.tnc = conf->tnc;
1181         srv.wps = hapd->wps;
1182         srv.ipv6 = conf->radius_server_ipv6;
1183         srv.get_eap_user = hostapd_radius_get_eap_user;
1184         srv.eap_req_id_text = conf->eap_req_id_text;
1185         srv.eap_req_id_text_len = conf->eap_req_id_text_len;
1186
1187         hapd->radius_srv = radius_server_init(&srv);
1188         if (hapd->radius_srv == NULL) {
1189                 wpa_printf(MSG_ERROR, "RADIUS server initialization failed.");
1190                 return -1;
1191         }
1192
1193         return 0;
1194 }
1195
1196
1197 /**
1198  * hostapd_setup_bss - Per-BSS setup (initialization)
1199  * @hapd: Pointer to BSS data
1200  * @first: Whether this BSS is the first BSS of an interface
1201  *
1202  * This function is used to initialize all per-BSS data structures and
1203  * resources. This gets called in a loop for each BSS when an interface is
1204  * initialized. Most of the modules that are initialized here will be
1205  * deinitialized in hostapd_cleanup().
1206  */
1207 static int hostapd_setup_bss(struct hostapd_data *hapd, int first)
1208 {
1209         struct hostapd_bss_config *conf = hapd->conf;
1210         u8 ssid[HOSTAPD_MAX_SSID_LEN + 1];
1211         int ssid_len, set_ssid;
1212
1213         if (!first) {
1214                 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0) {
1215                         /* Allocate the next available BSSID. */
1216                         do {
1217                                 inc_byte_array(hapd->own_addr, ETH_ALEN);
1218                         } while (mac_in_conf(hapd->iconf, hapd->own_addr));
1219                 } else {
1220                         /* Allocate the configured BSSID. */
1221                         os_memcpy(hapd->own_addr, hapd->conf->bssid, ETH_ALEN);
1222
1223                         if (hostapd_mac_comp(hapd->own_addr,
1224                                              hapd->iface->bss[0]->own_addr) ==
1225                             0) {
1226                                 wpa_printf(MSG_ERROR, "BSS '%s' may not have "
1227                                            "BSSID set to the MAC address of "
1228                                            "the radio", hapd->conf->iface);
1229                                 return -1;
1230                         }
1231                 }
1232
1233                 hapd->interface_added = 1;
1234                 if (hostapd_bss_add(hapd->iface->bss[0], hapd->conf->iface,
1235                                     hapd->own_addr)) {
1236                         wpa_printf(MSG_ERROR, "Failed to add BSS (BSSID="
1237                                    MACSTR ")", MAC2STR(hapd->own_addr));
1238                         return -1;
1239                 }
1240         }
1241
1242         /*
1243          * Fetch the SSID from the system and use it or,
1244          * if one was specified in the config file, verify they
1245          * match.
1246          */
1247         ssid_len = hostapd_get_ssid(hapd, ssid, sizeof(ssid));
1248         if (ssid_len < 0) {
1249                 wpa_printf(MSG_ERROR, "Could not read SSID from system");
1250                 return -1;
1251         }
1252         if (conf->ssid.ssid_set) {
1253                 /*
1254                  * If SSID is specified in the config file and it differs
1255                  * from what is being used then force installation of the
1256                  * new SSID.
1257                  */
1258                 set_ssid = (conf->ssid.ssid_len != (size_t) ssid_len ||
1259                             os_memcmp(conf->ssid.ssid, ssid, ssid_len) != 0);
1260         } else {
1261                 /*
1262                  * No SSID in the config file; just use the one we got
1263                  * from the system.
1264                  */
1265                 set_ssid = 0;
1266                 conf->ssid.ssid_len = ssid_len;
1267                 os_memcpy(conf->ssid.ssid, ssid, conf->ssid.ssid_len);
1268                 conf->ssid.ssid[conf->ssid.ssid_len] = '\0';
1269         }
1270
1271         if (!hostapd_drv_none(hapd)) {
1272                 wpa_printf(MSG_ERROR, "Using interface %s with hwaddr " MACSTR
1273                            " and ssid '%s'",
1274                            hapd->conf->iface, MAC2STR(hapd->own_addr),
1275                            hapd->conf->ssid.ssid);
1276         }
1277
1278         if (hostapd_setup_wpa_psk(conf)) {
1279                 wpa_printf(MSG_ERROR, "WPA-PSK setup failed.");
1280                 return -1;
1281         }
1282
1283         /* Set flag for whether SSID is broadcast in beacons */
1284         if (hostapd_set_broadcast_ssid(hapd,
1285                                        !!hapd->conf->ignore_broadcast_ssid)) {
1286                 wpa_printf(MSG_ERROR, "Could not set broadcast SSID flag for "
1287                            "kernel driver");
1288                 return -1;
1289         }
1290
1291         if (hostapd_set_dtim_period(hapd, hapd->conf->dtim_period)) {
1292                 wpa_printf(MSG_ERROR, "Could not set DTIM period for kernel "
1293                            "driver");
1294                 return -1;
1295         }
1296
1297         /* Set SSID for the kernel driver (to be used in beacon and probe
1298          * response frames) */
1299         if (set_ssid && hostapd_set_ssid(hapd, (u8 *) conf->ssid.ssid,
1300                                          conf->ssid.ssid_len)) {
1301                 wpa_printf(MSG_ERROR, "Could not set SSID for kernel driver");
1302                 return -1;
1303         }
1304
1305         if (wpa_debug_level == MSG_MSGDUMP)
1306                 conf->radius->msg_dumps = 1;
1307         hapd->radius = radius_client_init(hapd, conf->radius);
1308         if (hapd->radius == NULL) {
1309                 wpa_printf(MSG_ERROR, "RADIUS client initialization failed.");
1310                 return -1;
1311         }
1312
1313         if (hostapd_acl_init(hapd)) {
1314                 wpa_printf(MSG_ERROR, "ACL initialization failed.");
1315                 return -1;
1316         }
1317         if (hostapd_init_wps(hapd, conf))
1318                 return -1;
1319
1320         if (ieee802_1x_init(hapd)) {
1321                 wpa_printf(MSG_ERROR, "IEEE 802.1X initialization failed.");
1322                 return -1;
1323         }
1324
1325         if (hapd->conf->wpa && hostapd_setup_wpa(hapd))
1326                 return -1;
1327
1328         if (accounting_init(hapd)) {
1329                 wpa_printf(MSG_ERROR, "Accounting initialization failed.");
1330                 return -1;
1331         }
1332
1333         if (hapd->conf->ieee802_11f &&
1334             (hapd->iapp = iapp_init(hapd, hapd->conf->iapp_iface)) == NULL) {
1335                 wpa_printf(MSG_ERROR, "IEEE 802.11F (IAPP) initialization "
1336                            "failed.");
1337                 return -1;
1338         }
1339
1340         if (hostapd_ctrl_iface_init(hapd)) {
1341                 wpa_printf(MSG_ERROR, "Failed to setup control interface");
1342                 return -1;
1343         }
1344
1345         if (!hostapd_drv_none(hapd) && vlan_init(hapd)) {
1346                 wpa_printf(MSG_ERROR, "VLAN initialization failed.");
1347                 return -1;
1348         }
1349
1350 #ifdef CONFIG_IEEE80211R
1351         if (!hostapd_drv_none(hapd)) {
1352                 hapd->l2 = l2_packet_init(hapd->conf->iface, NULL, ETH_P_RRB,
1353                                           hostapd_rrb_receive, hapd, 0);
1354                 if (hapd->l2 == NULL &&
1355                     (hapd->driver == NULL ||
1356                      hapd->driver->send_ether == NULL)) {
1357                         wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1358                                    "interface");
1359                         return -1;
1360                 }
1361         }
1362 #endif /* CONFIG_IEEE80211R */
1363
1364         ieee802_11_set_beacon(hapd);
1365
1366         if (conf->radius_server_clients &&
1367             hostapd_setup_radius_srv(hapd, conf))
1368                 return -1;
1369
1370         return 0;
1371 }
1372
1373
1374 static void hostapd_tx_queue_params(struct hostapd_iface *iface)
1375 {
1376         struct hostapd_data *hapd = iface->bss[0];
1377         int i;
1378         struct hostapd_tx_queue_params *p;
1379
1380         for (i = 0; i < NUM_TX_QUEUES; i++) {
1381                 p = &iface->conf->tx_queue[i];
1382
1383                 if (!p->configured)
1384                         continue;
1385
1386                 if (hostapd_set_tx_queue_params(hapd, i, p->aifs, p->cwmin,
1387                                                 p->cwmax, p->burst)) {
1388                         wpa_printf(MSG_DEBUG, "Failed to set TX queue "
1389                                    "parameters for queue %d.", i);
1390                         /* Continue anyway */
1391                 }
1392         }
1393 }
1394
1395
1396 static int hostapd_radius_get_eap_user(void *ctx, const u8 *identity,
1397                                        size_t identity_len, int phase2,
1398                                        struct eap_user *user)
1399 {
1400         const struct hostapd_eap_user *eap_user;
1401         int i, count;
1402
1403         eap_user = hostapd_get_eap_user(ctx, identity, identity_len, phase2);
1404         if (eap_user == NULL)
1405                 return -1;
1406
1407         if (user == NULL)
1408                 return 0;
1409
1410         os_memset(user, 0, sizeof(*user));
1411         count = EAP_USER_MAX_METHODS;
1412         if (count > EAP_MAX_METHODS)
1413                 count = EAP_MAX_METHODS;
1414         for (i = 0; i < count; i++) {
1415                 user->methods[i].vendor = eap_user->methods[i].vendor;
1416                 user->methods[i].method = eap_user->methods[i].method;
1417         }
1418
1419         if (eap_user->password) {
1420                 user->password = os_malloc(eap_user->password_len);
1421                 if (user->password == NULL)
1422                         return -1;
1423                 os_memcpy(user->password, eap_user->password,
1424                           eap_user->password_len);
1425                 user->password_len = eap_user->password_len;
1426                 user->password_hash = eap_user->password_hash;
1427         }
1428         user->force_version = eap_user->force_version;
1429         user->ttls_auth = eap_user->ttls_auth;
1430
1431         return 0;
1432 }
1433
1434
1435 static int setup_interface(struct hostapd_iface *iface)
1436 {
1437         struct hostapd_data *hapd = iface->bss[0];
1438         struct hostapd_bss_config *conf = hapd->conf;
1439         size_t i;
1440         char country[4];
1441         u8 *b = conf->bssid;
1442         int freq;
1443         size_t j;
1444         int ret = 0;
1445         u8 *prev_addr;
1446
1447         /*
1448          * Initialize the driver interface and make sure that all BSSes get
1449          * configured with a pointer to this driver interface.
1450          */
1451         if (b[0] | b[1] | b[2] | b[3] | b[4] | b[5]) {
1452                 hapd->drv_priv = hostapd_driver_init_bssid(hapd, b);
1453         } else {
1454                 hapd->drv_priv = hostapd_driver_init(hapd);
1455         }
1456
1457         if (hapd->drv_priv == NULL) {
1458                 wpa_printf(MSG_ERROR, "%s driver initialization failed.",
1459                            hapd->driver ? hapd->driver->name : "Unknown");
1460                 hapd->driver = NULL;
1461                 return -1;
1462         }
1463         for (i = 0; i < iface->num_bss; i++) {
1464                 iface->bss[i]->driver = hapd->driver;
1465                 iface->bss[i]->drv_priv = hapd->drv_priv;
1466         }
1467
1468         if (hostapd_validate_bssid_configuration(iface))
1469                 return -1;
1470
1471 #ifdef CONFIG_IEEE80211N
1472         SET_2BIT_LE16(&iface->ht_op_mode,
1473                       HT_INFO_OPERATION_MODE_OP_MODE_OFFSET,
1474                       OP_MODE_PURE);
1475 #endif /* CONFIG_IEEE80211N */
1476
1477         os_memcpy(country, hapd->iconf->country, 3);
1478         country[3] = '\0';
1479         if (hostapd_set_country(hapd, country) < 0) {
1480                 wpa_printf(MSG_ERROR, "Failed to set country code");
1481                 return -1;
1482         }
1483
1484         if (hapd->iconf->ieee80211d &&
1485             hostapd_set_ieee80211d(hapd, 1) < 0) {
1486                 wpa_printf(MSG_ERROR, "Failed to set ieee80211d (%d)",
1487                            hapd->iconf->ieee80211d);
1488                 return -1;
1489         }
1490
1491         if (hapd->iconf->bridge_packets != INTERNAL_BRIDGE_DO_NOT_CONTROL &&
1492             hostapd_set_internal_bridge(hapd, hapd->iconf->bridge_packets)) {
1493                 wpa_printf(MSG_ERROR, "Failed to set bridge_packets for "
1494                            "kernel driver");
1495                 return -1;
1496         }
1497
1498         /* TODO: merge with hostapd_driver_init() ? */
1499         if (hostapd_wireless_event_init(hapd) < 0)
1500                 return -1;
1501
1502         if (hostapd_get_hw_features(iface)) {
1503                 /* Not all drivers support this yet, so continue without hw
1504                  * feature data. */
1505         } else {
1506                 int ret = hostapd_select_hw_mode(iface);
1507                 if (ret < 0) {
1508                         wpa_printf(MSG_ERROR, "Could not select hw_mode and "
1509                                    "channel. (%d)", ret);
1510                         return -1;
1511                 }
1512         }
1513
1514         hostapd_flush_old_stations(hapd);
1515         hostapd_set_privacy(hapd, 0);
1516
1517         if (hapd->iconf->channel) {
1518                 freq = hostapd_hw_get_freq(hapd, hapd->iconf->channel);
1519                 wpa_printf(MSG_DEBUG, "Mode: %s  Channel: %d  "
1520                            "Frequency: %d MHz",
1521                            hostapd_hw_mode_txt(hapd->iconf->hw_mode),
1522                            hapd->iconf->channel, freq);
1523
1524                 if (hostapd_set_freq(hapd, hapd->iconf->hw_mode, freq,
1525                                      hapd->iconf->ieee80211n,
1526                                      hapd->iconf->secondary_channel)) {
1527                         wpa_printf(MSG_ERROR, "Could not set channel for "
1528                                    "kernel driver");
1529                         return -1;
1530                 }
1531         }
1532
1533         hostapd_broadcast_wep_clear(hapd);
1534         if (hostapd_setup_encryption(hapd->conf->iface, hapd))
1535                 return -1;
1536
1537         hostapd_set_beacon_int(hapd, hapd->iconf->beacon_int);
1538         ieee802_11_set_beacon(hapd);
1539
1540         if (hapd->iconf->rts_threshold > -1 &&
1541             hostapd_set_rts(hapd, hapd->iconf->rts_threshold)) {
1542                 wpa_printf(MSG_ERROR, "Could not set RTS threshold for "
1543                            "kernel driver");
1544                 return -1;
1545         }
1546
1547         if (hapd->iconf->fragm_threshold > -1 &&
1548             hostapd_set_frag(hapd, hapd->iconf->fragm_threshold)) {
1549                 wpa_printf(MSG_ERROR, "Could not set fragmentation threshold "
1550                            "for kernel driver");
1551                 return -1;
1552         }
1553
1554         prev_addr = hapd->own_addr;
1555
1556         for (j = 0; j < iface->num_bss; j++) {
1557                 hapd = iface->bss[j];
1558                 if (j)
1559                         os_memcpy(hapd->own_addr, prev_addr, ETH_ALEN);
1560                 if (hostapd_setup_bss(hapd, j == 0))
1561                         return -1;
1562                 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0)
1563                         prev_addr = hapd->own_addr;
1564         }
1565
1566         hostapd_tx_queue_params(iface);
1567
1568         ap_list_init(iface);
1569
1570         if (hostapd_driver_commit(hapd) < 0) {
1571                 wpa_printf(MSG_ERROR, "%s: Failed to commit driver "
1572                            "configuration", __func__);
1573                 return -1;
1574         }
1575
1576         return ret;
1577 }
1578
1579
1580 /**
1581  * hostapd_setup_interface - Setup of an interface
1582  * @iface: Pointer to interface data.
1583  * Returns: 0 on success, -1 on failure
1584  *
1585  * Initializes the driver interface, validates the configuration,
1586  * and sets driver parameters based on the configuration.
1587  * Flushes old stations, sets the channel, encryption,
1588  * beacons, and WDS links based on the configuration.
1589  */
1590 static int hostapd_setup_interface(struct hostapd_iface *iface)
1591 {
1592         int ret;
1593
1594         ret = setup_interface(iface);
1595         if (ret) {
1596                 wpa_printf(MSG_DEBUG, "%s: Unable to setup interface.",
1597                            iface->bss[0]->conf->iface);
1598                 eloop_terminate();
1599                 return -1;
1600         } else if (!hostapd_drv_none(iface->bss[0])) {
1601                 wpa_printf(MSG_DEBUG, "%s: Setup of interface done.",
1602                            iface->bss[0]->conf->iface);
1603         }
1604
1605         return 0;
1606 }
1607
1608
1609 static void show_version(void)
1610 {
1611         fprintf(stderr,
1612                 "hostapd v" VERSION_STR "\n"
1613                 "User space daemon for IEEE 802.11 AP management,\n"
1614                 "IEEE 802.1X/WPA/WPA2/EAP/RADIUS Authenticator\n"
1615                 "Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi> "
1616                 "and contributors\n");
1617 }
1618
1619
1620 static void usage(void)
1621 {
1622         show_version();
1623         fprintf(stderr,
1624                 "\n"
1625                 "usage: hostapd [-hdBKtv] [-P <PID file>] "
1626                 "<configuration file(s)>\n"
1627                 "\n"
1628                 "options:\n"
1629                 "   -h   show this usage\n"
1630                 "   -d   show more debug messages (-dd for even more)\n"
1631                 "   -B   run daemon in the background\n"
1632                 "   -P   PID file\n"
1633                 "   -K   include key data in debug messages\n"
1634                 "   -t   include timestamps in some debug messages\n"
1635                 "   -v   show hostapd version\n");
1636
1637         exit(1);
1638 }
1639
1640
1641 /**
1642  * hostapd_alloc_bss_data - Allocate and initialize per-BSS data
1643  * @hapd_iface: Pointer to interface data
1644  * @conf: Pointer to per-interface configuration
1645  * @bss: Pointer to per-BSS configuration for this BSS
1646  * Returns: Pointer to allocated BSS data
1647  *
1648  * This function is used to allocate per-BSS data structure. This data will be
1649  * freed after hostapd_cleanup() is called for it during interface
1650  * deinitialization.
1651  */
1652 static struct hostapd_data *
1653 hostapd_alloc_bss_data(struct hostapd_iface *hapd_iface,
1654                        struct hostapd_config *conf,
1655                        struct hostapd_bss_config *bss)
1656 {
1657         struct hostapd_data *hapd;
1658
1659         hapd = os_zalloc(sizeof(*hapd));
1660         if (hapd == NULL)
1661                 return NULL;
1662
1663         hapd->iconf = conf;
1664         hapd->conf = bss;
1665         hapd->iface = hapd_iface;
1666
1667         if (hapd->conf->individual_wep_key_len > 0) {
1668                 /* use key0 in individual key and key1 in broadcast key */
1669                 hapd->default_wep_key_idx = 1;
1670         }
1671
1672 #ifdef EAP_TLS_FUNCS
1673         if (hapd->conf->eap_server &&
1674             (hapd->conf->ca_cert || hapd->conf->server_cert ||
1675              hapd->conf->dh_file)) {
1676                 struct tls_connection_params params;
1677
1678                 hapd->ssl_ctx = tls_init(NULL);
1679                 if (hapd->ssl_ctx == NULL) {
1680                         wpa_printf(MSG_ERROR, "Failed to initialize TLS");
1681                         goto fail;
1682                 }
1683
1684                 os_memset(&params, 0, sizeof(params));
1685                 params.ca_cert = hapd->conf->ca_cert;
1686                 params.client_cert = hapd->conf->server_cert;
1687                 params.private_key = hapd->conf->private_key;
1688                 params.private_key_passwd = hapd->conf->private_key_passwd;
1689                 params.dh_file = hapd->conf->dh_file;
1690
1691                 if (tls_global_set_params(hapd->ssl_ctx, &params)) {
1692                         wpa_printf(MSG_ERROR, "Failed to set TLS parameters");
1693                         goto fail;
1694                 }
1695
1696                 if (tls_global_set_verify(hapd->ssl_ctx,
1697                                           hapd->conf->check_crl)) {
1698                         wpa_printf(MSG_ERROR, "Failed to enable check_crl");
1699                         goto fail;
1700                 }
1701         }
1702 #endif /* EAP_TLS_FUNCS */
1703
1704 #ifdef EAP_SERVER
1705         if (hapd->conf->eap_sim_db) {
1706                 hapd->eap_sim_db_priv =
1707                         eap_sim_db_init(hapd->conf->eap_sim_db,
1708                                         hostapd_sim_db_cb, hapd);
1709                 if (hapd->eap_sim_db_priv == NULL) {
1710                         wpa_printf(MSG_ERROR, "Failed to initialize EAP-SIM "
1711                                    "database interface");
1712                         goto fail;
1713                 }
1714         }
1715 #endif /* EAP_SERVER */
1716
1717         hapd->driver = hapd->iconf->driver;
1718
1719         return hapd;
1720
1721 #if defined(EAP_TLS_FUNCS) || defined(EAP_SERVER)
1722 fail:
1723 #endif
1724         /* TODO: cleanup allocated resources(?) */
1725         os_free(hapd);
1726         return NULL;
1727 }
1728
1729
1730 /**
1731  * hostapd_init - Allocate and initialize per-interface data
1732  * @config_file: Path to the configuration file
1733  * Returns: Pointer to the allocated interface data or %NULL on failure
1734  *
1735  * This function is used to allocate main data structures for per-interface
1736  * data. The allocated data buffer will be freed by calling
1737  * hostapd_cleanup_iface().
1738  */
1739 static struct hostapd_iface * hostapd_init(const char *config_file)
1740 {
1741         struct hostapd_iface *hapd_iface = NULL;
1742         struct hostapd_config *conf = NULL;
1743         struct hostapd_data *hapd;
1744         size_t i;
1745
1746         hapd_iface = os_zalloc(sizeof(*hapd_iface));
1747         if (hapd_iface == NULL)
1748                 goto fail;
1749
1750         hapd_iface->config_fname = os_strdup(config_file);
1751         if (hapd_iface->config_fname == NULL)
1752                 goto fail;
1753
1754         conf = hostapd_config_read(hapd_iface->config_fname);
1755         if (conf == NULL)
1756                 goto fail;
1757         hapd_iface->conf = conf;
1758
1759         hapd_iface->num_bss = conf->num_bss;
1760         hapd_iface->bss = os_zalloc(conf->num_bss *
1761                                     sizeof(struct hostapd_data *));
1762         if (hapd_iface->bss == NULL)
1763                 goto fail;
1764
1765         for (i = 0; i < conf->num_bss; i++) {
1766                 hapd = hapd_iface->bss[i] =
1767                         hostapd_alloc_bss_data(hapd_iface, conf,
1768                                                &conf->bss[i]);
1769                 if (hapd == NULL)
1770                         goto fail;
1771         }
1772
1773         return hapd_iface;
1774
1775 fail:
1776         if (conf)
1777                 hostapd_config_free(conf);
1778         if (hapd_iface) {
1779                 for (i = 0; hapd_iface->bss && i < hapd_iface->num_bss; i++) {
1780                         hapd = hapd_iface->bss[i];
1781                         if (hapd && hapd->ssl_ctx)
1782                                 tls_deinit(hapd->ssl_ctx);
1783                 }
1784
1785                 os_free(hapd_iface->config_fname);
1786                 os_free(hapd_iface->bss);
1787                 os_free(hapd_iface);
1788         }
1789         return NULL;
1790 }
1791
1792
1793 static int hostapd_global_init(struct hapd_interfaces *interfaces)
1794 {
1795         hostapd_logger_register_cb(hostapd_logger_cb);
1796
1797         if (eap_server_register_methods()) {
1798                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
1799                 return -1;
1800         }
1801
1802         if (eloop_init(interfaces)) {
1803                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1804                 return -1;
1805         }
1806
1807 #ifndef CONFIG_NATIVE_WINDOWS
1808         eloop_register_signal(SIGHUP, handle_reload, NULL);
1809         eloop_register_signal(SIGUSR1, handle_dump_state, NULL);
1810 #endif /* CONFIG_NATIVE_WINDOWS */
1811         eloop_register_signal_terminate(handle_term, NULL);
1812
1813 #ifndef CONFIG_NATIVE_WINDOWS
1814         openlog("hostapd", 0, LOG_DAEMON);
1815 #endif /* CONFIG_NATIVE_WINDOWS */
1816
1817         return 0;
1818 }
1819
1820
1821 static void hostapd_global_deinit(const char *pid_file)
1822 {
1823 #ifdef EAP_TNC
1824         tncs_global_deinit();
1825 #endif /* EAP_TNC */
1826
1827         eloop_destroy();
1828
1829 #ifndef CONFIG_NATIVE_WINDOWS
1830         closelog();
1831 #endif /* CONFIG_NATIVE_WINDOWS */
1832
1833         eap_server_unregister_methods();
1834
1835         os_daemonize_terminate(pid_file);
1836 }
1837
1838
1839 static void hostapd_interface_deinit(struct hostapd_iface *iface)
1840 {
1841         size_t j;
1842
1843         if (iface == NULL)
1844                 return;
1845
1846         hostapd_cleanup_iface_pre(iface);
1847         for (j = 0; j < iface->num_bss; j++) {
1848                 struct hostapd_data *hapd = iface->bss[j];
1849                 hostapd_free_stas(hapd);
1850                 hostapd_flush_old_stations(hapd);
1851                 hostapd_cleanup(hapd);
1852                 if (j == iface->num_bss - 1 && hapd->driver)
1853                         hostapd_driver_deinit(hapd);
1854         }
1855         for (j = 0; j < iface->num_bss; j++)
1856                 os_free(iface->bss[j]);
1857         hostapd_cleanup_iface(iface);
1858 }
1859
1860
1861 static struct hostapd_iface * hostapd_interface_init(const char *config_fname,
1862                                                      int debug)
1863 {
1864         struct hostapd_iface *iface;
1865         int k;
1866
1867         wpa_printf(MSG_ERROR, "Configuration file: %s", config_fname);
1868         iface = hostapd_init(config_fname);
1869         if (!iface)
1870                 return NULL;
1871
1872         for (k = 0; k < debug; k++) {
1873                 if (iface->bss[0]->conf->logger_stdout_level > 0)
1874                         iface->bss[0]->conf->logger_stdout_level--;
1875         }
1876
1877         if (hostapd_setup_interface(iface)) {
1878                 hostapd_interface_deinit(iface);
1879                 return NULL;
1880         }
1881
1882         return iface;
1883 }
1884
1885
1886 static int hostapd_global_run(struct hapd_interfaces *ifaces, int daemonize,
1887                               const char *pid_file)
1888 {
1889 #ifdef EAP_TNC
1890         int tnc = 0;
1891         size_t i, k;
1892
1893         for (i = 0; !tnc && i < ifaces->count; i++) {
1894                 for (k = 0; k < ifaces->iface[i]->num_bss; k++) {
1895                         if (ifaces->iface[i]->bss[0]->conf->tnc) {
1896                                 tnc++;
1897                                 break;
1898                         }
1899                 }
1900         }
1901
1902         if (tnc && tncs_global_init() < 0) {
1903                 wpa_printf(MSG_ERROR, "Failed to initialize TNCS");
1904                 return -1;
1905         }
1906 #endif /* EAP_TNC */
1907
1908         if (daemonize && os_daemonize(pid_file)) {
1909                 perror("daemon");
1910                 return -1;
1911         }
1912
1913         eloop_run();
1914
1915         return 0;
1916 }
1917
1918
1919 int main(int argc, char *argv[])
1920 {
1921         struct hapd_interfaces interfaces;
1922         int ret = 1;
1923         size_t i;
1924         int c, debug = 0, daemonize = 0;
1925         const char *pid_file = NULL;
1926
1927         for (;;) {
1928                 c = getopt(argc, argv, "BdhKP:tv");
1929                 if (c < 0)
1930                         break;
1931                 switch (c) {
1932                 case 'h':
1933                         usage();
1934                         break;
1935                 case 'd':
1936                         debug++;
1937                         if (wpa_debug_level > 0)
1938                                 wpa_debug_level--;
1939                         break;
1940                 case 'B':
1941                         daemonize++;
1942                         break;
1943                 case 'K':
1944                         wpa_debug_show_keys++;
1945                         break;
1946                 case 'P':
1947                         pid_file = optarg;
1948                         break;
1949                 case 't':
1950                         wpa_debug_timestamp++;
1951                         break;
1952                 case 'v':
1953                         show_version();
1954                         exit(1);
1955                         break;
1956
1957                 default:
1958                         usage();
1959                         break;
1960                 }
1961         }
1962
1963         if (optind == argc)
1964                 usage();
1965
1966         interfaces.count = argc - optind;
1967         interfaces.iface = os_malloc(interfaces.count *
1968                                      sizeof(struct hostapd_iface *));
1969         if (interfaces.iface == NULL) {
1970                 wpa_printf(MSG_ERROR, "malloc failed\n");
1971                 return -1;
1972         }
1973
1974         if (hostapd_global_init(&interfaces))
1975                 return -1;
1976
1977         /* Initialize interfaces */
1978         for (i = 0; i < interfaces.count; i++) {
1979                 interfaces.iface[i] = hostapd_interface_init(argv[optind + i],
1980                                                              debug);
1981                 if (!interfaces.iface[i])
1982                         goto out;
1983         }
1984
1985         if (hostapd_global_run(&interfaces, daemonize, pid_file))
1986                 goto out;
1987
1988         ret = 0;
1989
1990  out:
1991         /* Deinitialize all interfaces */
1992         for (i = 0; i < interfaces.count; i++)
1993                 hostapd_interface_deinit(interfaces.iface[i]);
1994         os_free(interfaces.iface);
1995
1996         hostapd_global_deinit(pid_file);
1997
1998         return ret;
1999 }