contrib/hostapd/hostapd/config_file.c

   1 /*
   2  * hostapd / Configuration file parser
   3  * Copyright (c) 2003-2013, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #ifndef CONFIG_NATIVE_WINDOWS
  11 #include <grp.h>
  12 #endif /* CONFIG_NATIVE_WINDOWS */
  13
  14 #include "utils/common.h"
  15 #include "utils/uuid.h"
  16 #include "common/ieee802_11_defs.h"
  17 #include "drivers/driver.h"
  18 #include "eap_server/eap.h"
  19 #include "radius/radius_client.h"
  20 #include "ap/wpa_auth.h"
  21 #include "ap/ap_config.h"
  22 #include "config_file.h"
  23
  24
  25 #ifndef CONFIG_NO_VLAN
  26 static int hostapd_config_read_vlan_file(struct hostapd_bss_config *bss,
  27                                          const char *fname)
  28 {
  29         FILE *f;
  30         char buf[128], *pos, *pos2;
  31         int line = 0, vlan_id;
  32         struct hostapd_vlan *vlan;
  33
  34         f = fopen(fname, "r");
  35         if (!f) {
  36                 wpa_printf(MSG_ERROR, "VLAN file '%s' not readable.", fname);
  37                 return -1;
  38         }
  39
  40         while (fgets(buf, sizeof(buf), f)) {
  41                 line++;
  42
  43                 if (buf[0] == '#')
  44                         continue;
  45                 pos = buf;
  46                 while (*pos != '\0') {
  47                         if (*pos == '\n') {
  48                                 *pos = '\0';
  49                                 break;
  50                         }
  51                         pos++;
  52                 }
  53                 if (buf[0] == '\0')
  54                         continue;
  55
  56                 if (buf[0] == '*') {
  57                         vlan_id = VLAN_ID_WILDCARD;
  58                         pos = buf + 1;
  59                 } else {
  60                         vlan_id = strtol(buf, &pos, 10);
  61                         if (buf == pos || vlan_id < 1 ||
  62                             vlan_id > MAX_VLAN_ID) {
  63                                 wpa_printf(MSG_ERROR, "Invalid VLAN ID at "
  64                                            "line %d in '%s'", line, fname);
  65                                 fclose(f);
  66                                 return -1;
  67                         }
  68                 }
  69
  70                 while (*pos == ' ' || *pos == '\t')
  71                         pos++;
  72                 pos2 = pos;
  73                 while (*pos2 != ' ' && *pos2 != '\t' && *pos2 != '\0')
  74                         pos2++;
  75                 *pos2 = '\0';
  76                 if (*pos == '\0' || os_strlen(pos) > IFNAMSIZ) {
  77                         wpa_printf(MSG_ERROR, "Invalid VLAN ifname at line %d "
  78                                    "in '%s'", line, fname);
  79                         fclose(f);
  80                         return -1;
  81                 }
  82
  83                 vlan = os_zalloc(sizeof(*vlan));
  84                 if (vlan == NULL) {
  85                         wpa_printf(MSG_ERROR, "Out of memory while reading "
  86                                    "VLAN interfaces from '%s'", fname);
  87                         fclose(f);
  88                         return -1;
  89                 }
  90
  91                 vlan->vlan_id = vlan_id;
  92                 os_strlcpy(vlan->ifname, pos, sizeof(vlan->ifname));
  93                 vlan->next = bss->vlan;
  94                 bss->vlan = vlan;
  95         }
  96
  97         fclose(f);
  98
  99         return 0;
 100 }
 101 #endif /* CONFIG_NO_VLAN */
 102
 103
 104 static int hostapd_acl_comp(const void *a, const void *b)
 105 {
 106         const struct mac_acl_entry *aa = a;
 107         const struct mac_acl_entry *bb = b;
 108         return os_memcmp(aa->addr, bb->addr, sizeof(macaddr));
 109 }
 110
 111
 112 static int hostapd_config_read_maclist(const char *fname,
 113                                        struct mac_acl_entry **acl, int *num)
 114 {
 115         FILE *f;
 116         char buf[128], *pos;
 117         int line = 0;
 118         u8 addr[ETH_ALEN];
 119         struct mac_acl_entry *newacl;
 120         int vlan_id;
 121
 122         if (!fname)
 123                 return 0;
 124
 125         f = fopen(fname, "r");
 126         if (!f) {
 127                 wpa_printf(MSG_ERROR, "MAC list file '%s' not found.", fname);
 128                 return -1;
 129         }
 130
 131         while (fgets(buf, sizeof(buf), f)) {
 132                 line++;
 133
 134                 if (buf[0] == '#')
 135                         continue;
 136                 pos = buf;
 137                 while (*pos != '\0') {
 138                         if (*pos == '\n') {
 139                                 *pos = '\0';
 140                                 break;
 141                         }
 142                         pos++;
 143                 }
 144                 if (buf[0] == '\0')
 145                         continue;
 146
 147                 if (hwaddr_aton(buf, addr)) {
 148                         wpa_printf(MSG_ERROR, "Invalid MAC address '%s' at "
 149                                    "line %d in '%s'", buf, line, fname);
 150                         fclose(f);
 151                         return -1;
 152                 }
 153
 154                 vlan_id = 0;
 155                 pos = buf;
 156                 while (*pos != '\0' && *pos != ' ' && *pos != '\t')
 157                         pos++;
 158                 while (*pos == ' ' || *pos == '\t')
 159                         pos++;
 160                 if (*pos != '\0')
 161                         vlan_id = atoi(pos);
 162
 163                 newacl = os_realloc_array(*acl, *num + 1, sizeof(**acl));
 164                 if (newacl == NULL) {
 165                         wpa_printf(MSG_ERROR, "MAC list reallocation failed");
 166                         fclose(f);
 167                         return -1;
 168                 }
 169
 170                 *acl = newacl;
 171                 os_memcpy((*acl)[*num].addr, addr, ETH_ALEN);
 172                 (*acl)[*num].vlan_id = vlan_id;
 173                 (*num)++;
 174         }
 175
 176         fclose(f);
 177
 178         qsort(*acl, *num, sizeof(**acl), hostapd_acl_comp);
 179
 180         return 0;
 181 }
 182
 183
 184 #ifdef EAP_SERVER
 185 static int hostapd_config_read_eap_user(const char *fname,
 186                                         struct hostapd_bss_config *conf)
 187 {
 188         FILE *f;
 189         char buf[512], *pos, *start, *pos2;
 190         int line = 0, ret = 0, num_methods;
 191         struct hostapd_eap_user *user, *tail = NULL;
 192
 193         if (!fname)
 194                 return 0;
 195
 196         if (os_strncmp(fname, "sqlite:", 7) == 0) {
 197                 os_free(conf->eap_user_sqlite);
 198                 conf->eap_user_sqlite = os_strdup(fname + 7);
 199                 return 0;
 200         }
 201
 202         f = fopen(fname, "r");
 203         if (!f) {
 204                 wpa_printf(MSG_ERROR, "EAP user file '%s' not found.", fname);
 205                 return -1;
 206         }
 207
 208         /* Lines: "user" METHOD,METHOD2 "password" (password optional) */
 209         while (fgets(buf, sizeof(buf), f)) {
 210                 line++;
 211
 212                 if (buf[0] == '#')
 213                         continue;
 214                 pos = buf;
 215                 while (*pos != '\0') {
 216                         if (*pos == '\n') {
 217                                 *pos = '\0';
 218                                 break;
 219                         }
 220                         pos++;
 221                 }
 222                 if (buf[0] == '\0')
 223                         continue;
 224
 225                 user = NULL;
 226
 227                 if (buf[0] != '"' && buf[0] != '*') {
 228                         wpa_printf(MSG_ERROR, "Invalid EAP identity (no \" in "
 229                                    "start) on line %d in '%s'", line, fname);
 230                         goto failed;
 231                 }
 232
 233                 user = os_zalloc(sizeof(*user));
 234                 if (user == NULL) {
 235                         wpa_printf(MSG_ERROR, "EAP user allocation failed");
 236                         goto failed;
 237                 }
 238                 user->force_version = -1;
 239
 240                 if (buf[0] == '*') {
 241                         pos = buf;
 242                 } else {
 243                         pos = buf + 1;
 244                         start = pos;
 245                         while (*pos != '"' && *pos != '\0')
 246                                 pos++;
 247                         if (*pos == '\0') {
 248                                 wpa_printf(MSG_ERROR, "Invalid EAP identity "
 249                                            "(no \" in end) on line %d in '%s'",
 250                                            line, fname);
 251                                 goto failed;
 252                         }
 253
 254                         user->identity = os_malloc(pos - start);
 255                         if (user->identity == NULL) {
 256                                 wpa_printf(MSG_ERROR, "Failed to allocate "
 257                                            "memory for EAP identity");
 258                                 goto failed;
 259                         }
 260                         os_memcpy(user->identity, start, pos - start);
 261                         user->identity_len = pos - start;
 262
 263                         if (pos[0] == '"' && pos[1] == '*') {
 264                                 user->wildcard_prefix = 1;
 265                                 pos++;
 266                         }
 267                 }
 268                 pos++;
 269                 while (*pos == ' ' || *pos == '\t')
 270                         pos++;
 271
 272                 if (*pos == '\0') {
 273                         wpa_printf(MSG_ERROR, "No EAP method on line %d in "
 274                                    "'%s'", line, fname);
 275                         goto failed;
 276                 }
 277
 278                 start = pos;
 279                 while (*pos != ' ' && *pos != '\t' && *pos != '\0')
 280                         pos++;
 281                 if (*pos == '\0') {
 282                         pos = NULL;
 283                 } else {
 284                         *pos = '\0';
 285                         pos++;
 286                 }
 287                 num_methods = 0;
 288                 while (*start) {
 289                         char *pos3 = os_strchr(start, ',');
 290                         if (pos3) {
 291                                 *pos3++ = '\0';
 292                         }
 293                         user->methods[num_methods].method =
 294                                 eap_server_get_type(
 295                                         start,
 296                                         &user->methods[num_methods].vendor);
 297                         if (user->methods[num_methods].vendor ==
 298                             EAP_VENDOR_IETF &&
 299                             user->methods[num_methods].method == EAP_TYPE_NONE)
 300                         {
 301                                 if (os_strcmp(start, "TTLS-PAP") == 0) {
 302                                         user->ttls_auth |= EAP_TTLS_AUTH_PAP;
 303                                         goto skip_eap;
 304                                 }
 305                                 if (os_strcmp(start, "TTLS-CHAP") == 0) {
 306                                         user->ttls_auth |= EAP_TTLS_AUTH_CHAP;
 307                                         goto skip_eap;
 308                                 }
 309                                 if (os_strcmp(start, "TTLS-MSCHAP") == 0) {
 310                                         user->ttls_auth |=
 311                                                 EAP_TTLS_AUTH_MSCHAP;
 312                                         goto skip_eap;
 313                                 }
 314                                 if (os_strcmp(start, "TTLS-MSCHAPV2") == 0) {
 315                                         user->ttls_auth |=
 316                                                 EAP_TTLS_AUTH_MSCHAPV2;
 317                                         goto skip_eap;
 318                                 }
 319                                 wpa_printf(MSG_ERROR, "Unsupported EAP type "
 320                                            "'%s' on line %d in '%s'",
 321                                            start, line, fname);
 322                                 goto failed;
 323                         }
 324
 325                         num_methods++;
 326                         if (num_methods >= EAP_MAX_METHODS)
 327                                 break;
 328                 skip_eap:
 329                         if (pos3 == NULL)
 330                                 break;
 331                         start = pos3;
 332                 }
 333                 if (num_methods == 0 && user->ttls_auth == 0) {
 334                         wpa_printf(MSG_ERROR, "No EAP types configured on "
 335                                    "line %d in '%s'", line, fname);
 336                         goto failed;
 337                 }
 338
 339                 if (pos == NULL)
 340                         goto done;
 341
 342                 while (*pos == ' ' || *pos == '\t')
 343                         pos++;
 344                 if (*pos == '\0')
 345                         goto done;
 346
 347                 if (os_strncmp(pos, "[ver=0]", 7) == 0) {
 348                         user->force_version = 0;
 349                         goto done;
 350                 }
 351
 352                 if (os_strncmp(pos, "[ver=1]", 7) == 0) {
 353                         user->force_version = 1;
 354                         goto done;
 355                 }
 356
 357                 if (os_strncmp(pos, "[2]", 3) == 0) {
 358                         user->phase2 = 1;
 359                         goto done;
 360                 }
 361
 362                 if (*pos == '"') {
 363                         pos++;
 364                         start = pos;
 365                         while (*pos != '"' && *pos != '\0')
 366                                 pos++;
 367                         if (*pos == '\0') {
 368                                 wpa_printf(MSG_ERROR, "Invalid EAP password "
 369                                            "(no \" in end) on line %d in '%s'",
 370                                            line, fname);
 371                                 goto failed;
 372                         }
 373
 374                         user->password = os_malloc(pos - start);
 375                         if (user->password == NULL) {
 376                                 wpa_printf(MSG_ERROR, "Failed to allocate "
 377                                            "memory for EAP password");
 378                                 goto failed;
 379                         }
 380                         os_memcpy(user->password, start, pos - start);
 381                         user->password_len = pos - start;
 382
 383                         pos++;
 384                 } else if (os_strncmp(pos, "hash:", 5) == 0) {
 385                         pos += 5;
 386                         pos2 = pos;
 387                         while (*pos2 != '\0' && *pos2 != ' ' &&
 388                                *pos2 != '\t' && *pos2 != '#')
 389                                 pos2++;
 390                         if (pos2 - pos != 32) {
 391                                 wpa_printf(MSG_ERROR, "Invalid password hash "
 392                                            "on line %d in '%s'", line, fname);
 393                                 goto failed;
 394                         }
 395                         user->password = os_malloc(16);
 396                         if (user->password == NULL) {
 397                                 wpa_printf(MSG_ERROR, "Failed to allocate "
 398                                            "memory for EAP password hash");
 399                                 goto failed;
 400                         }
 401                         if (hexstr2bin(pos, user->password, 16) < 0) {
 402                                 wpa_printf(MSG_ERROR, "Invalid hash password "
 403                                            "on line %d in '%s'", line, fname);
 404                                 goto failed;
 405                         }
 406                         user->password_len = 16;
 407                         user->password_hash = 1;
 408                         pos = pos2;
 409                 } else {
 410                         pos2 = pos;
 411                         while (*pos2 != '\0' && *pos2 != ' ' &&
 412                                *pos2 != '\t' && *pos2 != '#')
 413                                 pos2++;
 414                         if ((pos2 - pos) & 1) {
 415                                 wpa_printf(MSG_ERROR, "Invalid hex password "
 416                                            "on line %d in '%s'", line, fname);
 417                                 goto failed;
 418                         }
 419                         user->password = os_malloc((pos2 - pos) / 2);
 420                         if (user->password == NULL) {
 421                                 wpa_printf(MSG_ERROR, "Failed to allocate "
 422                                            "memory for EAP password");
 423                                 goto failed;
 424                         }
 425                         if (hexstr2bin(pos, user->password,
 426                                        (pos2 - pos) / 2) < 0) {
 427                                 wpa_printf(MSG_ERROR, "Invalid hex password "
 428                                            "on line %d in '%s'", line, fname);
 429                                 goto failed;
 430                         }
 431                         user->password_len = (pos2 - pos) / 2;
 432                         pos = pos2;
 433                 }
 434
 435                 while (*pos == ' ' || *pos == '\t')
 436                         pos++;
 437                 if (os_strncmp(pos, "[2]", 3) == 0) {
 438                         user->phase2 = 1;
 439                 }
 440
 441         done:
 442                 if (tail == NULL) {
 443                         tail = conf->eap_user = user;
 444                 } else {
 445                         tail->next = user;
 446                         tail = user;
 447                 }
 448                 continue;
 449
 450         failed:
 451                 if (user) {
 452                         os_free(user->password);
 453                         os_free(user->identity);
 454                         os_free(user);
 455                 }
 456                 ret = -1;
 457                 break;
 458         }
 459
 460         fclose(f);
 461
 462         return ret;
 463 }
 464 #endif /* EAP_SERVER */
 465
 466
 467 #ifndef CONFIG_NO_RADIUS
 468 static int
 469 hostapd_config_read_radius_addr(struct hostapd_radius_server **server,
 470                                 int *num_server, const char *val, int def_port,
 471                                 struct hostapd_radius_server **curr_serv)
 472 {
 473         struct hostapd_radius_server *nserv;
 474         int ret;
 475         static int server_index = 1;
 476
 477         nserv = os_realloc_array(*server, *num_server + 1, sizeof(*nserv));
 478         if (nserv == NULL)
 479                 return -1;
 480
 481         *server = nserv;
 482         nserv = &nserv[*num_server];
 483         (*num_server)++;
 484         (*curr_serv) = nserv;
 485
 486         os_memset(nserv, 0, sizeof(*nserv));
 487         nserv->port = def_port;
 488         ret = hostapd_parse_ip_addr(val, &nserv->addr);
 489         nserv->index = server_index++;
 490
 491         return ret;
 492 }
 493
 494
 495 static struct hostapd_radius_attr *
 496 hostapd_parse_radius_attr(const char *value)
 497 {
 498         const char *pos;
 499         char syntax;
 500         struct hostapd_radius_attr *attr;
 501         size_t len;
 502
 503         attr = os_zalloc(sizeof(*attr));
 504         if (attr == NULL)
 505                 return NULL;
 506
 507         attr->type = atoi(value);
 508
 509         pos = os_strchr(value, ':');
 510         if (pos == NULL) {
 511                 attr->val = wpabuf_alloc(1);
 512                 if (attr->val == NULL) {
 513                         os_free(attr);
 514                         return NULL;
 515                 }
 516                 wpabuf_put_u8(attr->val, 0);
 517                 return attr;
 518         }
 519
 520         pos++;
 521         if (pos[0] == '\0' || pos[1] != ':') {
 522                 os_free(attr);
 523                 return NULL;
 524         }
 525         syntax = *pos++;
 526         pos++;
 527
 528         switch (syntax) {
 529         case 's':
 530                 attr->val = wpabuf_alloc_copy(pos, os_strlen(pos));
 531                 break;
 532         case 'x':
 533                 len = os_strlen(pos);
 534                 if (len & 1)
 535                         break;
 536                 len /= 2;
 537                 attr->val = wpabuf_alloc(len);
 538                 if (attr->val == NULL)
 539                         break;
 540                 if (hexstr2bin(pos, wpabuf_put(attr->val, len), len) < 0) {
 541                         wpabuf_free(attr->val);
 542                         os_free(attr);
 543                         return NULL;
 544                 }
 545                 break;
 546         case 'd':
 547                 attr->val = wpabuf_alloc(4);
 548                 if (attr->val)
 549                         wpabuf_put_be32(attr->val, atoi(pos));
 550                 break;
 551         default:
 552                 os_free(attr);
 553                 return NULL;
 554         }
 555
 556         if (attr->val == NULL) {
 557                 os_free(attr);
 558                 return NULL;
 559         }
 560
 561         return attr;
 562 }
 563
 564
 565 static int hostapd_parse_das_client(struct hostapd_bss_config *bss,
 566                                     const char *val)
 567 {
 568         char *secret;
 569
 570         secret = os_strchr(val, ' ');
 571         if (secret == NULL)
 572                 return -1;
 573
 574         secret++;
 575
 576         if (hostapd_parse_ip_addr(val, &bss->radius_das_client_addr))
 577                 return -1;
 578
 579         os_free(bss->radius_das_shared_secret);
 580         bss->radius_das_shared_secret = (u8 *) os_strdup(secret);
 581         if (bss->radius_das_shared_secret == NULL)
 582                 return -1;
 583         bss->radius_das_shared_secret_len = os_strlen(secret);
 584
 585         return 0;
 586 }
 587 #endif /* CONFIG_NO_RADIUS */
 588
 589
 590 static int hostapd_config_parse_key_mgmt(int line, const char *value)
 591 {
 592         int val = 0, last;
 593         char *start, *end, *buf;
 594
 595         buf = os_strdup(value);
 596         if (buf == NULL)
 597                 return -1;
 598         start = buf;
 599
 600         while (*start != '\0') {
 601                 while (*start == ' ' || *start == '\t')
 602                         start++;
 603                 if (*start == '\0')
 604                         break;
 605                 end = start;
 606                 while (*end != ' ' && *end != '\t' && *end != '\0')
 607                         end++;
 608                 last = *end == '\0';
 609                 *end = '\0';
 610                 if (os_strcmp(start, "WPA-PSK") == 0)
 611                         val |= WPA_KEY_MGMT_PSK;
 612                 else if (os_strcmp(start, "WPA-EAP") == 0)
 613                         val |= WPA_KEY_MGMT_IEEE8021X;
 614 #ifdef CONFIG_IEEE80211R
 615                 else if (os_strcmp(start, "FT-PSK") == 0)
 616                         val |= WPA_KEY_MGMT_FT_PSK;
 617                 else if (os_strcmp(start, "FT-EAP") == 0)
 618                         val |= WPA_KEY_MGMT_FT_IEEE8021X;
 619 #endif /* CONFIG_IEEE80211R */
 620 #ifdef CONFIG_IEEE80211W
 621                 else if (os_strcmp(start, "WPA-PSK-SHA256") == 0)
 622                         val |= WPA_KEY_MGMT_PSK_SHA256;
 623                 else if (os_strcmp(start, "WPA-EAP-SHA256") == 0)
 624                         val |= WPA_KEY_MGMT_IEEE8021X_SHA256;
 625 #endif /* CONFIG_IEEE80211W */
 626 #ifdef CONFIG_SAE
 627                 else if (os_strcmp(start, "SAE") == 0)
 628                         val |= WPA_KEY_MGMT_SAE;
 629                 else if (os_strcmp(start, "FT-SAE") == 0)
 630                         val |= WPA_KEY_MGMT_FT_SAE;
 631 #endif /* CONFIG_SAE */
 632                 else {
 633                         wpa_printf(MSG_ERROR, "Line %d: invalid key_mgmt '%s'",
 634                                    line, start);
 635                         os_free(buf);
 636                         return -1;
 637                 }
 638
 639                 if (last)
 640                         break;
 641                 start = end + 1;
 642         }
 643
 644         os_free(buf);
 645         if (val == 0) {
 646                 wpa_printf(MSG_ERROR, "Line %d: no key_mgmt values "
 647                            "configured.", line);
 648                 return -1;
 649         }
 650
 651         return val;
 652 }
 653
 654
 655 static int hostapd_config_parse_cipher(int line, const char *value)
 656 {
 657         int val = wpa_parse_cipher(value);
 658         if (val < 0) {
 659                 wpa_printf(MSG_ERROR, "Line %d: invalid cipher '%s'.",
 660                            line, value);
 661                 return -1;
 662         }
 663         if (val == 0) {
 664                 wpa_printf(MSG_ERROR, "Line %d: no cipher values configured.",
 665                            line);
 666                 return -1;
 667         }
 668         return val;
 669 }
 670
 671
 672 static int hostapd_config_read_wep(struct hostapd_wep_keys *wep, int keyidx,
 673                                    char *val)
 674 {
 675         size_t len = os_strlen(val);
 676
 677         if (keyidx < 0 || keyidx > 3 || wep->key[keyidx] != NULL)
 678                 return -1;
 679
 680         if (val[0] == '"') {
 681                 if (len < 2 || val[len - 1] != '"')
 682                         return -1;
 683                 len -= 2;
 684                 wep->key[keyidx] = os_malloc(len);
 685                 if (wep->key[keyidx] == NULL)
 686                         return -1;
 687                 os_memcpy(wep->key[keyidx], val + 1, len);
 688                 wep->len[keyidx] = len;
 689         } else {
 690                 if (len & 1)
 691                         return -1;
 692                 len /= 2;
 693                 wep->key[keyidx] = os_malloc(len);
 694                 if (wep->key[keyidx] == NULL)
 695                         return -1;
 696                 wep->len[keyidx] = len;
 697                 if (hexstr2bin(val, wep->key[keyidx], len) < 0)
 698                         return -1;
 699         }
 700
 701         wep->keys_set++;
 702
 703         return 0;
 704 }
 705
 706
 707 static int hostapd_parse_intlist(int **int_list, char *val)
 708 {
 709         int *list;
 710         int count;
 711         char *pos, *end;
 712
 713         os_free(*int_list);
 714         *int_list = NULL;
 715
 716         pos = val;
 717         count = 0;
 718         while (*pos != '\0') {
 719                 if (*pos == ' ')
 720                         count++;
 721                 pos++;
 722         }
 723
 724         list = os_malloc(sizeof(int) * (count + 2));
 725         if (list == NULL)
 726                 return -1;
 727         pos = val;
 728         count = 0;
 729         while (*pos != '\0') {
 730                 end = os_strchr(pos, ' ');
 731                 if (end)
 732                         *end = '\0';
 733
 734                 list[count++] = atoi(pos);
 735                 if (!end)
 736                         break;
 737                 pos = end + 1;
 738         }
 739         list[count] = -1;
 740
 741         *int_list = list;
 742         return 0;
 743 }
 744
 745
 746 static int hostapd_config_bss(struct hostapd_config *conf, const char *ifname)
 747 {
 748         struct hostapd_bss_config **all, *bss;
 749
 750         if (*ifname == '\0')
 751                 return -1;
 752
 753         all = os_realloc_array(conf->bss, conf->num_bss + 1,
 754                                sizeof(struct hostapd_bss_config *));
 755         if (all == NULL) {
 756                 wpa_printf(MSG_ERROR, "Failed to allocate memory for "
 757                            "multi-BSS entry");
 758                 return -1;
 759         }
 760         conf->bss = all;
 761
 762         bss = os_zalloc(sizeof(*bss));
 763         if (bss == NULL)
 764                 return -1;
 765         bss->radius = os_zalloc(sizeof(*bss->radius));
 766         if (bss->radius == NULL) {
 767                 wpa_printf(MSG_ERROR, "Failed to allocate memory for "
 768                            "multi-BSS RADIUS data");
 769                 os_free(bss);
 770                 return -1;
 771         }
 772
 773         conf->bss[conf->num_bss++] = bss;
 774         conf->last_bss = bss;
 775
 776         hostapd_config_defaults_bss(bss);
 777         os_strlcpy(bss->iface, ifname, sizeof(bss->iface));
 778         os_memcpy(bss->ssid.vlan, bss->iface, IFNAMSIZ + 1);
 779
 780         return 0;
 781 }
 782
 783
 784 /* convert floats with one decimal place to value*10 int, i.e.,
 785  * "1.5" will return 15 */
 786 static int hostapd_config_read_int10(const char *value)
 787 {
 788         int i, d;
 789         char *pos;
 790
 791         i = atoi(value);
 792         pos = os_strchr(value, '.');
 793         d = 0;
 794         if (pos) {
 795                 pos++;
 796                 if (*pos >= '0' && *pos <= '9')
 797                         d = *pos - '0';
 798         }
 799
 800         return i * 10 + d;
 801 }
 802
 803
 804 static int valid_cw(int cw)
 805 {
 806         return (cw == 1 || cw == 3 || cw == 7 || cw == 15 || cw == 31 ||
 807                 cw == 63 || cw == 127 || cw == 255 || cw == 511 || cw == 1023);
 808 }
 809
 810
 811 enum {
 812         IEEE80211_TX_QUEUE_DATA0 = 0, /* used for EDCA AC_VO data */
 813         IEEE80211_TX_QUEUE_DATA1 = 1, /* used for EDCA AC_VI data */
 814         IEEE80211_TX_QUEUE_DATA2 = 2, /* used for EDCA AC_BE data */
 815         IEEE80211_TX_QUEUE_DATA3 = 3 /* used for EDCA AC_BK data */
 816 };
 817
 818 static int hostapd_config_tx_queue(struct hostapd_config *conf, char *name,
 819                                    char *val)
 820 {
 821         int num;
 822         char *pos;
 823         struct hostapd_tx_queue_params *queue;
 824
 825         /* skip 'tx_queue_' prefix */
 826         pos = name + 9;
 827         if (os_strncmp(pos, "data", 4) == 0 &&
 828             pos[4] >= '0' && pos[4] <= '9' && pos[5] == '_') {
 829                 num = pos[4] - '0';
 830                 pos += 6;
 831         } else if (os_strncmp(pos, "after_beacon_", 13) == 0 ||
 832                    os_strncmp(pos, "beacon_", 7) == 0) {
 833                 wpa_printf(MSG_INFO, "DEPRECATED: '%s' not used", name);
 834                 return 0;
 835         } else {
 836                 wpa_printf(MSG_ERROR, "Unknown tx_queue name '%s'", pos);
 837                 return -1;
 838         }
 839
 840         if (num >= NUM_TX_QUEUES) {
 841                 /* for backwards compatibility, do not trigger failure */
 842                 wpa_printf(MSG_INFO, "DEPRECATED: '%s' not used", name);
 843                 return 0;
 844         }
 845
 846         queue = &conf->tx_queue[num];
 847
 848         if (os_strcmp(pos, "aifs") == 0) {
 849                 queue->aifs = atoi(val);
 850                 if (queue->aifs < 0 || queue->aifs > 255) {
 851                         wpa_printf(MSG_ERROR, "Invalid AIFS value %d",
 852                                    queue->aifs);
 853                         return -1;
 854                 }
 855         } else if (os_strcmp(pos, "cwmin") == 0) {
 856                 queue->cwmin = atoi(val);
 857                 if (!valid_cw(queue->cwmin)) {
 858                         wpa_printf(MSG_ERROR, "Invalid cwMin value %d",
 859                                    queue->cwmin);
 860                         return -1;
 861                 }
 862         } else if (os_strcmp(pos, "cwmax") == 0) {
 863                 queue->cwmax = atoi(val);
 864                 if (!valid_cw(queue->cwmax)) {
 865                         wpa_printf(MSG_ERROR, "Invalid cwMax value %d",
 866                                    queue->cwmax);
 867                         return -1;
 868                 }
 869         } else if (os_strcmp(pos, "burst") == 0) {
 870                 queue->burst = hostapd_config_read_int10(val);
 871         } else {
 872                 wpa_printf(MSG_ERROR, "Unknown tx_queue field '%s'", pos);
 873                 return -1;
 874         }
 875
 876         return 0;
 877 }
 878
 879
 880 #ifdef CONFIG_IEEE80211R
 881 static int add_r0kh(struct hostapd_bss_config *bss, char *value)
 882 {
 883         struct ft_remote_r0kh *r0kh;
 884         char *pos, *next;
 885
 886         r0kh = os_zalloc(sizeof(*r0kh));
 887         if (r0kh == NULL)
 888                 return -1;
 889
 890         /* 02:01:02:03:04:05 a.example.com 000102030405060708090a0b0c0d0e0f */
 891         pos = value;
 892         next = os_strchr(pos, ' ');
 893         if (next)
 894                 *next++ = '\0';
 895         if (next == NULL || hwaddr_aton(pos, r0kh->addr)) {
 896                 wpa_printf(MSG_ERROR, "Invalid R0KH MAC address: '%s'", pos);
 897                 os_free(r0kh);
 898                 return -1;
 899         }
 900
 901         pos = next;
 902         next = os_strchr(pos, ' ');
 903         if (next)
 904                 *next++ = '\0';
 905         if (next == NULL || next - pos > FT_R0KH_ID_MAX_LEN) {
 906                 wpa_printf(MSG_ERROR, "Invalid R0KH-ID: '%s'", pos);
 907                 os_free(r0kh);
 908                 return -1;
 909         }
 910         r0kh->id_len = next - pos - 1;
 911         os_memcpy(r0kh->id, pos, r0kh->id_len);
 912
 913         pos = next;
 914         if (hexstr2bin(pos, r0kh->key, sizeof(r0kh->key))) {
 915                 wpa_printf(MSG_ERROR, "Invalid R0KH key: '%s'", pos);
 916                 os_free(r0kh);
 917                 return -1;
 918         }
 919
 920         r0kh->next = bss->r0kh_list;
 921         bss->r0kh_list = r0kh;
 922
 923         return 0;
 924 }
 925
 926
 927 static int add_r1kh(struct hostapd_bss_config *bss, char *value)
 928 {
 929         struct ft_remote_r1kh *r1kh;
 930         char *pos, *next;
 931
 932         r1kh = os_zalloc(sizeof(*r1kh));
 933         if (r1kh == NULL)
 934                 return -1;
 935
 936         /* 02:01:02:03:04:05 02:01:02:03:04:05
 937          * 000102030405060708090a0b0c0d0e0f */
 938         pos = value;
 939         next = os_strchr(pos, ' ');
 940         if (next)
 941                 *next++ = '\0';
 942         if (next == NULL || hwaddr_aton(pos, r1kh->addr)) {
 943                 wpa_printf(MSG_ERROR, "Invalid R1KH MAC address: '%s'", pos);
 944                 os_free(r1kh);
 945                 return -1;
 946         }
 947
 948         pos = next;
 949         next = os_strchr(pos, ' ');
 950         if (next)
 951                 *next++ = '\0';
 952         if (next == NULL || hwaddr_aton(pos, r1kh->id)) {
 953                 wpa_printf(MSG_ERROR, "Invalid R1KH-ID: '%s'", pos);
 954                 os_free(r1kh);
 955                 return -1;
 956         }
 957
 958         pos = next;
 959         if (hexstr2bin(pos, r1kh->key, sizeof(r1kh->key))) {
 960                 wpa_printf(MSG_ERROR, "Invalid R1KH key: '%s'", pos);
 961                 os_free(r1kh);
 962                 return -1;
 963         }
 964
 965         r1kh->next = bss->r1kh_list;
 966         bss->r1kh_list = r1kh;
 967
 968         return 0;
 969 }
 970 #endif /* CONFIG_IEEE80211R */
 971
 972
 973 #ifdef CONFIG_IEEE80211N
 974 static int hostapd_config_ht_capab(struct hostapd_config *conf,
 975                                    const char *capab)
 976 {
 977         if (os_strstr(capab, "[LDPC]"))
 978                 conf->ht_capab |= HT_CAP_INFO_LDPC_CODING_CAP;
 979         if (os_strstr(capab, "[HT40-]")) {
 980                 conf->ht_capab |= HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET;
 981                 conf->secondary_channel = -1;
 982         }
 983         if (os_strstr(capab, "[HT40+]")) {
 984                 conf->ht_capab |= HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET;
 985                 conf->secondary_channel = 1;
 986         }
 987         if (os_strstr(capab, "[SMPS-STATIC]")) {
 988                 conf->ht_capab &= ~HT_CAP_INFO_SMPS_MASK;
 989                 conf->ht_capab |= HT_CAP_INFO_SMPS_STATIC;
 990         }
 991         if (os_strstr(capab, "[SMPS-DYNAMIC]")) {
 992                 conf->ht_capab &= ~HT_CAP_INFO_SMPS_MASK;
 993                 conf->ht_capab |= HT_CAP_INFO_SMPS_DYNAMIC;
 994         }
 995         if (os_strstr(capab, "[GF]"))
 996                 conf->ht_capab |= HT_CAP_INFO_GREEN_FIELD;
 997         if (os_strstr(capab, "[SHORT-GI-20]"))
 998                 conf->ht_capab |= HT_CAP_INFO_SHORT_GI20MHZ;
 999         if (os_strstr(capab, "[SHORT-GI-40]"))
1000                 conf->ht_capab |= HT_CAP_INFO_SHORT_GI40MHZ;
1001         if (os_strstr(capab, "[TX-STBC]"))
1002                 conf->ht_capab |= HT_CAP_INFO_TX_STBC;
1003         if (os_strstr(capab, "[RX-STBC1]")) {
1004                 conf->ht_capab &= ~HT_CAP_INFO_RX_STBC_MASK;
1005                 conf->ht_capab |= HT_CAP_INFO_RX_STBC_1;
1006         }
1007         if (os_strstr(capab, "[RX-STBC12]")) {
1008                 conf->ht_capab &= ~HT_CAP_INFO_RX_STBC_MASK;
1009                 conf->ht_capab |= HT_CAP_INFO_RX_STBC_12;
1010         }
1011         if (os_strstr(capab, "[RX-STBC123]")) {
1012                 conf->ht_capab &= ~HT_CAP_INFO_RX_STBC_MASK;
1013                 conf->ht_capab |= HT_CAP_INFO_RX_STBC_123;
1014         }
1015         if (os_strstr(capab, "[DELAYED-BA]"))
1016                 conf->ht_capab |= HT_CAP_INFO_DELAYED_BA;
1017         if (os_strstr(capab, "[MAX-AMSDU-7935]"))
1018                 conf->ht_capab |= HT_CAP_INFO_MAX_AMSDU_SIZE;
1019         if (os_strstr(capab, "[DSSS_CCK-40]"))
1020                 conf->ht_capab |= HT_CAP_INFO_DSSS_CCK40MHZ;
1021         if (os_strstr(capab, "[PSMP]"))
1022                 conf->ht_capab |= HT_CAP_INFO_PSMP_SUPP;
1023         if (os_strstr(capab, "[LSIG-TXOP-PROT]"))
1024                 conf->ht_capab |= HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT;
1025
1026         return 0;
1027 }
1028 #endif /* CONFIG_IEEE80211N */
1029
1030
1031 #ifdef CONFIG_IEEE80211AC
1032 static int hostapd_config_vht_capab(struct hostapd_config *conf,
1033                                     const char *capab)
1034 {
1035         if (os_strstr(capab, "[MAX-MPDU-7991]"))
1036                 conf->vht_capab |= VHT_CAP_MAX_MPDU_LENGTH_7991;
1037         if (os_strstr(capab, "[MAX-MPDU-11454]"))
1038                 conf->vht_capab |= VHT_CAP_MAX_MPDU_LENGTH_11454;
1039         if (os_strstr(capab, "[VHT160]"))
1040                 conf->vht_capab |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
1041         if (os_strstr(capab, "[VHT160-80PLUS80]"))
1042                 conf->vht_capab |= VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
1043         if (os_strstr(capab, "[VHT160-80PLUS80]"))
1044                 conf->vht_capab |= VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
1045         if (os_strstr(capab, "[RXLDPC]"))
1046                 conf->vht_capab |= VHT_CAP_RXLDPC;
1047         if (os_strstr(capab, "[SHORT-GI-80]"))
1048                 conf->vht_capab |= VHT_CAP_SHORT_GI_80;
1049         if (os_strstr(capab, "[SHORT-GI-160]"))
1050                 conf->vht_capab |= VHT_CAP_SHORT_GI_160;
1051         if (os_strstr(capab, "[TX-STBC-2BY1]"))
1052                 conf->vht_capab |= VHT_CAP_TXSTBC;
1053         if (os_strstr(capab, "[RX-STBC-1]"))
1054                 conf->vht_capab |= VHT_CAP_RXSTBC_1;
1055         if (os_strstr(capab, "[RX-STBC-12]"))
1056                 conf->vht_capab |= VHT_CAP_RXSTBC_2;
1057         if (os_strstr(capab, "[RX-STBC-123]"))
1058                 conf->vht_capab |= VHT_CAP_RXSTBC_3;
1059         if (os_strstr(capab, "[RX-STBC-1234]"))
1060                 conf->vht_capab |= VHT_CAP_RXSTBC_4;
1061         if (os_strstr(capab, "[SU-BEAMFORMER]"))
1062                 conf->vht_capab |= VHT_CAP_SU_BEAMFORMER_CAPABLE;
1063         if (os_strstr(capab, "[SU-BEAMFORMEE]"))
1064                 conf->vht_capab |= VHT_CAP_SU_BEAMFORMEE_CAPABLE;
1065         if (os_strstr(capab, "[BF-ANTENNA-2]") &&
1066             (conf->vht_capab & VHT_CAP_SU_BEAMFORMEE_CAPABLE))
1067                 conf->vht_capab |= (1 << VHT_CAP_BEAMFORMEE_STS_OFFSET);
1068         if (os_strstr(capab, "[SOUNDING-DIMENSION-2]") &&
1069             (conf->vht_capab & VHT_CAP_SU_BEAMFORMER_CAPABLE))
1070                 conf->vht_capab |= (1 << VHT_CAP_SOUNDING_DIMENSION_OFFSET);
1071         if (os_strstr(capab, "[MU-BEAMFORMER]"))
1072                 conf->vht_capab |= VHT_CAP_MU_BEAMFORMER_CAPABLE;
1073         if (os_strstr(capab, "[MU-BEAMFORMEE]"))
1074                 conf->vht_capab |= VHT_CAP_MU_BEAMFORMEE_CAPABLE;
1075         if (os_strstr(capab, "[VHT-TXOP-PS]"))
1076                 conf->vht_capab |= VHT_CAP_VHT_TXOP_PS;
1077         if (os_strstr(capab, "[HTC-VHT]"))
1078                 conf->vht_capab |= VHT_CAP_HTC_VHT;
1079         if (os_strstr(capab, "[MAX-A-MPDU-LEN-EXP0]"))
1080                 conf->vht_capab |= VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT;
1081         if (os_strstr(capab, "[VHT-LINK-ADAPT2]") &&
1082             (conf->vht_capab & VHT_CAP_HTC_VHT))
1083                 conf->vht_capab |= VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB;
1084         if (os_strstr(capab, "[VHT-LINK-ADAPT3]") &&
1085             (conf->vht_capab & VHT_CAP_HTC_VHT))
1086                 conf->vht_capab |= VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB;
1087         if (os_strstr(capab, "[RX-ANTENNA-PATTERN]"))
1088                 conf->vht_capab |= VHT_CAP_RX_ANTENNA_PATTERN;
1089         if (os_strstr(capab, "[TX-ANTENNA-PATTERN]"))
1090                 conf->vht_capab |= VHT_CAP_TX_ANTENNA_PATTERN;
1091         return 0;
1092 }
1093 #endif /* CONFIG_IEEE80211AC */
1094
1095
1096 #ifdef CONFIG_INTERWORKING
1097 static int parse_roaming_consortium(struct hostapd_bss_config *bss, char *pos,
1098                                     int line)
1099 {
1100         size_t len = os_strlen(pos);
1101         u8 oi[MAX_ROAMING_CONSORTIUM_LEN];
1102
1103         struct hostapd_roaming_consortium *rc;
1104
1105         if ((len & 1) || len < 2 * 3 || len / 2 > MAX_ROAMING_CONSORTIUM_LEN ||
1106             hexstr2bin(pos, oi, len / 2)) {
1107                 wpa_printf(MSG_ERROR, "Line %d: invalid roaming_consortium "
1108                            "'%s'", line, pos);
1109                 return -1;
1110         }
1111         len /= 2;
1112
1113         rc = os_realloc_array(bss->roaming_consortium,
1114                               bss->roaming_consortium_count + 1,
1115                               sizeof(struct hostapd_roaming_consortium));
1116         if (rc == NULL)
1117                 return -1;
1118
1119         os_memcpy(rc[bss->roaming_consortium_count].oi, oi, len);
1120         rc[bss->roaming_consortium_count].len = len;
1121
1122         bss->roaming_consortium = rc;
1123         bss->roaming_consortium_count++;
1124
1125         return 0;
1126 }
1127
1128
1129 static int parse_lang_string(struct hostapd_lang_string **array,
1130                              unsigned int *count, char *pos)
1131 {
1132         char *sep, *str = NULL;
1133         size_t clen, nlen, slen;
1134         struct hostapd_lang_string *ls;
1135         int ret = -1;
1136
1137         if (*pos == '"' || (*pos == 'P' && pos[1] == '"')) {
1138                 str = wpa_config_parse_string(pos, &slen);
1139                 if (!str)
1140                         return -1;
1141                 pos = str;
1142         }
1143
1144         sep = os_strchr(pos, ':');
1145         if (sep == NULL)
1146                 goto fail;
1147         *sep++ = '\0';
1148
1149         clen = os_strlen(pos);
1150         if (clen < 2 || clen > sizeof(ls->lang))
1151                 goto fail;
1152         nlen = os_strlen(sep);
1153         if (nlen > 252)
1154                 goto fail;
1155
1156         ls = os_realloc_array(*array, *count + 1,
1157                               sizeof(struct hostapd_lang_string));
1158         if (ls == NULL)
1159                 goto fail;
1160
1161         *array = ls;
1162         ls = &(*array)[*count];
1163         (*count)++;
1164
1165         os_memset(ls->lang, 0, sizeof(ls->lang));
1166         os_memcpy(ls->lang, pos, clen);
1167         ls->name_len = nlen;
1168         os_memcpy(ls->name, sep, nlen);
1169
1170         ret = 0;
1171 fail:
1172         os_free(str);
1173         return ret;
1174 }
1175
1176
1177 static int parse_venue_name(struct hostapd_bss_config *bss, char *pos,
1178                             int line)
1179 {
1180         if (parse_lang_string(&bss->venue_name, &bss->venue_name_count, pos)) {
1181                 wpa_printf(MSG_ERROR, "Line %d: Invalid venue_name '%s'",
1182                            line, pos);
1183                 return -1;
1184         }
1185         return 0;
1186 }
1187
1188
1189 static int parse_3gpp_cell_net(struct hostapd_bss_config *bss, char *buf,
1190                                int line)
1191 {
1192         size_t count;
1193         char *pos;
1194         u8 *info = NULL, *ipos;
1195
1196         /* format: <MCC1,MNC1>[;<MCC2,MNC2>][;...] */
1197
1198         count = 1;
1199         for (pos = buf; *pos; pos++) {
1200                 if ((*pos < '0' && *pos > '9') && *pos != ';' && *pos != ',')
1201                         goto fail;
1202                 if (*pos == ';')
1203                         count++;
1204         }
1205         if (1 + count * 3 > 0x7f)
1206                 goto fail;
1207
1208         info = os_zalloc(2 + 3 + count * 3);
1209         if (info == NULL)
1210                 return -1;
1211
1212         ipos = info;
1213         *ipos++ = 0; /* GUD - Version 1 */
1214         *ipos++ = 3 + count * 3; /* User Data Header Length (UDHL) */
1215         *ipos++ = 0; /* PLMN List IEI */
1216         /* ext(b8) | Length of PLMN List value contents(b7..1) */
1217         *ipos++ = 1 + count * 3;
1218         *ipos++ = count; /* Number of PLMNs */
1219
1220         pos = buf;
1221         while (pos && *pos) {
1222                 char *mcc, *mnc;
1223                 size_t mnc_len;
1224
1225                 mcc = pos;
1226                 mnc = os_strchr(pos, ',');
1227                 if (mnc == NULL)
1228                         goto fail;
1229                 *mnc++ = '\0';
1230                 pos = os_strchr(mnc, ';');
1231                 if (pos)
1232                         *pos++ = '\0';
1233
1234                 mnc_len = os_strlen(mnc);
1235                 if (os_strlen(mcc) != 3 || (mnc_len != 2 && mnc_len != 3))
1236                         goto fail;
1237
1238                 /* BC coded MCC,MNC */
1239                 /* MCC digit 2 | MCC digit 1 */
1240                 *ipos++ = ((mcc[1] - '0') << 4) | (mcc[0] - '0');
1241                 /* MNC digit 3 | MCC digit 3 */
1242                 *ipos++ = (((mnc_len == 2) ? 0xf0 : ((mnc[2] - '0') << 4))) |
1243                         (mcc[2] - '0');
1244                 /* MNC digit 2 | MNC digit 1 */
1245                 *ipos++ = ((mnc[1] - '0') << 4) | (mnc[0] - '0');
1246         }
1247
1248         os_free(bss->anqp_3gpp_cell_net);
1249         bss->anqp_3gpp_cell_net = info;
1250         bss->anqp_3gpp_cell_net_len = 2 + 3 + 3 * count;
1251         wpa_hexdump(MSG_MSGDUMP, "3GPP Cellular Network information",
1252                     bss->anqp_3gpp_cell_net, bss->anqp_3gpp_cell_net_len);
1253
1254         return 0;
1255
1256 fail:
1257         wpa_printf(MSG_ERROR, "Line %d: Invalid anqp_3gpp_cell_net: %s",
1258                    line, buf);
1259         os_free(info);
1260         return -1;
1261 }
1262
1263
1264 static int parse_nai_realm(struct hostapd_bss_config *bss, char *buf, int line)
1265 {
1266         struct hostapd_nai_realm_data *realm;
1267         size_t i, j, len;
1268         int *offsets;
1269         char *pos, *end, *rpos;
1270
1271         offsets = os_calloc(bss->nai_realm_count * MAX_NAI_REALMS,
1272                             sizeof(int));
1273         if (offsets == NULL)
1274                 return -1;
1275
1276         for (i = 0; i < bss->nai_realm_count; i++) {
1277                 realm = &bss->nai_realm_data[i];
1278                 for (j = 0; j < MAX_NAI_REALMS; j++) {
1279                         offsets[i * MAX_NAI_REALMS + j] =
1280                                 realm->realm[j] ?
1281                                 realm->realm[j] - realm->realm_buf : -1;
1282                 }
1283         }
1284
1285         realm = os_realloc_array(bss->nai_realm_data, bss->nai_realm_count + 1,
1286                                  sizeof(struct hostapd_nai_realm_data));
1287         if (realm == NULL) {
1288                 os_free(offsets);
1289                 return -1;
1290         }
1291         bss->nai_realm_data = realm;
1292
1293         /* patch the pointers after realloc */
1294         for (i = 0; i < bss->nai_realm_count; i++) {
1295                 realm = &bss->nai_realm_data[i];
1296                 for (j = 0; j < MAX_NAI_REALMS; j++) {
1297                         int offs = offsets[i * MAX_NAI_REALMS + j];
1298                         if (offs >= 0)
1299                                 realm->realm[j] = realm->realm_buf + offs;
1300                         else
1301                                 realm->realm[j] = NULL;
1302                 }
1303         }
1304         os_free(offsets);
1305
1306         realm = &bss->nai_realm_data[bss->nai_realm_count];
1307         os_memset(realm, 0, sizeof(*realm));
1308
1309         pos = buf;
1310         realm->encoding = atoi(pos);
1311         pos = os_strchr(pos, ',');
1312         if (pos == NULL)
1313                 goto fail;
1314         pos++;
1315
1316         end = os_strchr(pos, ',');
1317         if (end) {
1318                 len = end - pos;
1319                 *end = '\0';
1320         } else {
1321                 len = os_strlen(pos);
1322         }
1323
1324         if (len > MAX_NAI_REALMLEN) {
1325                 wpa_printf(MSG_ERROR, "Too long a realm string (%d > max %d "
1326                            "characters)", (int) len, MAX_NAI_REALMLEN);
1327                 goto fail;
1328         }
1329         os_memcpy(realm->realm_buf, pos, len);
1330
1331         if (end)
1332                 pos = end + 1;
1333         else
1334                 pos = NULL;
1335
1336         while (pos && *pos) {
1337                 struct hostapd_nai_realm_eap *eap;
1338
1339                 if (realm->eap_method_count >= MAX_NAI_EAP_METHODS) {
1340                         wpa_printf(MSG_ERROR, "Too many EAP methods");
1341                         goto fail;
1342                 }
1343
1344                 eap = &realm->eap_method[realm->eap_method_count];
1345                 realm->eap_method_count++;
1346
1347                 end = os_strchr(pos, ',');
1348                 if (end == NULL)
1349                         end = pos + os_strlen(pos);
1350
1351                 eap->eap_method = atoi(pos);
1352                 for (;;) {
1353                         pos = os_strchr(pos, '[');
1354                         if (pos == NULL || pos > end)
1355                                 break;
1356                         pos++;
1357                         if (eap->num_auths >= MAX_NAI_AUTH_TYPES) {
1358                                 wpa_printf(MSG_ERROR, "Too many auth params");
1359                                 goto fail;
1360                         }
1361                         eap->auth_id[eap->num_auths] = atoi(pos);
1362                         pos = os_strchr(pos, ':');
1363                         if (pos == NULL || pos > end)
1364                                 goto fail;
1365                         pos++;
1366                         eap->auth_val[eap->num_auths] = atoi(pos);
1367                         pos = os_strchr(pos, ']');
1368                         if (pos == NULL || pos > end)
1369                                 goto fail;
1370                         pos++;
1371                         eap->num_auths++;
1372                 }
1373
1374                 if (*end != ',')
1375                         break;
1376
1377                 pos = end + 1;
1378         }
1379
1380         /* Split realm list into null terminated realms */
1381         rpos = realm->realm_buf;
1382         i = 0;
1383         while (*rpos) {
1384                 if (i >= MAX_NAI_REALMS) {
1385                         wpa_printf(MSG_ERROR, "Too many realms");
1386                         goto fail;
1387                 }
1388                 realm->realm[i++] = rpos;
1389                 rpos = os_strchr(rpos, ';');
1390                 if (rpos == NULL)
1391                         break;
1392                 *rpos++ = '\0';
1393         }
1394
1395         bss->nai_realm_count++;
1396
1397         return 0;
1398
1399 fail:
1400         wpa_printf(MSG_ERROR, "Line %d: invalid nai_realm '%s'", line, buf);
1401         return -1;
1402 }
1403
1404
1405 static int parse_qos_map_set(struct hostapd_bss_config *bss,
1406                              char *buf, int line)
1407 {
1408         u8 qos_map_set[16 + 2 * 21], count = 0;
1409         char *pos = buf;
1410         int val;
1411
1412         for (;;) {
1413                 if (count == sizeof(qos_map_set)) {
1414                         wpa_printf(MSG_ERROR, "Line %d: Too many qos_map_set "
1415                                    "parameters '%s'", line, buf);
1416                         return -1;
1417                 }
1418
1419                 val = atoi(pos);
1420                 if (val > 255 || val < 0) {
1421                         wpa_printf(MSG_ERROR, "Line %d: Invalid qos_map_set "
1422                                    "'%s'", line, buf);
1423                         return -1;
1424                 }
1425
1426                 qos_map_set[count++] = val;
1427                 pos = os_strchr(pos, ',');
1428                 if (!pos)
1429                         break;
1430                 pos++;
1431         }
1432
1433         if (count < 16 || count & 1) {
1434                 wpa_printf(MSG_ERROR, "Line %d: Invalid qos_map_set '%s'",
1435                            line, buf);
1436                 return -1;
1437         }
1438
1439         os_memcpy(bss->qos_map_set, qos_map_set, count);
1440         bss->qos_map_set_len = count;
1441
1442         return 0;
1443 }
1444
1445 #endif /* CONFIG_INTERWORKING */
1446
1447
1448 #ifdef CONFIG_HS20
1449 static int hs20_parse_conn_capab(struct hostapd_bss_config *bss, char *buf,
1450                                  int line)
1451 {
1452         u8 *conn_cap;
1453         char *pos;
1454
1455         if (bss->hs20_connection_capability_len >= 0xfff0)
1456                 return -1;
1457
1458         conn_cap = os_realloc(bss->hs20_connection_capability,
1459                               bss->hs20_connection_capability_len + 4);
1460         if (conn_cap == NULL)
1461                 return -1;
1462
1463         bss->hs20_connection_capability = conn_cap;
1464         conn_cap += bss->hs20_connection_capability_len;
1465         pos = buf;
1466         conn_cap[0] = atoi(pos);
1467         pos = os_strchr(pos, ':');
1468         if (pos == NULL)
1469                 return -1;
1470         pos++;
1471         WPA_PUT_LE16(conn_cap + 1, atoi(pos));
1472         pos = os_strchr(pos, ':');
1473         if (pos == NULL)
1474                 return -1;
1475         pos++;
1476         conn_cap[3] = atoi(pos);
1477         bss->hs20_connection_capability_len += 4;
1478
1479         return 0;
1480 }
1481
1482
1483 static int hs20_parse_wan_metrics(struct hostapd_bss_config *bss, char *buf,
1484                                   int line)
1485 {
1486         u8 *wan_metrics;
1487         char *pos;
1488
1489         /* <WAN Info>:<DL Speed>:<UL Speed>:<DL Load>:<UL Load>:<LMD> */
1490
1491         wan_metrics = os_zalloc(13);
1492         if (wan_metrics == NULL)
1493                 return -1;
1494
1495         pos = buf;
1496         /* WAN Info */
1497         if (hexstr2bin(pos, wan_metrics, 1) < 0)
1498                 goto fail;
1499         pos += 2;
1500         if (*pos != ':')
1501                 goto fail;
1502         pos++;
1503
1504         /* Downlink Speed */
1505         WPA_PUT_LE32(wan_metrics + 1, atoi(pos));
1506         pos = os_strchr(pos, ':');
1507         if (pos == NULL)
1508                 goto fail;
1509         pos++;
1510
1511         /* Uplink Speed */
1512         WPA_PUT_LE32(wan_metrics + 5, atoi(pos));
1513         pos = os_strchr(pos, ':');
1514         if (pos == NULL)
1515                 goto fail;
1516         pos++;
1517
1518         /* Downlink Load */
1519         wan_metrics[9] = atoi(pos);
1520         pos = os_strchr(pos, ':');
1521         if (pos == NULL)
1522                 goto fail;
1523         pos++;
1524
1525         /* Uplink Load */
1526         wan_metrics[10] = atoi(pos);
1527         pos = os_strchr(pos, ':');
1528         if (pos == NULL)
1529                 goto fail;
1530         pos++;
1531
1532         /* LMD */
1533         WPA_PUT_LE16(wan_metrics + 11, atoi(pos));
1534
1535         os_free(bss->hs20_wan_metrics);
1536         bss->hs20_wan_metrics = wan_metrics;
1537
1538         return 0;
1539
1540 fail:
1541         wpa_printf(MSG_ERROR, "Line %d: Invalid hs20_wan_metrics '%s'",
1542                    line, pos);
1543         os_free(wan_metrics);
1544         return -1;
1545 }
1546
1547
1548 static int hs20_parse_oper_friendly_name(struct hostapd_bss_config *bss,
1549                                          char *pos, int line)
1550 {
1551         if (parse_lang_string(&bss->hs20_oper_friendly_name,
1552                               &bss->hs20_oper_friendly_name_count, pos)) {
1553                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
1554                            "hs20_oper_friendly_name '%s'", line, pos);
1555                 return -1;
1556         }
1557         return 0;
1558 }
1559 #endif /* CONFIG_HS20 */
1560
1561
1562 #ifdef CONFIG_WPS_NFC
1563 static struct wpabuf * hostapd_parse_bin(const char *buf)
1564 {
1565         size_t len;
1566         struct wpabuf *ret;
1567
1568         len = os_strlen(buf);
1569         if (len & 0x01)
1570                 return NULL;
1571         len /= 2;
1572
1573         ret = wpabuf_alloc(len);
1574         if (ret == NULL)
1575                 return NULL;
1576
1577         if (hexstr2bin(buf, wpabuf_put(ret, len), len)) {
1578                 wpabuf_free(ret);
1579                 return NULL;
1580         }
1581
1582         return ret;
1583 }
1584 #endif /* CONFIG_WPS_NFC */
1585
1586
1587 static int hostapd_config_fill(struct hostapd_config *conf,
1588                                struct hostapd_bss_config *bss,
1589                                char *buf, char *pos, int line)
1590 {
1591         int errors = 0;
1592
1593         {
1594                 if (os_strcmp(buf, "interface") == 0) {
1595                         os_strlcpy(conf->bss[0]->iface, pos,
1596                                    sizeof(conf->bss[0]->iface));
1597                 } else if (os_strcmp(buf, "bridge") == 0) {
1598                         os_strlcpy(bss->bridge, pos, sizeof(bss->bridge));
1599                 } else if (os_strcmp(buf, "vlan_bridge") == 0) {
1600                         os_strlcpy(bss->vlan_bridge, pos,
1601                                    sizeof(bss->vlan_bridge));
1602                 } else if (os_strcmp(buf, "wds_bridge") == 0) {
1603                         os_strlcpy(bss->wds_bridge, pos,
1604                                    sizeof(bss->wds_bridge));
1605                 } else if (os_strcmp(buf, "driver") == 0) {
1606                         int j;
1607                         /* clear to get error below if setting is invalid */
1608                         conf->driver = NULL;
1609                         for (j = 0; wpa_drivers[j]; j++) {
1610                                 if (os_strcmp(pos, wpa_drivers[j]->name) == 0)
1611                                 {
1612                                         conf->driver = wpa_drivers[j];
1613                                         break;
1614                                 }
1615                         }
1616                         if (conf->driver == NULL) {
1617                                 wpa_printf(MSG_ERROR, "Line %d: invalid/"
1618                                            "unknown driver '%s'", line, pos);
1619                                 errors++;
1620                         }
1621                 } else if (os_strcmp(buf, "debug") == 0) {
1622                         wpa_printf(MSG_DEBUG, "Line %d: DEPRECATED: 'debug' "
1623                                    "configuration variable is not used "
1624                                    "anymore", line);
1625                 } else if (os_strcmp(buf, "logger_syslog_level") == 0) {
1626                         bss->logger_syslog_level = atoi(pos);
1627                 } else if (os_strcmp(buf, "logger_stdout_level") == 0) {
1628                         bss->logger_stdout_level = atoi(pos);
1629                 } else if (os_strcmp(buf, "logger_syslog") == 0) {
1630                         bss->logger_syslog = atoi(pos);
1631                 } else if (os_strcmp(buf, "logger_stdout") == 0) {
1632                         bss->logger_stdout = atoi(pos);
1633                 } else if (os_strcmp(buf, "dump_file") == 0) {
1634                         wpa_printf(MSG_INFO, "Line %d: DEPRECATED: 'dump_file' configuration variable is not used anymore",
1635                                    line);
1636                 } else if (os_strcmp(buf, "ssid") == 0) {
1637                         bss->ssid.ssid_len = os_strlen(pos);
1638                         if (bss->ssid.ssid_len > HOSTAPD_MAX_SSID_LEN ||
1639                             bss->ssid.ssid_len < 1) {
1640                                 wpa_printf(MSG_ERROR, "Line %d: invalid SSID "
1641                                            "'%s'", line, pos);
1642                                 errors++;
1643                         } else {
1644                                 os_memcpy(bss->ssid.ssid, pos,
1645                                           bss->ssid.ssid_len);
1646                                 bss->ssid.ssid_set = 1;
1647                         }
1648                 } else if (os_strcmp(buf, "ssid2") == 0) {
1649                         size_t slen;
1650                         char *str = wpa_config_parse_string(pos, &slen);
1651                         if (str == NULL || slen < 1 ||
1652                                    slen > HOSTAPD_MAX_SSID_LEN) {
1653                                 wpa_printf(MSG_ERROR, "Line %d: invalid SSID "
1654                                            "'%s'", line, pos);
1655                                 errors++;
1656                         } else {
1657                                 os_memcpy(bss->ssid.ssid, str, slen);
1658                                 bss->ssid.ssid_len = slen;
1659                                 bss->ssid.ssid_set = 1;
1660                         }
1661                         os_free(str);
1662                 } else if (os_strcmp(buf, "utf8_ssid") == 0) {
1663                         bss->ssid.utf8_ssid = atoi(pos) > 0;
1664                 } else if (os_strcmp(buf, "macaddr_acl") == 0) {
1665                         bss->macaddr_acl = atoi(pos);
1666                         if (bss->macaddr_acl != ACCEPT_UNLESS_DENIED &&
1667                             bss->macaddr_acl != DENY_UNLESS_ACCEPTED &&
1668                             bss->macaddr_acl != USE_EXTERNAL_RADIUS_AUTH) {
1669                                 wpa_printf(MSG_ERROR, "Line %d: unknown "
1670                                            "macaddr_acl %d",
1671                                            line, bss->macaddr_acl);
1672                         }
1673                 } else if (os_strcmp(buf, "accept_mac_file") == 0) {
1674                         if (hostapd_config_read_maclist(pos, &bss->accept_mac,
1675                                                         &bss->num_accept_mac))
1676                         {
1677                                 wpa_printf(MSG_ERROR, "Line %d: Failed to "
1678                                            "read accept_mac_file '%s'",
1679                                            line, pos);
1680                                 errors++;
1681                         }
1682                 } else if (os_strcmp(buf, "deny_mac_file") == 0) {
1683                         if (hostapd_config_read_maclist(pos, &bss->deny_mac,
1684                                                         &bss->num_deny_mac)) {
1685                                 wpa_printf(MSG_ERROR, "Line %d: Failed to "
1686                                            "read deny_mac_file '%s'",
1687                                            line, pos);
1688                                 errors++;
1689                         }
1690                 } else if (os_strcmp(buf, "wds_sta") == 0) {
1691                         bss->wds_sta = atoi(pos);
1692                 } else if (os_strcmp(buf, "start_disabled") == 0) {
1693                         bss->start_disabled = atoi(pos);
1694                 } else if (os_strcmp(buf, "ap_isolate") == 0) {
1695                         bss->isolate = atoi(pos);
1696                 } else if (os_strcmp(buf, "ap_max_inactivity") == 0) {
1697                         bss->ap_max_inactivity = atoi(pos);
1698                 } else if (os_strcmp(buf, "skip_inactivity_poll") == 0) {
1699                         bss->skip_inactivity_poll = atoi(pos);
1700                 } else if (os_strcmp(buf, "country_code") == 0) {
1701                         os_memcpy(conf->country, pos, 2);
1702                         /* FIX: make this configurable */
1703                         conf->country[2] = ' ';
1704                 } else if (os_strcmp(buf, "ieee80211d") == 0) {
1705                         conf->ieee80211d = atoi(pos);
1706                 } else if (os_strcmp(buf, "ieee80211h") == 0) {
1707                         conf->ieee80211h = atoi(pos);
1708                 } else if (os_strcmp(buf, "ieee8021x") == 0) {
1709                         bss->ieee802_1x = atoi(pos);
1710                 } else if (os_strcmp(buf, "eapol_version") == 0) {
1711                         bss->eapol_version = atoi(pos);
1712                         if (bss->eapol_version < 1 ||
1713                             bss->eapol_version > 2) {
1714                                 wpa_printf(MSG_ERROR, "Line %d: invalid EAPOL "
1715                                            "version (%d): '%s'.",
1716                                            line, bss->eapol_version, pos);
1717                                 errors++;
1718                         } else
1719                                 wpa_printf(MSG_DEBUG, "eapol_version=%d",
1720                                            bss->eapol_version);
1721 #ifdef EAP_SERVER
1722                 } else if (os_strcmp(buf, "eap_authenticator") == 0) {
1723                         bss->eap_server = atoi(pos);
1724                         wpa_printf(MSG_ERROR, "Line %d: obsolete "
1725                                    "eap_authenticator used; this has been "
1726                                    "renamed to eap_server", line);
1727                 } else if (os_strcmp(buf, "eap_server") == 0) {
1728                         bss->eap_server = atoi(pos);
1729                 } else if (os_strcmp(buf, "eap_user_file") == 0) {
1730                         if (hostapd_config_read_eap_user(pos, bss))
1731                                 errors++;
1732                 } else if (os_strcmp(buf, "ca_cert") == 0) {
1733                         os_free(bss->ca_cert);
1734                         bss->ca_cert = os_strdup(pos);
1735                 } else if (os_strcmp(buf, "server_cert") == 0) {
1736                         os_free(bss->server_cert);
1737                         bss->server_cert = os_strdup(pos);
1738                 } else if (os_strcmp(buf, "private_key") == 0) {
1739                         os_free(bss->private_key);
1740                         bss->private_key = os_strdup(pos);
1741                 } else if (os_strcmp(buf, "private_key_passwd") == 0) {
1742                         os_free(bss->private_key_passwd);
1743                         bss->private_key_passwd = os_strdup(pos);
1744                 } else if (os_strcmp(buf, "check_crl") == 0) {
1745                         bss->check_crl = atoi(pos);
1746                 } else if (os_strcmp(buf, "ocsp_stapling_response") == 0) {
1747                         os_free(bss->ocsp_stapling_response);
1748                         bss->ocsp_stapling_response = os_strdup(pos);
1749                 } else if (os_strcmp(buf, "dh_file") == 0) {
1750                         os_free(bss->dh_file);
1751                         bss->dh_file = os_strdup(pos);
1752                 } else if (os_strcmp(buf, "fragment_size") == 0) {
1753                         bss->fragment_size = atoi(pos);
1754 #ifdef EAP_SERVER_FAST
1755                 } else if (os_strcmp(buf, "pac_opaque_encr_key") == 0) {
1756                         os_free(bss->pac_opaque_encr_key);
1757                         bss->pac_opaque_encr_key = os_malloc(16);
1758                         if (bss->pac_opaque_encr_key == NULL) {
1759                                 wpa_printf(MSG_ERROR, "Line %d: No memory for "
1760                                            "pac_opaque_encr_key", line);
1761                                 errors++;
1762                         } else if (hexstr2bin(pos, bss->pac_opaque_encr_key,
1763                                               16)) {
1764                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
1765                                            "pac_opaque_encr_key", line);
1766                                 errors++;
1767                         }
1768                 } else if (os_strcmp(buf, "eap_fast_a_id") == 0) {
1769                         size_t idlen = os_strlen(pos);
1770                         if (idlen & 1) {
1771                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
1772                                            "eap_fast_a_id", line);
1773                                 errors++;
1774                         } else {
1775                                 os_free(bss->eap_fast_a_id);
1776                                 bss->eap_fast_a_id = os_malloc(idlen / 2);
1777                                 if (bss->eap_fast_a_id == NULL ||
1778                                     hexstr2bin(pos, bss->eap_fast_a_id,
1779                                                idlen / 2)) {
1780                                         wpa_printf(MSG_ERROR, "Line %d: "
1781                                                    "Failed to parse "
1782                                                    "eap_fast_a_id", line);
1783                                         errors++;
1784                                 } else
1785                                         bss->eap_fast_a_id_len = idlen / 2;
1786                         }
1787                 } else if (os_strcmp(buf, "eap_fast_a_id_info") == 0) {
1788                         os_free(bss->eap_fast_a_id_info);
1789                         bss->eap_fast_a_id_info = os_strdup(pos);
1790                 } else if (os_strcmp(buf, "eap_fast_prov") == 0) {
1791                         bss->eap_fast_prov = atoi(pos);
1792                 } else if (os_strcmp(buf, "pac_key_lifetime") == 0) {
1793                         bss->pac_key_lifetime = atoi(pos);
1794                 } else if (os_strcmp(buf, "pac_key_refresh_time") == 0) {
1795                         bss->pac_key_refresh_time = atoi(pos);
1796 #endif /* EAP_SERVER_FAST */
1797 #ifdef EAP_SERVER_SIM
1798                 } else if (os_strcmp(buf, "eap_sim_db") == 0) {
1799                         os_free(bss->eap_sim_db);
1800                         bss->eap_sim_db = os_strdup(pos);
1801                 } else if (os_strcmp(buf, "eap_sim_aka_result_ind") == 0) {
1802                         bss->eap_sim_aka_result_ind = atoi(pos);
1803 #endif /* EAP_SERVER_SIM */
1804 #ifdef EAP_SERVER_TNC
1805                 } else if (os_strcmp(buf, "tnc") == 0) {
1806                         bss->tnc = atoi(pos);
1807 #endif /* EAP_SERVER_TNC */
1808 #ifdef EAP_SERVER_PWD
1809                 } else if (os_strcmp(buf, "pwd_group") == 0) {
1810                         bss->pwd_group = atoi(pos);
1811 #endif /* EAP_SERVER_PWD */
1812 #endif /* EAP_SERVER */
1813                 } else if (os_strcmp(buf, "eap_message") == 0) {
1814                         char *term;
1815                         bss->eap_req_id_text = os_strdup(pos);
1816                         if (bss->eap_req_id_text == NULL) {
1817                                 wpa_printf(MSG_ERROR, "Line %d: Failed to "
1818                                            "allocate memory for "
1819                                            "eap_req_id_text", line);
1820                                 errors++;
1821                                 return errors;
1822                         }
1823                         bss->eap_req_id_text_len =
1824                                 os_strlen(bss->eap_req_id_text);
1825                         term = os_strstr(bss->eap_req_id_text, "\\0");
1826                         if (term) {
1827                                 *term++ = '\0';
1828                                 os_memmove(term, term + 1,
1829                                            bss->eap_req_id_text_len -
1830                                            (term - bss->eap_req_id_text) - 1);
1831                                 bss->eap_req_id_text_len--;
1832                         }
1833                 } else if (os_strcmp(buf, "wep_key_len_broadcast") == 0) {
1834                         bss->default_wep_key_len = atoi(pos);
1835                         if (bss->default_wep_key_len > 13) {
1836                                 wpa_printf(MSG_ERROR, "Line %d: invalid WEP "
1837                                            "key len %lu (= %lu bits)", line,
1838                                            (unsigned long)
1839                                            bss->default_wep_key_len,
1840                                            (unsigned long)
1841                                            bss->default_wep_key_len * 8);
1842                                 errors++;
1843                         }
1844                 } else if (os_strcmp(buf, "wep_key_len_unicast") == 0) {
1845                         bss->individual_wep_key_len = atoi(pos);
1846                         if (bss->individual_wep_key_len < 0 ||
1847                             bss->individual_wep_key_len > 13) {
1848                                 wpa_printf(MSG_ERROR, "Line %d: invalid WEP "
1849                                            "key len %d (= %d bits)", line,
1850                                            bss->individual_wep_key_len,
1851                                            bss->individual_wep_key_len * 8);
1852                                 errors++;
1853                         }
1854                 } else if (os_strcmp(buf, "wep_rekey_period") == 0) {
1855                         bss->wep_rekeying_period = atoi(pos);
1856                         if (bss->wep_rekeying_period < 0) {
1857                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
1858                                            "period %d",
1859                                            line, bss->wep_rekeying_period);
1860                                 errors++;
1861                         }
1862                 } else if (os_strcmp(buf, "eap_reauth_period") == 0) {
1863                         bss->eap_reauth_period = atoi(pos);
1864                         if (bss->eap_reauth_period < 0) {
1865                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
1866                                            "period %d",
1867                                            line, bss->eap_reauth_period);
1868                                 errors++;
1869                         }
1870                 } else if (os_strcmp(buf, "eapol_key_index_workaround") == 0) {
1871                         bss->eapol_key_index_workaround = atoi(pos);
1872 #ifdef CONFIG_IAPP
1873                 } else if (os_strcmp(buf, "iapp_interface") == 0) {
1874                         bss->ieee802_11f = 1;
1875                         os_strlcpy(bss->iapp_iface, pos,
1876                                    sizeof(bss->iapp_iface));
1877 #endif /* CONFIG_IAPP */
1878                 } else if (os_strcmp(buf, "own_ip_addr") == 0) {
1879                         if (hostapd_parse_ip_addr(pos, &bss->own_ip_addr)) {
1880                                 wpa_printf(MSG_ERROR, "Line %d: invalid IP "
1881                                            "address '%s'", line, pos);
1882                                 errors++;
1883                         }
1884                 } else if (os_strcmp(buf, "nas_identifier") == 0) {
1885                         bss->nas_identifier = os_strdup(pos);
1886 #ifndef CONFIG_NO_RADIUS
1887                 } else if (os_strcmp(buf, "auth_server_addr") == 0) {
1888                         if (hostapd_config_read_radius_addr(
1889                                     &bss->radius->auth_servers,
1890                                     &bss->radius->num_auth_servers, pos, 1812,
1891                                     &bss->radius->auth_server)) {
1892                                 wpa_printf(MSG_ERROR, "Line %d: invalid IP "
1893                                            "address '%s'", line, pos);
1894                                 errors++;
1895                         }
1896                 } else if (bss->radius->auth_server &&
1897                            os_strcmp(buf, "auth_server_port") == 0) {
1898                         bss->radius->auth_server->port = atoi(pos);
1899                 } else if (bss->radius->auth_server &&
1900                            os_strcmp(buf, "auth_server_shared_secret") == 0) {
1901                         int len = os_strlen(pos);
1902                         if (len == 0) {
1903                                 /* RFC 2865, Ch. 3 */
1904                                 wpa_printf(MSG_ERROR, "Line %d: empty shared "
1905                                            "secret is not allowed.", line);
1906                                 errors++;
1907                         }
1908                         bss->radius->auth_server->shared_secret =
1909                                 (u8 *) os_strdup(pos);
1910                         bss->radius->auth_server->shared_secret_len = len;
1911                 } else if (os_strcmp(buf, "acct_server_addr") == 0) {
1912                         if (hostapd_config_read_radius_addr(
1913                                     &bss->radius->acct_servers,
1914                                     &bss->radius->num_acct_servers, pos, 1813,
1915                                     &bss->radius->acct_server)) {
1916                                 wpa_printf(MSG_ERROR, "Line %d: invalid IP "
1917                                            "address '%s'", line, pos);
1918                                 errors++;
1919                         }
1920                 } else if (bss->radius->acct_server &&
1921                            os_strcmp(buf, "acct_server_port") == 0) {
1922                         bss->radius->acct_server->port = atoi(pos);
1923                 } else if (bss->radius->acct_server &&
1924                            os_strcmp(buf, "acct_server_shared_secret") == 0) {
1925                         int len = os_strlen(pos);
1926                         if (len == 0) {
1927                                 /* RFC 2865, Ch. 3 */
1928                                 wpa_printf(MSG_ERROR, "Line %d: empty shared "
1929                                            "secret is not allowed.", line);
1930                                 errors++;
1931                         }
1932                         bss->radius->acct_server->shared_secret =
1933                                 (u8 *) os_strdup(pos);
1934                         bss->radius->acct_server->shared_secret_len = len;
1935                 } else if (os_strcmp(buf, "radius_retry_primary_interval") ==
1936                            0) {
1937                         bss->radius->retry_primary_interval = atoi(pos);
1938                 } else if (os_strcmp(buf, "radius_acct_interim_interval") == 0)
1939                 {
1940                         bss->acct_interim_interval = atoi(pos);
1941                 } else if (os_strcmp(buf, "radius_request_cui") == 0) {
1942                         bss->radius_request_cui = atoi(pos);
1943                 } else if (os_strcmp(buf, "radius_auth_req_attr") == 0) {
1944                         struct hostapd_radius_attr *attr, *a;
1945                         attr = hostapd_parse_radius_attr(pos);
1946                         if (attr == NULL) {
1947                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
1948                                            "radius_auth_req_attr", line);
1949                                 errors++;
1950                         } else if (bss->radius_auth_req_attr == NULL) {
1951                                 bss->radius_auth_req_attr = attr;
1952                         } else {
1953                                 a = bss->radius_auth_req_attr;
1954                                 while (a->next)
1955                                         a = a->next;
1956                                 a->next = attr;
1957                         }
1958                 } else if (os_strcmp(buf, "radius_acct_req_attr") == 0) {
1959                         struct hostapd_radius_attr *attr, *a;
1960                         attr = hostapd_parse_radius_attr(pos);
1961                         if (attr == NULL) {
1962                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
1963                                            "radius_acct_req_attr", line);
1964                                 errors++;
1965                         } else if (bss->radius_acct_req_attr == NULL) {
1966                                 bss->radius_acct_req_attr = attr;
1967                         } else {
1968                                 a = bss->radius_acct_req_attr;
1969                                 while (a->next)
1970                                         a = a->next;
1971                                 a->next = attr;
1972                         }
1973                 } else if (os_strcmp(buf, "radius_das_port") == 0) {
1974                         bss->radius_das_port = atoi(pos);
1975                 } else if (os_strcmp(buf, "radius_das_client") == 0) {
1976                         if (hostapd_parse_das_client(bss, pos) < 0) {
1977                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
1978                                            "DAS client", line);
1979                                 errors++;
1980                         }
1981                 } else if (os_strcmp(buf, "radius_das_time_window") == 0) {
1982                         bss->radius_das_time_window = atoi(pos);
1983                 } else if (os_strcmp(buf, "radius_das_require_event_timestamp")
1984                            == 0) {
1985                         bss->radius_das_require_event_timestamp = atoi(pos);
1986 #endif /* CONFIG_NO_RADIUS */
1987                 } else if (os_strcmp(buf, "auth_algs") == 0) {
1988                         bss->auth_algs = atoi(pos);
1989                         if (bss->auth_algs == 0) {
1990                                 wpa_printf(MSG_ERROR, "Line %d: no "
1991                                            "authentication algorithms allowed",
1992                                            line);
1993                                 errors++;
1994                         }
1995                 } else if (os_strcmp(buf, "max_num_sta") == 0) {
1996                         bss->max_num_sta = atoi(pos);
1997                         if (bss->max_num_sta < 0 ||
1998                             bss->max_num_sta > MAX_STA_COUNT) {
1999                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2000                                            "max_num_sta=%d; allowed range "
2001                                            "0..%d", line, bss->max_num_sta,
2002                                            MAX_STA_COUNT);
2003                                 errors++;
2004                         }
2005                 } else if (os_strcmp(buf, "wpa") == 0) {
2006                         bss->wpa = atoi(pos);
2007                 } else if (os_strcmp(buf, "wpa_group_rekey") == 0) {
2008                         bss->wpa_group_rekey = atoi(pos);
2009                 } else if (os_strcmp(buf, "wpa_strict_rekey") == 0) {
2010                         bss->wpa_strict_rekey = atoi(pos);
2011                 } else if (os_strcmp(buf, "wpa_gmk_rekey") == 0) {
2012                         bss->wpa_gmk_rekey = atoi(pos);
2013                 } else if (os_strcmp(buf, "wpa_ptk_rekey") == 0) {
2014                         bss->wpa_ptk_rekey = atoi(pos);
2015                 } else if (os_strcmp(buf, "wpa_passphrase") == 0) {
2016                         int len = os_strlen(pos);
2017                         if (len < 8 || len > 63) {
2018                                 wpa_printf(MSG_ERROR, "Line %d: invalid WPA "
2019                                            "passphrase length %d (expected "
2020                                            "8..63)", line, len);
2021                                 errors++;
2022                         } else {
2023                                 os_free(bss->ssid.wpa_passphrase);
2024                                 bss->ssid.wpa_passphrase = os_strdup(pos);
2025                                 if (bss->ssid.wpa_passphrase) {
2026                                         os_free(bss->ssid.wpa_psk);
2027                                         bss->ssid.wpa_psk = NULL;
2028                                         bss->ssid.wpa_passphrase_set = 1;
2029                                 }
2030                         }
2031                 } else if (os_strcmp(buf, "wpa_psk") == 0) {
2032                         os_free(bss->ssid.wpa_psk);
2033                         bss->ssid.wpa_psk =
2034                                 os_zalloc(sizeof(struct hostapd_wpa_psk));
2035                         if (bss->ssid.wpa_psk == NULL)
2036                                 errors++;
2037                         else if (hexstr2bin(pos, bss->ssid.wpa_psk->psk,
2038                                             PMK_LEN) ||
2039                                  pos[PMK_LEN * 2] != '\0') {
2040                                 wpa_printf(MSG_ERROR, "Line %d: Invalid PSK "
2041                                            "'%s'.", line, pos);
2042                                 errors++;
2043                         } else {
2044                                 bss->ssid.wpa_psk->group = 1;
2045                                 os_free(bss->ssid.wpa_passphrase);
2046                                 bss->ssid.wpa_passphrase = NULL;
2047                                 bss->ssid.wpa_psk_set = 1;
2048                         }
2049                 } else if (os_strcmp(buf, "wpa_psk_file") == 0) {
2050                         os_free(bss->ssid.wpa_psk_file);
2051                         bss->ssid.wpa_psk_file = os_strdup(pos);
2052                         if (!bss->ssid.wpa_psk_file) {
2053                                 wpa_printf(MSG_ERROR, "Line %d: allocation "
2054                                            "failed", line);
2055                                 errors++;
2056                         }
2057                 } else if (os_strcmp(buf, "wpa_key_mgmt") == 0) {
2058                         bss->wpa_key_mgmt =
2059                                 hostapd_config_parse_key_mgmt(line, pos);
2060                         if (bss->wpa_key_mgmt == -1)
2061                                 errors++;
2062                 } else if (os_strcmp(buf, "wpa_psk_radius") == 0) {
2063                         bss->wpa_psk_radius = atoi(pos);
2064                         if (bss->wpa_psk_radius != PSK_RADIUS_IGNORED &&
2065                             bss->wpa_psk_radius != PSK_RADIUS_ACCEPTED &&
2066                             bss->wpa_psk_radius != PSK_RADIUS_REQUIRED) {
2067                                 wpa_printf(MSG_ERROR, "Line %d: unknown "
2068                                            "wpa_psk_radius %d",
2069                                            line, bss->wpa_psk_radius);
2070                                 errors++;
2071                         }
2072                 } else if (os_strcmp(buf, "wpa_pairwise") == 0) {
2073                         bss->wpa_pairwise =
2074                                 hostapd_config_parse_cipher(line, pos);
2075                         if (bss->wpa_pairwise == -1 ||
2076                             bss->wpa_pairwise == 0)
2077                                 errors++;
2078                         else if (bss->wpa_pairwise &
2079                                  (WPA_CIPHER_NONE | WPA_CIPHER_WEP40 |
2080                                   WPA_CIPHER_WEP104)) {
2081                                 wpa_printf(MSG_ERROR, "Line %d: unsupported "
2082                                            "pairwise cipher suite '%s'",
2083                                            bss->wpa_pairwise, pos);
2084                                 errors++;
2085                         }
2086                 } else if (os_strcmp(buf, "rsn_pairwise") == 0) {
2087                         bss->rsn_pairwise =
2088                                 hostapd_config_parse_cipher(line, pos);
2089                         if (bss->rsn_pairwise == -1 ||
2090                             bss->rsn_pairwise == 0)
2091                                 errors++;
2092                         else if (bss->rsn_pairwise &
2093                                  (WPA_CIPHER_NONE | WPA_CIPHER_WEP40 |
2094                                   WPA_CIPHER_WEP104)) {
2095                                 wpa_printf(MSG_ERROR, "Line %d: unsupported "
2096                                            "pairwise cipher suite '%s'",
2097                                            bss->rsn_pairwise, pos);
2098                                 errors++;
2099                         }
2100 #ifdef CONFIG_RSN_PREAUTH
2101                 } else if (os_strcmp(buf, "rsn_preauth") == 0) {
2102                         bss->rsn_preauth = atoi(pos);
2103                 } else if (os_strcmp(buf, "rsn_preauth_interfaces") == 0) {
2104                         bss->rsn_preauth_interfaces = os_strdup(pos);
2105 #endif /* CONFIG_RSN_PREAUTH */
2106 #ifdef CONFIG_PEERKEY
2107                 } else if (os_strcmp(buf, "peerkey") == 0) {
2108                         bss->peerkey = atoi(pos);
2109 #endif /* CONFIG_PEERKEY */
2110 #ifdef CONFIG_IEEE80211R
2111                 } else if (os_strcmp(buf, "mobility_domain") == 0) {
2112                         if (os_strlen(pos) != 2 * MOBILITY_DOMAIN_ID_LEN ||
2113                             hexstr2bin(pos, bss->mobility_domain,
2114                                        MOBILITY_DOMAIN_ID_LEN) != 0) {
2115                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
2116                                            "mobility_domain '%s'", line, pos);
2117                                 errors++;
2118                                 return errors;
2119                         }
2120                 } else if (os_strcmp(buf, "r1_key_holder") == 0) {
2121                         if (os_strlen(pos) != 2 * FT_R1KH_ID_LEN ||
2122                             hexstr2bin(pos, bss->r1_key_holder,
2123                                        FT_R1KH_ID_LEN) != 0) {
2124                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
2125                                            "r1_key_holder '%s'", line, pos);
2126                                 errors++;
2127                                 return errors;
2128                         }
2129                 } else if (os_strcmp(buf, "r0_key_lifetime") == 0) {
2130                         bss->r0_key_lifetime = atoi(pos);
2131                 } else if (os_strcmp(buf, "reassociation_deadline") == 0) {
2132                         bss->reassociation_deadline = atoi(pos);
2133                 } else if (os_strcmp(buf, "r0kh") == 0) {
2134                         if (add_r0kh(bss, pos) < 0) {
2135                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
2136                                            "r0kh '%s'", line, pos);
2137                                 errors++;
2138                                 return errors;
2139                         }
2140                 } else if (os_strcmp(buf, "r1kh") == 0) {
2141                         if (add_r1kh(bss, pos) < 0) {
2142                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid "
2143                                            "r1kh '%s'", line, pos);
2144                                 errors++;
2145                                 return errors;
2146                         }
2147                 } else if (os_strcmp(buf, "pmk_r1_push") == 0) {
2148                         bss->pmk_r1_push = atoi(pos);
2149                 } else if (os_strcmp(buf, "ft_over_ds") == 0) {
2150                         bss->ft_over_ds = atoi(pos);
2151 #endif /* CONFIG_IEEE80211R */
2152 #ifndef CONFIG_NO_CTRL_IFACE
2153                 } else if (os_strcmp(buf, "ctrl_interface") == 0) {
2154                         os_free(bss->ctrl_interface);
2155                         bss->ctrl_interface = os_strdup(pos);
2156                 } else if (os_strcmp(buf, "ctrl_interface_group") == 0) {
2157 #ifndef CONFIG_NATIVE_WINDOWS
2158                         struct group *grp;
2159                         char *endp;
2160                         const char *group = pos;
2161
2162                         grp = getgrnam(group);
2163                         if (grp) {
2164                                 bss->ctrl_interface_gid = grp->gr_gid;
2165                                 bss->ctrl_interface_gid_set = 1;
2166                                 wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d"
2167                                            " (from group name '%s')",
2168                                            bss->ctrl_interface_gid, group);
2169                                 return errors;
2170                         }
2171
2172                         /* Group name not found - try to parse this as gid */
2173                         bss->ctrl_interface_gid = strtol(group, &endp, 10);
2174                         if (*group == '\0' || *endp != '\0') {
2175                                 wpa_printf(MSG_DEBUG, "Line %d: Invalid group "
2176                                            "'%s'", line, group);
2177                                 errors++;
2178                                 return errors;
2179                         }
2180                         bss->ctrl_interface_gid_set = 1;
2181                         wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d",
2182                                    bss->ctrl_interface_gid);
2183 #endif /* CONFIG_NATIVE_WINDOWS */
2184 #endif /* CONFIG_NO_CTRL_IFACE */
2185 #ifdef RADIUS_SERVER
2186                 } else if (os_strcmp(buf, "radius_server_clients") == 0) {
2187                         os_free(bss->radius_server_clients);
2188                         bss->radius_server_clients = os_strdup(pos);
2189                 } else if (os_strcmp(buf, "radius_server_auth_port") == 0) {
2190                         bss->radius_server_auth_port = atoi(pos);
2191                 } else if (os_strcmp(buf, "radius_server_ipv6") == 0) {
2192                         bss->radius_server_ipv6 = atoi(pos);
2193 #endif /* RADIUS_SERVER */
2194                 } else if (os_strcmp(buf, "test_socket") == 0) {
2195                         os_free(bss->test_socket);
2196                         bss->test_socket = os_strdup(pos);
2197                 } else if (os_strcmp(buf, "use_pae_group_addr") == 0) {
2198                         bss->use_pae_group_addr = atoi(pos);
2199                 } else if (os_strcmp(buf, "hw_mode") == 0) {
2200                         if (os_strcmp(pos, "a") == 0)
2201                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211A;
2202                         else if (os_strcmp(pos, "b") == 0)
2203                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211B;
2204                         else if (os_strcmp(pos, "g") == 0)
2205                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
2206                         else if (os_strcmp(pos, "ad") == 0)
2207                                 conf->hw_mode = HOSTAPD_MODE_IEEE80211AD;
2208                         else {
2209                                 wpa_printf(MSG_ERROR, "Line %d: unknown "
2210                                            "hw_mode '%s'", line, pos);
2211                                 errors++;
2212                         }
2213                 } else if (os_strcmp(buf, "wps_rf_bands") == 0) {
2214                         if (os_strcmp(pos, "a") == 0)
2215                                 bss->wps_rf_bands = WPS_RF_50GHZ;
2216                         else if (os_strcmp(pos, "g") == 0 ||
2217                                  os_strcmp(pos, "b") == 0)
2218                                 bss->wps_rf_bands = WPS_RF_24GHZ;
2219                         else if (os_strcmp(pos, "ag") == 0 ||
2220                                  os_strcmp(pos, "ga") == 0)
2221                                 bss->wps_rf_bands =
2222                                         WPS_RF_24GHZ | WPS_RF_50GHZ;
2223                         else {
2224                                 wpa_printf(MSG_ERROR, "Line %d: unknown "
2225                                            "wps_rf_band '%s'", line, pos);
2226                                 errors++;
2227                         }
2228                 } else if (os_strcmp(buf, "channel") == 0) {
2229                         if (os_strcmp(pos, "acs_survey") == 0) {
2230 #ifndef CONFIG_ACS
2231                                 wpa_printf(MSG_ERROR, "Line %d: tries to enable ACS but CONFIG_ACS disabled",
2232                                            line);
2233                                 errors++;
2234 #endif /* CONFIG_ACS */
2235                                 conf->channel = 0;
2236                         } else
2237                                 conf->channel = atoi(pos);
2238                 } else if (os_strcmp(buf, "beacon_int") == 0) {
2239                         int val = atoi(pos);
2240                         /* MIB defines range as 1..65535, but very small values
2241                          * cause problems with the current implementation.
2242                          * Since it is unlikely that this small numbers are
2243                          * useful in real life scenarios, do not allow beacon
2244                          * period to be set below 15 TU. */
2245                         if (val < 15 || val > 65535) {
2246                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2247                                            "beacon_int %d (expected "
2248                                            "15..65535)", line, val);
2249                                 errors++;
2250                         } else
2251                                 conf->beacon_int = val;
2252 #ifdef CONFIG_ACS
2253                 } else if (os_strcmp(buf, "acs_num_scans") == 0) {
2254                         int val = atoi(pos);
2255                         if (val <= 0 || val > 100) {
2256                                 wpa_printf(MSG_ERROR, "Line %d: invalid acs_num_scans %d (expected 1..100)",
2257                                            line, val);
2258                                 errors++;
2259                         } else
2260                                 conf->acs_num_scans = val;
2261 #endif /* CONFIG_ACS */
2262                 } else if (os_strcmp(buf, "dtim_period") == 0) {
2263                         bss->dtim_period = atoi(pos);
2264                         if (bss->dtim_period < 1 || bss->dtim_period > 255) {
2265                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2266                                            "dtim_period %d",
2267                                            line, bss->dtim_period);
2268                                 errors++;
2269                         }
2270                 } else if (os_strcmp(buf, "rts_threshold") == 0) {
2271                         conf->rts_threshold = atoi(pos);
2272                         if (conf->rts_threshold < 0 ||
2273                             conf->rts_threshold > 2347) {
2274                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2275                                            "rts_threshold %d",
2276                                            line, conf->rts_threshold);
2277                                 errors++;
2278                         }
2279                 } else if (os_strcmp(buf, "fragm_threshold") == 0) {
2280                         conf->fragm_threshold = atoi(pos);
2281                         if (conf->fragm_threshold < 256 ||
2282                             conf->fragm_threshold > 2346) {
2283                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2284                                            "fragm_threshold %d",
2285                                            line, conf->fragm_threshold);
2286                                 errors++;
2287                         }
2288                 } else if (os_strcmp(buf, "send_probe_response") == 0) {
2289                         int val = atoi(pos);
2290                         if (val != 0 && val != 1) {
2291                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2292                                            "send_probe_response %d (expected "
2293                                            "0 or 1)", line, val);
2294                         } else
2295                                 conf->send_probe_response = val;
2296                 } else if (os_strcmp(buf, "supported_rates") == 0) {
2297                         if (hostapd_parse_intlist(&conf->supported_rates, pos))
2298                         {
2299                                 wpa_printf(MSG_ERROR, "Line %d: invalid rate "
2300                                            "list", line);
2301                                 errors++;
2302                         }
2303                 } else if (os_strcmp(buf, "basic_rates") == 0) {
2304                         if (hostapd_parse_intlist(&conf->basic_rates, pos)) {
2305                                 wpa_printf(MSG_ERROR, "Line %d: invalid rate "
2306                                            "list", line);
2307                                 errors++;
2308                         }
2309                 } else if (os_strcmp(buf, "preamble") == 0) {
2310                         if (atoi(pos))
2311                                 conf->preamble = SHORT_PREAMBLE;
2312                         else
2313                                 conf->preamble = LONG_PREAMBLE;
2314                 } else if (os_strcmp(buf, "ignore_broadcast_ssid") == 0) {
2315                         bss->ignore_broadcast_ssid = atoi(pos);
2316                 } else if (os_strcmp(buf, "wep_default_key") == 0) {
2317                         bss->ssid.wep.idx = atoi(pos);
2318                         if (bss->ssid.wep.idx > 3) {
2319                                 wpa_printf(MSG_ERROR, "Invalid "
2320                                            "wep_default_key index %d",
2321                                            bss->ssid.wep.idx);
2322                                 errors++;
2323                         }
2324                 } else if (os_strcmp(buf, "wep_key0") == 0 ||
2325                            os_strcmp(buf, "wep_key1") == 0 ||
2326                            os_strcmp(buf, "wep_key2") == 0 ||
2327                            os_strcmp(buf, "wep_key3") == 0) {
2328                         if (hostapd_config_read_wep(&bss->ssid.wep,
2329                                                     buf[7] - '0', pos)) {
2330                                 wpa_printf(MSG_ERROR, "Line %d: invalid WEP "
2331                                            "key '%s'", line, buf);
2332                                 errors++;
2333                         }
2334 #ifndef CONFIG_NO_VLAN
2335                 } else if (os_strcmp(buf, "dynamic_vlan") == 0) {
2336                         bss->ssid.dynamic_vlan = atoi(pos);
2337                 } else if (os_strcmp(buf, "vlan_file") == 0) {
2338                         if (hostapd_config_read_vlan_file(bss, pos)) {
2339                                 wpa_printf(MSG_ERROR, "Line %d: failed to "
2340                                            "read VLAN file '%s'", line, pos);
2341                                 errors++;
2342                         }
2343                 } else if (os_strcmp(buf, "vlan_naming") == 0) {
2344                         bss->ssid.vlan_naming = atoi(pos);
2345                         if (bss->ssid.vlan_naming >= DYNAMIC_VLAN_NAMING_END ||
2346                             bss->ssid.vlan_naming < 0) {
2347                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2348                                            "naming scheme %d", line,
2349                                            bss->ssid.vlan_naming);
2350                                 errors++;
2351                         }
2352 #ifdef CONFIG_FULL_DYNAMIC_VLAN
2353                 } else if (os_strcmp(buf, "vlan_tagged_interface") == 0) {
2354                         bss->ssid.vlan_tagged_interface = os_strdup(pos);
2355 #endif /* CONFIG_FULL_DYNAMIC_VLAN */
2356 #endif /* CONFIG_NO_VLAN */
2357                 } else if (os_strcmp(buf, "ap_table_max_size") == 0) {
2358                         conf->ap_table_max_size = atoi(pos);
2359                 } else if (os_strcmp(buf, "ap_table_expiration_time") == 0) {
2360                         conf->ap_table_expiration_time = atoi(pos);
2361                 } else if (os_strncmp(buf, "tx_queue_", 9) == 0) {
2362                         if (hostapd_config_tx_queue(conf, buf, pos)) {
2363                                 wpa_printf(MSG_ERROR, "Line %d: invalid TX "
2364                                            "queue item", line);
2365                                 errors++;
2366                         }
2367                 } else if (os_strcmp(buf, "wme_enabled") == 0 ||
2368                            os_strcmp(buf, "wmm_enabled") == 0) {
2369                         bss->wmm_enabled = atoi(pos);
2370                 } else if (os_strcmp(buf, "uapsd_advertisement_enabled") == 0) {
2371                         bss->wmm_uapsd = atoi(pos);
2372                 } else if (os_strncmp(buf, "wme_ac_", 7) == 0 ||
2373                            os_strncmp(buf, "wmm_ac_", 7) == 0) {
2374                         if (hostapd_config_wmm_ac(conf->wmm_ac_params, buf,
2375                                                   pos)) {
2376                                 wpa_printf(MSG_ERROR, "Line %d: invalid WMM "
2377                                            "ac item", line);
2378                                 errors++;
2379                         }
2380                 } else if (os_strcmp(buf, "bss") == 0) {
2381                         if (hostapd_config_bss(conf, pos)) {
2382                                 wpa_printf(MSG_ERROR, "Line %d: invalid bss "
2383                                            "item", line);
2384                                 errors++;
2385                         }
2386                 } else if (os_strcmp(buf, "bssid") == 0) {
2387                         if (hwaddr_aton(pos, bss->bssid)) {
2388                                 wpa_printf(MSG_ERROR, "Line %d: invalid bssid "
2389                                            "item", line);
2390                                 errors++;
2391                         }
2392 #ifdef CONFIG_IEEE80211W
2393                 } else if (os_strcmp(buf, "ieee80211w") == 0) {
2394                         bss->ieee80211w = atoi(pos);
2395                 } else if (os_strcmp(buf, "assoc_sa_query_max_timeout") == 0) {
2396                         bss->assoc_sa_query_max_timeout = atoi(pos);
2397                         if (bss->assoc_sa_query_max_timeout == 0) {
2398                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2399                                            "assoc_sa_query_max_timeout", line);
2400                                 errors++;
2401                         }
2402                 } else if (os_strcmp(buf, "assoc_sa_query_retry_timeout") == 0)
2403                 {
2404                         bss->assoc_sa_query_retry_timeout = atoi(pos);
2405                         if (bss->assoc_sa_query_retry_timeout == 0) {
2406                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2407                                            "assoc_sa_query_retry_timeout",
2408                                            line);
2409                                 errors++;
2410                         }
2411 #endif /* CONFIG_IEEE80211W */
2412 #ifdef CONFIG_IEEE80211N
2413                 } else if (os_strcmp(buf, "ieee80211n") == 0) {
2414                         conf->ieee80211n = atoi(pos);
2415                 } else if (os_strcmp(buf, "ht_capab") == 0) {
2416                         if (hostapd_config_ht_capab(conf, pos) < 0) {
2417                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2418                                            "ht_capab", line);
2419                                 errors++;
2420                         }
2421                 } else if (os_strcmp(buf, "require_ht") == 0) {
2422                         conf->require_ht = atoi(pos);
2423                 } else if (os_strcmp(buf, "obss_interval") == 0) {
2424                         conf->obss_interval = atoi(pos);
2425 #endif /* CONFIG_IEEE80211N */
2426 #ifdef CONFIG_IEEE80211AC
2427                 } else if (os_strcmp(buf, "ieee80211ac") == 0) {
2428                         conf->ieee80211ac = atoi(pos);
2429                 } else if (os_strcmp(buf, "vht_capab") == 0) {
2430                         if (hostapd_config_vht_capab(conf, pos) < 0) {
2431                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2432                                            "vht_capab", line);
2433                                 errors++;
2434                         }
2435                 } else if (os_strcmp(buf, "require_vht") == 0) {
2436                         conf->require_vht = atoi(pos);
2437                 } else if (os_strcmp(buf, "vht_oper_chwidth") == 0) {
2438                         conf->vht_oper_chwidth = atoi(pos);
2439                 } else if (os_strcmp(buf, "vht_oper_centr_freq_seg0_idx") == 0)
2440                 {
2441                         conf->vht_oper_centr_freq_seg0_idx = atoi(pos);
2442                 } else if (os_strcmp(buf, "vht_oper_centr_freq_seg1_idx") == 0)
2443                 {
2444                         conf->vht_oper_centr_freq_seg1_idx = atoi(pos);
2445 #endif /* CONFIG_IEEE80211AC */
2446                 } else if (os_strcmp(buf, "max_listen_interval") == 0) {
2447                         bss->max_listen_interval = atoi(pos);
2448                 } else if (os_strcmp(buf, "disable_pmksa_caching") == 0) {
2449                         bss->disable_pmksa_caching = atoi(pos);
2450                 } else if (os_strcmp(buf, "okc") == 0) {
2451                         bss->okc = atoi(pos);
2452 #ifdef CONFIG_WPS
2453                 } else if (os_strcmp(buf, "wps_state") == 0) {
2454                         bss->wps_state = atoi(pos);
2455                         if (bss->wps_state < 0 || bss->wps_state > 2) {
2456                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2457                                            "wps_state", line);
2458                                 errors++;
2459                         }
2460                 } else if (os_strcmp(buf, "wps_independent") == 0) {
2461                         bss->wps_independent = atoi(pos);
2462                 } else if (os_strcmp(buf, "ap_setup_locked") == 0) {
2463                         bss->ap_setup_locked = atoi(pos);
2464                 } else if (os_strcmp(buf, "uuid") == 0) {
2465                         if (uuid_str2bin(pos, bss->uuid)) {
2466                                 wpa_printf(MSG_ERROR, "Line %d: invalid UUID",
2467                                            line);
2468                                 errors++;
2469                         }
2470                 } else if (os_strcmp(buf, "wps_pin_requests") == 0) {
2471                         os_free(bss->wps_pin_requests);
2472                         bss->wps_pin_requests = os_strdup(pos);
2473                 } else if (os_strcmp(buf, "device_name") == 0) {
2474                         if (os_strlen(pos) > 32) {
2475                                 wpa_printf(MSG_ERROR, "Line %d: Too long "
2476                                            "device_name", line);
2477                                 errors++;
2478                         }
2479                         os_free(bss->device_name);
2480                         bss->device_name = os_strdup(pos);
2481                 } else if (os_strcmp(buf, "manufacturer") == 0) {
2482                         if (os_strlen(pos) > 64) {
2483                                 wpa_printf(MSG_ERROR, "Line %d: Too long "
2484                                            "manufacturer", line);
2485                                 errors++;
2486                         }
2487                         os_free(bss->manufacturer);
2488                         bss->manufacturer = os_strdup(pos);
2489                 } else if (os_strcmp(buf, "model_name") == 0) {
2490                         if (os_strlen(pos) > 32) {
2491                                 wpa_printf(MSG_ERROR, "Line %d: Too long "
2492                                            "model_name", line);
2493                                 errors++;
2494                         }
2495                         os_free(bss->model_name);
2496                         bss->model_name = os_strdup(pos);
2497                 } else if (os_strcmp(buf, "model_number") == 0) {
2498                         if (os_strlen(pos) > 32) {
2499                                 wpa_printf(MSG_ERROR, "Line %d: Too long "
2500                                            "model_number", line);
2501                                 errors++;
2502                         }
2503                         os_free(bss->model_number);
2504                         bss->model_number = os_strdup(pos);
2505                 } else if (os_strcmp(buf, "serial_number") == 0) {
2506                         if (os_strlen(pos) > 32) {
2507                                 wpa_printf(MSG_ERROR, "Line %d: Too long "
2508                                            "serial_number", line);
2509                                 errors++;
2510                         }
2511                         os_free(bss->serial_number);
2512                         bss->serial_number = os_strdup(pos);
2513                 } else if (os_strcmp(buf, "device_type") == 0) {
2514                         if (wps_dev_type_str2bin(pos, bss->device_type))
2515                                 errors++;
2516                 } else if (os_strcmp(buf, "config_methods") == 0) {
2517                         os_free(bss->config_methods);
2518                         bss->config_methods = os_strdup(pos);
2519                 } else if (os_strcmp(buf, "os_version") == 0) {
2520                         if (hexstr2bin(pos, bss->os_version, 4)) {
2521                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2522                                            "os_version", line);
2523                                 errors++;
2524                         }
2525                 } else if (os_strcmp(buf, "ap_pin") == 0) {
2526                         os_free(bss->ap_pin);
2527                         bss->ap_pin = os_strdup(pos);
2528                 } else if (os_strcmp(buf, "skip_cred_build") == 0) {
2529                         bss->skip_cred_build = atoi(pos);
2530                 } else if (os_strcmp(buf, "extra_cred") == 0) {
2531                         os_free(bss->extra_cred);
2532                         bss->extra_cred =
2533                                 (u8 *) os_readfile(pos, &bss->extra_cred_len);
2534                         if (bss->extra_cred == NULL) {
2535                                 wpa_printf(MSG_ERROR, "Line %d: could not "
2536                                            "read Credentials from '%s'",
2537                                            line, pos);
2538                                 errors++;
2539                         }
2540                 } else if (os_strcmp(buf, "wps_cred_processing") == 0) {
2541                         bss->wps_cred_processing = atoi(pos);
2542                 } else if (os_strcmp(buf, "ap_settings") == 0) {
2543                         os_free(bss->ap_settings);
2544                         bss->ap_settings =
2545                                 (u8 *) os_readfile(pos, &bss->ap_settings_len);
2546                         if (bss->ap_settings == NULL) {
2547                                 wpa_printf(MSG_ERROR, "Line %d: could not "
2548                                            "read AP Settings from '%s'",
2549                                            line, pos);
2550                                 errors++;
2551                         }
2552                 } else if (os_strcmp(buf, "upnp_iface") == 0) {
2553                         bss->upnp_iface = os_strdup(pos);
2554                 } else if (os_strcmp(buf, "friendly_name") == 0) {
2555                         os_free(bss->friendly_name);
2556                         bss->friendly_name = os_strdup(pos);
2557                 } else if (os_strcmp(buf, "manufacturer_url") == 0) {
2558                         os_free(bss->manufacturer_url);
2559                         bss->manufacturer_url = os_strdup(pos);
2560                 } else if (os_strcmp(buf, "model_description") == 0) {
2561                         os_free(bss->model_description);
2562                         bss->model_description = os_strdup(pos);
2563                 } else if (os_strcmp(buf, "model_url") == 0) {
2564                         os_free(bss->model_url);
2565                         bss->model_url = os_strdup(pos);
2566                 } else if (os_strcmp(buf, "upc") == 0) {
2567                         os_free(bss->upc);
2568                         bss->upc = os_strdup(pos);
2569                 } else if (os_strcmp(buf, "pbc_in_m1") == 0) {
2570                         bss->pbc_in_m1 = atoi(pos);
2571                 } else if (os_strcmp(buf, "server_id") == 0) {
2572                         os_free(bss->server_id);
2573                         bss->server_id = os_strdup(pos);
2574 #ifdef CONFIG_WPS_NFC
2575                 } else if (os_strcmp(buf, "wps_nfc_dev_pw_id") == 0) {
2576                         bss->wps_nfc_dev_pw_id = atoi(pos);
2577                         if (bss->wps_nfc_dev_pw_id < 0x10 ||
2578                             bss->wps_nfc_dev_pw_id > 0xffff) {
2579                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2580                                            "wps_nfc_dev_pw_id value", line);
2581                                 errors++;
2582                         }
2583                         bss->wps_nfc_pw_from_config = 1;
2584                 } else if (os_strcmp(buf, "wps_nfc_dh_pubkey") == 0) {
2585                         wpabuf_free(bss->wps_nfc_dh_pubkey);
2586                         bss->wps_nfc_dh_pubkey = hostapd_parse_bin(pos);
2587                         bss->wps_nfc_pw_from_config = 1;
2588                 } else if (os_strcmp(buf, "wps_nfc_dh_privkey") == 0) {
2589                         wpabuf_free(bss->wps_nfc_dh_privkey);
2590                         bss->wps_nfc_dh_privkey = hostapd_parse_bin(pos);
2591                         bss->wps_nfc_pw_from_config = 1;
2592                 } else if (os_strcmp(buf, "wps_nfc_dev_pw") == 0) {
2593                         wpabuf_free(bss->wps_nfc_dev_pw);
2594                         bss->wps_nfc_dev_pw = hostapd_parse_bin(pos);
2595                         bss->wps_nfc_pw_from_config = 1;
2596 #endif /* CONFIG_WPS_NFC */
2597 #endif /* CONFIG_WPS */
2598 #ifdef CONFIG_P2P_MANAGER
2599                 } else if (os_strcmp(buf, "manage_p2p") == 0) {
2600                         int manage = atoi(pos);
2601                         if (manage)
2602                                 bss->p2p |= P2P_MANAGE;
2603                         else
2604                                 bss->p2p &= ~P2P_MANAGE;
2605                 } else if (os_strcmp(buf, "allow_cross_connection") == 0) {
2606                         if (atoi(pos))
2607                                 bss->p2p |= P2P_ALLOW_CROSS_CONNECTION;
2608                         else
2609                                 bss->p2p &= ~P2P_ALLOW_CROSS_CONNECTION;
2610 #endif /* CONFIG_P2P_MANAGER */
2611                 } else if (os_strcmp(buf, "disassoc_low_ack") == 0) {
2612                         bss->disassoc_low_ack = atoi(pos);
2613                 } else if (os_strcmp(buf, "tdls_prohibit") == 0) {
2614                         int val = atoi(pos);
2615                         if (val)
2616                                 bss->tdls |= TDLS_PROHIBIT;
2617                         else
2618                                 bss->tdls &= ~TDLS_PROHIBIT;
2619                 } else if (os_strcmp(buf, "tdls_prohibit_chan_switch") == 0) {
2620                         int val = atoi(pos);
2621                         if (val)
2622                                 bss->tdls |= TDLS_PROHIBIT_CHAN_SWITCH;
2623                         else
2624                                 bss->tdls &= ~TDLS_PROHIBIT_CHAN_SWITCH;
2625 #ifdef CONFIG_RSN_TESTING
2626                 } else if (os_strcmp(buf, "rsn_testing") == 0) {
2627                         extern int rsn_testing;
2628                         rsn_testing = atoi(pos);
2629 #endif /* CONFIG_RSN_TESTING */
2630                 } else if (os_strcmp(buf, "time_advertisement") == 0) {
2631                         bss->time_advertisement = atoi(pos);
2632                 } else if (os_strcmp(buf, "time_zone") == 0) {
2633                         size_t tz_len = os_strlen(pos);
2634                         if (tz_len < 4 || tz_len > 255) {
2635                                 wpa_printf(MSG_DEBUG, "Line %d: invalid "
2636                                            "time_zone", line);
2637                                 errors++;
2638                                 return errors;
2639                         }
2640                         os_free(bss->time_zone);
2641                         bss->time_zone = os_strdup(pos);
2642                         if (bss->time_zone == NULL)
2643                                 errors++;
2644 #ifdef CONFIG_WNM
2645                 } else if (os_strcmp(buf, "wnm_sleep_mode") == 0) {
2646                         bss->wnm_sleep_mode = atoi(pos);
2647                 } else if (os_strcmp(buf, "bss_transition") == 0) {
2648                         bss->bss_transition = atoi(pos);
2649 #endif /* CONFIG_WNM */
2650 #ifdef CONFIG_INTERWORKING
2651                 } else if (os_strcmp(buf, "interworking") == 0) {
2652                         bss->interworking = atoi(pos);
2653                 } else if (os_strcmp(buf, "access_network_type") == 0) {
2654                         bss->access_network_type = atoi(pos);
2655                         if (bss->access_network_type < 0 ||
2656                             bss->access_network_type > 15) {
2657                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2658                                            "access_network_type", line);
2659                                 errors++;
2660                         }
2661                 } else if (os_strcmp(buf, "internet") == 0) {
2662                         bss->internet = atoi(pos);
2663                 } else if (os_strcmp(buf, "asra") == 0) {
2664                         bss->asra = atoi(pos);
2665                 } else if (os_strcmp(buf, "esr") == 0) {
2666                         bss->esr = atoi(pos);
2667                 } else if (os_strcmp(buf, "uesa") == 0) {
2668                         bss->uesa = atoi(pos);
2669                 } else if (os_strcmp(buf, "venue_group") == 0) {
2670                         bss->venue_group = atoi(pos);
2671                         bss->venue_info_set = 1;
2672                 } else if (os_strcmp(buf, "venue_type") == 0) {
2673                         bss->venue_type = atoi(pos);
2674                         bss->venue_info_set = 1;
2675                 } else if (os_strcmp(buf, "hessid") == 0) {
2676                         if (hwaddr_aton(pos, bss->hessid)) {
2677                                 wpa_printf(MSG_ERROR, "Line %d: invalid "
2678                                            "hessid", line);
2679                                 errors++;
2680                         }
2681                 } else if (os_strcmp(buf, "roaming_consortium") == 0) {
2682                         if (parse_roaming_consortium(bss, pos, line) < 0)
2683                                 errors++;
2684                 } else if (os_strcmp(buf, "venue_name") == 0) {
2685                         if (parse_venue_name(bss, pos, line) < 0)
2686                                 errors++;
2687                 } else if (os_strcmp(buf, "network_auth_type") == 0) {
2688                         u8 auth_type;
2689                         u16 redirect_url_len;
2690                         if (hexstr2bin(pos, &auth_type, 1)) {
2691                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2692                                            "network_auth_type '%s'",
2693                                            line, pos);
2694                                 errors++;
2695                                 return errors;
2696                         }
2697                         if (auth_type == 0 || auth_type == 2)
2698                                 redirect_url_len = os_strlen(pos + 2);
2699                         else
2700                                 redirect_url_len = 0;
2701                         os_free(bss->network_auth_type);
2702                         bss->network_auth_type =
2703                                 os_malloc(redirect_url_len + 3 + 1);
2704                         if (bss->network_auth_type == NULL) {
2705                                 errors++;
2706                                 return errors;
2707                         }
2708                         *bss->network_auth_type = auth_type;
2709                         WPA_PUT_LE16(bss->network_auth_type + 1,
2710                                      redirect_url_len);
2711                         if (redirect_url_len)
2712                                 os_memcpy(bss->network_auth_type + 3,
2713                                           pos + 2, redirect_url_len);
2714                         bss->network_auth_type_len = 3 + redirect_url_len;
2715                 } else if (os_strcmp(buf, "ipaddr_type_availability") == 0) {
2716                         if (hexstr2bin(pos, &bss->ipaddr_type_availability, 1))
2717                         {
2718                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2719                                            "ipaddr_type_availability '%s'",
2720                                            line, pos);
2721                                 bss->ipaddr_type_configured = 0;
2722                                 errors++;
2723                                 return errors;
2724                         }
2725                         bss->ipaddr_type_configured = 1;
2726                 } else if (os_strcmp(buf, "domain_name") == 0) {
2727                         int j, num_domains, domain_len, domain_list_len = 0;
2728                         char *tok_start, *tok_prev;
2729                         u8 *domain_list, *domain_ptr;
2730
2731                         domain_list_len = os_strlen(pos) + 1;
2732                         domain_list = os_malloc(domain_list_len);
2733                         if (domain_list == NULL) {
2734                                 errors++;
2735                                 return errors;
2736                         }
2737
2738                         domain_ptr = domain_list;
2739                         tok_prev = pos;
2740                         num_domains = 1;
2741                         while ((tok_prev = os_strchr(tok_prev, ','))) {
2742                                 num_domains++;
2743                                 tok_prev++;
2744                         }
2745                         tok_prev = pos;
2746                         for (j = 0; j < num_domains; j++) {
2747                                 tok_start = os_strchr(tok_prev, ',');
2748                                 if (tok_start) {
2749                                         domain_len = tok_start - tok_prev;
2750                                         *domain_ptr = domain_len;
2751                                         os_memcpy(domain_ptr + 1, tok_prev,
2752                                                   domain_len);
2753                                         domain_ptr += domain_len + 1;
2754                                         tok_prev = ++tok_start;
2755                                 } else {
2756                                         domain_len = os_strlen(tok_prev);
2757                                         *domain_ptr = domain_len;
2758                                         os_memcpy(domain_ptr + 1, tok_prev,
2759                                                   domain_len);
2760                                         domain_ptr += domain_len + 1;
2761                                 }
2762                         }
2763
2764                         os_free(bss->domain_name);
2765                         bss->domain_name = domain_list;
2766                         bss->domain_name_len = domain_list_len;
2767                 } else if (os_strcmp(buf, "anqp_3gpp_cell_net") == 0) {
2768                         if (parse_3gpp_cell_net(bss, pos, line) < 0)
2769                                 errors++;
2770                 } else if (os_strcmp(buf, "nai_realm") == 0) {
2771                         if (parse_nai_realm(bss, pos, line) < 0)
2772                                 errors++;
2773                 } else if (os_strcmp(buf, "gas_frag_limit") == 0) {
2774                         bss->gas_frag_limit = atoi(pos);
2775                 } else if (os_strcmp(buf, "gas_comeback_delay") == 0) {
2776                         bss->gas_comeback_delay = atoi(pos);
2777                 } else if (os_strcmp(buf, "qos_map_set") == 0) {
2778                         if (parse_qos_map_set(bss, pos, line) < 0)
2779                                 errors++;
2780 #endif /* CONFIG_INTERWORKING */
2781 #ifdef CONFIG_RADIUS_TEST
2782                 } else if (os_strcmp(buf, "dump_msk_file") == 0) {
2783                         os_free(bss->dump_msk_file);
2784                         bss->dump_msk_file = os_strdup(pos);
2785 #endif /* CONFIG_RADIUS_TEST */
2786 #ifdef CONFIG_HS20
2787                 } else if (os_strcmp(buf, "hs20") == 0) {
2788                         bss->hs20 = atoi(pos);
2789                 } else if (os_strcmp(buf, "disable_dgaf") == 0) {
2790                         bss->disable_dgaf = atoi(pos);
2791                 } else if (os_strcmp(buf, "hs20_oper_friendly_name") == 0) {
2792                         if (hs20_parse_oper_friendly_name(bss, pos, line) < 0)
2793                                 errors++;
2794                 } else if (os_strcmp(buf, "hs20_wan_metrics") == 0) {
2795                         if (hs20_parse_wan_metrics(bss, pos, line) < 0) {
2796                                 errors++;
2797                                 return errors;
2798                         }
2799                 } else if (os_strcmp(buf, "hs20_conn_capab") == 0) {
2800                         if (hs20_parse_conn_capab(bss, pos, line) < 0) {
2801                                 errors++;
2802                                 return errors;
2803                         }
2804                 } else if (os_strcmp(buf, "hs20_operating_class") == 0) {
2805                         u8 *oper_class;
2806                         size_t oper_class_len;
2807                         oper_class_len = os_strlen(pos);
2808                         if (oper_class_len < 2 || (oper_class_len & 0x01)) {
2809                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2810                                            "hs20_operating_class '%s'",
2811                                            line, pos);
2812                                 errors++;
2813                                 return errors;
2814                         }
2815                         oper_class_len /= 2;
2816                         oper_class = os_malloc(oper_class_len);
2817                         if (oper_class == NULL) {
2818                                 errors++;
2819                                 return errors;
2820                         }
2821                         if (hexstr2bin(pos, oper_class, oper_class_len)) {
2822                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2823                                            "hs20_operating_class '%s'",
2824                                            line, pos);
2825                                 os_free(oper_class);
2826                                 errors++;
2827                                 return errors;
2828                         }
2829                         os_free(bss->hs20_operating_class);
2830                         bss->hs20_operating_class = oper_class;
2831                         bss->hs20_operating_class_len = oper_class_len;
2832 #endif /* CONFIG_HS20 */
2833 #ifdef CONFIG_TESTING_OPTIONS
2834 #define PARSE_TEST_PROBABILITY(_val)                                    \
2835                 } else if (os_strcmp(buf, #_val) == 0) {                \
2836                         char *end;                                      \
2837                                                                         \
2838                         conf->_val = strtod(pos, &end);                 \
2839                         if (*end || conf->_val < 0.0d ||                \
2840                             conf->_val > 1.0d) {                        \
2841                                 wpa_printf(MSG_ERROR,                   \
2842                                            "Line %d: Invalid value '%s'", \
2843                                            line, pos);                  \
2844                                 errors++;                               \
2845                                 return errors;                          \
2846                         }
2847                 PARSE_TEST_PROBABILITY(ignore_probe_probability)
2848                 PARSE_TEST_PROBABILITY(ignore_auth_probability)
2849                 PARSE_TEST_PROBABILITY(ignore_assoc_probability)
2850                 PARSE_TEST_PROBABILITY(ignore_reassoc_probability)
2851                 PARSE_TEST_PROBABILITY(corrupt_gtk_rekey_mic_probability)
2852                 } else if (os_strcmp(buf, "bss_load_test") == 0) {
2853                         WPA_PUT_LE16(bss->bss_load_test, atoi(pos));
2854                         pos = os_strchr(pos, ':');
2855                         if (pos == NULL) {
2856                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2857                                            "bss_load_test", line);
2858                                 return 1;
2859                         }
2860                         pos++;
2861                         bss->bss_load_test[2] = atoi(pos);
2862                         pos = os_strchr(pos, ':');
2863                         if (pos == NULL) {
2864                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2865                                            "bss_load_test", line);
2866                                 return 1;
2867                         }
2868                         pos++;
2869                         WPA_PUT_LE16(&bss->bss_load_test[3], atoi(pos));
2870                         bss->bss_load_test_set = 1;
2871 #endif /* CONFIG_TESTING_OPTIONS */
2872                 } else if (os_strcmp(buf, "vendor_elements") == 0) {
2873                         struct wpabuf *elems;
2874                         size_t len = os_strlen(pos);
2875                         if (len & 0x01) {
2876                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2877                                            "vendor_elements '%s'", line, pos);
2878                                 return 1;
2879                         }
2880                         len /= 2;
2881                         if (len == 0) {
2882                                 wpabuf_free(bss->vendor_elements);
2883                                 bss->vendor_elements = NULL;
2884                                 return 0;
2885                         }
2886
2887                         elems = wpabuf_alloc(len);
2888                         if (elems == NULL)
2889                                 return 1;
2890
2891                         if (hexstr2bin(pos, wpabuf_put(elems, len), len)) {
2892                                 wpabuf_free(elems);
2893                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2894                                            "vendor_elements '%s'", line, pos);
2895                                 return 1;
2896                         }
2897
2898                         wpabuf_free(bss->vendor_elements);
2899                         bss->vendor_elements = elems;
2900                 } else if (os_strcmp(buf, "sae_anti_clogging_threshold") == 0) {
2901                         bss->sae_anti_clogging_threshold = atoi(pos);
2902                 } else if (os_strcmp(buf, "sae_groups") == 0) {
2903                         if (hostapd_parse_intlist(&bss->sae_groups, pos)) {
2904                                 wpa_printf(MSG_ERROR, "Line %d: Invalid "
2905                                            "sae_groups value '%s'", line, pos);
2906                                 return 1;
2907                         }
2908                 } else {
2909                         wpa_printf(MSG_ERROR, "Line %d: unknown configuration "
2910                                    "item '%s'", line, buf);
2911                         errors++;
2912                 }
2913         }
2914
2915         return errors;
2916 }
2917
2918
2919 /**
2920  * hostapd_config_read - Read and parse a configuration file
2921  * @fname: Configuration file name (including path, if needed)
2922  * Returns: Allocated configuration data structure
2923  */
2924 struct hostapd_config * hostapd_config_read(const char *fname)
2925 {
2926         struct hostapd_config *conf;
2927         struct hostapd_bss_config *bss;
2928         FILE *f;
2929         char buf[512], *pos;
2930         int line = 0;
2931         int errors = 0;
2932         size_t i;
2933
2934         f = fopen(fname, "r");
2935         if (f == NULL) {
2936                 wpa_printf(MSG_ERROR, "Could not open configuration file '%s' "
2937                            "for reading.", fname);
2938                 return NULL;
2939         }
2940
2941         conf = hostapd_config_defaults();
2942         if (conf == NULL) {
2943                 fclose(f);
2944                 return NULL;
2945         }
2946
2947         /* set default driver based on configuration */
2948         conf->driver = wpa_drivers[0];
2949         if (conf->driver == NULL) {
2950                 wpa_printf(MSG_ERROR, "No driver wrappers registered!");
2951                 hostapd_config_free(conf);
2952                 fclose(f);
2953                 return NULL;
2954         }
2955
2956         bss = conf->last_bss = conf->bss[0];
2957
2958         while (fgets(buf, sizeof(buf), f)) {
2959                 bss = conf->last_bss;
2960                 line++;
2961
2962                 if (buf[0] == '#')
2963                         continue;
2964                 pos = buf;
2965                 while (*pos != '\0') {
2966                         if (*pos == '\n') {
2967                                 *pos = '\0';
2968                                 break;
2969                         }
2970                         pos++;
2971                 }
2972                 if (buf[0] == '\0')
2973                         continue;
2974
2975                 pos = os_strchr(buf, '=');
2976                 if (pos == NULL) {
2977                         wpa_printf(MSG_ERROR, "Line %d: invalid line '%s'",
2978                                    line, buf);
2979                         errors++;
2980                         continue;
2981                 }
2982                 *pos = '\0';
2983                 pos++;
2984                 errors += hostapd_config_fill(conf, bss, buf, pos, line);
2985         }
2986
2987         fclose(f);
2988
2989         for (i = 0; i < conf->num_bss; i++)
2990                 hostapd_set_security_params(conf->bss[i]);
2991
2992         if (hostapd_config_check(conf, 1))
2993                 errors++;
2994
2995 #ifndef WPA_IGNORE_CONFIG_ERRORS
2996         if (errors) {
2997                 wpa_printf(MSG_ERROR, "%d errors found in configuration file "
2998                            "'%s'", errors, fname);
2999                 hostapd_config_free(conf);
3000                 conf = NULL;
3001         }
3002 #endif /* WPA_IGNORE_CONFIG_ERRORS */
3003
3004         return conf;
3005 }
3006
3007
3008 int hostapd_set_iface(struct hostapd_config *conf,
3009                       struct hostapd_bss_config *bss, char *field, char *value)
3010 {
3011         int errors;
3012         size_t i;
3013
3014         errors = hostapd_config_fill(conf, bss, field, value, 0);
3015         if (errors) {
3016                 wpa_printf(MSG_INFO, "Failed to set configuration field '%s' "
3017                            "to value '%s'", field, value);
3018                 return -1;
3019         }
3020
3021         for (i = 0; i < conf->num_bss; i++)
3022                 hostapd_set_security_params(conf->bss[i]);
3023
3024         if (hostapd_config_check(conf, 0)) {
3025                 wpa_printf(MSG_ERROR, "Configuration check failed");
3026                 return -1;
3027         }
3028
3029         return 0;
3030 }