hostapd/config_file.c

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