hostapd/reconfig.c

   1 /*
   2  * hostapd / Configuration reloading
   3  * Copyright (c) 2002-2007, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2002-2004, Instant802 Networks, Inc.
   5  * Copyright (c) 2005-2006, Devicescape Software, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * Alternatively, this software may be distributed under the terms of BSD
  12  * license.
  13  *
  14  * See README and COPYING for more details.
  15  */
  16
  17 #include "includes.h"
  18
  19 #include "hostapd.h"
  20 #include "beacon.h"
  21 #include "hw_features.h"
  22 #include "driver.h"
  23 #include "sta_info.h"
  24 #include "radius/radius_client.h"
  25 #include "ieee802_11.h"
  26 #include "iapp.h"
  27 #include "ap_list.h"
  28 #include "wpa.h"
  29 #include "vlan_init.h"
  30 #include "ieee802_11_auth.h"
  31 #include "ieee802_1x.h"
  32 #include "accounting.h"
  33 #include "eloop.h"
  34
  35
  36 /**
  37  * struct hostapd_config_change - Configuration change information
  38  * This is for two purposes:
  39  * - Storing configuration information in the hostapd_iface during
  40  *   the asynchronous parts of reconfiguration.
  41  * - Passing configuration information for per-station reconfiguration.
  42  */
  43 struct hostapd_config_change {
  44         struct hostapd_data *hapd;
  45         struct hostapd_config *newconf, *oldconf;
  46         struct hostapd_bss_config *newbss, *oldbss;
  47         int mac_acl_changed;
  48         int num_sta_remove; /* number of STAs that need to be removed */
  49         int beacon_changed;
  50         struct hostapd_iface *hapd_iface;
  51         struct hostapd_data **new_hapd, **old_hapd;
  52         int num_old_hapd;
  53 };
  54
  55
  56 static int hostapd_config_reload_sta(struct hostapd_data *hapd,
  57                                      struct sta_info *sta, void *data)
  58 {
  59         struct hostapd_config_change *change = data;
  60         struct hostapd_bss_config *newbss, *oldbss;
  61         int deauth = 0;
  62         u8 reason = WLAN_REASON_PREV_AUTH_NOT_VALID;
  63
  64         newbss = change->newbss;
  65         oldbss = change->oldbss;
  66         hapd = change->hapd;
  67
  68         if (sta->ssid == &oldbss->ssid) {
  69                 sta->ssid = &newbss->ssid;
  70
  71                 if (newbss->ssid.ssid_len != oldbss->ssid.ssid_len ||
  72                     os_memcmp(newbss->ssid.ssid, oldbss->ssid.ssid,
  73                               newbss->ssid.ssid_len) != 0) {
  74                         /* main SSID was changed - kick STA out */
  75                         deauth++;
  76                 }
  77         }
  78         sta->ssid_probe = sta->ssid;
  79
  80         /*
  81          * If MAC ACL configuration has changed, deauthenticate stations that
  82          * have been removed from accepted list or have been added to denied
  83          * list. If external RADIUS server is used for ACL, all stations are
  84          * deauthenticated and they will need to authenticate again. This
  85          * limits sudden load on the RADIUS server since the verification will
  86          * be done over the time needed for the STAs to reauthenticate
  87          * themselves.
  88          */
  89         if (change->mac_acl_changed &&
  90             (newbss->macaddr_acl == USE_EXTERNAL_RADIUS_AUTH ||
  91              !hostapd_allowed_address(hapd, sta->addr, NULL, 0, NULL, NULL,
  92                                       NULL)))
  93                 deauth++;
  94
  95         if (newbss->ieee802_1x != oldbss->ieee802_1x &&
  96             sta->ssid == &hapd->conf->ssid)
  97                 deauth++;
  98
  99         if (newbss->wpa != oldbss->wpa)
 100                 deauth++;
 101
 102         if (!newbss->wme_enabled && (sta->flags & WLAN_STA_WME))
 103                 deauth++;
 104
 105         if (newbss->auth_algs != oldbss->auth_algs &&
 106             ((sta->auth_alg == WLAN_AUTH_OPEN &&
 107               !(newbss->auth_algs & WPA_AUTH_ALG_OPEN)) ||
 108              (sta->auth_alg == WLAN_AUTH_SHARED_KEY &&
 109               !(newbss->auth_algs & WPA_AUTH_ALG_SHARED))))
 110                 deauth++;
 111
 112         if (change->num_sta_remove > 0) {
 113                 deauth++;
 114                 reason = WLAN_REASON_DISASSOC_AP_BUSY;
 115         }
 116
 117         if (deauth) {
 118                 wpa_printf(MSG_DEBUG, "STA " MACSTR " deauthenticated during "
 119                            "config reloading (reason=%d)",
 120                            MAC2STR(sta->addr), reason);
 121                 ieee802_11_send_deauth(hapd, sta->addr, reason);
 122                 ap_sta_deauthenticate(hapd, sta, reason);
 123                 change->num_sta_remove--;
 124         }
 125
 126         return 0;
 127 }
 128
 129
 130 static void hostapd_reconfig_tx_queue_params(struct hostapd_data *hapd,
 131                                              struct hostapd_config *newconf,
 132                                              struct hostapd_config *oldconf)
 133 {
 134         int i;
 135         struct hostapd_tx_queue_params *o, *n;
 136
 137         for (i = 0; i < NUM_TX_QUEUES; i++) {
 138                 o = &oldconf->tx_queue[i];
 139                 n = &newconf->tx_queue[i];
 140
 141                 if (!n->configured)
 142                         continue;
 143
 144                 if ((n->aifs != o->aifs || n->cwmin != o->cwmin ||
 145                      n->cwmax != o->cwmax || n->burst != o->burst) &&
 146                     hostapd_set_tx_queue_params(hapd, i, n->aifs, n->cwmin,
 147                                                 n->cwmax, n->burst))
 148                         printf("Failed to set TX queue parameters for queue %d"
 149                                ".\n", i);
 150         }
 151 }
 152
 153
 154 static int hostapd_reconfig_wme(struct hostapd_data *hapd,
 155                                 struct hostapd_config *newconf,
 156                                 struct hostapd_config *oldconf)
 157 {
 158         int beacon_changed = 0;
 159         size_t i;
 160         struct hostapd_wme_ac_params *o, *n;
 161
 162         for (i = 0; i < sizeof(newconf->wme_ac_params) /
 163                         sizeof(newconf->wme_ac_params[0]); i++) {
 164                 o = &oldconf->wme_ac_params[i];
 165                 n = &newconf->wme_ac_params[i];
 166                 if (n->cwmin != o->cwmin ||
 167                     n->cwmax != o->cwmax ||
 168                     n->aifs != o->aifs ||
 169                     n->txopLimit != o->txopLimit ||
 170                     n->admission_control_mandatory !=
 171                     o->admission_control_mandatory) {
 172                         beacon_changed++;
 173                         hapd->parameter_set_count++;
 174                 }
 175         }
 176
 177         return beacon_changed;
 178 }
 179
 180
 181 static int rate_array_diff(int *a1, int *a2)
 182 {
 183         int i;
 184
 185         if (a1 == NULL && a2 == NULL)
 186                 return 0;
 187         if (a1 == NULL || a2 == NULL)
 188                 return 1;
 189
 190         i = 0;
 191         for (;;) {
 192                 if (a1[i] != a2[i])
 193                         return 1;
 194                 if (a1[i] == -1)
 195                         break;
 196                 i++;
 197         }
 198
 199         return 0;
 200 }
 201
 202
 203 static int hostapd_acl_diff(struct hostapd_bss_config *a,
 204                             struct hostapd_bss_config *b)
 205 {
 206         int i;
 207
 208         if (a->macaddr_acl != b->macaddr_acl ||
 209             a->num_accept_mac != b->num_accept_mac ||
 210             a->num_deny_mac != b->num_deny_mac)
 211                 return 1;
 212
 213         for (i = 0; i < a->num_accept_mac; i++) {
 214                 if (os_memcmp(a->accept_mac[i].addr, b->accept_mac[i].addr,
 215                               ETH_ALEN) != 0)
 216                         return 1;
 217         }
 218
 219         for (i = 0; i < a->num_deny_mac; i++) {
 220                 if (os_memcmp(a->deny_mac[i].addr, b->deny_mac[i].addr,
 221                               ETH_ALEN) != 0)
 222                         return 1;
 223         }
 224
 225         return 0;
 226 }
 227
 228
 229 /**
 230  * reload_iface2 - Part 2 of reload_iface
 231  * @hapd_iface: Pointer to hostapd interface data.
 232  */
 233 static void reload_iface2(struct hostapd_iface *hapd_iface)
 234 {
 235         struct hostapd_data *hapd = hapd_iface->bss[0];
 236         struct hostapd_config *newconf = hapd_iface->change->newconf;
 237         struct hostapd_config *oldconf = hapd_iface->change->oldconf;
 238         int beacon_changed = hapd_iface->change->beacon_changed;
 239         hostapd_iface_cb cb = hapd_iface->reload_iface_cb;
 240
 241         if (newconf->preamble != oldconf->preamble) {
 242                 if (hostapd_set_preamble(hapd, hapd->iconf->preamble))
 243                         printf("Could not set preamble for kernel driver\n");
 244                 beacon_changed++;
 245         }
 246
 247         if (newconf->beacon_int != oldconf->beacon_int) {
 248                 /* Need to change beacon interval if it has changed or if
 249                  * auto channel selection was used. */
 250                 if (hostapd_set_beacon_int(hapd, newconf->beacon_int))
 251                         printf("Could not set beacon interval for kernel "
 252                                "driver\n");
 253                 if (newconf->beacon_int != oldconf->beacon_int)
 254                         beacon_changed++;
 255         }
 256
 257         if (newconf->cts_protection_type != oldconf->cts_protection_type)
 258                 beacon_changed++;
 259
 260         if (newconf->rts_threshold > -1 &&
 261             newconf->rts_threshold != oldconf->rts_threshold &&
 262             hostapd_set_rts(hapd, newconf->rts_threshold))
 263                 printf("Could not set RTS threshold for kernel driver\n");
 264
 265         if (newconf->fragm_threshold > -1 &&
 266             newconf->fragm_threshold != oldconf->fragm_threshold &&
 267             hostapd_set_frag(hapd, newconf->fragm_threshold))
 268                 printf("Could not set fragmentation threshold for kernel "
 269                        "driver\n");
 270
 271         hostapd_reconfig_tx_queue_params(hapd, newconf, oldconf);
 272
 273         if (hostapd_reconfig_wme(hapd, newconf, oldconf) > 0)
 274                 beacon_changed++;
 275
 276         ap_list_reconfig(hapd_iface, oldconf);
 277
 278         hapd_iface->change->beacon_changed = beacon_changed;
 279
 280         hapd_iface->reload_iface_cb = NULL;
 281         cb(hapd_iface, 0);
 282 }
 283
 284
 285 /**
 286  * reload_iface2_handler - Handler that calls reload_face2
 287  * @eloop_data: Stores the struct hostapd_iface for the interface.
 288  * @user_ctx: Unused.
 289  */
 290 static void reload_iface2_handler(void *eloop_data, void *user_ctx)
 291 {
 292         struct hostapd_iface *hapd_iface = eloop_data;
 293
 294         reload_iface2(hapd_iface);
 295 }
 296
 297
 298 /**
 299  * reload_hw_mode_done - Callback for after the HW mode is setup
 300  * @hapd_iface: Pointer to interface data.
 301  * @status: Status of the HW mode setup.
 302  */
 303 static void reload_hw_mode_done(struct hostapd_iface *hapd_iface, int status)
 304 {
 305         struct hostapd_data *hapd = hapd_iface->bss[0];
 306         struct hostapd_config_change *change = hapd_iface->change;
 307         struct hostapd_config *newconf = change->newconf;
 308         hostapd_iface_cb cb;
 309         int freq;
 310
 311         if (status) {
 312                 printf("Failed to select hw_mode.\n");
 313
 314                 cb = hapd_iface->reload_iface_cb;
 315                 hapd_iface->reload_iface_cb = NULL;
 316                 cb(hapd_iface, -1);
 317
 318                 return;
 319         }
 320
 321         freq = hostapd_hw_get_freq(hapd, newconf->channel);
 322         wpa_printf(MSG_DEBUG, "Mode: %s  Channel: %d  Frequency: %d MHz",
 323                    hostapd_hw_mode_txt(newconf->hw_mode),
 324                    newconf->channel, freq);
 325
 326         if (hostapd_set_freq(hapd, newconf->hw_mode, freq)) {
 327                 printf("Could not set channel %d (%d MHz) for kernel "
 328                        "driver\n", newconf->channel, freq);
 329         }
 330
 331         change->beacon_changed++;
 332
 333         reload_iface2(hapd_iface);
 334 }
 335
 336
 337 /**
 338  * hostapd_config_reload_iface_start - Start interface reload
 339  * @hapd_iface: Pointer to interface data.
 340  * @cb: The function to callback when done.
 341  * Returns:  0 if it starts successfully; cb will be called when done.
 342  *          -1 on failure; cb will not be called.
 343  */
 344 static int hostapd_config_reload_iface_start(struct hostapd_iface *hapd_iface,
 345                                              hostapd_iface_cb cb)
 346 {
 347         struct hostapd_config_change *change = hapd_iface->change;
 348         struct hostapd_config *newconf = change->newconf;
 349         struct hostapd_config *oldconf = change->oldconf;
 350         struct hostapd_data *hapd = hapd_iface->bss[0];
 351
 352         if (hapd_iface->reload_iface_cb) {
 353                 wpa_printf(MSG_DEBUG,
 354                            "%s: Interface reload already in progress.",
 355                            hapd_iface->bss[0]->conf->iface);
 356                 return -1;
 357         }
 358
 359         hapd_iface->reload_iface_cb = cb;
 360
 361         if (newconf->bridge_packets != oldconf->bridge_packets &&
 362             hapd->iconf->bridge_packets != INTERNAL_BRIDGE_DO_NOT_CONTROL &&
 363             hostapd_set_internal_bridge(hapd, hapd->iconf->bridge_packets))
 364                 printf("Failed to set bridge_packets for kernel driver\n");
 365
 366         if (newconf->channel != oldconf->channel ||
 367             newconf->hw_mode != oldconf->hw_mode ||
 368             rate_array_diff(newconf->supported_rates,
 369                             oldconf->supported_rates) ||
 370             rate_array_diff(newconf->basic_rates, oldconf->basic_rates)) {
 371                 hostapd_free_stas(hapd);
 372
 373                 if (hostapd_get_hw_features(hapd_iface)) {
 374                         printf("Could not read HW feature info from the kernel"
 375                                " driver.\n");
 376                         hapd_iface->reload_iface_cb = NULL;
 377                         return -1;
 378                 }
 379
 380                 if (hostapd_select_hw_mode_start(hapd_iface,
 381                                                  reload_hw_mode_done)) {
 382                         printf("Failed to start select hw_mode.\n");
 383                         hapd_iface->reload_iface_cb = NULL;
 384                         return -1;
 385                 }
 386
 387                 return 0;
 388         }
 389
 390         eloop_register_timeout(0, 0, reload_iface2_handler, hapd_iface, NULL);
 391         return 0;
 392 }
 393
 394
 395 static void hostapd_reconfig_bss(struct hostapd_data *hapd,
 396                                  struct hostapd_bss_config *newbss,
 397                                  struct hostapd_bss_config *oldbss,
 398                                  struct hostapd_config *oldconf,
 399                                  int beacon_changed)
 400 {
 401         struct hostapd_config_change change;
 402         int encr_changed = 0;
 403         struct radius_client_data *old_radius;
 404
 405         radius_client_flush(hapd->radius, 0);
 406
 407         if (hostapd_set_dtim_period(hapd, newbss->dtim_period))
 408                 printf("Could not set DTIM period for kernel driver\n");
 409
 410         if (newbss->ssid.ssid_len != oldbss->ssid.ssid_len ||
 411             os_memcmp(newbss->ssid.ssid, oldbss->ssid.ssid,
 412                       newbss->ssid.ssid_len) != 0) {
 413                 if (hostapd_set_ssid(hapd, (u8 *) newbss->ssid.ssid,
 414                                      newbss->ssid.ssid_len))
 415                         printf("Could not set SSID for kernel driver\n");
 416                 beacon_changed++;
 417         }
 418
 419         if (newbss->ignore_broadcast_ssid != oldbss->ignore_broadcast_ssid)
 420                 beacon_changed++;
 421
 422         if (hostapd_wep_key_cmp(&newbss->ssid.wep, &oldbss->ssid.wep)) {
 423                 encr_changed++;
 424                 beacon_changed++;
 425         }
 426
 427         vlan_reconfig(hapd, oldconf, oldbss);
 428
 429         if (beacon_changed) {
 430                 wpa_printf(MSG_DEBUG, "Updating beacon frame information");
 431                 ieee802_11_set_beacon(hapd);
 432         }
 433
 434         change.hapd = hapd;
 435         change.oldconf = oldconf;
 436         change.newconf = hapd->iconf;
 437         change.oldbss = oldbss;
 438         change.newbss = newbss;
 439         change.mac_acl_changed = hostapd_acl_diff(newbss, oldbss);
 440         if (newbss->max_num_sta != oldbss->max_num_sta &&
 441             newbss->max_num_sta < hapd->num_sta) {
 442                 change.num_sta_remove = hapd->num_sta - newbss->max_num_sta;
 443         } else
 444                 change.num_sta_remove = 0;
 445         ap_for_each_sta(hapd, hostapd_config_reload_sta, &change);
 446
 447         old_radius = hapd->radius;
 448         hapd->radius = radius_client_reconfig(hapd->radius, hapd,
 449                                               oldbss->radius, newbss->radius);
 450         hapd->radius_client_reconfigured = old_radius != hapd->radius ||
 451                 hostapd_ip_diff(&newbss->own_ip_addr, &oldbss->own_ip_addr);
 452
 453         ieee802_1x_reconfig(hapd, oldconf, oldbss);
 454         iapp_reconfig(hapd, oldconf, oldbss);
 455
 456         hostapd_acl_reconfig(hapd, oldconf);
 457         accounting_reconfig(hapd, oldconf);
 458 }
 459
 460
 461 /**
 462  * config_reload2 - Part 2 of configuration reloading
 463  * @hapd_iface:
 464  */
 465 static void config_reload2(struct hostapd_iface *hapd_iface, int status)
 466 {
 467         struct hostapd_config_change *change = hapd_iface->change;
 468         struct hostapd_data *hapd = change->hapd;
 469         struct hostapd_config *newconf = change->newconf;
 470         struct hostapd_config *oldconf = change->oldconf;
 471         int beacon_changed = change->beacon_changed;
 472         struct hostapd_data **new_hapd = change->new_hapd;
 473         struct hostapd_data **old_hapd = change->old_hapd;
 474         int num_old_hapd = change->num_old_hapd;
 475         size_t i, j, max_bss, same_bssid;
 476         struct hostapd_bss_config *newbss, *oldbss;
 477         u8 *prev_addr;
 478         hostapd_iface_cb cb;
 479
 480         os_free(change);
 481         hapd_iface->change = NULL;
 482
 483         if (status) {
 484                 printf("Failed to setup new interface config\n");
 485
 486                 cb = hapd_iface->config_reload_cb;
 487                 hapd_iface->config_reload_cb = NULL;
 488
 489                 /* Invalid configuration - cleanup and terminate hostapd */
 490                 hapd_iface->bss = old_hapd;
 491                 hapd_iface->num_bss = num_old_hapd;
 492                 hapd_iface->conf = hapd->iconf = oldconf;
 493                 hapd->conf = &oldconf->bss[0];
 494                 hostapd_config_free(newconf);
 495                 os_free(new_hapd);
 496
 497                 cb(hapd_iface, -2);
 498
 499                 return;
 500         }
 501
 502         /*
 503          * If any BSSes have been removed, added, or had their BSSIDs changed,
 504          * completely remove and reinitialize such BSSes and all the BSSes
 505          * following them since their BSSID might have changed.
 506          */
 507         max_bss = oldconf->num_bss;
 508         if (max_bss > newconf->num_bss)
 509                 max_bss = newconf->num_bss;
 510
 511         for (i = 0; i < max_bss; i++) {
 512                 if (os_strcmp(oldconf->bss[i].iface, newconf->bss[i].iface) !=
 513                     0 || hostapd_mac_comp(oldconf->bss[i].bssid,
 514                                           newconf->bss[i].bssid) != 0)
 515                         break;
 516         }
 517         same_bssid = i;
 518
 519         for (i = 0; i < oldconf->num_bss; i++) {
 520                 oldbss = &oldconf->bss[i];
 521                 newbss = NULL;
 522                 for (j = 0; j < newconf->num_bss; j++) {
 523                         if (os_strcmp(oldbss->iface, newconf->bss[j].iface) ==
 524                             0) {
 525                                 newbss = &newconf->bss[j];
 526                                 break;
 527                         }
 528                 }
 529
 530                 if (newbss && i < same_bssid) {
 531                         hapd = hapd_iface->bss[j] = old_hapd[i];
 532                         hapd->iconf = newconf;
 533                         hapd->conf = newbss;
 534                         hostapd_reconfig_bss(hapd, newbss, oldbss, oldconf,
 535                                              beacon_changed);
 536                 } else {
 537                         hapd = old_hapd[i];
 538                         wpa_printf(MSG_DEBUG, "Removing BSS (ifname %s)",
 539                                    hapd->conf->iface);
 540                         hostapd_free_stas(hapd);
 541                         /* Send broadcast deauthentication for this BSS, but do
 542                          * not clear all STAs from the driver since other BSSes
 543                          * may have STA entries. The driver will remove all STA
 544                          * entries for this BSS anyway when the interface is
 545                          * being removed. */
 546 #if 0
 547                         hostapd_deauth_all_stas(hapd);
 548                         hostapd_cleanup(hapd);
 549 #endif
 550
 551                         os_free(hapd);
 552                 }
 553         }
 554
 555
 556         prev_addr = hapd_iface->bss[0]->own_addr;
 557         hapd = hapd_iface->bss[0];
 558         for (j = 0; j < newconf->num_bss; j++) {
 559                 if (hapd_iface->bss[j] != NULL) {
 560                         prev_addr = hapd_iface->bss[j]->own_addr;
 561                         continue;
 562                 }
 563
 564                 newbss = &newconf->bss[j];
 565
 566                 wpa_printf(MSG_DEBUG, "Reconfiguration: adding new BSS "
 567                            "(ifname=%s)", newbss->iface);
 568
 569 #if 0
 570                 hapd = hapd_iface->bss[j] =
 571                         hostapd_alloc_bss_data(hapd_iface, newconf, newbss);
 572                 if (hapd == NULL) {
 573                         printf("Failed to initialize new BSS\n");
 574                         /* FIX: This one is somewhat hard to recover
 575                          * from.. Would need to remove this BSS from
 576                          * conf and BSS list. */
 577                         exit(1);
 578                 }
 579 #endif
 580                 hapd->driver = hapd_iface->bss[0]->driver;
 581                 hapd->iface = hapd_iface;
 582                 hapd->iconf = newconf;
 583                 hapd->conf = newbss;
 584
 585                 os_memcpy(hapd->own_addr, prev_addr, ETH_ALEN);
 586                 if (hostapd_mac_comp_empty(hapd->conf->bssid) == 0)
 587                         prev_addr = hapd->own_addr;
 588
 589 #if 0
 590                 if (hostapd_setup_bss(hapd, j == 0)) {
 591                         printf("Failed to setup new BSS\n");
 592                         /* FIX */
 593                         exit(1);
 594                 }
 595 #endif
 596
 597         }
 598
 599         os_free(old_hapd);
 600         hostapd_config_free(oldconf);
 601
 602         cb = hapd_iface->config_reload_cb;
 603         hapd_iface->config_reload_cb = NULL;
 604
 605         cb(hapd_iface, 0);
 606 }
 607
 608
 609 /**
 610  * hostapd_config_reload_start - Start reconfiguration of an interface
 611  * @hapd_iface: Pointer to hostapd interface data
 612  * @cb: Function to be called back when done.
 613  *      The status indicates:
 614  *       0 = success, new configuration in use;
 615  *      -1 = failed to update configuraiton, old configuration in use;
 616  *      -2 = failed to update configuration and failed to recover; caller
 617  *           should cleanup and terminate hostapd
 618  * Returns:
 619  *  0 = reconfiguration started;
 620  * -1 = failed to update configuration, old configuration in use;
 621  * -2 = failed to update configuration and failed to recover; caller
 622  *      should cleanup and terminate hostapd
 623  */
 624 int hostapd_config_reload_start(struct hostapd_iface *hapd_iface,
 625                                 hostapd_iface_cb cb)
 626 {
 627         struct hostapd_config *newconf, *oldconf;
 628         struct hostapd_config_change *change;
 629         struct hostapd_data *hapd = NULL;
 630         struct hostapd_data **old_hapd, **new_hapd;
 631         int num_old_hapd;
 632
 633         if (hapd_iface->config_reload_cb) {
 634                 wpa_printf(MSG_DEBUG, "%s: Config reload already in progress.",
 635                            hapd_iface->bss[0]->conf->iface);
 636                 return -1;
 637         }
 638
 639         newconf = hostapd_config_read(hapd_iface->config_fname);
 640         if (newconf == NULL) {
 641                 printf("Failed to read new configuration file - continuing "
 642                        "with old.\n");
 643                 return -1;
 644         }
 645
 646         if (os_strcmp(newconf->bss[0].iface, hapd_iface->conf->bss[0].iface) !=
 647             0) {
 648                 printf("Interface name changing is not allowed in "
 649                        "configuration reloading (%s -> %s).\n",
 650                        hapd_iface->conf->bss[0].iface,  newconf->bss[0].iface);
 651                 hostapd_config_free(newconf);
 652                 return -1;
 653         }
 654
 655         new_hapd = os_zalloc(newconf->num_bss *
 656                              sizeof(struct hostapd_data *));
 657         if (new_hapd == NULL) {
 658                 hostapd_config_free(newconf);
 659                 return -1;
 660         }
 661         old_hapd = hapd_iface->bss;
 662         num_old_hapd = hapd_iface->num_bss;
 663
 664         hapd_iface->bss = new_hapd;
 665         hapd_iface->num_bss = newconf->num_bss;
 666         /*
 667          * First BSS remains the same since interface name changing was
 668          * prohibited above. Now, this is only used in
 669          * hostapd_config_reload_iface() and following loop will anyway set
 670          * this again.
 671          */
 672         hapd = hapd_iface->bss[0] = old_hapd[0];
 673
 674         oldconf = hapd_iface->conf;
 675         hapd->iconf = hapd_iface->conf = newconf;
 676         hapd->conf = &newconf->bss[0];
 677
 678         change = os_zalloc(sizeof(struct hostapd_config_change));
 679         if (change == NULL) {
 680                 hostapd_config_free(newconf);
 681                 return -1;
 682         }
 683
 684         change->hapd = hapd;
 685         change->newconf = newconf;
 686         change->oldconf = oldconf;
 687         change->beacon_changed = 0;
 688         change->hapd_iface = hapd_iface;
 689         change->new_hapd = new_hapd;
 690         change->old_hapd = old_hapd;
 691         change->num_old_hapd = num_old_hapd;
 692
 693         hapd_iface->config_reload_cb = cb;
 694         hapd_iface->change = change;
 695         if (hostapd_config_reload_iface_start(hapd_iface, config_reload2)) {
 696                 printf("Failed to start setup of new interface config\n");
 697
 698                 hapd_iface->config_reload_cb = NULL;
 699                 os_free(change);
 700                 hapd_iface->change = NULL;
 701
 702                 /* Invalid configuration - cleanup and terminate hostapd */
 703                 hapd_iface->bss = old_hapd;
 704                 hapd_iface->num_bss = num_old_hapd;
 705                 hapd_iface->conf = hapd->iconf = oldconf;
 706                 hapd->conf = &oldconf->bss[0];
 707                 hostapd_config_free(newconf);
 708                 os_free(new_hapd);
 709                 return -2;
 710         }
 711
 712         return 0;
 713 }