hostapd/config.c

   1 /*
   2  * hostapd / Configuration file
   3  * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2007-2008, Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #include "includes.h"
  17 #ifndef CONFIG_NATIVE_WINDOWS
  18 #include <grp.h>
  19 #endif /* CONFIG_NATIVE_WINDOWS */
  20
  21 #include "hostapd.h"
  22 #include "driver.h"
  23 #include "sha1.h"
  24 #include "eap_server/eap.h"
  25 #include "radius/radius_client.h"
  26 #include "wpa_common.h"
  27 #include "wpa.h"
  28 #include "uuid.h"
  29
  30
  31 #define MAX_STA_COUNT 2007
  32
  33 extern struct wpa_driver_ops *hostapd_drivers[];
  34
  35
  36 static int hostapd_config_read_vlan_file(struct hostapd_bss_config *bss,
  37                                          const char *fname)
  38 {
  39         FILE *f;
  40         char buf[128], *pos, *pos2;
  41         int line = 0, vlan_id;
  42         struct hostapd_vlan *vlan;
  43
  44         f = fopen(fname, "r");
  45         if (!f) {
  46                 printf("VLAN file '%s' not readable.\n", fname);
  47                 return -1;
  48         }
  49
  50         while (fgets(buf, sizeof(buf), f)) {
  51                 line++;
  52
  53                 if (buf[0] == '#')
  54                         continue;
  55                 pos = buf;
  56                 while (*pos != '\0') {
  57                         if (*pos == '\n') {
  58                                 *pos = '\0';
  59                                 break;
  60                         }
  61                         pos++;
  62                 }
  63                 if (buf[0] == '\0')
  64                         continue;
  65
  66                 if (buf[0] == '*') {
  67                         vlan_id = VLAN_ID_WILDCARD;
  68                         pos = buf + 1;
  69                 } else {
  70                         vlan_id = strtol(buf, &pos, 10);
  71                         if (buf == pos || vlan_id < 1 ||
  72                             vlan_id > MAX_VLAN_ID) {
  73                                 printf("Invalid VLAN ID at line %d in '%s'\n",
  74                                        line, fname);
  75                                 fclose(f);
  76                                 return -1;
  77                         }
  78                 }
  79
  80                 while (*pos == ' ' || *pos == '\t')
  81                         pos++;
  82                 pos2 = pos;
  83                 while (*pos2 != ' ' && *pos2 != '\t' && *pos2 != '\0')
  84                         pos2++;
  85                 *pos2 = '\0';
  86                 if (*pos == '\0' || os_strlen(pos) > IFNAMSIZ) {
  87                         printf("Invalid VLAN ifname at line %d in '%s'\n",
  88                                line, fname);
  89                         fclose(f);
  90                         return -1;
  91                 }
  92
  93                 vlan = os_malloc(sizeof(*vlan));
  94                 if (vlan == NULL) {
  95                         printf("Out of memory while reading VLAN interfaces "
  96                                "from '%s'\n", fname);
  97                         fclose(f);
  98                         return -1;
  99                 }
 100
 101                 os_memset(vlan, 0, sizeof(*vlan));
 102                 vlan->vlan_id = vlan_id;
 103                 os_strlcpy(vlan->ifname, pos, sizeof(vlan->ifname));
 104                 if (bss->vlan_tail)
 105                         bss->vlan_tail->next = vlan;
 106                 else
 107                         bss->vlan = vlan;
 108                 bss->vlan_tail = vlan;
 109         }
 110
 111         fclose(f);
 112
 113         return 0;
 114 }
 115
 116
 117 static void hostapd_config_free_vlan(struct hostapd_bss_config *bss)
 118 {
 119         struct hostapd_vlan *vlan, *prev;
 120
 121         vlan = bss->vlan;
 122         prev = NULL;
 123         while (vlan) {
 124                 prev = vlan;
 125                 vlan = vlan->next;
 126                 os_free(prev);
 127         }
 128
 129         bss->vlan = NULL;
 130 }
 131
 132
 133 /* convert floats with one decimal place to value*10 int, i.e.,
 134  * "1.5" will return 15 */
 135 static int hostapd_config_read_int10(const char *value)
 136 {
 137         int i, d;
 138         char *pos;
 139
 140         i = atoi(value);
 141         pos = os_strchr(value, '.');
 142         d = 0;
 143         if (pos) {
 144                 pos++;
 145                 if (*pos >= '0' && *pos <= '9')
 146                         d = *pos - '0';
 147         }
 148
 149         return i * 10 + d;
 150 }
 151
 152
 153 static void hostapd_config_defaults_bss(struct hostapd_bss_config *bss)
 154 {
 155         bss->logger_syslog_level = HOSTAPD_LEVEL_INFO;
 156         bss->logger_stdout_level = HOSTAPD_LEVEL_INFO;
 157         bss->logger_syslog = (unsigned int) -1;
 158         bss->logger_stdout = (unsigned int) -1;
 159
 160         bss->auth_algs = WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED;
 161
 162         bss->wep_rekeying_period = 300;
 163         /* use key0 in individual key and key1 in broadcast key */
 164         bss->broadcast_key_idx_min = 1;
 165         bss->broadcast_key_idx_max = 2;
 166         bss->eap_reauth_period = 3600;
 167
 168         bss->wpa_group_rekey = 600;
 169         bss->wpa_gmk_rekey = 86400;
 170         bss->wpa_key_mgmt = WPA_KEY_MGMT_PSK;
 171         bss->wpa_pairwise = WPA_CIPHER_TKIP;
 172         bss->wpa_group = WPA_CIPHER_TKIP;
 173         bss->rsn_pairwise = 0;
 174
 175         bss->max_num_sta = MAX_STA_COUNT;
 176
 177         bss->dtim_period = 2;
 178
 179         bss->radius_server_auth_port = 1812;
 180         bss->ap_max_inactivity = AP_MAX_INACTIVITY;
 181         bss->eapol_version = EAPOL_VERSION;
 182
 183         bss->max_listen_interval = 65535;
 184
 185 #ifdef CONFIG_IEEE80211W
 186         bss->assoc_ping_timeout = 1000;
 187         bss->assoc_ping_attempts = 3;
 188 #endif /* CONFIG_IEEE80211W */
 189 #ifdef EAP_FAST
 190          /* both anonymous and authenticated provisioning */
 191         bss->eap_fast_prov = 3;
 192         bss->pac_key_lifetime = 7 * 24 * 60 * 60;
 193         bss->pac_key_refresh_time = 1 * 24 * 60 * 60;
 194 #endif /* EAP_FAST */
 195 }
 196
 197
 198 static struct hostapd_config * hostapd_config_defaults(void)
 199 {
 200         struct hostapd_config *conf;
 201         struct hostapd_bss_config *bss;
 202         int i;
 203         const int aCWmin = 15, aCWmax = 1024;
 204         const struct hostapd_wme_ac_params ac_bk =
 205                 { aCWmin, aCWmax, 7, 0, 0 }; /* background traffic */
 206         const struct hostapd_wme_ac_params ac_be =
 207                 { aCWmin, aCWmax, 3, 0, 0 }; /* best effort traffic */
 208         const struct hostapd_wme_ac_params ac_vi = /* video traffic */
 209                 { aCWmin >> 1, aCWmin, 2, 3000 / 32, 1 };
 210         const struct hostapd_wme_ac_params ac_vo = /* voice traffic */
 211                 { aCWmin >> 2, aCWmin >> 1, 2, 1500 / 32, 1 };
 212
 213         conf = os_zalloc(sizeof(*conf));
 214         bss = os_zalloc(sizeof(*bss));
 215         if (conf == NULL || bss == NULL) {
 216                 printf("Failed to allocate memory for configuration data.\n");
 217                 os_free(conf);
 218                 os_free(bss);
 219                 return NULL;
 220         }
 221
 222         /* set default driver based on configuration */
 223         conf->driver = hostapd_drivers[0];
 224         if (conf->driver == NULL) {
 225                 printf("No driver wrappers registered!\n");
 226                 os_free(conf);
 227                 os_free(bss);
 228                 return NULL;
 229         }
 230
 231         bss->radius = os_zalloc(sizeof(*bss->radius));
 232         if (bss->radius == NULL) {
 233                 os_free(conf);
 234                 os_free(bss);
 235                 return NULL;
 236         }
 237
 238         hostapd_config_defaults_bss(bss);
 239
 240         conf->num_bss = 1;
 241         conf->bss = bss;
 242
 243         conf->beacon_int = 100;
 244         conf->rts_threshold = -1; /* use driver default: 2347 */
 245         conf->fragm_threshold = -1; /* user driver default: 2346 */
 246         conf->send_probe_response = 1;
 247         conf->bridge_packets = INTERNAL_BRIDGE_DO_NOT_CONTROL;
 248
 249         os_memcpy(conf->country, "US ", 3);
 250
 251         for (i = 0; i < NUM_TX_QUEUES; i++)
 252                 conf->tx_queue[i].aifs = -1; /* use hw default */
 253
 254         conf->wme_ac_params[0] = ac_be;
 255         conf->wme_ac_params[1] = ac_bk;
 256         conf->wme_ac_params[2] = ac_vi;
 257         conf->wme_ac_params[3] = ac_vo;
 258
 259 #ifdef CONFIG_IEEE80211N
 260         SET_2BIT_LE16(&conf->ht_capab,
 261                       HT_CAP_INFO_MIMO_PWR_SAVE_OFFSET,
 262                       MIMO_PWR_NO_LIMIT_ON_MIMO_SEQS);
 263
 264         conf->ht_capab |= HT_CAP_INFO_GREEN_FIELD;
 265 #endif /* CONFIG_IEEE80211N */
 266
 267         return conf;
 268 }
 269
 270
 271 int hostapd_mac_comp(const void *a, const void *b)
 272 {
 273         return os_memcmp(a, b, sizeof(macaddr));
 274 }
 275
 276
 277 int hostapd_mac_comp_empty(const void *a)
 278 {
 279         macaddr empty = { 0 };
 280         return os_memcmp(a, empty, sizeof(macaddr));
 281 }
 282
 283
 284 static int hostapd_acl_comp(const void *a, const void *b)
 285 {
 286         const struct mac_acl_entry *aa = a;
 287         const struct mac_acl_entry *bb = b;
 288         return os_memcmp(aa->addr, bb->addr, sizeof(macaddr));
 289 }
 290
 291
 292 static int hostapd_config_read_maclist(const char *fname,
 293                                        struct mac_acl_entry **acl, int *num)
 294 {
 295         FILE *f;
 296         char buf[128], *pos;
 297         int line = 0;
 298         u8 addr[ETH_ALEN];
 299         struct mac_acl_entry *newacl;
 300         int vlan_id;
 301
 302         if (!fname)
 303                 return 0;
 304
 305         f = fopen(fname, "r");
 306         if (!f) {
 307                 printf("MAC list file '%s' not found.\n", fname);
 308                 return -1;
 309         }
 310
 311         while (fgets(buf, sizeof(buf), f)) {
 312                 line++;
 313
 314                 if (buf[0] == '#')
 315                         continue;
 316                 pos = buf;
 317                 while (*pos != '\0') {
 318                         if (*pos == '\n') {
 319                                 *pos = '\0';
 320                                 break;
 321                         }
 322                         pos++;
 323                 }
 324                 if (buf[0] == '\0')
 325                         continue;
 326
 327                 if (hwaddr_aton(buf, addr)) {
 328                         printf("Invalid MAC address '%s' at line %d in '%s'\n",
 329                                buf, line, fname);
 330                         fclose(f);
 331                         return -1;
 332                 }
 333
 334                 vlan_id = 0;
 335                 pos = buf;
 336                 while (*pos != '\0' && *pos != ' ' && *pos != '\t')
 337                         pos++;
 338                 while (*pos == ' ' || *pos == '\t')
 339                         pos++;
 340                 if (*pos != '\0')
 341                         vlan_id = atoi(pos);
 342
 343                 newacl = os_realloc(*acl, (*num + 1) * sizeof(**acl));
 344                 if (newacl == NULL) {
 345                         printf("MAC list reallocation failed\n");
 346                         fclose(f);
 347                         return -1;
 348                 }
 349
 350                 *acl = newacl;
 351                 os_memcpy((*acl)[*num].addr, addr, ETH_ALEN);
 352                 (*acl)[*num].vlan_id = vlan_id;
 353                 (*num)++;
 354         }
 355
 356         fclose(f);
 357
 358         qsort(*acl, *num, sizeof(**acl), hostapd_acl_comp);
 359
 360         return 0;
 361 }
 362
 363
 364 static int hostapd_config_read_wpa_psk(const char *fname,
 365                                        struct hostapd_ssid *ssid)
 366 {
 367         FILE *f;
 368         char buf[128], *pos;
 369         int line = 0, ret = 0, len, ok;
 370         u8 addr[ETH_ALEN];
 371         struct hostapd_wpa_psk *psk;
 372
 373         if (!fname)
 374                 return 0;
 375
 376         f = fopen(fname, "r");
 377         if (!f) {
 378                 printf("WPA PSK file '%s' not found.\n", fname);
 379                 return -1;
 380         }
 381
 382         while (fgets(buf, sizeof(buf), f)) {
 383                 line++;
 384
 385                 if (buf[0] == '#')
 386                         continue;
 387                 pos = buf;
 388                 while (*pos != '\0') {
 389                         if (*pos == '\n') {
 390                                 *pos = '\0';
 391                                 break;
 392                         }
 393                         pos++;
 394                 }
 395                 if (buf[0] == '\0')
 396                         continue;
 397
 398                 if (hwaddr_aton(buf, addr)) {
 399                         printf("Invalid MAC address '%s' on line %d in '%s'\n",
 400                                buf, line, fname);
 401                         ret = -1;
 402                         break;
 403                 }
 404
 405                 psk = os_zalloc(sizeof(*psk));
 406                 if (psk == NULL) {
 407                         printf("WPA PSK allocation failed\n");
 408                         ret = -1;
 409                         break;
 410                 }
 411                 if (is_zero_ether_addr(addr))
 412                         psk->group = 1;
 413                 else
 414                         os_memcpy(psk->addr, addr, ETH_ALEN);
 415
 416                 pos = buf + 17;
 417                 if (pos == '\0') {
 418                         printf("No PSK on line %d in '%s'\n", line, fname);
 419                         os_free(psk);
 420                         ret = -1;
 421                         break;
 422                 }
 423                 pos++;
 424
 425                 ok = 0;
 426                 len = os_strlen(pos);
 427                 if (len == 64 && hexstr2bin(pos, psk->psk, PMK_LEN) == 0)
 428                         ok = 1;
 429                 else if (len >= 8 && len < 64) {
 430                         pbkdf2_sha1(pos, ssid->ssid, ssid->ssid_len,
 431                                     4096, psk->psk, PMK_LEN);
 432                         ok = 1;
 433                 }
 434                 if (!ok) {
 435                         printf("Invalid PSK '%s' on line %d in '%s'\n",
 436                                pos, line, fname);
 437                         os_free(psk);
 438                         ret = -1;
 439                         break;
 440                 }
 441
 442                 psk->next = ssid->wpa_psk;
 443                 ssid->wpa_psk = psk;
 444         }
 445
 446         fclose(f);
 447
 448         return ret;
 449 }
 450
 451
 452 int hostapd_setup_wpa_psk(struct hostapd_bss_config *conf)
 453 {
 454         struct hostapd_ssid *ssid = &conf->ssid;
 455
 456         if (ssid->wpa_passphrase != NULL) {
 457                 if (ssid->wpa_psk != NULL) {
 458                         printf("Warning: both WPA PSK and passphrase set. "
 459                                "Using passphrase.\n");
 460                         os_free(ssid->wpa_psk);
 461                 }
 462                 ssid->wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk));
 463                 if (ssid->wpa_psk == NULL) {
 464                         printf("Unable to alloc space for PSK\n");
 465                         return -1;
 466                 }
 467                 wpa_hexdump_ascii(MSG_DEBUG, "SSID",
 468                                   (u8 *) ssid->ssid, ssid->ssid_len);
 469                 wpa_hexdump_ascii(MSG_DEBUG, "PSK (ASCII passphrase)",
 470                                   (u8 *) ssid->wpa_passphrase,
 471                                   os_strlen(ssid->wpa_passphrase));
 472                 pbkdf2_sha1(ssid->wpa_passphrase,
 473                             ssid->ssid, ssid->ssid_len,
 474                             4096, ssid->wpa_psk->psk, PMK_LEN);
 475                 wpa_hexdump(MSG_DEBUG, "PSK (from passphrase)",
 476                             ssid->wpa_psk->psk, PMK_LEN);
 477                 ssid->wpa_psk->group = 1;
 478
 479                 os_memset(ssid->wpa_passphrase, 0,
 480                           os_strlen(ssid->wpa_passphrase));
 481                 os_free(ssid->wpa_passphrase);
 482                 ssid->wpa_passphrase = NULL;
 483         }
 484
 485         if (ssid->wpa_psk_file) {
 486                 if (hostapd_config_read_wpa_psk(ssid->wpa_psk_file,
 487                                                 &conf->ssid))
 488                         return -1;
 489         }
 490
 491         return 0;
 492 }
 493
 494
 495 #ifdef EAP_SERVER
 496 static int hostapd_config_read_eap_user(const char *fname,
 497                                         struct hostapd_bss_config *conf)
 498 {
 499         FILE *f;
 500         char buf[512], *pos, *start, *pos2;
 501         int line = 0, ret = 0, num_methods;
 502         struct hostapd_eap_user *user, *tail = NULL;
 503
 504         if (!fname)
 505                 return 0;
 506
 507         f = fopen(fname, "r");
 508         if (!f) {
 509                 printf("EAP user file '%s' not found.\n", fname);
 510                 return -1;
 511         }
 512
 513         /* Lines: "user" METHOD,METHOD2 "password" (password optional) */
 514         while (fgets(buf, sizeof(buf), f)) {
 515                 line++;
 516
 517                 if (buf[0] == '#')
 518                         continue;
 519                 pos = buf;
 520                 while (*pos != '\0') {
 521                         if (*pos == '\n') {
 522                                 *pos = '\0';
 523                                 break;
 524                         }
 525                         pos++;
 526                 }
 527                 if (buf[0] == '\0')
 528                         continue;
 529
 530                 user = NULL;
 531
 532                 if (buf[0] != '"' && buf[0] != '*') {
 533                         printf("Invalid EAP identity (no \" in start) on "
 534                                "line %d in '%s'\n", line, fname);
 535                         goto failed;
 536                 }
 537
 538                 user = os_zalloc(sizeof(*user));
 539                 if (user == NULL) {
 540                         printf("EAP user allocation failed\n");
 541                         goto failed;
 542                 }
 543                 user->force_version = -1;
 544
 545                 if (buf[0] == '*') {
 546                         pos = buf;
 547                 } else {
 548                         pos = buf + 1;
 549                         start = pos;
 550                         while (*pos != '"' && *pos != '\0')
 551                                 pos++;
 552                         if (*pos == '\0') {
 553                                 printf("Invalid EAP identity (no \" in end) on"
 554                                        " line %d in '%s'\n", line, fname);
 555                                 goto failed;
 556                         }
 557
 558                         user->identity = os_malloc(pos - start);
 559                         if (user->identity == NULL) {
 560                                 printf("Failed to allocate memory for EAP "
 561                                        "identity\n");
 562                                 goto failed;
 563                         }
 564                         os_memcpy(user->identity, start, pos - start);
 565                         user->identity_len = pos - start;
 566
 567                         if (pos[0] == '"' && pos[1] == '*') {
 568                                 user->wildcard_prefix = 1;
 569                                 pos++;
 570                         }
 571                 }
 572                 pos++;
 573                 while (*pos == ' ' || *pos == '\t')
 574                         pos++;
 575
 576                 if (*pos == '\0') {
 577                         printf("No EAP method on line %d in '%s'\n",
 578                                line, fname);
 579                         goto failed;
 580                 }
 581
 582                 start = pos;
 583                 while (*pos != ' ' && *pos != '\t' && *pos != '\0')
 584                         pos++;
 585                 if (*pos == '\0') {
 586                         pos = NULL;
 587                 } else {
 588                         *pos = '\0';
 589                         pos++;
 590                 }
 591                 num_methods = 0;
 592                 while (*start) {
 593                         char *pos3 = os_strchr(start, ',');
 594                         if (pos3) {
 595                                 *pos3++ = '\0';
 596                         }
 597                         user->methods[num_methods].method =
 598                                 eap_server_get_type(
 599                                         start,
 600                                         &user->methods[num_methods].vendor);
 601                         if (user->methods[num_methods].vendor ==
 602                             EAP_VENDOR_IETF &&
 603                             user->methods[num_methods].method == EAP_TYPE_NONE)
 604                         {
 605                                 if (os_strcmp(start, "TTLS-PAP") == 0) {
 606                                         user->ttls_auth |= EAP_TTLS_AUTH_PAP;
 607                                         goto skip_eap;
 608                                 }
 609                                 if (os_strcmp(start, "TTLS-CHAP") == 0) {
 610                                         user->ttls_auth |= EAP_TTLS_AUTH_CHAP;
 611                                         goto skip_eap;
 612                                 }
 613                                 if (os_strcmp(start, "TTLS-MSCHAP") == 0) {
 614                                         user->ttls_auth |=
 615                                                 EAP_TTLS_AUTH_MSCHAP;
 616                                         goto skip_eap;
 617                                 }
 618                                 if (os_strcmp(start, "TTLS-MSCHAPV2") == 0) {
 619                                         user->ttls_auth |=
 620                                                 EAP_TTLS_AUTH_MSCHAPV2;
 621                                         goto skip_eap;
 622                                 }
 623                                 printf("Unsupported EAP type '%s' on line %d "
 624                                        "in '%s'\n", start, line, fname);
 625                                 goto failed;
 626                         }
 627
 628                         num_methods++;
 629                         if (num_methods >= EAP_USER_MAX_METHODS)
 630                                 break;
 631                 skip_eap:
 632                         if (pos3 == NULL)
 633                                 break;
 634                         start = pos3;
 635                 }
 636                 if (num_methods == 0 && user->ttls_auth == 0) {
 637                         printf("No EAP types configured on line %d in '%s'\n",
 638                                line, fname);
 639                         goto failed;
 640                 }
 641
 642                 if (pos == NULL)
 643                         goto done;
 644
 645                 while (*pos == ' ' || *pos == '\t')
 646                         pos++;
 647                 if (*pos == '\0')
 648                         goto done;
 649
 650                 if (os_strncmp(pos, "[ver=0]", 7) == 0) {
 651                         user->force_version = 0;
 652                         goto done;
 653                 }
 654
 655                 if (os_strncmp(pos, "[ver=1]", 7) == 0) {
 656                         user->force_version = 1;
 657                         goto done;
 658                 }
 659
 660                 if (os_strncmp(pos, "[2]", 3) == 0) {
 661                         user->phase2 = 1;
 662                         goto done;
 663                 }
 664
 665                 if (*pos == '"') {
 666                         pos++;
 667                         start = pos;
 668                         while (*pos != '"' && *pos != '\0')
 669                                 pos++;
 670                         if (*pos == '\0') {
 671                                 printf("Invalid EAP password (no \" in end) "
 672                                        "on line %d in '%s'\n", line, fname);
 673                                 goto failed;
 674                         }
 675
 676                         user->password = os_malloc(pos - start);
 677                         if (user->password == NULL) {
 678                                 printf("Failed to allocate memory for EAP "
 679                                        "password\n");
 680                                 goto failed;
 681                         }
 682                         os_memcpy(user->password, start, pos - start);
 683                         user->password_len = pos - start;
 684
 685                         pos++;
 686                 } else if (os_strncmp(pos, "hash:", 5) == 0) {
 687                         pos += 5;
 688                         pos2 = pos;
 689                         while (*pos2 != '\0' && *pos2 != ' ' &&
 690                                *pos2 != '\t' && *pos2 != '#')
 691                                 pos2++;
 692                         if (pos2 - pos != 32) {
 693                                 printf("Invalid password hash on line %d in "
 694                                        "'%s'\n", line, fname);
 695                                 goto failed;
 696                         }
 697                         user->password = os_malloc(16);
 698                         if (user->password == NULL) {
 699                                 printf("Failed to allocate memory for EAP "
 700                                        "password hash\n");
 701                                 goto failed;
 702                         }
 703                         if (hexstr2bin(pos, user->password, 16) < 0) {
 704                                 printf("Invalid hash password on line %d in "
 705                                        "'%s'\n", line, fname);
 706                                 goto failed;
 707                         }
 708                         user->password_len = 16;
 709                         user->password_hash = 1;
 710                         pos = pos2;
 711                 } else {
 712                         pos2 = pos;
 713                         while (*pos2 != '\0' && *pos2 != ' ' &&
 714                                *pos2 != '\t' && *pos2 != '#')
 715                                 pos2++;
 716                         if ((pos2 - pos) & 1) {
 717                                 printf("Invalid hex password on line %d in "
 718                                        "'%s'\n", line, fname);
 719                                 goto failed;
 720                         }
 721                         user->password = os_malloc((pos2 - pos) / 2);
 722                         if (user->password == NULL) {
 723                                 printf("Failed to allocate memory for EAP "
 724                                        "password\n");
 725                                 goto failed;
 726                         }
 727                         if (hexstr2bin(pos, user->password,
 728                                        (pos2 - pos) / 2) < 0) {
 729                                 printf("Invalid hex password on line %d in "
 730                                        "'%s'\n", line, fname);
 731                                 goto failed;
 732                         }
 733                         user->password_len = (pos2 - pos) / 2;
 734                         pos = pos2;
 735                 }
 736
 737                 while (*pos == ' ' || *pos == '\t')
 738                         pos++;
 739                 if (os_strncmp(pos, "[2]", 3) == 0) {
 740                         user->phase2 = 1;
 741                 }
 742
 743         done:
 744                 if (tail == NULL) {
 745                         tail = conf->eap_user = user;
 746                 } else {
 747                         tail->next = user;
 748                         tail = user;
 749                 }
 750                 continue;
 751
 752         failed:
 753                 if (user) {
 754                         os_free(user->password);
 755                         os_free(user->identity);
 756                         os_free(user);
 757                 }
 758                 ret = -1;
 759                 break;
 760         }
 761
 762         fclose(f);
 763
 764         return ret;
 765 }
 766 #endif /* EAP_SERVER */
 767
 768
 769 static int
 770 hostapd_config_read_radius_addr(struct hostapd_radius_server **server,
 771                                 int *num_server, const char *val, int def_port,
 772                                 struct hostapd_radius_server **curr_serv)
 773 {
 774         struct hostapd_radius_server *nserv;
 775         int ret;
 776         static int server_index = 1;
 777
 778         nserv = os_realloc(*server, (*num_server + 1) * sizeof(*nserv));
 779         if (nserv == NULL)
 780                 return -1;
 781
 782         *server = nserv;
 783         nserv = &nserv[*num_server];
 784         (*num_server)++;
 785         (*curr_serv) = nserv;
 786
 787         os_memset(nserv, 0, sizeof(*nserv));
 788         nserv->port = def_port;
 789         ret = hostapd_parse_ip_addr(val, &nserv->addr);
 790         nserv->index = server_index++;
 791
 792         return ret;
 793 }
 794
 795
 796 static int hostapd_config_parse_key_mgmt(int line, const char *value)
 797 {
 798         int val = 0, last;
 799         char *start, *end, *buf;
 800
 801         buf = os_strdup(value);
 802         if (buf == NULL)
 803                 return -1;
 804         start = buf;
 805
 806         while (start != '\0') {
 807                 while (*start == ' ' || *start == '\t')
 808                         start++;
 809                 if (*start == '\0')
 810                         break;
 811                 end = start;
 812                 while (*end != ' ' && *end != '\t' && *end != '\0')
 813                         end++;
 814                 last = *end == '\0';
 815                 *end = '\0';
 816                 if (os_strcmp(start, "WPA-PSK") == 0)
 817                         val |= WPA_KEY_MGMT_PSK;
 818                 else if (os_strcmp(start, "WPA-EAP") == 0)
 819                         val |= WPA_KEY_MGMT_IEEE8021X;
 820 #ifdef CONFIG_IEEE80211R
 821                 else if (os_strcmp(start, "FT-PSK") == 0)
 822                         val |= WPA_KEY_MGMT_FT_PSK;
 823                 else if (os_strcmp(start, "FT-EAP") == 0)
 824                         val |= WPA_KEY_MGMT_FT_IEEE8021X;
 825 #endif /* CONFIG_IEEE80211R */
 826 #ifdef CONFIG_IEEE80211W
 827                 else if (os_strcmp(start, "WPA-PSK-SHA256") == 0)
 828                         val |= WPA_KEY_MGMT_PSK_SHA256;
 829                 else if (os_strcmp(start, "WPA-EAP-SHA256") == 0)
 830                         val |= WPA_KEY_MGMT_IEEE8021X_SHA256;
 831 #endif /* CONFIG_IEEE80211W */
 832                 else {
 833                         printf("Line %d: invalid key_mgmt '%s'\n",
 834                                line, start);
 835                         os_free(buf);
 836                         return -1;
 837                 }
 838
 839                 if (last)
 840                         break;
 841                 start = end + 1;
 842         }
 843
 844         os_free(buf);
 845         if (val == 0) {
 846                 printf("Line %d: no key_mgmt values configured.\n", line);
 847                 return -1;
 848         }
 849
 850         return val;
 851 }
 852
 853
 854 static int hostapd_config_parse_cipher(int line, const char *value)
 855 {
 856         int val = 0, last;
 857         char *start, *end, *buf;
 858
 859         buf = os_strdup(value);
 860         if (buf == NULL)
 861                 return -1;
 862         start = buf;
 863
 864         while (start != '\0') {
 865                 while (*start == ' ' || *start == '\t')
 866                         start++;
 867                 if (*start == '\0')
 868                         break;
 869                 end = start;
 870                 while (*end != ' ' && *end != '\t' && *end != '\0')
 871                         end++;
 872                 last = *end == '\0';
 873                 *end = '\0';
 874                 if (os_strcmp(start, "CCMP") == 0)
 875                         val |= WPA_CIPHER_CCMP;
 876                 else if (os_strcmp(start, "TKIP") == 0)
 877                         val |= WPA_CIPHER_TKIP;
 878                 else if (os_strcmp(start, "WEP104") == 0)
 879                         val |= WPA_CIPHER_WEP104;
 880                 else if (os_strcmp(start, "WEP40") == 0)
 881                         val |= WPA_CIPHER_WEP40;
 882                 else if (os_strcmp(start, "NONE") == 0)
 883                         val |= WPA_CIPHER_NONE;
 884                 else {
 885                         printf("Line %d: invalid cipher '%s'.", line, start);
 886                         os_free(buf);
 887                         return -1;
 888                 }
 889
 890                 if (last)
 891                         break;
 892                 start = end + 1;
 893         }
 894         os_free(buf);
 895
 896         if (val == 0) {
 897                 printf("Line %d: no cipher values configured.", line);
 898                 return -1;
 899         }
 900         return val;
 901 }
 902
 903
 904 static int hostapd_config_check_bss(struct hostapd_bss_config *bss,
 905                                     struct hostapd_config *conf)
 906 {
 907         if (bss->ieee802_1x && !bss->eap_server &&
 908             !bss->radius->auth_servers) {
 909                 printf("Invalid IEEE 802.1X configuration (no EAP "
 910                        "authenticator configured).\n");
 911                 return -1;
 912         }
 913
 914         if (bss->wpa && (bss->wpa_key_mgmt & WPA_KEY_MGMT_PSK) &&
 915             bss->ssid.wpa_psk == NULL && bss->ssid.wpa_passphrase == NULL &&
 916             bss->ssid.wpa_psk_file == NULL) {
 917                 printf("WPA-PSK enabled, but PSK or passphrase is not "
 918                        "configured.\n");
 919                 return -1;
 920         }
 921
 922         if (hostapd_mac_comp_empty(bss->bssid) != 0) {
 923                 size_t i;
 924
 925                 for (i = 0; i < conf->num_bss; i++) {
 926                         if ((&conf->bss[i] != bss) &&
 927                             (hostapd_mac_comp(conf->bss[i].bssid,
 928                                               bss->bssid) == 0)) {
 929                                 printf("Duplicate BSSID " MACSTR
 930                                        " on interface '%s' and '%s'.\n",
 931                                        MAC2STR(bss->bssid),
 932                                        conf->bss[i].iface, bss->iface);
 933                                 return -1;
 934                         }
 935                 }
 936         }
 937
 938 #ifdef CONFIG_IEEE80211R
 939         if ((bss->wpa_key_mgmt &
 940              (WPA_KEY_MGMT_FT_PSK | WPA_KEY_MGMT_FT_IEEE8021X)) &&
 941             (bss->nas_identifier == NULL ||
 942              os_strlen(bss->nas_identifier) < 1 ||
 943              os_strlen(bss->nas_identifier) > FT_R0KH_ID_MAX_LEN)) {
 944                 printf("FT (IEEE 802.11r) requires nas_identifier to be "
 945                        "configured as a 1..48 octet string\n");
 946                 return -1;
 947         }
 948 #endif /* CONFIG_IEEE80211R */
 949
 950         return 0;
 951 }
 952
 953
 954 static int hostapd_config_check(struct hostapd_config *conf)
 955 {
 956         size_t i;
 957
 958         for (i = 0; i < conf->num_bss; i++) {
 959                 if (hostapd_config_check_bss(&conf->bss[i], conf))
 960                         return -1;
 961         }
 962
 963         return 0;
 964 }
 965
 966
 967 static int hostapd_config_read_wep(struct hostapd_wep_keys *wep, int keyidx,
 968                                    char *val)
 969 {
 970         size_t len = os_strlen(val);
 971
 972         if (keyidx < 0 || keyidx > 3 || wep->key[keyidx] != NULL)
 973                 return -1;
 974
 975         if (val[0] == '"') {
 976                 if (len < 2 || val[len - 1] != '"')
 977                         return -1;
 978                 len -= 2;
 979                 wep->key[keyidx] = os_malloc(len);
 980                 if (wep->key[keyidx] == NULL)
 981                         return -1;
 982                 os_memcpy(wep->key[keyidx], val + 1, len);
 983                 wep->len[keyidx] = len;
 984         } else {
 985                 if (len & 1)
 986                         return -1;
 987                 len /= 2;
 988                 wep->key[keyidx] = os_malloc(len);
 989                 if (wep->key[keyidx] == NULL)
 990                         return -1;
 991                 wep->len[keyidx] = len;
 992                 if (hexstr2bin(val, wep->key[keyidx], len) < 0)
 993                         return -1;
 994         }
 995
 996         wep->keys_set++;
 997
 998         return 0;
 999 }
1000
1001
1002 static int hostapd_parse_rates(int **rate_list, char *val)
1003 {
1004         int *list;
1005         int count;
1006         char *pos, *end;
1007
1008         os_free(*rate_list);
1009         *rate_list = NULL;
1010
1011         pos = val;
1012         count = 0;
1013         while (*pos != '\0') {
1014                 if (*pos == ' ')
1015                         count++;
1016                 pos++;
1017         }
1018
1019         list = os_malloc(sizeof(int) * (count + 2));
1020         if (list == NULL)
1021                 return -1;
1022         pos = val;
1023         count = 0;
1024         while (*pos != '\0') {
1025                 end = os_strchr(pos, ' ');
1026                 if (end)
1027                         *end = '\0';
1028
1029                 list[count++] = atoi(pos);
1030                 if (!end)
1031                         break;
1032                 pos = end + 1;
1033         }
1034         list[count] = -1;
1035
1036         *rate_list = list;
1037         return 0;
1038 }
1039
1040
1041 static int hostapd_config_bss(struct hostapd_config *conf, const char *ifname)
1042 {
1043         struct hostapd_bss_config *bss;
1044
1045         if (*ifname == '\0')
1046                 return -1;
1047
1048         bss = os_realloc(conf->bss, (conf->num_bss + 1) *
1049                          sizeof(struct hostapd_bss_config));
1050         if (bss == NULL) {
1051                 printf("Failed to allocate memory for multi-BSS entry\n");
1052                 return -1;
1053         }
1054         conf->bss = bss;
1055
1056         bss = &(conf->bss[conf->num_bss]);
1057         os_memset(bss, 0, sizeof(*bss));
1058         bss->radius = os_zalloc(sizeof(*bss->radius));
1059         if (bss->radius == NULL) {
1060                 printf("Failed to allocate memory for multi-BSS RADIUS "
1061                        "data\n");
1062                 return -1;
1063         }
1064
1065         conf->num_bss++;
1066         conf->last_bss = bss;
1067
1068         hostapd_config_defaults_bss(bss);
1069         os_strlcpy(bss->iface, ifname, sizeof(bss->iface));
1070         os_memcpy(bss->ssid.vlan, bss->iface, IFNAMSIZ + 1);
1071
1072         return 0;
1073 }
1074
1075
1076 static int valid_cw(int cw)
1077 {
1078         return (cw == 1 || cw == 3 || cw == 7 || cw == 15 || cw == 31 ||
1079                 cw == 63 || cw == 127 || cw == 255 || cw == 511 || cw == 1023);
1080 }
1081
1082
1083 enum {
1084         IEEE80211_TX_QUEUE_DATA0 = 0, /* used for EDCA AC_VO data */
1085         IEEE80211_TX_QUEUE_DATA1 = 1, /* used for EDCA AC_VI data */
1086         IEEE80211_TX_QUEUE_DATA2 = 2, /* used for EDCA AC_BE data */
1087         IEEE80211_TX_QUEUE_DATA3 = 3, /* used for EDCA AC_BK data */
1088         IEEE80211_TX_QUEUE_DATA4 = 4,
1089         IEEE80211_TX_QUEUE_AFTER_BEACON = 6,
1090         IEEE80211_TX_QUEUE_BEACON = 7
1091 };
1092
1093 static int hostapd_config_tx_queue(struct hostapd_config *conf, char *name,
1094                                    char *val)
1095 {
1096         int num;
1097         char *pos;
1098         struct hostapd_tx_queue_params *queue;
1099
1100         /* skip 'tx_queue_' prefix */
1101         pos = name + 9;
1102         if (os_strncmp(pos, "data", 4) == 0 &&
1103             pos[4] >= '0' && pos[4] <= '9' && pos[5] == '_') {
1104                 num = pos[4] - '0';
1105                 pos += 6;
1106         } else if (os_strncmp(pos, "after_beacon_", 13) == 0) {
1107                 num = IEEE80211_TX_QUEUE_AFTER_BEACON;
1108                 pos += 13;
1109         } else if (os_strncmp(pos, "beacon_", 7) == 0) {
1110                 num = IEEE80211_TX_QUEUE_BEACON;
1111                 pos += 7;
1112         } else {
1113                 printf("Unknown tx_queue name '%s'\n", pos);
1114                 return -1;
1115         }
1116
1117         queue = &conf->tx_queue[num];
1118
1119         if (os_strcmp(pos, "aifs") == 0) {
1120                 queue->aifs = atoi(val);
1121                 if (queue->aifs < 0 || queue->aifs > 255) {
1122                         printf("Invalid AIFS value %d\n", queue->aifs);
1123                         return -1;
1124                 }
1125         } else if (os_strcmp(pos, "cwmin") == 0) {
1126                 queue->cwmin = atoi(val);
1127                 if (!valid_cw(queue->cwmin)) {
1128                         printf("Invalid cwMin value %d\n", queue->cwmin);
1129                         return -1;
1130                 }
1131         } else if (os_strcmp(pos, "cwmax") == 0) {
1132                 queue->cwmax = atoi(val);
1133                 if (!valid_cw(queue->cwmax)) {
1134                         printf("Invalid cwMax value %d\n", queue->cwmax);
1135                         return -1;
1136                 }
1137         } else if (os_strcmp(pos, "burst") == 0) {
1138                 queue->burst = hostapd_config_read_int10(val);
1139         } else {
1140                 printf("Unknown tx_queue field '%s'\n", pos);
1141                 return -1;
1142         }
1143
1144         queue->configured = 1;
1145
1146         return 0;
1147 }
1148
1149
1150 static int hostapd_config_wme_ac(struct hostapd_config *conf, char *name,
1151                                    char *val)
1152 {
1153         int num, v;
1154         char *pos;
1155         struct hostapd_wme_ac_params *ac;
1156
1157         /* skip 'wme_ac_' prefix */
1158         pos = name + 7;
1159         if (os_strncmp(pos, "be_", 3) == 0) {
1160                 num = 0;
1161                 pos += 3;
1162         } else if (os_strncmp(pos, "bk_", 3) == 0) {
1163                 num = 1;
1164                 pos += 3;
1165         } else if (os_strncmp(pos, "vi_", 3) == 0) {
1166                 num = 2;
1167                 pos += 3;
1168         } else if (os_strncmp(pos, "vo_", 3) == 0) {
1169                 num = 3;
1170                 pos += 3;
1171         } else {
1172                 printf("Unknown wme name '%s'\n", pos);
1173                 return -1;
1174         }
1175
1176         ac = &conf->wme_ac_params[num];
1177
1178         if (os_strcmp(pos, "aifs") == 0) {
1179                 v = atoi(val);
1180                 if (v < 1 || v > 255) {
1181                         printf("Invalid AIFS value %d\n", v);
1182                         return -1;
1183                 }
1184                 ac->aifs = v;
1185         } else if (os_strcmp(pos, "cwmin") == 0) {
1186                 v = atoi(val);
1187                 if (v < 0 || v > 12) {
1188                         printf("Invalid cwMin value %d\n", v);
1189                         return -1;
1190                 }
1191                 ac->cwmin = v;
1192         } else if (os_strcmp(pos, "cwmax") == 0) {
1193                 v = atoi(val);
1194                 if (v < 0 || v > 12) {
1195                         printf("Invalid cwMax value %d\n", v);
1196                         return -1;
1197                 }
1198                 ac->cwmax = v;
1199         } else if (os_strcmp(pos, "txop_limit") == 0) {
1200                 v = atoi(val);
1201                 if (v < 0 || v > 0xffff) {
1202                         printf("Invalid txop value %d\n", v);
1203                         return -1;
1204                 }
1205                 ac->txopLimit = v;
1206         } else if (os_strcmp(pos, "acm") == 0) {
1207                 v = atoi(val);
1208                 if (v < 0 || v > 1) {
1209                         printf("Invalid acm value %d\n", v);
1210                         return -1;
1211                 }
1212                 ac->admission_control_mandatory = v;
1213         } else {
1214                 printf("Unknown wme_ac_ field '%s'\n", pos);
1215                 return -1;
1216         }
1217
1218         return 0;
1219 }
1220
1221
1222 #ifdef CONFIG_IEEE80211R
1223 static int add_r0kh(struct hostapd_bss_config *bss, char *value)
1224 {
1225         struct ft_remote_r0kh *r0kh;
1226         char *pos, *next;
1227
1228         r0kh = os_zalloc(sizeof(*r0kh));
1229         if (r0kh == NULL)
1230                 return -1;
1231
1232         /* 02:01:02:03:04:05 a.example.com 000102030405060708090a0b0c0d0e0f */
1233         pos = value;
1234         next = os_strchr(pos, ' ');
1235         if (next)
1236                 *next++ = '\0';
1237         if (next == NULL || hwaddr_aton(pos, r0kh->addr)) {
1238                 printf("Invalid R0KH MAC address: '%s'\n", pos);
1239                 os_free(r0kh);
1240                 return -1;
1241         }
1242
1243         pos = next;
1244         next = os_strchr(pos, ' ');
1245         if (next)
1246                 *next++ = '\0';
1247         if (next == NULL || next - pos > FT_R0KH_ID_MAX_LEN) {
1248                 printf("Invalid R0KH-ID: '%s'\n", pos);
1249                 os_free(r0kh);
1250                 return -1;
1251         }
1252         r0kh->id_len = next - pos - 1;
1253         os_memcpy(r0kh->id, pos, r0kh->id_len);
1254
1255         pos = next;
1256         if (hexstr2bin(pos, r0kh->key, sizeof(r0kh->key))) {
1257                 printf("Invalid R0KH key: '%s'\n", pos);
1258                 os_free(r0kh);
1259                 return -1;
1260         }
1261
1262         r0kh->next = bss->r0kh_list;
1263         bss->r0kh_list = r0kh;
1264
1265         return 0;
1266 }
1267
1268
1269 static int add_r1kh(struct hostapd_bss_config *bss, char *value)
1270 {
1271         struct ft_remote_r1kh *r1kh;
1272         char *pos, *next;
1273
1274         r1kh = os_zalloc(sizeof(*r1kh));
1275         if (r1kh == NULL)
1276                 return -1;
1277
1278         /* 02:01:02:03:04:05 02:01:02:03:04:05
1279          * 000102030405060708090a0b0c0d0e0f */
1280         pos = value;
1281         next = os_strchr(pos, ' ');
1282         if (next)
1283                 *next++ = '\0';
1284         if (next == NULL || hwaddr_aton(pos, r1kh->addr)) {
1285                 printf("Invalid R1KH MAC address: '%s'\n", pos);
1286                 os_free(r1kh);
1287                 return -1;
1288         }
1289
1290         pos = next;
1291         next = os_strchr(pos, ' ');
1292         if (next)
1293                 *next++ = '\0';
1294         if (next == NULL || hwaddr_aton(pos, r1kh->id)) {
1295                 printf("Invalid R1KH-ID: '%s'\n", pos);
1296                 os_free(r1kh);
1297                 return -1;
1298         }
1299
1300         pos = next;
1301         if (hexstr2bin(pos, r1kh->key, sizeof(r1kh->key))) {
1302                 printf("Invalid R1KH key: '%s'\n", pos);
1303                 os_free(r1kh);
1304                 return -1;
1305         }
1306
1307         r1kh->next = bss->r1kh_list;
1308         bss->r1kh_list = r1kh;
1309
1310         return 0;
1311 }
1312 #endif /* CONFIG_IEEE80211R */
1313
1314
1315 struct hostapd_config * hostapd_config_read(const char *fname)
1316 {
1317         struct hostapd_config *conf;
1318         struct hostapd_bss_config *bss;
1319         FILE *f;
1320         char buf[256], *pos;
1321         int line = 0;
1322         int errors = 0;
1323         int pairwise;
1324         size_t i;
1325
1326         f = fopen(fname, "r");
1327         if (f == NULL) {
1328                 printf("Could not open configuration file '%s' for reading.\n",
1329                        fname);
1330                 return NULL;
1331         }
1332
1333         conf = hostapd_config_defaults();
1334         if (conf == NULL) {
1335                 fclose(f);
1336                 return NULL;
1337         }
1338         bss = conf->last_bss = conf->bss;
1339
1340         while (fgets(buf, sizeof(buf), f)) {
1341                 bss = conf->last_bss;
1342                 line++;
1343
1344                 if (buf[0] == '#')
1345                         continue;
1346                 pos = buf;
1347                 while (*pos != '\0') {
1348                         if (*pos == '\n') {
1349                                 *pos = '\0';
1350                                 break;
1351                         }
1352                         pos++;
1353                 }
1354                 if (buf[0] == '\0')
1355                         continue;
1356
1357                 pos = os_strchr(buf, '=');
1358                 if (pos == NULL) {
1359                         printf("Line %d: invalid line '%s'\n", line, buf);
1360                         errors++;
1361                         continue;
1362                 }
1363                 *pos = '\0';
1364                 pos++;
1365
1366                 if (os_strcmp(buf, "interface") == 0) {
1367                         os_strlcpy(conf->bss[0].iface, pos,
1368                                    sizeof(conf->bss[0].iface));
1369                 } else if (os_strcmp(buf, "bridge") == 0) {
1370                         os_strlcpy(bss->bridge, pos, sizeof(bss->bridge));
1371                 } else if (os_strcmp(buf, "driver") == 0) {
1372                         int i;
1373                         /* clear to get error below if setting is invalid */
1374                         conf->driver = NULL;
1375                         for (i = 0; hostapd_drivers[i]; i++) {
1376                                 if (os_strcmp(pos, hostapd_drivers[i]->name) ==
1377                                     0) {
1378                                         conf->driver = hostapd_drivers[i];
1379                                         break;
1380                                 }
1381                         }
1382                         if (conf->driver == NULL) {
1383                                 printf("Line %d: invalid/unknown driver "
1384                                        "'%s'\n", line, pos);
1385                                 errors++;
1386                         }
1387                 } else if (os_strcmp(buf, "debug") == 0) {
1388                         wpa_printf(MSG_DEBUG, "Line %d: DEPRECATED: 'debug' "
1389                                    "configuration variable is not used "
1390                                    "anymore", line);
1391                 } else if (os_strcmp(buf, "logger_syslog_level") == 0) {
1392                         bss->logger_syslog_level = atoi(pos);
1393                 } else if (os_strcmp(buf, "logger_stdout_level") == 0) {
1394                         bss->logger_stdout_level = atoi(pos);
1395                 } else if (os_strcmp(buf, "logger_syslog") == 0) {
1396                         bss->logger_syslog = atoi(pos);
1397                 } else if (os_strcmp(buf, "logger_stdout") == 0) {
1398                         bss->logger_stdout = atoi(pos);
1399                 } else if (os_strcmp(buf, "dump_file") == 0) {
1400                         bss->dump_log_name = os_strdup(pos);
1401                 } else if (os_strcmp(buf, "ssid") == 0) {
1402                         bss->ssid.ssid_len = os_strlen(pos);
1403                         if (bss->ssid.ssid_len > HOSTAPD_MAX_SSID_LEN ||
1404                             bss->ssid.ssid_len < 1) {
1405                                 printf("Line %d: invalid SSID '%s'\n", line,
1406                                        pos);
1407                                 errors++;
1408                         } else {
1409                                 os_memcpy(bss->ssid.ssid, pos,
1410                                           bss->ssid.ssid_len);
1411                                 bss->ssid.ssid[bss->ssid.ssid_len] = '\0';
1412                                 bss->ssid.ssid_set = 1;
1413                         }
1414                 } else if (os_strcmp(buf, "macaddr_acl") == 0) {
1415                         bss->macaddr_acl = atoi(pos);
1416                         if (bss->macaddr_acl != ACCEPT_UNLESS_DENIED &&
1417                             bss->macaddr_acl != DENY_UNLESS_ACCEPTED &&
1418                             bss->macaddr_acl != USE_EXTERNAL_RADIUS_AUTH) {
1419                                 printf("Line %d: unknown macaddr_acl %d\n",
1420                                        line, bss->macaddr_acl);
1421                         }
1422                 } else if (os_strcmp(buf, "accept_mac_file") == 0) {
1423                         if (hostapd_config_read_maclist(pos, &bss->accept_mac,
1424                                                         &bss->num_accept_mac))
1425                         {
1426                                 printf("Line %d: Failed to read "
1427                                        "accept_mac_file '%s'\n",
1428                                        line, pos);
1429                                 errors++;
1430                         }
1431                 } else if (os_strcmp(buf, "deny_mac_file") == 0) {
1432                         if (hostapd_config_read_maclist(pos, &bss->deny_mac,
1433                                                         &bss->num_deny_mac))
1434                         {
1435                                 printf("Line %d: Failed to read "
1436                                        "deny_mac_file '%s'\n",
1437                                        line, pos);
1438                                 errors++;
1439                         }
1440                 } else if (os_strcmp(buf, "ap_max_inactivity") == 0) {
1441                         bss->ap_max_inactivity = atoi(pos);
1442                 } else if (os_strcmp(buf, "country_code") == 0) {
1443                         os_memcpy(conf->country, pos, 2);
1444                         /* FIX: make this configurable */
1445                         conf->country[2] = ' ';
1446                 } else if (os_strcmp(buf, "ieee80211d") == 0) {
1447                         conf->ieee80211d = atoi(pos);
1448                 } else if (os_strcmp(buf, "assoc_ap_addr") == 0) {
1449                         if (hwaddr_aton(pos, bss->assoc_ap_addr)) {
1450                                 printf("Line %d: invalid MAC address '%s'\n",
1451                                        line, pos);
1452                                 errors++;
1453                         }
1454                         bss->assoc_ap = 1;
1455                 } else if (os_strcmp(buf, "ieee8021x") == 0) {
1456                         bss->ieee802_1x = atoi(pos);
1457                 } else if (os_strcmp(buf, "eapol_version") == 0) {
1458                         bss->eapol_version = atoi(pos);
1459                         if (bss->eapol_version < 1 ||
1460                             bss->eapol_version > 2) {
1461                                 printf("Line %d: invalid EAPOL "
1462                                        "version (%d): '%s'.\n",
1463                                        line, bss->eapol_version, pos);
1464                                 errors++;
1465                         } else
1466                                 wpa_printf(MSG_DEBUG, "eapol_version=%d",
1467                                            bss->eapol_version);
1468 #ifdef EAP_SERVER
1469                 } else if (os_strcmp(buf, "eap_authenticator") == 0) {
1470                         bss->eap_server = atoi(pos);
1471                         printf("Line %d: obsolete eap_authenticator used; "
1472                                "this has been renamed to eap_server\n", line);
1473                 } else if (os_strcmp(buf, "eap_server") == 0) {
1474                         bss->eap_server = atoi(pos);
1475                 } else if (os_strcmp(buf, "eap_user_file") == 0) {
1476                         if (hostapd_config_read_eap_user(pos, bss))
1477                                 errors++;
1478                 } else if (os_strcmp(buf, "ca_cert") == 0) {
1479                         os_free(bss->ca_cert);
1480                         bss->ca_cert = os_strdup(pos);
1481                 } else if (os_strcmp(buf, "server_cert") == 0) {
1482                         os_free(bss->server_cert);
1483                         bss->server_cert = os_strdup(pos);
1484                 } else if (os_strcmp(buf, "private_key") == 0) {
1485                         os_free(bss->private_key);
1486                         bss->private_key = os_strdup(pos);
1487                 } else if (os_strcmp(buf, "private_key_passwd") == 0) {
1488                         os_free(bss->private_key_passwd);
1489                         bss->private_key_passwd = os_strdup(pos);
1490                 } else if (os_strcmp(buf, "check_crl") == 0) {
1491                         bss->check_crl = atoi(pos);
1492                 } else if (os_strcmp(buf, "dh_file") == 0) {
1493                         os_free(bss->dh_file);
1494                         bss->dh_file = os_strdup(pos);
1495 #ifdef EAP_FAST
1496                 } else if (os_strcmp(buf, "pac_opaque_encr_key") == 0) {
1497                         os_free(bss->pac_opaque_encr_key);
1498                         bss->pac_opaque_encr_key = os_malloc(16);
1499                         if (bss->pac_opaque_encr_key == NULL) {
1500                                 printf("Line %d: No memory for "
1501                                        "pac_opque_encr_key\n", line);
1502                                 errors++;
1503                         } else if (hexstr2bin(pos, bss->pac_opaque_encr_key,
1504                                               16)) {
1505                                 printf("Line %d: Invalid pac_opque_encr_key\n",
1506                                        line);
1507                                 errors++;
1508                         }
1509                 } else if (os_strcmp(buf, "eap_fast_a_id") == 0) {
1510                         size_t idlen = os_strlen(pos);
1511                         if (idlen & 1) {
1512                                 printf("Line %d: Invalid eap_fast_a_id\n",
1513                                        line);
1514                                 errors++;
1515                         } else {
1516                                 os_free(bss->eap_fast_a_id);
1517                                 bss->eap_fast_a_id = os_malloc(idlen / 2);
1518                                 if (bss->eap_fast_a_id == NULL ||
1519                                     hexstr2bin(pos, bss->eap_fast_a_id,
1520                                                idlen / 2)) {
1521                                         printf("Line %d: Failed to parse "
1522                                                "eap_fast_a_id\n", line);
1523                                         errors++;
1524                                 } else
1525                                         bss->eap_fast_a_id_len = idlen / 2;
1526                         }
1527                 } else if (os_strcmp(buf, "eap_fast_a_id_info") == 0) {
1528                         os_free(bss->eap_fast_a_id_info);
1529                         bss->eap_fast_a_id_info = os_strdup(pos);
1530                 } else if (os_strcmp(buf, "eap_fast_prov") == 0) {
1531                         bss->eap_fast_prov = atoi(pos);
1532                 } else if (os_strcmp(buf, "pac_key_lifetime") == 0) {
1533                         bss->pac_key_lifetime = atoi(pos);
1534                 } else if (os_strcmp(buf, "pac_key_refresh_time") == 0) {
1535                         bss->pac_key_refresh_time = atoi(pos);
1536 #endif /* EAP_FAST */
1537 #ifdef EAP_SIM
1538                 } else if (os_strcmp(buf, "eap_sim_db") == 0) {
1539                         os_free(bss->eap_sim_db);
1540                         bss->eap_sim_db = os_strdup(pos);
1541                 } else if (os_strcmp(buf, "eap_sim_aka_result_ind") == 0) {
1542                         bss->eap_sim_aka_result_ind = atoi(pos);
1543 #endif /* EAP_SIM */
1544 #ifdef EAP_TNC
1545                 } else if (os_strcmp(buf, "tnc") == 0) {
1546                         bss->tnc = atoi(pos);
1547 #endif /* EAP_TNC */
1548 #endif /* EAP_SERVER */
1549                 } else if (os_strcmp(buf, "eap_message") == 0) {
1550                         char *term;
1551                         bss->eap_req_id_text = os_strdup(pos);
1552                         if (bss->eap_req_id_text == NULL) {
1553                                 printf("Line %d: Failed to allocate memory "
1554                                        "for eap_req_id_text\n", line);
1555                                 errors++;
1556                                 continue;
1557                         }
1558                         bss->eap_req_id_text_len =
1559                                 os_strlen(bss->eap_req_id_text);
1560                         term = os_strstr(bss->eap_req_id_text, "\\0");
1561                         if (term) {
1562                                 *term++ = '\0';
1563                                 os_memmove(term, term + 1,
1564                                            bss->eap_req_id_text_len -
1565                                            (term - bss->eap_req_id_text) - 1);
1566                                 bss->eap_req_id_text_len--;
1567                         }
1568                 } else if (os_strcmp(buf, "wep_key_len_broadcast") == 0) {
1569                         bss->default_wep_key_len = atoi(pos);
1570                         if (bss->default_wep_key_len > 13) {
1571                                 printf("Line %d: invalid WEP key len %lu "
1572                                        "(= %lu bits)\n", line,
1573                                        (unsigned long)
1574                                        bss->default_wep_key_len,
1575                                        (unsigned long)
1576                                        bss->default_wep_key_len * 8);
1577                                 errors++;
1578                         }
1579                 } else if (os_strcmp(buf, "wep_key_len_unicast") == 0) {
1580                         bss->individual_wep_key_len = atoi(pos);
1581                         if (bss->individual_wep_key_len < 0 ||
1582                             bss->individual_wep_key_len > 13) {
1583                                 printf("Line %d: invalid WEP key len %d "
1584                                        "(= %d bits)\n", line,
1585                                        bss->individual_wep_key_len,
1586                                        bss->individual_wep_key_len * 8);
1587                                 errors++;
1588                         }
1589                 } else if (os_strcmp(buf, "wep_rekey_period") == 0) {
1590                         bss->wep_rekeying_period = atoi(pos);
1591                         if (bss->wep_rekeying_period < 0) {
1592                                 printf("Line %d: invalid period %d\n",
1593                                        line, bss->wep_rekeying_period);
1594                                 errors++;
1595                         }
1596                 } else if (os_strcmp(buf, "eap_reauth_period") == 0) {
1597                         bss->eap_reauth_period = atoi(pos);
1598                         if (bss->eap_reauth_period < 0) {
1599                                 printf("Line %d: invalid period %d\n",
1600                                        line, bss->eap_reauth_period);
1601                                 errors++;
1602                         }
1603                 } else if (os_strcmp(buf, "eapol_key_index_workaround") == 0) {
1604                         bss->eapol_key_index_workaround = atoi(pos);
1605 #ifdef CONFIG_IAPP
1606                 } else if (os_strcmp(buf, "iapp_interface") == 0) {
1607                         bss->ieee802_11f = 1;
1608                         os_strlcpy(bss->iapp_iface, pos,
1609                                    sizeof(bss->iapp_iface));
1610 #endif /* CONFIG_IAPP */
1611                 } else if (os_strcmp(buf, "own_ip_addr") == 0) {
1612                         if (hostapd_parse_ip_addr(pos, &bss->own_ip_addr)) {
1613                                 printf("Line %d: invalid IP address '%s'\n",
1614                                        line, pos);
1615                                 errors++;
1616                         }
1617                 } else if (os_strcmp(buf, "nas_identifier") == 0) {
1618                         bss->nas_identifier = os_strdup(pos);
1619                 } else if (os_strcmp(buf, "auth_server_addr") == 0) {
1620                         if (hostapd_config_read_radius_addr(
1621                                     &bss->radius->auth_servers,
1622                                     &bss->radius->num_auth_servers, pos, 1812,
1623                                     &bss->radius->auth_server)) {
1624                                 printf("Line %d: invalid IP address '%s'\n",
1625                                        line, pos);
1626                                 errors++;
1627                         }
1628                 } else if (bss->radius->auth_server &&
1629                            os_strcmp(buf, "auth_server_port") == 0) {
1630                         bss->radius->auth_server->port = atoi(pos);
1631                 } else if (bss->radius->auth_server &&
1632                            os_strcmp(buf, "auth_server_shared_secret") == 0) {
1633                         int len = os_strlen(pos);
1634                         if (len == 0) {
1635                                 /* RFC 2865, Ch. 3 */
1636                                 printf("Line %d: empty shared secret is not "
1637                                        "allowed.\n", line);
1638                                 errors++;
1639                         }
1640                         bss->radius->auth_server->shared_secret =
1641                                 (u8 *) os_strdup(pos);
1642                         bss->radius->auth_server->shared_secret_len = len;
1643                 } else if (os_strcmp(buf, "acct_server_addr") == 0) {
1644                         if (hostapd_config_read_radius_addr(
1645                                     &bss->radius->acct_servers,
1646                                     &bss->radius->num_acct_servers, pos, 1813,
1647                                     &bss->radius->acct_server)) {
1648                                 printf("Line %d: invalid IP address '%s'\n",
1649                                        line, pos);
1650                                 errors++;
1651                         }
1652                 } else if (bss->radius->acct_server &&
1653                            os_strcmp(buf, "acct_server_port") == 0) {
1654                         bss->radius->acct_server->port = atoi(pos);
1655                 } else if (bss->radius->acct_server &&
1656                            os_strcmp(buf, "acct_server_shared_secret") == 0) {
1657                         int len = os_strlen(pos);
1658                         if (len == 0) {
1659                                 /* RFC 2865, Ch. 3 */
1660                                 printf("Line %d: empty shared secret is not "
1661                                        "allowed.\n", line);
1662                                 errors++;
1663                         }
1664                         bss->radius->acct_server->shared_secret =
1665                                 (u8 *) os_strdup(pos);
1666                         bss->radius->acct_server->shared_secret_len = len;
1667                 } else if (os_strcmp(buf, "radius_retry_primary_interval") ==
1668                            0) {
1669                         bss->radius->retry_primary_interval = atoi(pos);
1670                 } else if (os_strcmp(buf, "radius_acct_interim_interval") == 0)
1671                 {
1672                         bss->radius->acct_interim_interval = atoi(pos);
1673                 } else if (os_strcmp(buf, "auth_algs") == 0) {
1674                         bss->auth_algs = atoi(pos);
1675                         if (bss->auth_algs == 0) {
1676                                 printf("Line %d: no authentication algorithms "
1677                                        "allowed\n",
1678                                        line);
1679                                 errors++;
1680                         }
1681                 } else if (os_strcmp(buf, "max_num_sta") == 0) {
1682                         bss->max_num_sta = atoi(pos);
1683                         if (bss->max_num_sta < 0 ||
1684                             bss->max_num_sta > MAX_STA_COUNT) {
1685                                 printf("Line %d: Invalid max_num_sta=%d; "
1686                                        "allowed range 0..%d\n", line,
1687                                        bss->max_num_sta, MAX_STA_COUNT);
1688                                 errors++;
1689                         }
1690                 } else if (os_strcmp(buf, "wpa") == 0) {
1691                         bss->wpa = atoi(pos);
1692                 } else if (os_strcmp(buf, "wpa_group_rekey") == 0) {
1693                         bss->wpa_group_rekey = atoi(pos);
1694                 } else if (os_strcmp(buf, "wpa_strict_rekey") == 0) {
1695                         bss->wpa_strict_rekey = atoi(pos);
1696                 } else if (os_strcmp(buf, "wpa_gmk_rekey") == 0) {
1697                         bss->wpa_gmk_rekey = atoi(pos);
1698                 } else if (os_strcmp(buf, "wpa_ptk_rekey") == 0) {
1699                         bss->wpa_ptk_rekey = atoi(pos);
1700                 } else if (os_strcmp(buf, "wpa_passphrase") == 0) {
1701                         int len = os_strlen(pos);
1702                         if (len < 8 || len > 63) {
1703                                 printf("Line %d: invalid WPA passphrase length"
1704                                        " %d (expected 8..63)\n", line, len);
1705                                 errors++;
1706                         } else {
1707                                 os_free(bss->ssid.wpa_passphrase);
1708                                 bss->ssid.wpa_passphrase = os_strdup(pos);
1709                         }
1710                 } else if (os_strcmp(buf, "wpa_psk") == 0) {
1711                         os_free(bss->ssid.wpa_psk);
1712                         bss->ssid.wpa_psk =
1713                                 os_zalloc(sizeof(struct hostapd_wpa_psk));
1714                         if (bss->ssid.wpa_psk == NULL)
1715                                 errors++;
1716                         else if (hexstr2bin(pos, bss->ssid.wpa_psk->psk,
1717                                             PMK_LEN) ||
1718                                  pos[PMK_LEN * 2] != '\0') {
1719                                 printf("Line %d: Invalid PSK '%s'.\n", line,
1720                                        pos);
1721                                 errors++;
1722                         } else {
1723                                 bss->ssid.wpa_psk->group = 1;
1724                         }
1725                 } else if (os_strcmp(buf, "wpa_psk_file") == 0) {
1726                         os_free(bss->ssid.wpa_psk_file);
1727                         bss->ssid.wpa_psk_file = os_strdup(pos);
1728                         if (!bss->ssid.wpa_psk_file) {
1729                                 printf("Line %d: allocation failed\n", line);
1730                                 errors++;
1731                         }
1732                 } else if (os_strcmp(buf, "wpa_key_mgmt") == 0) {
1733                         bss->wpa_key_mgmt =
1734                                 hostapd_config_parse_key_mgmt(line, pos);
1735                         if (bss->wpa_key_mgmt == -1)
1736                                 errors++;
1737                 } else if (os_strcmp(buf, "wpa_pairwise") == 0) {
1738                         bss->wpa_pairwise =
1739                                 hostapd_config_parse_cipher(line, pos);
1740                         if (bss->wpa_pairwise == -1 ||
1741                             bss->wpa_pairwise == 0)
1742                                 errors++;
1743                         else if (bss->wpa_pairwise &
1744                                  (WPA_CIPHER_NONE | WPA_CIPHER_WEP40 |
1745                                   WPA_CIPHER_WEP104)) {
1746                                 printf("Line %d: unsupported pairwise "
1747                                        "cipher suite '%s'\n",
1748                                        bss->wpa_pairwise, pos);
1749                                 errors++;
1750                         }
1751                 } else if (os_strcmp(buf, "rsn_pairwise") == 0) {
1752                         bss->rsn_pairwise =
1753                                 hostapd_config_parse_cipher(line, pos);
1754                         if (bss->rsn_pairwise == -1 ||
1755                             bss->rsn_pairwise == 0)
1756                                 errors++;
1757                         else if (bss->rsn_pairwise &
1758                                  (WPA_CIPHER_NONE | WPA_CIPHER_WEP40 |
1759                                   WPA_CIPHER_WEP104)) {
1760                                 printf("Line %d: unsupported pairwise "
1761                                        "cipher suite '%s'\n",
1762                                        bss->rsn_pairwise, pos);
1763                                 errors++;
1764                         }
1765 #ifdef CONFIG_RSN_PREAUTH
1766                 } else if (os_strcmp(buf, "rsn_preauth") == 0) {
1767                         bss->rsn_preauth = atoi(pos);
1768                 } else if (os_strcmp(buf, "rsn_preauth_interfaces") == 0) {
1769                         bss->rsn_preauth_interfaces = os_strdup(pos);
1770 #endif /* CONFIG_RSN_PREAUTH */
1771 #ifdef CONFIG_PEERKEY
1772                 } else if (os_strcmp(buf, "peerkey") == 0) {
1773                         bss->peerkey = atoi(pos);
1774 #endif /* CONFIG_PEERKEY */
1775 #ifdef CONFIG_IEEE80211R
1776                 } else if (os_strcmp(buf, "mobility_domain") == 0) {
1777                         if (os_strlen(pos) != 2 * MOBILITY_DOMAIN_ID_LEN ||
1778                             hexstr2bin(pos, bss->mobility_domain,
1779                                        MOBILITY_DOMAIN_ID_LEN) != 0) {
1780                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
1781                                            "mobility_domain '%s'", line, pos);
1782                                 errors++;
1783                                 continue;
1784                         }
1785                 } else if (os_strcmp(buf, "r1_key_holder") == 0) {
1786                         if (os_strlen(pos) != 2 * FT_R1KH_ID_LEN ||
1787                             hexstr2bin(pos, bss->r1_key_holder,
1788                                        FT_R1KH_ID_LEN) != 0) {
1789                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
1790                                            "r1_key_holder '%s'", line, pos);
1791                                 errors++;
1792                                 continue;
1793                         }
1794                 } else if (os_strcmp(buf, "r0_key_lifetime") == 0) {
1795                         bss->r0_key_lifetime = atoi(pos);
1796                 } else if (os_strcmp(buf, "reassociation_deadline") == 0) {
1797                         bss->reassociation_deadline = atoi(pos);
1798                 } else if (os_strcmp(buf, "r0kh") == 0) {
1799                         if (add_r0kh(bss, pos) < 0) {
1800                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
1801                                            "r0kh '%s'", line, pos);
1802                                 errors++;
1803                                 continue;
1804                         }
1805                 } else if (os_strcmp(buf, "r1kh") == 0) {
1806                         if (add_r1kh(bss, pos) < 0) {
1807                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
1808                                            "r1kh '%s'", line, pos);
1809                                 errors++;
1810                                 continue;
1811                         }
1812                 } else if (os_strcmp(buf, "pmk_r1_push") == 0) {
1813                         bss->pmk_r1_push = atoi(pos);
1814 #endif /* CONFIG_IEEE80211R */
1815                 } else if (os_strcmp(buf, "ctrl_interface") == 0) {
1816                         os_free(bss->ctrl_interface);
1817                         bss->ctrl_interface = os_strdup(pos);
1818                 } else if (os_strcmp(buf, "ctrl_interface_group") == 0) {
1819 #ifndef CONFIG_NATIVE_WINDOWS
1820                         struct group *grp;
1821                         char *endp;
1822                         const char *group = pos;
1823
1824                         grp = getgrnam(group);
1825                         if (grp) {
1826                                 bss->ctrl_interface_gid = grp->gr_gid;
1827                                 bss->ctrl_interface_gid_set = 1;
1828                                 wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d"
1829                                            " (from group name '%s')",
1830                                            bss->ctrl_interface_gid, group);
1831                                 continue;
1832                         }
1833
1834                         /* Group name not found - try to parse this as gid */
1835                         bss->ctrl_interface_gid = strtol(group, &endp, 10);
1836                         if (*group == '\0' || *endp != '\0') {
1837                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid group "
1838                                            "'%s'", line, group);
1839                                 errors++;
1840                                 continue;
1841                         }
1842                         bss->ctrl_interface_gid_set = 1;
1843                         wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d",
1844                                    bss->ctrl_interface_gid);
1845 #endif /* CONFIG_NATIVE_WINDOWS */
1846 #ifdef RADIUS_SERVER
1847                 } else if (os_strcmp(buf, "radius_server_clients") == 0) {
1848                         os_free(bss->radius_server_clients);
1849                         bss->radius_server_clients = os_strdup(pos);
1850                 } else if (os_strcmp(buf, "radius_server_auth_port") == 0) {
1851                         bss->radius_server_auth_port = atoi(pos);
1852                 } else if (os_strcmp(buf, "radius_server_ipv6") == 0) {
1853                         bss->radius_server_ipv6 = atoi(pos);
1854 #endif /* RADIUS_SERVER */
1855                 } else if (os_strcmp(buf, "test_socket") == 0) {
1856                         os_free(bss->test_socket);
1857                         bss->test_socket = os_strdup(pos);
1858                 } else if (os_strcmp(buf, "use_pae_group_addr") == 0) {
1859                         bss->use_pae_group_addr = atoi(pos);
1860                 } else if (os_strcmp(buf, "hw_mode") == 0) {
1861                         if (os_strcmp(pos, "a") == 0)
1862                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211A;
1863                         else if (os_strcmp(pos, "b") == 0)
1864                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211B;
1865                         else if (os_strcmp(pos, "g") == 0)
1866                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
1867                         else {
1868                                 printf("Line %d: unknown hw_mode '%s'\n",
1869                                        line, pos);
1870                                 errors++;
1871                         }
1872                 } else if (os_strcmp(buf, "channel") == 0) {
1873                         conf->channel = atoi(pos);
1874                 } else if (os_strcmp(buf, "beacon_int") == 0) {
1875                         int val = atoi(pos);
1876                         /* MIB defines range as 1..65535, but very small values
1877                          * cause problems with the current implementation.
1878                          * Since it is unlikely that this small numbers are
1879                          * useful in real life scenarios, do not allow beacon
1880                          * period to be set below 15 TU. */
1881                         if (val < 15 || val > 65535) {
1882                                 printf("Line %d: invalid beacon_int %d "
1883                                        "(expected 15..65535)\n",
1884                                        line, val);
1885                                 errors++;
1886                         } else
1887                                 conf->beacon_int = val;
1888                 } else if (os_strcmp(buf, "dtim_period") == 0) {
1889                         bss->dtim_period = atoi(pos);
1890                         if (bss->dtim_period < 1 || bss->dtim_period > 255) {
1891                                 printf("Line %d: invalid dtim_period %d\n",
1892                                        line, bss->dtim_period);
1893                                 errors++;
1894                         }
1895                 } else if (os_strcmp(buf, "rts_threshold") == 0) {
1896                         conf->rts_threshold = atoi(pos);
1897                         if (conf->rts_threshold < 0 ||
1898                             conf->rts_threshold > 2347) {
1899                                 printf("Line %d: invalid rts_threshold %d\n",
1900                                        line, conf->rts_threshold);
1901                                 errors++;
1902                         }
1903                 } else if (os_strcmp(buf, "fragm_threshold") == 0) {
1904                         conf->fragm_threshold = atoi(pos);
1905                         if (conf->fragm_threshold < 256 ||
1906                             conf->fragm_threshold > 2346) {
1907                                 printf("Line %d: invalid fragm_threshold %d\n",
1908                                        line, conf->fragm_threshold);
1909                                 errors++;
1910                         }
1911                 } else if (os_strcmp(buf, "send_probe_response") == 0) {
1912                         int val = atoi(pos);
1913                         if (val != 0 && val != 1) {
1914                                 printf("Line %d: invalid send_probe_response "
1915                                        "%d (expected 0 or 1)\n", line, val);
1916                         } else
1917                                 conf->send_probe_response = val;
1918                 } else if (os_strcmp(buf, "supported_rates") == 0) {
1919                         if (hostapd_parse_rates(&conf->supported_rates, pos)) {
1920                                 printf("Line %d: invalid rate list\n", line);
1921                                 errors++;
1922                         }
1923                 } else if (os_strcmp(buf, "basic_rates") == 0) {
1924                         if (hostapd_parse_rates(&conf->basic_rates, pos)) {
1925                                 printf("Line %d: invalid rate list\n", line);
1926                                 errors++;
1927                         }
1928                 } else if (os_strcmp(buf, "preamble") == 0) {
1929                         if (atoi(pos))
1930                                 conf->preamble = SHORT_PREAMBLE;
1931                         else
1932                                 conf->preamble = LONG_PREAMBLE;
1933                 } else if (os_strcmp(buf, "ignore_broadcast_ssid") == 0) {
1934                         bss->ignore_broadcast_ssid = atoi(pos);
1935                 } else if (os_strcmp(buf, "bridge_packets") == 0) {
1936                         conf->bridge_packets = atoi(pos);
1937                 } else if (os_strcmp(buf, "wep_default_key") == 0) {
1938                         bss->ssid.wep.idx = atoi(pos);
1939                         if (bss->ssid.wep.idx > 3) {
1940                                 printf("Invalid wep_default_key index %d\n",
1941                                        bss->ssid.wep.idx);
1942                                 errors++;
1943                         }
1944                 } else if (os_strcmp(buf, "wep_key0") == 0 ||
1945                            os_strcmp(buf, "wep_key1") == 0 ||
1946                            os_strcmp(buf, "wep_key2") == 0 ||
1947                            os_strcmp(buf, "wep_key3") == 0) {
1948                         if (hostapd_config_read_wep(&bss->ssid.wep,
1949                                                     buf[7] - '0', pos)) {
1950                                 printf("Line %d: invalid WEP key '%s'\n",
1951                                        line, buf);
1952                                 errors++;
1953                         }
1954                 } else if (os_strcmp(buf, "dynamic_vlan") == 0) {
1955                         bss->ssid.dynamic_vlan = atoi(pos);
1956                 } else if (os_strcmp(buf, "vlan_file") == 0) {
1957                         if (hostapd_config_read_vlan_file(bss, pos)) {
1958                                 printf("Line %d: failed to read VLAN file "
1959                                        "'%s'\n", line, pos);
1960                                 errors++;
1961                         }
1962 #ifdef CONFIG_FULL_DYNAMIC_VLAN
1963                 } else if (os_strcmp(buf, "vlan_tagged_interface") == 0) {
1964                         bss->ssid.vlan_tagged_interface = os_strdup(pos);
1965 #endif /* CONFIG_FULL_DYNAMIC_VLAN */
1966                 } else if (os_strcmp(buf, "passive_scan_interval") == 0) {
1967                         conf->passive_scan_interval = atoi(pos);
1968                 } else if (os_strcmp(buf, "passive_scan_listen") == 0) {
1969                         conf->passive_scan_listen = atoi(pos);
1970                 } else if (os_strcmp(buf, "passive_scan_mode") == 0) {
1971                         conf->passive_scan_mode = atoi(pos);
1972                 } else if (os_strcmp(buf, "ap_table_max_size") == 0) {
1973                         conf->ap_table_max_size = atoi(pos);
1974                 } else if (os_strcmp(buf, "ap_table_expiration_time") == 0) {
1975                         conf->ap_table_expiration_time = atoi(pos);
1976                 } else if (os_strncmp(buf, "tx_queue_", 9) == 0) {
1977                         if (hostapd_config_tx_queue(conf, buf, pos)) {
1978                                 printf("Line %d: invalid TX queue item\n",
1979                                        line);
1980                                 errors++;
1981                         }
1982                 } else if (os_strcmp(buf, "wme_enabled") == 0) {
1983                         bss->wme_enabled = atoi(pos);
1984                 } else if (os_strncmp(buf, "wme_ac_", 7) == 0) {
1985                         if (hostapd_config_wme_ac(conf, buf, pos)) {
1986                                 printf("Line %d: invalid wme ac item\n",
1987                                        line);
1988                                 errors++;
1989                         }
1990                 } else if (os_strcmp(buf, "bss") == 0) {
1991                         if (hostapd_config_bss(conf, pos)) {
1992                                 printf("Line %d: invalid bss item\n", line);
1993                                 errors++;
1994                         }
1995                 } else if (os_strcmp(buf, "bssid") == 0) {
1996                         if (bss == conf->bss &&
1997                             (!conf->driver || !conf->driver->init_bssid)) {
1998                                 printf("Line %d: bssid item not allowed "
1999                                        "for the default interface and this "
2000                                        "driver\n", line);
2001                                 errors++;
2002                         } else if (hwaddr_aton(pos, bss->bssid)) {
2003                                 printf("Line %d: invalid bssid item\n", line);
2004                                 errors++;
2005                         }
2006 #ifdef CONFIG_IEEE80211W
2007                 } else if (os_strcmp(buf, "ieee80211w") == 0) {
2008                         bss->ieee80211w = atoi(pos);
2009                 } else if (os_strcmp(buf, "assoc_ping_timeout") == 0) {
2010                         bss->assoc_ping_timeout = atoi(pos);
2011                         if (bss->assoc_ping_timeout == 0) {
2012                                 printf("Line %d: invalid assoc_ping_timeout\n",
2013                                         line);
2014                                 errors++;
2015                         }
2016                 } else if (os_strcmp(buf, "assoc_ping_attempts") == 0) {
2017                         bss->assoc_ping_timeout = atoi(pos);
2018                         if (bss->assoc_ping_timeout == 0) {
2019                                 printf("Line %d: invalid assoc_ping_attempts "
2020                                        "(valid range: 1..255)\n",
2021                                        line);
2022                                 errors++;
2023                         }
2024 #endif /* CONFIG_IEEE80211W */
2025 #ifdef CONFIG_IEEE80211N
2026                 } else if (os_strcmp(buf, "ieee80211n") == 0) {
2027                         conf->ieee80211n = atoi(pos);
2028 #endif /* CONFIG_IEEE80211N */
2029                 } else if (os_strcmp(buf, "max_listen_interval") == 0) {
2030                         bss->max_listen_interval = atoi(pos);
2031                 } else if (os_strcmp(buf, "okc") == 0) {
2032                         bss->okc = atoi(pos);
2033                 } else {
2034                         printf("Line %d: unknown configuration item '%s'\n",
2035                                line, buf);
2036                         errors++;
2037                 }
2038         }
2039
2040         fclose(f);
2041
2042         if (bss->individual_wep_key_len == 0) {
2043                 /* individual keys are not use; can use key idx0 for broadcast
2044                  * keys */
2045                 bss->broadcast_key_idx_min = 0;
2046         }
2047
2048         /* Select group cipher based on the enabled pairwise cipher suites */
2049         pairwise = 0;
2050         if (bss->wpa & 1)
2051                 pairwise |= bss->wpa_pairwise;
2052         if (bss->wpa & 2) {
2053                 if (bss->rsn_pairwise == 0)
2054                         bss->rsn_pairwise = bss->wpa_pairwise;
2055                 pairwise |= bss->rsn_pairwise;
2056         }
2057         if (pairwise & WPA_CIPHER_TKIP)
2058                 bss->wpa_group = WPA_CIPHER_TKIP;
2059         else
2060                 bss->wpa_group = WPA_CIPHER_CCMP;
2061
2062         for (i = 0; i < conf->num_bss; i++) {
2063                 bss = &conf->bss[i];
2064
2065                 bss->radius->auth_server = bss->radius->auth_servers;
2066                 bss->radius->acct_server = bss->radius->acct_servers;
2067
2068                 if (bss->wpa && bss->ieee802_1x) {
2069                         bss->ssid.security_policy = SECURITY_WPA;
2070                 } else if (bss->wpa) {
2071                         bss->ssid.security_policy = SECURITY_WPA_PSK;
2072                 } else if (bss->ieee802_1x) {
2073                         bss->ssid.security_policy = SECURITY_IEEE_802_1X;
2074                         bss->ssid.wep.default_len = bss->default_wep_key_len;
2075                 } else if (bss->ssid.wep.keys_set)
2076                         bss->ssid.security_policy = SECURITY_STATIC_WEP;
2077                 else
2078                         bss->ssid.security_policy = SECURITY_PLAINTEXT;
2079         }
2080
2081         if (hostapd_config_check(conf))
2082                 errors++;
2083
2084         if (errors) {
2085                 printf("%d errors found in configuration file '%s'\n",
2086                        errors, fname);
2087                 hostapd_config_free(conf);
2088                 conf = NULL;
2089         }
2090
2091         return conf;
2092 }
2093
2094
2095 int hostapd_wep_key_cmp(struct hostapd_wep_keys *a, struct hostapd_wep_keys *b)
2096 {
2097         int i;
2098
2099         if (a->idx != b->idx || a->default_len != b->default_len)
2100                 return 1;
2101         for (i = 0; i < NUM_WEP_KEYS; i++)
2102                 if (a->len[i] != b->len[i] ||
2103                     os_memcmp(a->key[i], b->key[i], a->len[i]) != 0)
2104                         return 1;
2105         return 0;
2106 }
2107
2108
2109 static void hostapd_config_free_radius(struct hostapd_radius_server *servers,
2110                                        int num_servers)
2111 {
2112         int i;
2113
2114         for (i = 0; i < num_servers; i++) {
2115                 os_free(servers[i].shared_secret);
2116         }
2117         os_free(servers);
2118 }
2119
2120
2121 static void hostapd_config_free_eap_user(struct hostapd_eap_user *user)
2122 {
2123         os_free(user->identity);
2124         os_free(user->password);
2125         os_free(user);
2126 }
2127
2128
2129 static void hostapd_config_free_wep(struct hostapd_wep_keys *keys)
2130 {
2131         int i;
2132         for (i = 0; i < NUM_WEP_KEYS; i++) {
2133                 os_free(keys->key[i]);
2134                 keys->key[i] = NULL;
2135         }
2136 }
2137
2138
2139 static void hostapd_config_free_bss(struct hostapd_bss_config *conf)
2140 {
2141         struct hostapd_wpa_psk *psk, *prev;
2142         struct hostapd_eap_user *user, *prev_user;
2143
2144         if (conf == NULL)
2145                 return;
2146
2147         psk = conf->ssid.wpa_psk;
2148         while (psk) {
2149                 prev = psk;
2150                 psk = psk->next;
2151                 os_free(prev);
2152         }
2153
2154         os_free(conf->ssid.wpa_passphrase);
2155         os_free(conf->ssid.wpa_psk_file);
2156 #ifdef CONFIG_FULL_DYNAMIC_VLAN
2157         os_free(conf->ssid.vlan_tagged_interface);
2158 #endif /* CONFIG_FULL_DYNAMIC_VLAN */
2159
2160         user = conf->eap_user;
2161         while (user) {
2162                 prev_user = user;
2163                 user = user->next;
2164                 hostapd_config_free_eap_user(prev_user);
2165         }
2166
2167         os_free(conf->dump_log_name);
2168         os_free(conf->eap_req_id_text);
2169         os_free(conf->accept_mac);
2170         os_free(conf->deny_mac);
2171         os_free(conf->nas_identifier);
2172         hostapd_config_free_radius(conf->radius->auth_servers,
2173                                    conf->radius->num_auth_servers);
2174         hostapd_config_free_radius(conf->radius->acct_servers,
2175                                    conf->radius->num_acct_servers);
2176         os_free(conf->rsn_preauth_interfaces);
2177         os_free(conf->ctrl_interface);
2178         os_free(conf->ca_cert);
2179         os_free(conf->server_cert);
2180         os_free(conf->private_key);
2181         os_free(conf->private_key_passwd);
2182         os_free(conf->dh_file);
2183         os_free(conf->pac_opaque_encr_key);
2184         os_free(conf->eap_fast_a_id);
2185         os_free(conf->eap_fast_a_id_info);
2186         os_free(conf->eap_sim_db);
2187         os_free(conf->radius_server_clients);
2188         os_free(conf->test_socket);
2189         os_free(conf->radius);
2190         hostapd_config_free_vlan(conf);
2191         if (conf->ssid.dyn_vlan_keys) {
2192                 struct hostapd_ssid *ssid = &conf->ssid;
2193                 size_t i;
2194                 for (i = 0; i <= ssid->max_dyn_vlan_keys; i++) {
2195                         if (ssid->dyn_vlan_keys[i] == NULL)
2196                                 continue;
2197                         hostapd_config_free_wep(ssid->dyn_vlan_keys[i]);
2198                         os_free(ssid->dyn_vlan_keys[i]);
2199                 }
2200                 os_free(ssid->dyn_vlan_keys);
2201                 ssid->dyn_vlan_keys = NULL;
2202         }
2203
2204 #ifdef CONFIG_IEEE80211R
2205         {
2206                 struct ft_remote_r0kh *r0kh, *r0kh_prev;
2207                 struct ft_remote_r1kh *r1kh, *r1kh_prev;
2208
2209                 r0kh = conf->r0kh_list;
2210                 conf->r0kh_list = NULL;
2211                 while (r0kh) {
2212                         r0kh_prev = r0kh;
2213                         r0kh = r0kh->next;
2214                         os_free(r0kh_prev);
2215                 }
2216
2217                 r1kh = conf->r1kh_list;
2218                 conf->r1kh_list = NULL;
2219                 while (r1kh) {
2220                         r1kh_prev = r1kh;
2221                         r1kh = r1kh->next;
2222                         os_free(r1kh_prev);
2223                 }
2224         }
2225 #endif /* CONFIG_IEEE80211R */
2226 }
2227
2228
2229 void hostapd_config_free(struct hostapd_config *conf)
2230 {
2231         size_t i;
2232
2233         if (conf == NULL)
2234                 return;
2235
2236         for (i = 0; i < conf->num_bss; i++)
2237                 hostapd_config_free_bss(&conf->bss[i]);
2238         os_free(conf->bss);
2239
2240         os_free(conf);
2241 }
2242
2243
2244 /* Perform a binary search for given MAC address from a pre-sorted list.
2245  * Returns 1 if address is in the list or 0 if not. */
2246 int hostapd_maclist_found(struct mac_acl_entry *list, int num_entries,
2247                           const u8 *addr, int *vlan_id)
2248 {
2249         int start, end, middle, res;
2250
2251         start = 0;
2252         end = num_entries - 1;
2253
2254         while (start <= end) {
2255                 middle = (start + end) / 2;
2256                 res = os_memcmp(list[middle].addr, addr, ETH_ALEN);
2257                 if (res == 0) {
2258                         if (vlan_id)
2259                                 *vlan_id = list[middle].vlan_id;
2260                         return 1;
2261                 }
2262                 if (res < 0)
2263                         start = middle + 1;
2264                 else
2265                         end = middle - 1;
2266         }
2267
2268         return 0;
2269 }
2270
2271
2272 int hostapd_rate_found(int *list, int rate)
2273 {
2274         int i;
2275
2276         if (list == NULL)
2277                 return 0;
2278
2279         for (i = 0; list[i] >= 0; i++)
2280                 if (list[i] == rate)
2281                         return 1;
2282
2283         return 0;
2284 }
2285
2286
2287 const char * hostapd_get_vlan_id_ifname(struct hostapd_vlan *vlan, int vlan_id)
2288 {
2289         struct hostapd_vlan *v = vlan;
2290         while (v) {
2291                 if (v->vlan_id == vlan_id || v->vlan_id == VLAN_ID_WILDCARD)
2292                         return v->ifname;
2293                 v = v->next;
2294         }
2295         return NULL;
2296 }
2297
2298
2299 const u8 * hostapd_get_psk(const struct hostapd_bss_config *conf,
2300                            const u8 *addr, const u8 *prev_psk)
2301 {
2302         struct hostapd_wpa_psk *psk;
2303         int next_ok = prev_psk == NULL;
2304
2305         for (psk = conf->ssid.wpa_psk; psk != NULL; psk = psk->next) {
2306                 if (next_ok &&
2307                     (psk->group || os_memcmp(psk->addr, addr, ETH_ALEN) == 0))
2308                         return psk->psk;
2309
2310                 if (psk->psk == prev_psk)
2311                         next_ok = 1;
2312         }
2313
2314         return NULL;
2315 }
2316
2317
2318 const struct hostapd_eap_user *
2319 hostapd_get_eap_user(const struct hostapd_bss_config *conf, const u8 *identity,
2320                      size_t identity_len, int phase2)
2321 {
2322         struct hostapd_eap_user *user = conf->eap_user;
2323
2324         while (user) {
2325                 if (!phase2 && user->identity == NULL) {
2326                         /* Wildcard match */
2327                         break;
2328                 }
2329
2330                 if (user->phase2 == !!phase2 && user->wildcard_prefix &&
2331                     identity_len >= user->identity_len &&
2332                     os_memcmp(user->identity, identity, user->identity_len) ==
2333                     0) {
2334                         /* Wildcard prefix match */
2335                         break;
2336                 }
2337
2338                 if (user->phase2 == !!phase2 &&
2339                     user->identity_len == identity_len &&
2340                     os_memcmp(user->identity, identity, identity_len) == 0)
2341                         break;
2342                 user = user->next;
2343         }
2344
2345         return user;
2346 }