wpa_supplicant/config.c

   1 /*
   2  * WPA Supplicant / Configuration parser and common functions
   3  * Copyright (c) 2003-2012, 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 "includes.h"
  10
  11 #include "common.h"
  12 #include "utils/uuid.h"
  13 #include "crypto/sha1.h"
  14 #include "rsn_supp/wpa.h"
  15 #include "eap_peer/eap.h"
  16 #include "p2p/p2p.h"
  17 #include "config.h"
  18
  19
  20 #if !defined(CONFIG_CTRL_IFACE) && defined(CONFIG_NO_CONFIG_WRITE)
  21 #define NO_CONFIG_WRITE
  22 #endif
  23
  24 /*
  25  * Structure for network configuration parsing. This data is used to implement
  26  * a generic parser for each network block variable. The table of configuration
  27  * variables is defined below in this file (ssid_fields[]).
  28  */
  29 struct parse_data {
  30         /* Configuration variable name */
  31         char *name;
  32
  33         /* Parser function for this variable */
  34         int (*parser)(const struct parse_data *data, struct wpa_ssid *ssid,
  35                       int line, const char *value);
  36
  37 #ifndef NO_CONFIG_WRITE
  38         /* Writer function (i.e., to get the variable in text format from
  39          * internal presentation). */
  40         char * (*writer)(const struct parse_data *data, struct wpa_ssid *ssid);
  41 #endif /* NO_CONFIG_WRITE */
  42
  43         /* Variable specific parameters for the parser. */
  44         void *param1, *param2, *param3, *param4;
  45
  46         /* 0 = this variable can be included in debug output and ctrl_iface
  47          * 1 = this variable contains key/private data and it must not be
  48          *     included in debug output unless explicitly requested. In
  49          *     addition, this variable will not be readable through the
  50          *     ctrl_iface.
  51          */
  52         int key_data;
  53 };
  54
  55
  56 static int wpa_config_parse_str(const struct parse_data *data,
  57                                 struct wpa_ssid *ssid,
  58                                 int line, const char *value)
  59 {
  60         size_t res_len, *dst_len;
  61         char **dst, *tmp;
  62
  63         if (os_strcmp(value, "NULL") == 0) {
  64                 wpa_printf(MSG_DEBUG, "Unset configuration string '%s'",
  65                            data->name);
  66                 tmp = NULL;
  67                 res_len = 0;
  68                 goto set;
  69         }
  70
  71         tmp = wpa_config_parse_string(value, &res_len);
  72         if (tmp == NULL) {
  73                 wpa_printf(MSG_ERROR, "Line %d: failed to parse %s '%s'.",
  74                            line, data->name,
  75                            data->key_data ? "[KEY DATA REMOVED]" : value);
  76                 return -1;
  77         }
  78
  79         if (data->key_data) {
  80                 wpa_hexdump_ascii_key(MSG_MSGDUMP, data->name,
  81                                       (u8 *) tmp, res_len);
  82         } else {
  83                 wpa_hexdump_ascii(MSG_MSGDUMP, data->name,
  84                                   (u8 *) tmp, res_len);
  85         }
  86
  87         if (data->param3 && res_len < (size_t) data->param3) {
  88                 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
  89                            "min_len=%ld)", line, data->name,
  90                            (unsigned long) res_len, (long) data->param3);
  91                 os_free(tmp);
  92                 return -1;
  93         }
  94
  95         if (data->param4 && res_len > (size_t) data->param4) {
  96                 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
  97                            "max_len=%ld)", line, data->name,
  98                            (unsigned long) res_len, (long) data->param4);
  99                 os_free(tmp);
 100                 return -1;
 101         }
 102
 103 set:
 104         dst = (char **) (((u8 *) ssid) + (long) data->param1);
 105         dst_len = (size_t *) (((u8 *) ssid) + (long) data->param2);
 106         os_free(*dst);
 107         *dst = tmp;
 108         if (data->param2)
 109                 *dst_len = res_len;
 110
 111         return 0;
 112 }
 113
 114
 115 #ifndef NO_CONFIG_WRITE
 116 static char * wpa_config_write_string_ascii(const u8 *value, size_t len)
 117 {
 118         char *buf;
 119
 120         buf = os_malloc(len + 3);
 121         if (buf == NULL)
 122                 return NULL;
 123         buf[0] = '"';
 124         os_memcpy(buf + 1, value, len);
 125         buf[len + 1] = '"';
 126         buf[len + 2] = '\0';
 127
 128         return buf;
 129 }
 130
 131
 132 static char * wpa_config_write_string_hex(const u8 *value, size_t len)
 133 {
 134         char *buf;
 135
 136         buf = os_zalloc(2 * len + 1);
 137         if (buf == NULL)
 138                 return NULL;
 139         wpa_snprintf_hex(buf, 2 * len + 1, value, len);
 140
 141         return buf;
 142 }
 143
 144
 145 static char * wpa_config_write_string(const u8 *value, size_t len)
 146 {
 147         if (value == NULL)
 148                 return NULL;
 149
 150         if (is_hex(value, len))
 151                 return wpa_config_write_string_hex(value, len);
 152         else
 153                 return wpa_config_write_string_ascii(value, len);
 154 }
 155
 156
 157 static char * wpa_config_write_str(const struct parse_data *data,
 158                                    struct wpa_ssid *ssid)
 159 {
 160         size_t len;
 161         char **src;
 162
 163         src = (char **) (((u8 *) ssid) + (long) data->param1);
 164         if (*src == NULL)
 165                 return NULL;
 166
 167         if (data->param2)
 168                 len = *((size_t *) (((u8 *) ssid) + (long) data->param2));
 169         else
 170                 len = os_strlen(*src);
 171
 172         return wpa_config_write_string((const u8 *) *src, len);
 173 }
 174 #endif /* NO_CONFIG_WRITE */
 175
 176
 177 static int wpa_config_parse_int(const struct parse_data *data,
 178                                 struct wpa_ssid *ssid,
 179                                 int line, const char *value)
 180 {
 181         int *dst;
 182
 183         dst = (int *) (((u8 *) ssid) + (long) data->param1);
 184         *dst = atoi(value);
 185         wpa_printf(MSG_MSGDUMP, "%s=%d (0x%x)", data->name, *dst, *dst);
 186
 187         if (data->param3 && *dst < (long) data->param3) {
 188                 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
 189                            "min_value=%ld)", line, data->name, *dst,
 190                            (long) data->param3);
 191                 *dst = (long) data->param3;
 192                 return -1;
 193         }
 194
 195         if (data->param4 && *dst > (long) data->param4) {
 196                 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
 197                            "max_value=%ld)", line, data->name, *dst,
 198                            (long) data->param4);
 199                 *dst = (long) data->param4;
 200                 return -1;
 201         }
 202
 203         return 0;
 204 }
 205
 206
 207 #ifndef NO_CONFIG_WRITE
 208 static char * wpa_config_write_int(const struct parse_data *data,
 209                                    struct wpa_ssid *ssid)
 210 {
 211         int *src, res;
 212         char *value;
 213
 214         src = (int *) (((u8 *) ssid) + (long) data->param1);
 215
 216         value = os_malloc(20);
 217         if (value == NULL)
 218                 return NULL;
 219         res = os_snprintf(value, 20, "%d", *src);
 220         if (res < 0 || res >= 20) {
 221                 os_free(value);
 222                 return NULL;
 223         }
 224         value[20 - 1] = '\0';
 225         return value;
 226 }
 227 #endif /* NO_CONFIG_WRITE */
 228
 229
 230 static int wpa_config_parse_bssid(const struct parse_data *data,
 231                                   struct wpa_ssid *ssid, int line,
 232                                   const char *value)
 233 {
 234         if (value[0] == '\0' || os_strcmp(value, "\"\"") == 0 ||
 235             os_strcmp(value, "any") == 0) {
 236                 ssid->bssid_set = 0;
 237                 wpa_printf(MSG_MSGDUMP, "BSSID any");
 238                 return 0;
 239         }
 240         if (hwaddr_aton(value, ssid->bssid)) {
 241                 wpa_printf(MSG_ERROR, "Line %d: Invalid BSSID '%s'.",
 242                            line, value);
 243                 return -1;
 244         }
 245         ssid->bssid_set = 1;
 246         wpa_hexdump(MSG_MSGDUMP, "BSSID", ssid->bssid, ETH_ALEN);
 247         return 0;
 248 }
 249
 250
 251 #ifndef NO_CONFIG_WRITE
 252 static char * wpa_config_write_bssid(const struct parse_data *data,
 253                                      struct wpa_ssid *ssid)
 254 {
 255         char *value;
 256         int res;
 257
 258         if (!ssid->bssid_set)
 259                 return NULL;
 260
 261         value = os_malloc(20);
 262         if (value == NULL)
 263                 return NULL;
 264         res = os_snprintf(value, 20, MACSTR, MAC2STR(ssid->bssid));
 265         if (res < 0 || res >= 20) {
 266                 os_free(value);
 267                 return NULL;
 268         }
 269         value[20 - 1] = '\0';
 270         return value;
 271 }
 272 #endif /* NO_CONFIG_WRITE */
 273
 274
 275 static int wpa_config_parse_psk(const struct parse_data *data,
 276                                 struct wpa_ssid *ssid, int line,
 277                                 const char *value)
 278 {
 279 #ifdef CONFIG_EXT_PASSWORD
 280         if (os_strncmp(value, "ext:", 4) == 0) {
 281                 os_free(ssid->passphrase);
 282                 ssid->passphrase = NULL;
 283                 ssid->psk_set = 0;
 284                 os_free(ssid->ext_psk);
 285                 ssid->ext_psk = os_strdup(value + 4);
 286                 if (ssid->ext_psk == NULL)
 287                         return -1;
 288                 wpa_printf(MSG_DEBUG, "PSK: External password '%s'",
 289                            ssid->ext_psk);
 290                 return 0;
 291         }
 292 #endif /* CONFIG_EXT_PASSWORD */
 293
 294         if (*value == '"') {
 295 #ifndef CONFIG_NO_PBKDF2
 296                 const char *pos;
 297                 size_t len;
 298
 299                 value++;
 300                 pos = os_strrchr(value, '"');
 301                 if (pos)
 302                         len = pos - value;
 303                 else
 304                         len = os_strlen(value);
 305                 if (len < 8 || len > 63) {
 306                         wpa_printf(MSG_ERROR, "Line %d: Invalid passphrase "
 307                                    "length %lu (expected: 8..63) '%s'.",
 308                                    line, (unsigned long) len, value);
 309                         return -1;
 310                 }
 311                 wpa_hexdump_ascii_key(MSG_MSGDUMP, "PSK (ASCII passphrase)",
 312                                       (u8 *) value, len);
 313                 if (ssid->passphrase && os_strlen(ssid->passphrase) == len &&
 314                     os_memcmp(ssid->passphrase, value, len) == 0)
 315                         return 0;
 316                 ssid->psk_set = 0;
 317                 os_free(ssid->passphrase);
 318                 ssid->passphrase = os_malloc(len + 1);
 319                 if (ssid->passphrase == NULL)
 320                         return -1;
 321                 os_memcpy(ssid->passphrase, value, len);
 322                 ssid->passphrase[len] = '\0';
 323                 return 0;
 324 #else /* CONFIG_NO_PBKDF2 */
 325                 wpa_printf(MSG_ERROR, "Line %d: ASCII passphrase not "
 326                            "supported.", line);
 327                 return -1;
 328 #endif /* CONFIG_NO_PBKDF2 */
 329         }
 330
 331         if (hexstr2bin(value, ssid->psk, PMK_LEN) ||
 332             value[PMK_LEN * 2] != '\0') {
 333                 wpa_printf(MSG_ERROR, "Line %d: Invalid PSK '%s'.",
 334                            line, value);
 335                 return -1;
 336         }
 337
 338         os_free(ssid->passphrase);
 339         ssid->passphrase = NULL;
 340
 341         ssid->psk_set = 1;
 342         wpa_hexdump_key(MSG_MSGDUMP, "PSK", ssid->psk, PMK_LEN);
 343         return 0;
 344 }
 345
 346
 347 #ifndef NO_CONFIG_WRITE
 348 static char * wpa_config_write_psk(const struct parse_data *data,
 349                                    struct wpa_ssid *ssid)
 350 {
 351 #ifdef CONFIG_EXT_PASSWORD
 352         if (ssid->ext_psk) {
 353                 size_t len = 4 + os_strlen(ssid->ext_psk) + 1;
 354                 char *buf = os_malloc(len);
 355                 if (buf == NULL)
 356                         return NULL;
 357                 os_snprintf(buf, len, "ext:%s", ssid->ext_psk);
 358                 return buf;
 359         }
 360 #endif /* CONFIG_EXT_PASSWORD */
 361
 362         if (ssid->passphrase)
 363                 return wpa_config_write_string_ascii(
 364                         (const u8 *) ssid->passphrase,
 365                         os_strlen(ssid->passphrase));
 366
 367         if (ssid->psk_set)
 368                 return wpa_config_write_string_hex(ssid->psk, PMK_LEN);
 369
 370         return NULL;
 371 }
 372 #endif /* NO_CONFIG_WRITE */
 373
 374
 375 static int wpa_config_parse_proto(const struct parse_data *data,
 376                                   struct wpa_ssid *ssid, int line,
 377                                   const char *value)
 378 {
 379         int val = 0, last, errors = 0;
 380         char *start, *end, *buf;
 381
 382         buf = os_strdup(value);
 383         if (buf == NULL)
 384                 return -1;
 385         start = buf;
 386
 387         while (*start != '\0') {
 388                 while (*start == ' ' || *start == '\t')
 389                         start++;
 390                 if (*start == '\0')
 391                         break;
 392                 end = start;
 393                 while (*end != ' ' && *end != '\t' && *end != '\0')
 394                         end++;
 395                 last = *end == '\0';
 396                 *end = '\0';
 397                 if (os_strcmp(start, "WPA") == 0)
 398                         val |= WPA_PROTO_WPA;
 399                 else if (os_strcmp(start, "RSN") == 0 ||
 400                          os_strcmp(start, "WPA2") == 0)
 401                         val |= WPA_PROTO_RSN;
 402                 else {
 403                         wpa_printf(MSG_ERROR, "Line %d: invalid proto '%s'",
 404                                    line, start);
 405                         errors++;
 406                 }
 407
 408                 if (last)
 409                         break;
 410                 start = end + 1;
 411         }
 412         os_free(buf);
 413
 414         if (val == 0) {
 415                 wpa_printf(MSG_ERROR,
 416                            "Line %d: no proto values configured.", line);
 417                 errors++;
 418         }
 419
 420         wpa_printf(MSG_MSGDUMP, "proto: 0x%x", val);
 421         ssid->proto = val;
 422         return errors ? -1 : 0;
 423 }
 424
 425
 426 #ifndef NO_CONFIG_WRITE
 427 static char * wpa_config_write_proto(const struct parse_data *data,
 428                                      struct wpa_ssid *ssid)
 429 {
 430         int first = 1, ret;
 431         char *buf, *pos, *end;
 432
 433         pos = buf = os_zalloc(10);
 434         if (buf == NULL)
 435                 return NULL;
 436         end = buf + 10;
 437
 438         if (ssid->proto & WPA_PROTO_WPA) {
 439                 ret = os_snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
 440                 if (ret < 0 || ret >= end - pos)
 441                         return buf;
 442                 pos += ret;
 443                 first = 0;
 444         }
 445
 446         if (ssid->proto & WPA_PROTO_RSN) {
 447                 ret = os_snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
 448                 if (ret < 0 || ret >= end - pos)
 449                         return buf;
 450                 pos += ret;
 451                 first = 0;
 452         }
 453
 454         return buf;
 455 }
 456 #endif /* NO_CONFIG_WRITE */
 457
 458
 459 static int wpa_config_parse_key_mgmt(const struct parse_data *data,
 460                                      struct wpa_ssid *ssid, int line,
 461                                      const char *value)
 462 {
 463         int val = 0, last, errors = 0;
 464         char *start, *end, *buf;
 465
 466         buf = os_strdup(value);
 467         if (buf == NULL)
 468                 return -1;
 469         start = buf;
 470
 471         while (*start != '\0') {
 472                 while (*start == ' ' || *start == '\t')
 473                         start++;
 474                 if (*start == '\0')
 475                         break;
 476                 end = start;
 477                 while (*end != ' ' && *end != '\t' && *end != '\0')
 478                         end++;
 479                 last = *end == '\0';
 480                 *end = '\0';
 481                 if (os_strcmp(start, "WPA-PSK") == 0)
 482                         val |= WPA_KEY_MGMT_PSK;
 483                 else if (os_strcmp(start, "WPA-EAP") == 0)
 484                         val |= WPA_KEY_MGMT_IEEE8021X;
 485                 else if (os_strcmp(start, "IEEE8021X") == 0)
 486                         val |= WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 487                 else if (os_strcmp(start, "NONE") == 0)
 488                         val |= WPA_KEY_MGMT_NONE;
 489                 else if (os_strcmp(start, "WPA-NONE") == 0)
 490                         val |= WPA_KEY_MGMT_WPA_NONE;
 491 #ifdef CONFIG_IEEE80211R
 492                 else if (os_strcmp(start, "FT-PSK") == 0)
 493                         val |= WPA_KEY_MGMT_FT_PSK;
 494                 else if (os_strcmp(start, "FT-EAP") == 0)
 495                         val |= WPA_KEY_MGMT_FT_IEEE8021X;
 496 #endif /* CONFIG_IEEE80211R */
 497 #ifdef CONFIG_IEEE80211W
 498                 else if (os_strcmp(start, "WPA-PSK-SHA256") == 0)
 499                         val |= WPA_KEY_MGMT_PSK_SHA256;
 500                 else if (os_strcmp(start, "WPA-EAP-SHA256") == 0)
 501                         val |= WPA_KEY_MGMT_IEEE8021X_SHA256;
 502 #endif /* CONFIG_IEEE80211W */
 503 #ifdef CONFIG_WPS
 504                 else if (os_strcmp(start, "WPS") == 0)
 505                         val |= WPA_KEY_MGMT_WPS;
 506 #endif /* CONFIG_WPS */
 507                 else {
 508                         wpa_printf(MSG_ERROR, "Line %d: invalid key_mgmt '%s'",
 509                                    line, start);
 510                         errors++;
 511                 }
 512
 513                 if (last)
 514                         break;
 515                 start = end + 1;
 516         }
 517         os_free(buf);
 518
 519         if (val == 0) {
 520                 wpa_printf(MSG_ERROR,
 521                            "Line %d: no key_mgmt values configured.", line);
 522                 errors++;
 523         }
 524
 525         wpa_printf(MSG_MSGDUMP, "key_mgmt: 0x%x", val);
 526         ssid->key_mgmt = val;
 527         return errors ? -1 : 0;
 528 }
 529
 530
 531 #ifndef NO_CONFIG_WRITE
 532 static char * wpa_config_write_key_mgmt(const struct parse_data *data,
 533                                         struct wpa_ssid *ssid)
 534 {
 535         char *buf, *pos, *end;
 536         int ret;
 537
 538         pos = buf = os_zalloc(50);
 539         if (buf == NULL)
 540                 return NULL;
 541         end = buf + 50;
 542
 543         if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
 544                 ret = os_snprintf(pos, end - pos, "%sWPA-PSK",
 545                                   pos == buf ? "" : " ");
 546                 if (ret < 0 || ret >= end - pos) {
 547                         end[-1] = '\0';
 548                         return buf;
 549                 }
 550                 pos += ret;
 551         }
 552
 553         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 554                 ret = os_snprintf(pos, end - pos, "%sWPA-EAP",
 555                                   pos == buf ? "" : " ");
 556                 if (ret < 0 || ret >= end - pos) {
 557                         end[-1] = '\0';
 558                         return buf;
 559                 }
 560                 pos += ret;
 561         }
 562
 563         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 564                 ret = os_snprintf(pos, end - pos, "%sIEEE8021X",
 565                                   pos == buf ? "" : " ");
 566                 if (ret < 0 || ret >= end - pos) {
 567                         end[-1] = '\0';
 568                         return buf;
 569                 }
 570                 pos += ret;
 571         }
 572
 573         if (ssid->key_mgmt & WPA_KEY_MGMT_NONE) {
 574                 ret = os_snprintf(pos, end - pos, "%sNONE",
 575                                   pos == buf ? "" : " ");
 576                 if (ret < 0 || ret >= end - pos) {
 577                         end[-1] = '\0';
 578                         return buf;
 579                 }
 580                 pos += ret;
 581         }
 582
 583         if (ssid->key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
 584                 ret = os_snprintf(pos, end - pos, "%sWPA-NONE",
 585                                   pos == buf ? "" : " ");
 586                 if (ret < 0 || ret >= end - pos) {
 587                         end[-1] = '\0';
 588                         return buf;
 589                 }
 590                 pos += ret;
 591         }
 592
 593 #ifdef CONFIG_IEEE80211R
 594         if (ssid->key_mgmt & WPA_KEY_MGMT_FT_PSK)
 595                 pos += os_snprintf(pos, end - pos, "%sFT-PSK",
 596                                    pos == buf ? "" : " ");
 597
 598         if (ssid->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
 599                 pos += os_snprintf(pos, end - pos, "%sFT-EAP",
 600                                    pos == buf ? "" : " ");
 601 #endif /* CONFIG_IEEE80211R */
 602
 603 #ifdef CONFIG_IEEE80211W
 604         if (ssid->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
 605                 pos += os_snprintf(pos, end - pos, "%sWPA-PSK-SHA256",
 606                                    pos == buf ? "" : " ");
 607
 608         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
 609                 pos += os_snprintf(pos, end - pos, "%sWPA-EAP-SHA256",
 610                                    pos == buf ? "" : " ");
 611 #endif /* CONFIG_IEEE80211W */
 612
 613 #ifdef CONFIG_WPS
 614         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 615                 pos += os_snprintf(pos, end - pos, "%sWPS",
 616                                    pos == buf ? "" : " ");
 617 #endif /* CONFIG_WPS */
 618
 619         return buf;
 620 }
 621 #endif /* NO_CONFIG_WRITE */
 622
 623
 624 static int wpa_config_parse_cipher(int line, const char *value)
 625 {
 626         int val = 0, last;
 627         char *start, *end, *buf;
 628
 629         buf = os_strdup(value);
 630         if (buf == NULL)
 631                 return -1;
 632         start = buf;
 633
 634         while (*start != '\0') {
 635                 while (*start == ' ' || *start == '\t')
 636                         start++;
 637                 if (*start == '\0')
 638                         break;
 639                 end = start;
 640                 while (*end != ' ' && *end != '\t' && *end != '\0')
 641                         end++;
 642                 last = *end == '\0';
 643                 *end = '\0';
 644                 if (os_strcmp(start, "CCMP") == 0)
 645                         val |= WPA_CIPHER_CCMP;
 646                 else if (os_strcmp(start, "TKIP") == 0)
 647                         val |= WPA_CIPHER_TKIP;
 648                 else if (os_strcmp(start, "WEP104") == 0)
 649                         val |= WPA_CIPHER_WEP104;
 650                 else if (os_strcmp(start, "WEP40") == 0)
 651                         val |= WPA_CIPHER_WEP40;
 652                 else if (os_strcmp(start, "NONE") == 0)
 653                         val |= WPA_CIPHER_NONE;
 654                 else {
 655                         wpa_printf(MSG_ERROR, "Line %d: invalid cipher '%s'.",
 656                                    line, start);
 657                         os_free(buf);
 658                         return -1;
 659                 }
 660
 661                 if (last)
 662                         break;
 663                 start = end + 1;
 664         }
 665         os_free(buf);
 666
 667         if (val == 0) {
 668                 wpa_printf(MSG_ERROR, "Line %d: no cipher values configured.",
 669                            line);
 670                 return -1;
 671         }
 672         return val;
 673 }
 674
 675
 676 #ifndef NO_CONFIG_WRITE
 677 static char * wpa_config_write_cipher(int cipher)
 678 {
 679         char *buf, *pos, *end;
 680         int ret;
 681
 682         pos = buf = os_zalloc(50);
 683         if (buf == NULL)
 684                 return NULL;
 685         end = buf + 50;
 686
 687         if (cipher & WPA_CIPHER_CCMP) {
 688                 ret = os_snprintf(pos, end - pos, "%sCCMP",
 689                                   pos == buf ? "" : " ");
 690                 if (ret < 0 || ret >= end - pos) {
 691                         end[-1] = '\0';
 692                         return buf;
 693                 }
 694                 pos += ret;
 695         }
 696
 697         if (cipher & WPA_CIPHER_TKIP) {
 698                 ret = os_snprintf(pos, end - pos, "%sTKIP",
 699                                   pos == buf ? "" : " ");
 700                 if (ret < 0 || ret >= end - pos) {
 701                         end[-1] = '\0';
 702                         return buf;
 703                 }
 704                 pos += ret;
 705         }
 706
 707         if (cipher & WPA_CIPHER_WEP104) {
 708                 ret = os_snprintf(pos, end - pos, "%sWEP104",
 709                                   pos == buf ? "" : " ");
 710                 if (ret < 0 || ret >= end - pos) {
 711                         end[-1] = '\0';
 712                         return buf;
 713                 }
 714                 pos += ret;
 715         }
 716
 717         if (cipher & WPA_CIPHER_WEP40) {
 718                 ret = os_snprintf(pos, end - pos, "%sWEP40",
 719                                   pos == buf ? "" : " ");
 720                 if (ret < 0 || ret >= end - pos) {
 721                         end[-1] = '\0';
 722                         return buf;
 723                 }
 724                 pos += ret;
 725         }
 726
 727         if (cipher & WPA_CIPHER_NONE) {
 728                 ret = os_snprintf(pos, end - pos, "%sNONE",
 729                                   pos == buf ? "" : " ");
 730                 if (ret < 0 || ret >= end - pos) {
 731                         end[-1] = '\0';
 732                         return buf;
 733                 }
 734                 pos += ret;
 735         }
 736
 737         return buf;
 738 }
 739 #endif /* NO_CONFIG_WRITE */
 740
 741
 742 static int wpa_config_parse_pairwise(const struct parse_data *data,
 743                                      struct wpa_ssid *ssid, int line,
 744                                      const char *value)
 745 {
 746         int val;
 747         val = wpa_config_parse_cipher(line, value);
 748         if (val == -1)
 749                 return -1;
 750         if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_TKIP | WPA_CIPHER_NONE)) {
 751                 wpa_printf(MSG_ERROR, "Line %d: not allowed pairwise cipher "
 752                            "(0x%x).", line, val);
 753                 return -1;
 754         }
 755
 756         wpa_printf(MSG_MSGDUMP, "pairwise: 0x%x", val);
 757         ssid->pairwise_cipher = val;
 758         return 0;
 759 }
 760
 761
 762 #ifndef NO_CONFIG_WRITE
 763 static char * wpa_config_write_pairwise(const struct parse_data *data,
 764                                         struct wpa_ssid *ssid)
 765 {
 766         return wpa_config_write_cipher(ssid->pairwise_cipher);
 767 }
 768 #endif /* NO_CONFIG_WRITE */
 769
 770
 771 static int wpa_config_parse_group(const struct parse_data *data,
 772                                   struct wpa_ssid *ssid, int line,
 773                                   const char *value)
 774 {
 775         int val;
 776         val = wpa_config_parse_cipher(line, value);
 777         if (val == -1)
 778                 return -1;
 779         if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_TKIP | WPA_CIPHER_WEP104 |
 780                     WPA_CIPHER_WEP40)) {
 781                 wpa_printf(MSG_ERROR, "Line %d: not allowed group cipher "
 782                            "(0x%x).", line, val);
 783                 return -1;
 784         }
 785
 786         wpa_printf(MSG_MSGDUMP, "group: 0x%x", val);
 787         ssid->group_cipher = val;
 788         return 0;
 789 }
 790
 791
 792 #ifndef NO_CONFIG_WRITE
 793 static char * wpa_config_write_group(const struct parse_data *data,
 794                                      struct wpa_ssid *ssid)
 795 {
 796         return wpa_config_write_cipher(ssid->group_cipher);
 797 }
 798 #endif /* NO_CONFIG_WRITE */
 799
 800
 801 static int wpa_config_parse_auth_alg(const struct parse_data *data,
 802                                      struct wpa_ssid *ssid, int line,
 803                                      const char *value)
 804 {
 805         int val = 0, last, errors = 0;
 806         char *start, *end, *buf;
 807
 808         buf = os_strdup(value);
 809         if (buf == NULL)
 810                 return -1;
 811         start = buf;
 812
 813         while (*start != '\0') {
 814                 while (*start == ' ' || *start == '\t')
 815                         start++;
 816                 if (*start == '\0')
 817                         break;
 818                 end = start;
 819                 while (*end != ' ' && *end != '\t' && *end != '\0')
 820                         end++;
 821                 last = *end == '\0';
 822                 *end = '\0';
 823                 if (os_strcmp(start, "OPEN") == 0)
 824                         val |= WPA_AUTH_ALG_OPEN;
 825                 else if (os_strcmp(start, "SHARED") == 0)
 826                         val |= WPA_AUTH_ALG_SHARED;
 827                 else if (os_strcmp(start, "LEAP") == 0)
 828                         val |= WPA_AUTH_ALG_LEAP;
 829                 else {
 830                         wpa_printf(MSG_ERROR, "Line %d: invalid auth_alg '%s'",
 831                                    line, start);
 832                         errors++;
 833                 }
 834
 835                 if (last)
 836                         break;
 837                 start = end + 1;
 838         }
 839         os_free(buf);
 840
 841         if (val == 0) {
 842                 wpa_printf(MSG_ERROR,
 843                            "Line %d: no auth_alg values configured.", line);
 844                 errors++;
 845         }
 846
 847         wpa_printf(MSG_MSGDUMP, "auth_alg: 0x%x", val);
 848         ssid->auth_alg = val;
 849         return errors ? -1 : 0;
 850 }
 851
 852
 853 #ifndef NO_CONFIG_WRITE
 854 static char * wpa_config_write_auth_alg(const struct parse_data *data,
 855                                         struct wpa_ssid *ssid)
 856 {
 857         char *buf, *pos, *end;
 858         int ret;
 859
 860         pos = buf = os_zalloc(30);
 861         if (buf == NULL)
 862                 return NULL;
 863         end = buf + 30;
 864
 865         if (ssid->auth_alg & WPA_AUTH_ALG_OPEN) {
 866                 ret = os_snprintf(pos, end - pos, "%sOPEN",
 867                                   pos == buf ? "" : " ");
 868                 if (ret < 0 || ret >= end - pos) {
 869                         end[-1] = '\0';
 870                         return buf;
 871                 }
 872                 pos += ret;
 873         }
 874
 875         if (ssid->auth_alg & WPA_AUTH_ALG_SHARED) {
 876                 ret = os_snprintf(pos, end - pos, "%sSHARED",
 877                                   pos == buf ? "" : " ");
 878                 if (ret < 0 || ret >= end - pos) {
 879                         end[-1] = '\0';
 880                         return buf;
 881                 }
 882                 pos += ret;
 883         }
 884
 885         if (ssid->auth_alg & WPA_AUTH_ALG_LEAP) {
 886                 ret = os_snprintf(pos, end - pos, "%sLEAP",
 887                                   pos == buf ? "" : " ");
 888                 if (ret < 0 || ret >= end - pos) {
 889                         end[-1] = '\0';
 890                         return buf;
 891                 }
 892                 pos += ret;
 893         }
 894
 895         return buf;
 896 }
 897 #endif /* NO_CONFIG_WRITE */
 898
 899
 900 static int * wpa_config_parse_freqs(const struct parse_data *data,
 901                                     struct wpa_ssid *ssid, int line,
 902                                     const char *value)
 903 {
 904         int *freqs;
 905         size_t used, len;
 906         const char *pos;
 907
 908         used = 0;
 909         len = 10;
 910         freqs = os_zalloc((len + 1) * sizeof(int));
 911         if (freqs == NULL)
 912                 return NULL;
 913
 914         pos = value;
 915         while (pos) {
 916                 while (*pos == ' ')
 917                         pos++;
 918                 if (used == len) {
 919                         int *n;
 920                         size_t i;
 921                         n = os_realloc(freqs, (len * 2 + 1) * sizeof(int));
 922                         if (n == NULL) {
 923                                 os_free(freqs);
 924                                 return NULL;
 925                         }
 926                         for (i = len; i <= len * 2; i++)
 927                                 n[i] = 0;
 928                         freqs = n;
 929                         len *= 2;
 930                 }
 931
 932                 freqs[used] = atoi(pos);
 933                 if (freqs[used] == 0)
 934                         break;
 935                 used++;
 936                 pos = os_strchr(pos + 1, ' ');
 937         }
 938
 939         return freqs;
 940 }
 941
 942
 943 static int wpa_config_parse_scan_freq(const struct parse_data *data,
 944                                       struct wpa_ssid *ssid, int line,
 945                                       const char *value)
 946 {
 947         int *freqs;
 948
 949         freqs = wpa_config_parse_freqs(data, ssid, line, value);
 950         if (freqs == NULL)
 951                 return -1;
 952         os_free(ssid->scan_freq);
 953         ssid->scan_freq = freqs;
 954
 955         return 0;
 956 }
 957
 958
 959 static int wpa_config_parse_freq_list(const struct parse_data *data,
 960                                       struct wpa_ssid *ssid, int line,
 961                                       const char *value)
 962 {
 963         int *freqs;
 964
 965         freqs = wpa_config_parse_freqs(data, ssid, line, value);
 966         if (freqs == NULL)
 967                 return -1;
 968         os_free(ssid->freq_list);
 969         ssid->freq_list = freqs;
 970
 971         return 0;
 972 }
 973
 974
 975 #ifndef NO_CONFIG_WRITE
 976 static char * wpa_config_write_freqs(const struct parse_data *data,
 977                                      const int *freqs)
 978 {
 979         char *buf, *pos, *end;
 980         int i, ret;
 981         size_t count;
 982
 983         if (freqs == NULL)
 984                 return NULL;
 985
 986         count = 0;
 987         for (i = 0; freqs[i]; i++)
 988                 count++;
 989
 990         pos = buf = os_zalloc(10 * count + 1);
 991         if (buf == NULL)
 992                 return NULL;
 993         end = buf + 10 * count + 1;
 994
 995         for (i = 0; freqs[i]; i++) {
 996                 ret = os_snprintf(pos, end - pos, "%s%u",
 997                                   i == 0 ? "" : " ", freqs[i]);
 998                 if (ret < 0 || ret >= end - pos) {
 999                         end[-1] = '\0';
1000                         return buf;
1001                 }
1002                 pos += ret;
1003         }
1004
1005         return buf;
1006 }
1007
1008
1009 static char * wpa_config_write_scan_freq(const struct parse_data *data,
1010                                          struct wpa_ssid *ssid)
1011 {
1012         return wpa_config_write_freqs(data, ssid->scan_freq);
1013 }
1014
1015
1016 static char * wpa_config_write_freq_list(const struct parse_data *data,
1017                                          struct wpa_ssid *ssid)
1018 {
1019         return wpa_config_write_freqs(data, ssid->freq_list);
1020 }
1021 #endif /* NO_CONFIG_WRITE */
1022
1023
1024 #ifdef IEEE8021X_EAPOL
1025 static int wpa_config_parse_eap(const struct parse_data *data,
1026                                 struct wpa_ssid *ssid, int line,
1027                                 const char *value)
1028 {
1029         int last, errors = 0;
1030         char *start, *end, *buf;
1031         struct eap_method_type *methods = NULL, *tmp;
1032         size_t num_methods = 0;
1033
1034         buf = os_strdup(value);
1035         if (buf == NULL)
1036                 return -1;
1037         start = buf;
1038
1039         while (*start != '\0') {
1040                 while (*start == ' ' || *start == '\t')
1041                         start++;
1042                 if (*start == '\0')
1043                         break;
1044                 end = start;
1045                 while (*end != ' ' && *end != '\t' && *end != '\0')
1046                         end++;
1047                 last = *end == '\0';
1048                 *end = '\0';
1049                 tmp = methods;
1050                 methods = os_realloc(methods,
1051                                      (num_methods + 1) * sizeof(*methods));
1052                 if (methods == NULL) {
1053                         os_free(tmp);
1054                         os_free(buf);
1055                         return -1;
1056                 }
1057                 methods[num_methods].method = eap_peer_get_type(
1058                         start, &methods[num_methods].vendor);
1059                 if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
1060                     methods[num_methods].method == EAP_TYPE_NONE) {
1061                         wpa_printf(MSG_ERROR, "Line %d: unknown EAP method "
1062                                    "'%s'", line, start);
1063                         wpa_printf(MSG_ERROR, "You may need to add support for"
1064                                    " this EAP method during wpa_supplicant\n"
1065                                    "build time configuration.\n"
1066                                    "See README for more information.");
1067                         errors++;
1068                 } else if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
1069                            methods[num_methods].method == EAP_TYPE_LEAP)
1070                         ssid->leap++;
1071                 else
1072                         ssid->non_leap++;
1073                 num_methods++;
1074                 if (last)
1075                         break;
1076                 start = end + 1;
1077         }
1078         os_free(buf);
1079
1080         tmp = methods;
1081         methods = os_realloc(methods, (num_methods + 1) * sizeof(*methods));
1082         if (methods == NULL) {
1083                 os_free(tmp);
1084                 return -1;
1085         }
1086         methods[num_methods].vendor = EAP_VENDOR_IETF;
1087         methods[num_methods].method = EAP_TYPE_NONE;
1088         num_methods++;
1089
1090         wpa_hexdump(MSG_MSGDUMP, "eap methods",
1091                     (u8 *) methods, num_methods * sizeof(*methods));
1092         os_free(ssid->eap.eap_methods);
1093         ssid->eap.eap_methods = methods;
1094         return errors ? -1 : 0;
1095 }
1096
1097
1098 static char * wpa_config_write_eap(const struct parse_data *data,
1099                                    struct wpa_ssid *ssid)
1100 {
1101         int i, ret;
1102         char *buf, *pos, *end;
1103         const struct eap_method_type *eap_methods = ssid->eap.eap_methods;
1104         const char *name;
1105
1106         if (eap_methods == NULL)
1107                 return NULL;
1108
1109         pos = buf = os_zalloc(100);
1110         if (buf == NULL)
1111                 return NULL;
1112         end = buf + 100;
1113
1114         for (i = 0; eap_methods[i].vendor != EAP_VENDOR_IETF ||
1115                      eap_methods[i].method != EAP_TYPE_NONE; i++) {
1116                 name = eap_get_name(eap_methods[i].vendor,
1117                                     eap_methods[i].method);
1118                 if (name) {
1119                         ret = os_snprintf(pos, end - pos, "%s%s",
1120                                           pos == buf ? "" : " ", name);
1121                         if (ret < 0 || ret >= end - pos)
1122                                 break;
1123                         pos += ret;
1124                 }
1125         }
1126
1127         end[-1] = '\0';
1128
1129         return buf;
1130 }
1131
1132
1133 static int wpa_config_parse_password(const struct parse_data *data,
1134                                      struct wpa_ssid *ssid, int line,
1135                                      const char *value)
1136 {
1137         u8 *hash;
1138
1139         if (os_strcmp(value, "NULL") == 0) {
1140                 wpa_printf(MSG_DEBUG, "Unset configuration string 'password'");
1141                 os_free(ssid->eap.password);
1142                 ssid->eap.password = NULL;
1143                 ssid->eap.password_len = 0;
1144                 return 0;
1145         }
1146
1147 #ifdef CONFIG_EXT_PASSWORD
1148         if (os_strncmp(value, "ext:", 4) == 0) {
1149                 char *name = os_strdup(value + 4);
1150                 if (name == NULL)
1151                         return -1;
1152                 os_free(ssid->eap.password);
1153                 ssid->eap.password = (u8 *) name;
1154                 ssid->eap.password_len = os_strlen(name);
1155                 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1156                 ssid->eap.flags |= EAP_CONFIG_FLAGS_EXT_PASSWORD;
1157                 return 0;
1158         }
1159 #endif /* CONFIG_EXT_PASSWORD */
1160
1161         if (os_strncmp(value, "hash:", 5) != 0) {
1162                 char *tmp;
1163                 size_t res_len;
1164
1165                 tmp = wpa_config_parse_string(value, &res_len);
1166                 if (tmp == NULL) {
1167                         wpa_printf(MSG_ERROR, "Line %d: failed to parse "
1168                                    "password.", line);
1169                         return -1;
1170                 }
1171                 wpa_hexdump_ascii_key(MSG_MSGDUMP, data->name,
1172                                       (u8 *) tmp, res_len);
1173
1174                 os_free(ssid->eap.password);
1175                 ssid->eap.password = (u8 *) tmp;
1176                 ssid->eap.password_len = res_len;
1177                 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1178                 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_EXT_PASSWORD;
1179
1180                 return 0;
1181         }
1182
1183
1184         /* NtPasswordHash: hash:<32 hex digits> */
1185         if (os_strlen(value + 5) != 2 * 16) {
1186                 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash length "
1187                            "(expected 32 hex digits)", line);
1188                 return -1;
1189         }
1190
1191         hash = os_malloc(16);
1192         if (hash == NULL)
1193                 return -1;
1194
1195         if (hexstr2bin(value + 5, hash, 16)) {
1196                 os_free(hash);
1197                 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash", line);
1198                 return -1;
1199         }
1200
1201         wpa_hexdump_key(MSG_MSGDUMP, data->name, hash, 16);
1202
1203         os_free(ssid->eap.password);
1204         ssid->eap.password = hash;
1205         ssid->eap.password_len = 16;
1206         ssid->eap.flags |= EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1207         ssid->eap.flags &= ~EAP_CONFIG_FLAGS_EXT_PASSWORD;
1208
1209         return 0;
1210 }
1211
1212
1213 static char * wpa_config_write_password(const struct parse_data *data,
1214                                         struct wpa_ssid *ssid)
1215 {
1216         char *buf;
1217
1218         if (ssid->eap.password == NULL)
1219                 return NULL;
1220
1221 #ifdef CONFIG_EXT_PASSWORD
1222         if (ssid->eap.flags & EAP_CONFIG_FLAGS_EXT_PASSWORD) {
1223                 buf = os_zalloc(4 + ssid->eap.password_len + 1);
1224                 if (buf == NULL)
1225                         return NULL;
1226                 os_memcpy(buf, "ext:", 4);
1227                 os_memcpy(buf + 4, ssid->eap.password, ssid->eap.password_len);
1228                 return buf;
1229         }
1230 #endif /* CONFIG_EXT_PASSWORD */
1231
1232         if (!(ssid->eap.flags & EAP_CONFIG_FLAGS_PASSWORD_NTHASH)) {
1233                 return wpa_config_write_string(
1234                         ssid->eap.password, ssid->eap.password_len);
1235         }
1236
1237         buf = os_malloc(5 + 32 + 1);
1238         if (buf == NULL)
1239                 return NULL;
1240
1241         os_memcpy(buf, "hash:", 5);
1242         wpa_snprintf_hex(buf + 5, 32 + 1, ssid->eap.password, 16);
1243
1244         return buf;
1245 }
1246 #endif /* IEEE8021X_EAPOL */
1247
1248
1249 static int wpa_config_parse_wep_key(u8 *key, size_t *len, int line,
1250                                     const char *value, int idx)
1251 {
1252         char *buf, title[20];
1253         int res;
1254
1255         buf = wpa_config_parse_string(value, len);
1256         if (buf == NULL) {
1257                 wpa_printf(MSG_ERROR, "Line %d: Invalid WEP key %d '%s'.",
1258                            line, idx, value);
1259                 return -1;
1260         }
1261         if (*len > MAX_WEP_KEY_LEN) {
1262                 wpa_printf(MSG_ERROR, "Line %d: Too long WEP key %d '%s'.",
1263                            line, idx, value);
1264                 os_free(buf);
1265                 return -1;
1266         }
1267         if (*len && *len != 5 && *len != 13 && *len != 16) {
1268                 wpa_printf(MSG_ERROR, "Line %d: Invalid WEP key length %u - "
1269                            "this network block will be ignored",
1270                            line, (unsigned int) *len);
1271         }
1272         os_memcpy(key, buf, *len);
1273         os_free(buf);
1274         res = os_snprintf(title, sizeof(title), "wep_key%d", idx);
1275         if (res >= 0 && (size_t) res < sizeof(title))
1276                 wpa_hexdump_key(MSG_MSGDUMP, title, key, *len);
1277         return 0;
1278 }
1279
1280
1281 static int wpa_config_parse_wep_key0(const struct parse_data *data,
1282                                      struct wpa_ssid *ssid, int line,
1283                                      const char *value)
1284 {
1285         return wpa_config_parse_wep_key(ssid->wep_key[0],
1286                                         &ssid->wep_key_len[0], line,
1287                                         value, 0);
1288 }
1289
1290
1291 static int wpa_config_parse_wep_key1(const struct parse_data *data,
1292                                      struct wpa_ssid *ssid, int line,
1293                                      const char *value)
1294 {
1295         return wpa_config_parse_wep_key(ssid->wep_key[1],
1296                                         &ssid->wep_key_len[1], line,
1297                                         value, 1);
1298 }
1299
1300
1301 static int wpa_config_parse_wep_key2(const struct parse_data *data,
1302                                      struct wpa_ssid *ssid, int line,
1303                                      const char *value)
1304 {
1305         return wpa_config_parse_wep_key(ssid->wep_key[2],
1306                                         &ssid->wep_key_len[2], line,
1307                                         value, 2);
1308 }
1309
1310
1311 static int wpa_config_parse_wep_key3(const struct parse_data *data,
1312                                      struct wpa_ssid *ssid, int line,
1313                                      const char *value)
1314 {
1315         return wpa_config_parse_wep_key(ssid->wep_key[3],
1316                                         &ssid->wep_key_len[3], line,
1317                                         value, 3);
1318 }
1319
1320
1321 #ifndef NO_CONFIG_WRITE
1322 static char * wpa_config_write_wep_key(struct wpa_ssid *ssid, int idx)
1323 {
1324         if (ssid->wep_key_len[idx] == 0)
1325                 return NULL;
1326         return wpa_config_write_string(ssid->wep_key[idx],
1327                                        ssid->wep_key_len[idx]);
1328 }
1329
1330
1331 static char * wpa_config_write_wep_key0(const struct parse_data *data,
1332                                         struct wpa_ssid *ssid)
1333 {
1334         return wpa_config_write_wep_key(ssid, 0);
1335 }
1336
1337
1338 static char * wpa_config_write_wep_key1(const struct parse_data *data,
1339                                         struct wpa_ssid *ssid)
1340 {
1341         return wpa_config_write_wep_key(ssid, 1);
1342 }
1343
1344
1345 static char * wpa_config_write_wep_key2(const struct parse_data *data,
1346                                         struct wpa_ssid *ssid)
1347 {
1348         return wpa_config_write_wep_key(ssid, 2);
1349 }
1350
1351
1352 static char * wpa_config_write_wep_key3(const struct parse_data *data,
1353                                         struct wpa_ssid *ssid)
1354 {
1355         return wpa_config_write_wep_key(ssid, 3);
1356 }
1357 #endif /* NO_CONFIG_WRITE */
1358
1359
1360 #ifdef CONFIG_P2P
1361
1362 static int wpa_config_parse_p2p_client_list(const struct parse_data *data,
1363                                             struct wpa_ssid *ssid, int line,
1364                                             const char *value)
1365 {
1366         const char *pos;
1367         u8 *buf, *n, addr[ETH_ALEN];
1368         size_t count;
1369
1370         buf = NULL;
1371         count = 0;
1372
1373         pos = value;
1374         while (pos && *pos) {
1375                 while (*pos == ' ')
1376                         pos++;
1377
1378                 if (hwaddr_aton(pos, addr)) {
1379                         wpa_printf(MSG_ERROR, "Line %d: Invalid "
1380                                    "p2p_client_list address '%s'.",
1381                                    line, value);
1382                         /* continue anyway */
1383                 } else {
1384                         n = os_realloc(buf, (count + 1) * ETH_ALEN);
1385                         if (n == NULL) {
1386                                 os_free(buf);
1387                                 return -1;
1388                         }
1389                         buf = n;
1390                         os_memcpy(buf + count * ETH_ALEN, addr, ETH_ALEN);
1391                         count++;
1392                         wpa_hexdump(MSG_MSGDUMP, "p2p_client_list",
1393                                     addr, ETH_ALEN);
1394                 }
1395
1396                 pos = os_strchr(pos, ' ');
1397         }
1398
1399         os_free(ssid->p2p_client_list);
1400         ssid->p2p_client_list = buf;
1401         ssid->num_p2p_clients = count;
1402
1403         return 0;
1404 }
1405
1406
1407 #ifndef NO_CONFIG_WRITE
1408 static char * wpa_config_write_p2p_client_list(const struct parse_data *data,
1409                                                struct wpa_ssid *ssid)
1410 {
1411         char *value, *end, *pos;
1412         int res;
1413         size_t i;
1414
1415         if (ssid->p2p_client_list == NULL || ssid->num_p2p_clients == 0)
1416                 return NULL;
1417
1418         value = os_malloc(20 * ssid->num_p2p_clients);
1419         if (value == NULL)
1420                 return NULL;
1421         pos = value;
1422         end = value + 20 * ssid->num_p2p_clients;
1423
1424         for (i = 0; i < ssid->num_p2p_clients; i++) {
1425                 res = os_snprintf(pos, end - pos, MACSTR " ",
1426                                   MAC2STR(ssid->p2p_client_list +
1427                                           i * ETH_ALEN));
1428                 if (res < 0 || res >= end - pos) {
1429                         os_free(value);
1430                         return NULL;
1431                 }
1432                 pos += res;
1433         }
1434
1435         if (pos > value)
1436                 pos[-1] = '\0';
1437
1438         return value;
1439 }
1440 #endif /* NO_CONFIG_WRITE */
1441
1442 #endif /* CONFIG_P2P */
1443
1444 /* Helper macros for network block parser */
1445
1446 #ifdef OFFSET
1447 #undef OFFSET
1448 #endif /* OFFSET */
1449 /* OFFSET: Get offset of a variable within the wpa_ssid structure */
1450 #define OFFSET(v) ((void *) &((struct wpa_ssid *) 0)->v)
1451
1452 /* STR: Define a string variable for an ASCII string; f = field name */
1453 #ifdef NO_CONFIG_WRITE
1454 #define _STR(f) #f, wpa_config_parse_str, OFFSET(f)
1455 #define _STRe(f) #f, wpa_config_parse_str, OFFSET(eap.f)
1456 #else /* NO_CONFIG_WRITE */
1457 #define _STR(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(f)
1458 #define _STRe(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(eap.f)
1459 #endif /* NO_CONFIG_WRITE */
1460 #define STR(f) _STR(f), NULL, NULL, NULL, 0
1461 #define STRe(f) _STRe(f), NULL, NULL, NULL, 0
1462 #define STR_KEY(f) _STR(f), NULL, NULL, NULL, 1
1463 #define STR_KEYe(f) _STRe(f), NULL, NULL, NULL, 1
1464
1465 /* STR_LEN: Define a string variable with a separate variable for storing the
1466  * data length. Unlike STR(), this can be used to store arbitrary binary data
1467  * (i.e., even nul termination character). */
1468 #define _STR_LEN(f) _STR(f), OFFSET(f ## _len)
1469 #define _STR_LENe(f) _STRe(f), OFFSET(eap.f ## _len)
1470 #define STR_LEN(f) _STR_LEN(f), NULL, NULL, 0
1471 #define STR_LENe(f) _STR_LENe(f), NULL, NULL, 0
1472 #define STR_LEN_KEY(f) _STR_LEN(f), NULL, NULL, 1
1473
1474 /* STR_RANGE: Like STR_LEN(), but with minimum and maximum allowed length
1475  * explicitly specified. */
1476 #define _STR_RANGE(f, min, max) _STR_LEN(f), (void *) (min), (void *) (max)
1477 #define STR_RANGE(f, min, max) _STR_RANGE(f, min, max), 0
1478 #define STR_RANGE_KEY(f, min, max) _STR_RANGE(f, min, max), 1
1479
1480 #ifdef NO_CONFIG_WRITE
1481 #define _INT(f) #f, wpa_config_parse_int, OFFSET(f), (void *) 0
1482 #define _INTe(f) #f, wpa_config_parse_int, OFFSET(eap.f), (void *) 0
1483 #else /* NO_CONFIG_WRITE */
1484 #define _INT(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1485         OFFSET(f), (void *) 0
1486 #define _INTe(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1487         OFFSET(eap.f), (void *) 0
1488 #endif /* NO_CONFIG_WRITE */
1489
1490 /* INT: Define an integer variable */
1491 #define INT(f) _INT(f), NULL, NULL, 0
1492 #define INTe(f) _INTe(f), NULL, NULL, 0
1493
1494 /* INT_RANGE: Define an integer variable with allowed value range */
1495 #define INT_RANGE(f, min, max) _INT(f), (void *) (min), (void *) (max), 0
1496
1497 /* FUNC: Define a configuration variable that uses a custom function for
1498  * parsing and writing the value. */
1499 #ifdef NO_CONFIG_WRITE
1500 #define _FUNC(f) #f, wpa_config_parse_ ## f, NULL, NULL, NULL, NULL
1501 #else /* NO_CONFIG_WRITE */
1502 #define _FUNC(f) #f, wpa_config_parse_ ## f, wpa_config_write_ ## f, \
1503         NULL, NULL, NULL, NULL
1504 #endif /* NO_CONFIG_WRITE */
1505 #define FUNC(f) _FUNC(f), 0
1506 #define FUNC_KEY(f) _FUNC(f), 1
1507
1508 /*
1509  * Table of network configuration variables. This table is used to parse each
1510  * network configuration variable, e.g., each line in wpa_supplicant.conf file
1511  * that is inside a network block.
1512  *
1513  * This table is generated using the helper macros defined above and with
1514  * generous help from the C pre-processor. The field name is stored as a string
1515  * into .name and for STR and INT types, the offset of the target buffer within
1516  * struct wpa_ssid is stored in .param1. .param2 (if not NULL) is similar
1517  * offset to the field containing the length of the configuration variable.
1518  * .param3 and .param4 can be used to mark the allowed range (length for STR
1519  * and value for INT).
1520  *
1521  * For each configuration line in wpa_supplicant.conf, the parser goes through
1522  * this table and select the entry that matches with the field name. The parser
1523  * function (.parser) is then called to parse the actual value of the field.
1524  *
1525  * This kind of mechanism makes it easy to add new configuration parameters,
1526  * since only one line needs to be added into this table and into the
1527  * struct wpa_ssid definition if the new variable is either a string or
1528  * integer. More complex types will need to use their own parser and writer
1529  * functions.
1530  */
1531 static const struct parse_data ssid_fields[] = {
1532         { STR_RANGE(ssid, 0, MAX_SSID_LEN) },
1533         { INT_RANGE(scan_ssid, 0, 1) },
1534         { FUNC(bssid) },
1535         { FUNC_KEY(psk) },
1536         { FUNC(proto) },
1537         { FUNC(key_mgmt) },
1538         { INT(bg_scan_period) },
1539         { FUNC(pairwise) },
1540         { FUNC(group) },
1541         { FUNC(auth_alg) },
1542         { FUNC(scan_freq) },
1543         { FUNC(freq_list) },
1544 #ifdef IEEE8021X_EAPOL
1545         { FUNC(eap) },
1546         { STR_LENe(identity) },
1547         { STR_LENe(anonymous_identity) },
1548         { FUNC_KEY(password) },
1549         { STRe(ca_cert) },
1550         { STRe(ca_path) },
1551         { STRe(client_cert) },
1552         { STRe(private_key) },
1553         { STR_KEYe(private_key_passwd) },
1554         { STRe(dh_file) },
1555         { STRe(subject_match) },
1556         { STRe(altsubject_match) },
1557         { STRe(ca_cert2) },
1558         { STRe(ca_path2) },
1559         { STRe(client_cert2) },
1560         { STRe(private_key2) },
1561         { STR_KEYe(private_key2_passwd) },
1562         { STRe(dh_file2) },
1563         { STRe(subject_match2) },
1564         { STRe(altsubject_match2) },
1565         { STRe(phase1) },
1566         { STRe(phase2) },
1567         { STRe(pcsc) },
1568         { STR_KEYe(pin) },
1569         { STRe(engine_id) },
1570         { STRe(key_id) },
1571         { STRe(cert_id) },
1572         { STRe(ca_cert_id) },
1573         { STR_KEYe(pin2) },
1574         { STRe(engine2_id) },
1575         { STRe(key2_id) },
1576         { STRe(cert2_id) },
1577         { STRe(ca_cert2_id) },
1578         { INTe(engine) },
1579         { INTe(engine2) },
1580         { INT(eapol_flags) },
1581 #endif /* IEEE8021X_EAPOL */
1582         { FUNC_KEY(wep_key0) },
1583         { FUNC_KEY(wep_key1) },
1584         { FUNC_KEY(wep_key2) },
1585         { FUNC_KEY(wep_key3) },
1586         { INT(wep_tx_keyidx) },
1587         { INT(priority) },
1588 #ifdef IEEE8021X_EAPOL
1589         { INT(eap_workaround) },
1590         { STRe(pac_file) },
1591         { INTe(fragment_size) },
1592 #endif /* IEEE8021X_EAPOL */
1593         { INT_RANGE(mode, 0, 4) },
1594         { INT_RANGE(proactive_key_caching, 0, 1) },
1595         { INT_RANGE(disabled, 0, 2) },
1596         { STR(id_str) },
1597 #ifdef CONFIG_IEEE80211W
1598         { INT_RANGE(ieee80211w, 0, 2) },
1599 #endif /* CONFIG_IEEE80211W */
1600         { INT_RANGE(peerkey, 0, 1) },
1601         { INT_RANGE(mixed_cell, 0, 1) },
1602         { INT_RANGE(frequency, 0, 10000) },
1603         { INT(wpa_ptk_rekey) },
1604         { STR(bgscan) },
1605         { INT_RANGE(ignore_broadcast_ssid, 0, 2) },
1606 #ifdef CONFIG_P2P
1607         { FUNC(p2p_client_list) },
1608 #endif /* CONFIG_P2P */
1609 #ifdef CONFIG_HT_OVERRIDES
1610         { INT_RANGE(disable_ht, 0, 1) },
1611         { INT_RANGE(disable_ht40, -1, 1) },
1612         { INT_RANGE(disable_max_amsdu, -1, 1) },
1613         { INT_RANGE(ampdu_factor, -1, 3) },
1614         { INT_RANGE(ampdu_density, -1, 7) },
1615         { STR(ht_mcs) },
1616 #endif /* CONFIG_HT_OVERRIDES */
1617         { INT(ap_max_inactivity) },
1618         { INT(dtim_period) },
1619 };
1620
1621 #undef OFFSET
1622 #undef _STR
1623 #undef STR
1624 #undef STR_KEY
1625 #undef _STR_LEN
1626 #undef STR_LEN
1627 #undef STR_LEN_KEY
1628 #undef _STR_RANGE
1629 #undef STR_RANGE
1630 #undef STR_RANGE_KEY
1631 #undef _INT
1632 #undef INT
1633 #undef INT_RANGE
1634 #undef _FUNC
1635 #undef FUNC
1636 #undef FUNC_KEY
1637 #define NUM_SSID_FIELDS (sizeof(ssid_fields) / sizeof(ssid_fields[0]))
1638
1639
1640 /**
1641  * wpa_config_add_prio_network - Add a network to priority lists
1642  * @config: Configuration data from wpa_config_read()
1643  * @ssid: Pointer to the network configuration to be added to the list
1644  * Returns: 0 on success, -1 on failure
1645  *
1646  * This function is used to add a network block to the priority list of
1647  * networks. This must be called for each network when reading in the full
1648  * configuration. In addition, this can be used indirectly when updating
1649  * priorities by calling wpa_config_update_prio_list().
1650  */
1651 int wpa_config_add_prio_network(struct wpa_config *config,
1652                                 struct wpa_ssid *ssid)
1653 {
1654         int prio;
1655         struct wpa_ssid *prev, **nlist;
1656
1657         /*
1658          * Add to an existing priority list if one is available for the
1659          * configured priority level for this network.
1660          */
1661         for (prio = 0; prio < config->num_prio; prio++) {
1662                 prev = config->pssid[prio];
1663                 if (prev->priority == ssid->priority) {
1664                         while (prev->pnext)
1665                                 prev = prev->pnext;
1666                         prev->pnext = ssid;
1667                         return 0;
1668                 }
1669         }
1670
1671         /* First network for this priority - add a new priority list */
1672         nlist = os_realloc(config->pssid,
1673                            (config->num_prio + 1) * sizeof(struct wpa_ssid *));
1674         if (nlist == NULL)
1675                 return -1;
1676
1677         for (prio = 0; prio < config->num_prio; prio++) {
1678                 if (nlist[prio]->priority < ssid->priority) {
1679                         os_memmove(&nlist[prio + 1], &nlist[prio],
1680                                    (config->num_prio - prio) *
1681                                    sizeof(struct wpa_ssid *));
1682                         break;
1683                 }
1684         }
1685
1686         nlist[prio] = ssid;
1687         config->num_prio++;
1688         config->pssid = nlist;
1689
1690         return 0;
1691 }
1692
1693
1694 /**
1695  * wpa_config_update_prio_list - Update network priority list
1696  * @config: Configuration data from wpa_config_read()
1697  * Returns: 0 on success, -1 on failure
1698  *
1699  * This function is called to update the priority list of networks in the
1700  * configuration when a network is being added or removed. This is also called
1701  * if a priority for a network is changed.
1702  */
1703 int wpa_config_update_prio_list(struct wpa_config *config)
1704 {
1705         struct wpa_ssid *ssid;
1706         int ret = 0;
1707
1708         os_free(config->pssid);
1709         config->pssid = NULL;
1710         config->num_prio = 0;
1711
1712         ssid = config->ssid;
1713         while (ssid) {
1714                 ssid->pnext = NULL;
1715                 if (wpa_config_add_prio_network(config, ssid) < 0)
1716                         ret = -1;
1717                 ssid = ssid->next;
1718         }
1719
1720         return ret;
1721 }
1722
1723
1724 #ifdef IEEE8021X_EAPOL
1725 static void eap_peer_config_free(struct eap_peer_config *eap)
1726 {
1727         os_free(eap->eap_methods);
1728         os_free(eap->identity);
1729         os_free(eap->anonymous_identity);
1730         os_free(eap->password);
1731         os_free(eap->ca_cert);
1732         os_free(eap->ca_path);
1733         os_free(eap->client_cert);
1734         os_free(eap->private_key);
1735         os_free(eap->private_key_passwd);
1736         os_free(eap->dh_file);
1737         os_free(eap->subject_match);
1738         os_free(eap->altsubject_match);
1739         os_free(eap->ca_cert2);
1740         os_free(eap->ca_path2);
1741         os_free(eap->client_cert2);
1742         os_free(eap->private_key2);
1743         os_free(eap->private_key2_passwd);
1744         os_free(eap->dh_file2);
1745         os_free(eap->subject_match2);
1746         os_free(eap->altsubject_match2);
1747         os_free(eap->phase1);
1748         os_free(eap->phase2);
1749         os_free(eap->pcsc);
1750         os_free(eap->pin);
1751         os_free(eap->engine_id);
1752         os_free(eap->key_id);
1753         os_free(eap->cert_id);
1754         os_free(eap->ca_cert_id);
1755         os_free(eap->key2_id);
1756         os_free(eap->cert2_id);
1757         os_free(eap->ca_cert2_id);
1758         os_free(eap->pin2);
1759         os_free(eap->engine2_id);
1760         os_free(eap->otp);
1761         os_free(eap->pending_req_otp);
1762         os_free(eap->pac_file);
1763         os_free(eap->new_password);
1764 }
1765 #endif /* IEEE8021X_EAPOL */
1766
1767
1768 /**
1769  * wpa_config_free_ssid - Free network/ssid configuration data
1770  * @ssid: Configuration data for the network
1771  *
1772  * This function frees all resources allocated for the network configuration
1773  * data.
1774  */
1775 void wpa_config_free_ssid(struct wpa_ssid *ssid)
1776 {
1777         os_free(ssid->ssid);
1778         os_free(ssid->passphrase);
1779         os_free(ssid->ext_psk);
1780 #ifdef IEEE8021X_EAPOL
1781         eap_peer_config_free(&ssid->eap);
1782 #endif /* IEEE8021X_EAPOL */
1783         os_free(ssid->id_str);
1784         os_free(ssid->scan_freq);
1785         os_free(ssid->freq_list);
1786         os_free(ssid->bgscan);
1787         os_free(ssid->p2p_client_list);
1788 #ifdef CONFIG_HT_OVERRIDES
1789         os_free(ssid->ht_mcs);
1790 #endif /* CONFIG_HT_OVERRIDES */
1791         os_free(ssid);
1792 }
1793
1794
1795 void wpa_config_free_cred(struct wpa_cred *cred)
1796 {
1797         os_free(cred->realm);
1798         os_free(cred->username);
1799         os_free(cred->password);
1800         os_free(cred->ca_cert);
1801         os_free(cred->client_cert);
1802         os_free(cred->private_key);
1803         os_free(cred->private_key_passwd);
1804         os_free(cred->imsi);
1805         os_free(cred->milenage);
1806         os_free(cred->domain);
1807         os_free(cred->eap_method);
1808         os_free(cred->phase1);
1809         os_free(cred->phase2);
1810         os_free(cred);
1811 }
1812
1813
1814 /**
1815  * wpa_config_free - Free configuration data
1816  * @config: Configuration data from wpa_config_read()
1817  *
1818  * This function frees all resources allocated for the configuration data by
1819  * wpa_config_read().
1820  */
1821 void wpa_config_free(struct wpa_config *config)
1822 {
1823 #ifndef CONFIG_NO_CONFIG_BLOBS
1824         struct wpa_config_blob *blob, *prevblob;
1825 #endif /* CONFIG_NO_CONFIG_BLOBS */
1826         struct wpa_ssid *ssid, *prev = NULL;
1827         struct wpa_cred *cred, *cprev;
1828
1829         ssid = config->ssid;
1830         while (ssid) {
1831                 prev = ssid;
1832                 ssid = ssid->next;
1833                 wpa_config_free_ssid(prev);
1834         }
1835
1836         cred = config->cred;
1837         while (cred) {
1838                 cprev = cred;
1839                 cred = cred->next;
1840                 wpa_config_free_cred(cprev);
1841         }
1842
1843 #ifndef CONFIG_NO_CONFIG_BLOBS
1844         blob = config->blobs;
1845         prevblob = NULL;
1846         while (blob) {
1847                 prevblob = blob;
1848                 blob = blob->next;
1849                 wpa_config_free_blob(prevblob);
1850         }
1851 #endif /* CONFIG_NO_CONFIG_BLOBS */
1852
1853         wpabuf_free(config->wps_vendor_ext_m1);
1854         os_free(config->ctrl_interface);
1855         os_free(config->ctrl_interface_group);
1856         os_free(config->opensc_engine_path);
1857         os_free(config->pkcs11_engine_path);
1858         os_free(config->pkcs11_module_path);
1859         os_free(config->pcsc_reader);
1860         os_free(config->pcsc_pin);
1861         os_free(config->driver_param);
1862         os_free(config->device_name);
1863         os_free(config->manufacturer);
1864         os_free(config->model_name);
1865         os_free(config->model_number);
1866         os_free(config->serial_number);
1867         os_free(config->config_methods);
1868         os_free(config->p2p_ssid_postfix);
1869         os_free(config->pssid);
1870         os_free(config->p2p_pref_chan);
1871         os_free(config->autoscan);
1872         wpabuf_free(config->wps_nfc_dh_pubkey);
1873         wpabuf_free(config->wps_nfc_dh_privkey);
1874         wpabuf_free(config->wps_nfc_dev_pw);
1875         os_free(config->ext_password_backend);
1876         os_free(config);
1877 }
1878
1879
1880 /**
1881  * wpa_config_foreach_network - Iterate over each configured network
1882  * @config: Configuration data from wpa_config_read()
1883  * @func: Callback function to process each network
1884  * @arg: Opaque argument to pass to callback function
1885  *
1886  * Iterate over the set of configured networks calling the specified
1887  * function for each item. We guard against callbacks removing the
1888  * supplied network.
1889  */
1890 void wpa_config_foreach_network(struct wpa_config *config,
1891                                 void (*func)(void *, struct wpa_ssid *),
1892                                 void *arg)
1893 {
1894         struct wpa_ssid *ssid, *next;
1895
1896         ssid = config->ssid;
1897         while (ssid) {
1898                 next = ssid->next;
1899                 func(arg, ssid);
1900                 ssid = next;
1901         }
1902 }
1903
1904
1905 /**
1906  * wpa_config_get_network - Get configured network based on id
1907  * @config: Configuration data from wpa_config_read()
1908  * @id: Unique network id to search for
1909  * Returns: Network configuration or %NULL if not found
1910  */
1911 struct wpa_ssid * wpa_config_get_network(struct wpa_config *config, int id)
1912 {
1913         struct wpa_ssid *ssid;
1914
1915         ssid = config->ssid;
1916         while (ssid) {
1917                 if (id == ssid->id)
1918                         break;
1919                 ssid = ssid->next;
1920         }
1921
1922         return ssid;
1923 }
1924
1925
1926 /**
1927  * wpa_config_add_network - Add a new network with empty configuration
1928  * @config: Configuration data from wpa_config_read()
1929  * Returns: The new network configuration or %NULL if operation failed
1930  */
1931 struct wpa_ssid * wpa_config_add_network(struct wpa_config *config)
1932 {
1933         int id;
1934         struct wpa_ssid *ssid, *last = NULL;
1935
1936         id = -1;
1937         ssid = config->ssid;
1938         while (ssid) {
1939                 if (ssid->id > id)
1940                         id = ssid->id;
1941                 last = ssid;
1942                 ssid = ssid->next;
1943         }
1944         id++;
1945
1946         ssid = os_zalloc(sizeof(*ssid));
1947         if (ssid == NULL)
1948                 return NULL;
1949         ssid->id = id;
1950         if (last)
1951                 last->next = ssid;
1952         else
1953                 config->ssid = ssid;
1954
1955         wpa_config_update_prio_list(config);
1956
1957         return ssid;
1958 }
1959
1960
1961 /**
1962  * wpa_config_remove_network - Remove a configured network based on id
1963  * @config: Configuration data from wpa_config_read()
1964  * @id: Unique network id to search for
1965  * Returns: 0 on success, or -1 if the network was not found
1966  */
1967 int wpa_config_remove_network(struct wpa_config *config, int id)
1968 {
1969         struct wpa_ssid *ssid, *prev = NULL;
1970
1971         ssid = config->ssid;
1972         while (ssid) {
1973                 if (id == ssid->id)
1974                         break;
1975                 prev = ssid;
1976                 ssid = ssid->next;
1977         }
1978
1979         if (ssid == NULL)
1980                 return -1;
1981
1982         if (prev)
1983                 prev->next = ssid->next;
1984         else
1985                 config->ssid = ssid->next;
1986
1987         wpa_config_update_prio_list(config);
1988         wpa_config_free_ssid(ssid);
1989         return 0;
1990 }
1991
1992
1993 /**
1994  * wpa_config_set_network_defaults - Set network default values
1995  * @ssid: Pointer to network configuration data
1996  */
1997 void wpa_config_set_network_defaults(struct wpa_ssid *ssid)
1998 {
1999         ssid->proto = DEFAULT_PROTO;
2000         ssid->pairwise_cipher = DEFAULT_PAIRWISE;
2001         ssid->group_cipher = DEFAULT_GROUP;
2002         ssid->key_mgmt = DEFAULT_KEY_MGMT;
2003         ssid->bg_scan_period = DEFAULT_BG_SCAN_PERIOD;
2004 #ifdef IEEE8021X_EAPOL
2005         ssid->eapol_flags = DEFAULT_EAPOL_FLAGS;
2006         ssid->eap_workaround = DEFAULT_EAP_WORKAROUND;
2007         ssid->eap.fragment_size = DEFAULT_FRAGMENT_SIZE;
2008 #endif /* IEEE8021X_EAPOL */
2009 #ifdef CONFIG_HT_OVERRIDES
2010         ssid->disable_ht = DEFAULT_DISABLE_HT;
2011         ssid->disable_ht40 = DEFAULT_DISABLE_HT40;
2012         ssid->disable_max_amsdu = DEFAULT_DISABLE_MAX_AMSDU;
2013         ssid->ampdu_factor = DEFAULT_AMPDU_FACTOR;
2014         ssid->ampdu_density = DEFAULT_AMPDU_DENSITY;
2015 #endif /* CONFIG_HT_OVERRIDES */
2016 }
2017
2018
2019 /**
2020  * wpa_config_set - Set a variable in network configuration
2021  * @ssid: Pointer to network configuration data
2022  * @var: Variable name, e.g., "ssid"
2023  * @value: Variable value
2024  * @line: Line number in configuration file or 0 if not used
2025  * Returns: 0 on success, -1 on failure
2026  *
2027  * This function can be used to set network configuration variables based on
2028  * both the configuration file and management interface input. The value
2029  * parameter must be in the same format as the text-based configuration file is
2030  * using. For example, strings are using double quotation marks.
2031  */
2032 int wpa_config_set(struct wpa_ssid *ssid, const char *var, const char *value,
2033                    int line)
2034 {
2035         size_t i;
2036         int ret = 0;
2037
2038         if (ssid == NULL || var == NULL || value == NULL)
2039                 return -1;
2040
2041         for (i = 0; i < NUM_SSID_FIELDS; i++) {
2042                 const struct parse_data *field = &ssid_fields[i];
2043                 if (os_strcmp(var, field->name) != 0)
2044                         continue;
2045
2046                 if (field->parser(field, ssid, line, value)) {
2047                         if (line) {
2048                                 wpa_printf(MSG_ERROR, "Line %d: failed to "
2049                                            "parse %s '%s'.", line, var, value);
2050                         }
2051                         ret = -1;
2052                 }
2053                 break;
2054         }
2055         if (i == NUM_SSID_FIELDS) {
2056                 if (line) {
2057                         wpa_printf(MSG_ERROR, "Line %d: unknown network field "
2058                                    "'%s'.", line, var);
2059                 }
2060                 ret = -1;
2061         }
2062
2063         return ret;
2064 }
2065
2066
2067 int wpa_config_set_quoted(struct wpa_ssid *ssid, const char *var,
2068                           const char *value)
2069 {
2070         size_t len;
2071         char *buf;
2072         int ret;
2073
2074         len = os_strlen(value);
2075         buf = os_malloc(len + 3);
2076         if (buf == NULL)
2077                 return -1;
2078         buf[0] = '"';
2079         os_memcpy(buf + 1, value, len);
2080         buf[len + 1] = '"';
2081         buf[len + 2] = '\0';
2082         ret = wpa_config_set(ssid, var, buf, 0);
2083         os_free(buf);
2084         return ret;
2085 }
2086
2087
2088 /**
2089  * wpa_config_get_all - Get all options from network configuration
2090  * @ssid: Pointer to network configuration data
2091  * @get_keys: Determines if keys/passwords will be included in returned list
2092  *      (if they may be exported)
2093  * Returns: %NULL terminated list of all set keys and their values in the form
2094  * of [key1, val1, key2, val2, ... , NULL]
2095  *
2096  * This function can be used to get list of all configured network properties.
2097  * The caller is responsible for freeing the returned list and all its
2098  * elements.
2099  */
2100 char ** wpa_config_get_all(struct wpa_ssid *ssid, int get_keys)
2101 {
2102         const struct parse_data *field;
2103         char *key, *value;
2104         size_t i;
2105         char **props;
2106         int fields_num;
2107
2108         get_keys = get_keys && ssid->export_keys;
2109
2110         props = os_zalloc(sizeof(char *) * ((2 * NUM_SSID_FIELDS) + 1));
2111         if (!props)
2112                 return NULL;
2113
2114         fields_num = 0;
2115         for (i = 0; i < NUM_SSID_FIELDS; i++) {
2116                 field = &ssid_fields[i];
2117                 if (field->key_data && !get_keys)
2118                         continue;
2119                 value = field->writer(field, ssid);
2120                 if (value == NULL)
2121                         continue;
2122                 if (os_strlen(value) == 0) {
2123                         os_free(value);
2124                         continue;
2125                 }
2126
2127                 key = os_strdup(field->name);
2128                 if (key == NULL) {
2129                         os_free(value);
2130                         goto err;
2131                 }
2132
2133                 props[fields_num * 2] = key;
2134                 props[fields_num * 2 + 1] = value;
2135
2136                 fields_num++;
2137         }
2138
2139         return props;
2140
2141 err:
2142         value = *props;
2143         while (value)
2144                 os_free(value++);
2145         os_free(props);
2146         return NULL;
2147 }
2148
2149
2150 #ifndef NO_CONFIG_WRITE
2151 /**
2152  * wpa_config_get - Get a variable in network configuration
2153  * @ssid: Pointer to network configuration data
2154  * @var: Variable name, e.g., "ssid"
2155  * Returns: Value of the variable or %NULL on failure
2156  *
2157  * This function can be used to get network configuration variables. The
2158  * returned value is a copy of the configuration variable in text format, i.e,.
2159  * the same format that the text-based configuration file and wpa_config_set()
2160  * are using for the value. The caller is responsible for freeing the returned
2161  * value.
2162  */
2163 char * wpa_config_get(struct wpa_ssid *ssid, const char *var)
2164 {
2165         size_t i;
2166
2167         if (ssid == NULL || var == NULL)
2168                 return NULL;
2169
2170         for (i = 0; i < NUM_SSID_FIELDS; i++) {
2171                 const struct parse_data *field = &ssid_fields[i];
2172                 if (os_strcmp(var, field->name) == 0)
2173                         return field->writer(field, ssid);
2174         }
2175
2176         return NULL;
2177 }
2178
2179
2180 /**
2181  * wpa_config_get_no_key - Get a variable in network configuration (no keys)
2182  * @ssid: Pointer to network configuration data
2183  * @var: Variable name, e.g., "ssid"
2184  * Returns: Value of the variable or %NULL on failure
2185  *
2186  * This function can be used to get network configuration variable like
2187  * wpa_config_get(). The only difference is that this functions does not expose
2188  * key/password material from the configuration. In case a key/password field
2189  * is requested, the returned value is an empty string or %NULL if the variable
2190  * is not set or "*" if the variable is set (regardless of its value). The
2191  * returned value is a copy of the configuration variable in text format, i.e,.
2192  * the same format that the text-based configuration file and wpa_config_set()
2193  * are using for the value. The caller is responsible for freeing the returned
2194  * value.
2195  */
2196 char * wpa_config_get_no_key(struct wpa_ssid *ssid, const char *var)
2197 {
2198         size_t i;
2199
2200         if (ssid == NULL || var == NULL)
2201                 return NULL;
2202
2203         for (i = 0; i < NUM_SSID_FIELDS; i++) {
2204                 const struct parse_data *field = &ssid_fields[i];
2205                 if (os_strcmp(var, field->name) == 0) {
2206                         char *res = field->writer(field, ssid);
2207                         if (field->key_data) {
2208                                 if (res && res[0]) {
2209                                         wpa_printf(MSG_DEBUG, "Do not allow "
2210                                                    "key_data field to be "
2211                                                    "exposed");
2212                                         os_free(res);
2213                                         return os_strdup("*");
2214                                 }
2215
2216                                 os_free(res);
2217                                 return NULL;
2218                         }
2219                         return res;
2220                 }
2221         }
2222
2223         return NULL;
2224 }
2225 #endif /* NO_CONFIG_WRITE */
2226
2227
2228 /**
2229  * wpa_config_update_psk - Update WPA PSK based on passphrase and SSID
2230  * @ssid: Pointer to network configuration data
2231  *
2232  * This function must be called to update WPA PSK when either SSID or the
2233  * passphrase has changed for the network configuration.
2234  */
2235 void wpa_config_update_psk(struct wpa_ssid *ssid)
2236 {
2237 #ifndef CONFIG_NO_PBKDF2
2238         pbkdf2_sha1(ssid->passphrase, ssid->ssid, ssid->ssid_len, 4096,
2239                     ssid->psk, PMK_LEN);
2240         wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
2241                         ssid->psk, PMK_LEN);
2242         ssid->psk_set = 1;
2243 #endif /* CONFIG_NO_PBKDF2 */
2244 }
2245
2246
2247 int wpa_config_set_cred(struct wpa_cred *cred, const char *var,
2248                         const char *value, int line)
2249 {
2250         char *val;
2251         size_t len;
2252
2253         if (os_strcmp(var, "priority") == 0) {
2254                 cred->priority = atoi(value);
2255                 return 0;
2256         }
2257
2258         if (os_strcmp(var, "pcsc") == 0) {
2259                 cred->pcsc = atoi(value);
2260                 return 0;
2261         }
2262
2263         if (os_strcmp(var, "eap") == 0) {
2264                 struct eap_method_type method;
2265                 method.method = eap_peer_get_type(value, &method.vendor);
2266                 if (method.vendor == EAP_VENDOR_IETF &&
2267                     method.method == EAP_TYPE_NONE) {
2268                         wpa_printf(MSG_ERROR, "Line %d: unknown EAP type '%s' "
2269                                    "for a credential", line, value);
2270                         return -1;
2271                 }
2272                 os_free(cred->eap_method);
2273                 cred->eap_method = os_malloc(sizeof(*cred->eap_method));
2274                 if (cred->eap_method == NULL)
2275                         return -1;
2276                 os_memcpy(cred->eap_method, &method, sizeof(method));
2277                 return 0;
2278         }
2279
2280         if (os_strcmp(var, "password") == 0 &&
2281             os_strncmp(value, "ext:", 4) == 0) {
2282                 os_free(cred->password);
2283                 cred->password = os_strdup(value);
2284                 cred->ext_password = 1;
2285                 return 0;
2286         }
2287
2288         val = wpa_config_parse_string(value, &len);
2289         if (val == NULL) {
2290                 wpa_printf(MSG_ERROR, "Line %d: invalid field '%s' string "
2291                            "value '%s'.", line, var, value);
2292                 return -1;
2293         }
2294
2295         if (os_strcmp(var, "realm") == 0) {
2296                 os_free(cred->realm);
2297                 cred->realm = val;
2298                 return 0;
2299         }
2300
2301         if (os_strcmp(var, "username") == 0) {
2302                 os_free(cred->username);
2303                 cred->username = val;
2304                 return 0;
2305         }
2306
2307         if (os_strcmp(var, "password") == 0) {
2308                 os_free(cred->password);
2309                 cred->password = val;
2310                 cred->ext_password = 0;
2311                 return 0;
2312         }
2313
2314         if (os_strcmp(var, "ca_cert") == 0) {
2315                 os_free(cred->ca_cert);
2316                 cred->ca_cert = val;
2317                 return 0;
2318         }
2319
2320         if (os_strcmp(var, "client_cert") == 0) {
2321                 os_free(cred->client_cert);
2322                 cred->client_cert = val;
2323                 return 0;
2324         }
2325
2326         if (os_strcmp(var, "private_key") == 0) {
2327                 os_free(cred->private_key);
2328                 cred->private_key = val;
2329                 return 0;
2330         }
2331
2332         if (os_strcmp(var, "private_key_passwd") == 0) {
2333                 os_free(cred->private_key_passwd);
2334                 cred->private_key_passwd = val;
2335                 return 0;
2336         }
2337
2338         if (os_strcmp(var, "imsi") == 0) {
2339                 os_free(cred->imsi);
2340                 cred->imsi = val;
2341                 return 0;
2342         }
2343
2344         if (os_strcmp(var, "milenage") == 0) {
2345                 os_free(cred->milenage);
2346                 cred->milenage = val;
2347                 return 0;
2348         }
2349
2350         if (os_strcmp(var, "domain") == 0) {
2351                 os_free(cred->domain);
2352                 cred->domain = val;
2353                 return 0;
2354         }
2355
2356         if (os_strcmp(var, "phase1") == 0) {
2357                 os_free(cred->phase1);
2358                 cred->phase1 = val;
2359                 return 0;
2360         }
2361
2362         if (os_strcmp(var, "phase2") == 0) {
2363                 os_free(cred->phase2);
2364                 cred->phase2 = val;
2365                 return 0;
2366         }
2367
2368         if (os_strcmp(var, "roaming_consortium") == 0) {
2369                 if (len < 3 || len > sizeof(cred->roaming_consortium)) {
2370                         wpa_printf(MSG_ERROR, "Line %d: invalid "
2371                                    "roaming_consortium length %d (3..15 "
2372                                    "expected)", line, (int) len);
2373                         os_free(val);
2374                         return -1;
2375                 }
2376                 os_memcpy(cred->roaming_consortium, val, len);
2377                 cred->roaming_consortium_len = len;
2378                 os_free(val);
2379                 return 0;
2380         }
2381
2382         if (line) {
2383                 wpa_printf(MSG_ERROR, "Line %d: unknown cred field '%s'.",
2384                            line, var);
2385         }
2386
2387         os_free(val);
2388
2389         return -1;
2390 }
2391
2392
2393 struct wpa_cred * wpa_config_get_cred(struct wpa_config *config, int id)
2394 {
2395         struct wpa_cred *cred;
2396
2397         cred = config->cred;
2398         while (cred) {
2399                 if (id == cred->id)
2400                         break;
2401                 cred = cred->next;
2402         }
2403
2404         return cred;
2405 }
2406
2407
2408 struct wpa_cred * wpa_config_add_cred(struct wpa_config *config)
2409 {
2410         int id;
2411         struct wpa_cred *cred, *last = NULL;
2412
2413         id = -1;
2414         cred = config->cred;
2415         while (cred) {
2416                 if (cred->id > id)
2417                         id = cred->id;
2418                 last = cred;
2419                 cred = cred->next;
2420         }
2421         id++;
2422
2423         cred = os_zalloc(sizeof(*cred));
2424         if (cred == NULL)
2425                 return NULL;
2426         cred->id = id;
2427         if (last)
2428                 last->next = cred;
2429         else
2430                 config->cred = cred;
2431
2432         return cred;
2433 }
2434
2435
2436 int wpa_config_remove_cred(struct wpa_config *config, int id)
2437 {
2438         struct wpa_cred *cred, *prev = NULL;
2439
2440         cred = config->cred;
2441         while (cred) {
2442                 if (id == cred->id)
2443                         break;
2444                 prev = cred;
2445                 cred = cred->next;
2446         }
2447
2448         if (cred == NULL)
2449                 return -1;
2450
2451         if (prev)
2452                 prev->next = cred->next;
2453         else
2454                 config->cred = cred->next;
2455
2456         wpa_config_free_cred(cred);
2457         return 0;
2458 }
2459
2460
2461 #ifndef CONFIG_NO_CONFIG_BLOBS
2462 /**
2463  * wpa_config_get_blob - Get a named configuration blob
2464  * @config: Configuration data from wpa_config_read()
2465  * @name: Name of the blob
2466  * Returns: Pointer to blob data or %NULL if not found
2467  */
2468 const struct wpa_config_blob * wpa_config_get_blob(struct wpa_config *config,
2469                                                    const char *name)
2470 {
2471         struct wpa_config_blob *blob = config->blobs;
2472
2473         while (blob) {
2474                 if (os_strcmp(blob->name, name) == 0)
2475                         return blob;
2476                 blob = blob->next;
2477         }
2478         return NULL;
2479 }
2480
2481
2482 /**
2483  * wpa_config_set_blob - Set or add a named configuration blob
2484  * @config: Configuration data from wpa_config_read()
2485  * @blob: New value for the blob
2486  *
2487  * Adds a new configuration blob or replaces the current value of an existing
2488  * blob.
2489  */
2490 void wpa_config_set_blob(struct wpa_config *config,
2491                          struct wpa_config_blob *blob)
2492 {
2493         wpa_config_remove_blob(config, blob->name);
2494         blob->next = config->blobs;
2495         config->blobs = blob;
2496 }
2497
2498
2499 /**
2500  * wpa_config_free_blob - Free blob data
2501  * @blob: Pointer to blob to be freed
2502  */
2503 void wpa_config_free_blob(struct wpa_config_blob *blob)
2504 {
2505         if (blob) {
2506                 os_free(blob->name);
2507                 os_free(blob->data);
2508                 os_free(blob);
2509         }
2510 }
2511
2512
2513 /**
2514  * wpa_config_remove_blob - Remove a named configuration blob
2515  * @config: Configuration data from wpa_config_read()
2516  * @name: Name of the blob to remove
2517  * Returns: 0 if blob was removed or -1 if blob was not found
2518  */
2519 int wpa_config_remove_blob(struct wpa_config *config, const char *name)
2520 {
2521         struct wpa_config_blob *pos = config->blobs, *prev = NULL;
2522
2523         while (pos) {
2524                 if (os_strcmp(pos->name, name) == 0) {
2525                         if (prev)
2526                                 prev->next = pos->next;
2527                         else
2528                                 config->blobs = pos->next;
2529                         wpa_config_free_blob(pos);
2530                         return 0;
2531                 }
2532                 prev = pos;
2533                 pos = pos->next;
2534         }
2535
2536         return -1;
2537 }
2538 #endif /* CONFIG_NO_CONFIG_BLOBS */
2539
2540
2541 /**
2542  * wpa_config_alloc_empty - Allocate an empty configuration
2543  * @ctrl_interface: Control interface parameters, e.g., path to UNIX domain
2544  * socket
2545  * @driver_param: Driver parameters
2546  * Returns: Pointer to allocated configuration data or %NULL on failure
2547  */
2548 struct wpa_config * wpa_config_alloc_empty(const char *ctrl_interface,
2549                                            const char *driver_param)
2550 {
2551         struct wpa_config *config;
2552         const int aCWmin = 4, aCWmax = 10;
2553         const struct hostapd_wmm_ac_params ac_bk =
2554                 { aCWmin, aCWmax, 7, 0, 0 }; /* background traffic */
2555         const struct hostapd_wmm_ac_params ac_be =
2556                 { aCWmin, aCWmax, 3, 0, 0 }; /* best effort traffic */
2557         const struct hostapd_wmm_ac_params ac_vi = /* video traffic */
2558                 { aCWmin - 1, aCWmin, 2, 3000 / 32, 1 };
2559         const struct hostapd_wmm_ac_params ac_vo = /* voice traffic */
2560                 { aCWmin - 2, aCWmin - 1, 2, 1500 / 32, 1 };
2561
2562         config = os_zalloc(sizeof(*config));
2563         if (config == NULL)
2564                 return NULL;
2565         config->eapol_version = DEFAULT_EAPOL_VERSION;
2566         config->ap_scan = DEFAULT_AP_SCAN;
2567         config->fast_reauth = DEFAULT_FAST_REAUTH;
2568         config->p2p_go_intent = DEFAULT_P2P_GO_INTENT;
2569         config->p2p_intra_bss = DEFAULT_P2P_INTRA_BSS;
2570         config->p2p_go_max_inactivity = DEFAULT_P2P_GO_MAX_INACTIVITY;
2571         config->bss_max_count = DEFAULT_BSS_MAX_COUNT;
2572         config->bss_expiration_age = DEFAULT_BSS_EXPIRATION_AGE;
2573         config->bss_expiration_scan_count = DEFAULT_BSS_EXPIRATION_SCAN_COUNT;
2574         config->max_num_sta = DEFAULT_MAX_NUM_STA;
2575         config->access_network_type = DEFAULT_ACCESS_NETWORK_TYPE;
2576         config->wmm_ac_params[0] = ac_be;
2577         config->wmm_ac_params[1] = ac_bk;
2578         config->wmm_ac_params[2] = ac_vi;
2579         config->wmm_ac_params[3] = ac_vo;
2580
2581         if (ctrl_interface)
2582                 config->ctrl_interface = os_strdup(ctrl_interface);
2583         if (driver_param)
2584                 config->driver_param = os_strdup(driver_param);
2585
2586         return config;
2587 }
2588
2589
2590 #ifndef CONFIG_NO_STDOUT_DEBUG
2591 /**
2592  * wpa_config_debug_dump_networks - Debug dump of configured networks
2593  * @config: Configuration data from wpa_config_read()
2594  */
2595 void wpa_config_debug_dump_networks(struct wpa_config *config)
2596 {
2597         int prio;
2598         struct wpa_ssid *ssid;
2599
2600         for (prio = 0; prio < config->num_prio; prio++) {
2601                 ssid = config->pssid[prio];
2602                 wpa_printf(MSG_DEBUG, "Priority group %d",
2603                            ssid->priority);
2604                 while (ssid) {
2605                         wpa_printf(MSG_DEBUG, "   id=%d ssid='%s'",
2606                                    ssid->id,
2607                                    wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2608                         ssid = ssid->pnext;
2609                 }
2610         }
2611 }
2612 #endif /* CONFIG_NO_STDOUT_DEBUG */
2613
2614
2615 struct global_parse_data {
2616         char *name;
2617         int (*parser)(const struct global_parse_data *data,
2618                       struct wpa_config *config, int line, const char *value);
2619         void *param1, *param2, *param3;
2620         unsigned int changed_flag;
2621 };
2622
2623
2624 static int wpa_global_config_parse_int(const struct global_parse_data *data,
2625                                        struct wpa_config *config, int line,
2626                                        const char *pos)
2627 {
2628         int *dst;
2629         dst = (int *) (((u8 *) config) + (long) data->param1);
2630         *dst = atoi(pos);
2631         wpa_printf(MSG_DEBUG, "%s=%d", data->name, *dst);
2632
2633         if (data->param2 && *dst < (long) data->param2) {
2634                 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
2635                            "min_value=%ld)", line, data->name, *dst,
2636                            (long) data->param2);
2637                 *dst = (long) data->param2;
2638                 return -1;
2639         }
2640
2641         if (data->param3 && *dst > (long) data->param3) {
2642                 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
2643                            "max_value=%ld)", line, data->name, *dst,
2644                            (long) data->param3);
2645                 *dst = (long) data->param3;
2646                 return -1;
2647         }
2648
2649         return 0;
2650 }
2651
2652
2653 static int wpa_global_config_parse_str(const struct global_parse_data *data,
2654                                        struct wpa_config *config, int line,
2655                                        const char *pos)
2656 {
2657         size_t len;
2658         char **dst, *tmp;
2659
2660         len = os_strlen(pos);
2661         if (data->param2 && len < (size_t) data->param2) {
2662                 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
2663                            "min_len=%ld)", line, data->name,
2664                            (unsigned long) len, (long) data->param2);
2665                 return -1;
2666         }
2667
2668         if (data->param3 && len > (size_t) data->param3) {
2669                 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
2670                            "max_len=%ld)", line, data->name,
2671                            (unsigned long) len, (long) data->param3);
2672                 return -1;
2673         }
2674
2675         tmp = os_strdup(pos);
2676         if (tmp == NULL)
2677                 return -1;
2678
2679         dst = (char **) (((u8 *) config) + (long) data->param1);
2680         os_free(*dst);
2681         *dst = tmp;
2682         wpa_printf(MSG_DEBUG, "%s='%s'", data->name, *dst);
2683
2684         return 0;
2685 }
2686
2687
2688 static int wpa_global_config_parse_bin(const struct global_parse_data *data,
2689                                        struct wpa_config *config, int line,
2690                                        const char *pos)
2691 {
2692         size_t len;
2693         struct wpabuf **dst, *tmp;
2694
2695         len = os_strlen(pos);
2696         if (len & 0x01)
2697                 return -1;
2698
2699         tmp = wpabuf_alloc(len / 2);
2700         if (tmp == NULL)
2701                 return -1;
2702
2703         if (hexstr2bin(pos, wpabuf_put(tmp, len / 2), len / 2)) {
2704                 wpabuf_free(tmp);
2705                 return -1;
2706         }
2707
2708         dst = (struct wpabuf **) (((u8 *) config) + (long) data->param1);
2709         wpabuf_free(*dst);
2710         *dst = tmp;
2711         wpa_printf(MSG_DEBUG, "%s", data->name);
2712
2713         return 0;
2714 }
2715
2716
2717 static int wpa_config_process_country(const struct global_parse_data *data,
2718                                       struct wpa_config *config, int line,
2719                                       const char *pos)
2720 {
2721         if (!pos[0] || !pos[1]) {
2722                 wpa_printf(MSG_DEBUG, "Invalid country set");
2723                 return -1;
2724         }
2725         config->country[0] = pos[0];
2726         config->country[1] = pos[1];
2727         wpa_printf(MSG_DEBUG, "country='%c%c'",
2728                    config->country[0], config->country[1]);
2729         return 0;
2730 }
2731
2732
2733 static int wpa_config_process_load_dynamic_eap(
2734         const struct global_parse_data *data, struct wpa_config *config,
2735         int line, const char *so)
2736 {
2737         int ret;
2738         wpa_printf(MSG_DEBUG, "load_dynamic_eap=%s", so);
2739         ret = eap_peer_method_load(so);
2740         if (ret == -2) {
2741                 wpa_printf(MSG_DEBUG, "This EAP type was already loaded - not "
2742                            "reloading.");
2743         } else if (ret) {
2744                 wpa_printf(MSG_ERROR, "Line %d: Failed to load dynamic EAP "
2745                            "method '%s'.", line, so);
2746                 return -1;
2747         }
2748
2749         return 0;
2750 }
2751
2752
2753 #ifdef CONFIG_WPS
2754
2755 static int wpa_config_process_uuid(const struct global_parse_data *data,
2756                                    struct wpa_config *config, int line,
2757                                    const char *pos)
2758 {
2759         char buf[40];
2760         if (uuid_str2bin(pos, config->uuid)) {
2761                 wpa_printf(MSG_ERROR, "Line %d: invalid UUID", line);
2762                 return -1;
2763         }
2764         uuid_bin2str(config->uuid, buf, sizeof(buf));
2765         wpa_printf(MSG_DEBUG, "uuid=%s", buf);
2766         return 0;
2767 }
2768
2769
2770 static int wpa_config_process_device_type(
2771         const struct global_parse_data *data,
2772         struct wpa_config *config, int line, const char *pos)
2773 {
2774         return wps_dev_type_str2bin(pos, config->device_type);
2775 }
2776
2777
2778 static int wpa_config_process_os_version(const struct global_parse_data *data,
2779                                          struct wpa_config *config, int line,
2780                                          const char *pos)
2781 {
2782         if (hexstr2bin(pos, config->os_version, 4)) {
2783                 wpa_printf(MSG_ERROR, "Line %d: invalid os_version", line);
2784                 return -1;
2785         }
2786         wpa_printf(MSG_DEBUG, "os_version=%08x",
2787                    WPA_GET_BE32(config->os_version));
2788         return 0;
2789 }
2790
2791
2792 static int wpa_config_process_wps_vendor_ext_m1(
2793         const struct global_parse_data *data,
2794         struct wpa_config *config, int line, const char *pos)
2795 {
2796         struct wpabuf *tmp;
2797         int len = os_strlen(pos) / 2;
2798         u8 *p;
2799
2800         if (!len) {
2801                 wpa_printf(MSG_ERROR, "Line %d: "
2802                            "invalid wps_vendor_ext_m1", line);
2803                 return -1;
2804         }
2805
2806         tmp = wpabuf_alloc(len);
2807         if (tmp) {
2808                 p = wpabuf_put(tmp, len);
2809
2810                 if (hexstr2bin(pos, p, len)) {
2811                         wpa_printf(MSG_ERROR, "Line %d: "
2812                                    "invalid wps_vendor_ext_m1", line);
2813                         wpabuf_free(tmp);
2814                         return -1;
2815                 }
2816
2817                 wpabuf_free(config->wps_vendor_ext_m1);
2818                 config->wps_vendor_ext_m1 = tmp;
2819         } else {
2820                 wpa_printf(MSG_ERROR, "Can not allocate "
2821                            "memory for wps_vendor_ext_m1");
2822                 return -1;
2823         }
2824
2825         return 0;
2826 }
2827
2828 #endif /* CONFIG_WPS */
2829
2830 #ifdef CONFIG_P2P
2831 static int wpa_config_process_sec_device_type(
2832         const struct global_parse_data *data,
2833         struct wpa_config *config, int line, const char *pos)
2834 {
2835         int idx;
2836
2837         if (config->num_sec_device_types >= MAX_SEC_DEVICE_TYPES) {
2838                 wpa_printf(MSG_ERROR, "Line %d: too many sec_device_type "
2839                            "items", line);
2840                 return -1;
2841         }
2842
2843         idx = config->num_sec_device_types;
2844
2845         if (wps_dev_type_str2bin(pos, config->sec_device_type[idx]))
2846                 return -1;
2847
2848         config->num_sec_device_types++;
2849         return 0;
2850 }
2851
2852
2853 static int wpa_config_process_p2p_pref_chan(
2854         const struct global_parse_data *data,
2855         struct wpa_config *config, int line, const char *pos)
2856 {
2857         struct p2p_channel *pref = NULL, *n;
2858         unsigned int num = 0;
2859         const char *pos2;
2860         u8 op_class, chan;
2861
2862         /* format: class:chan,class:chan,... */
2863
2864         while (*pos) {
2865                 op_class = atoi(pos);
2866                 pos2 = os_strchr(pos, ':');
2867                 if (pos2 == NULL)
2868                         goto fail;
2869                 pos2++;
2870                 chan = atoi(pos2);
2871
2872                 n = os_realloc(pref, (num + 1) * sizeof(struct p2p_channel));
2873                 if (n == NULL)
2874                         goto fail;
2875                 pref = n;
2876                 pref[num].op_class = op_class;
2877                 pref[num].chan = chan;
2878                 num++;
2879
2880                 pos = os_strchr(pos2, ',');
2881                 if (pos == NULL)
2882                         break;
2883                 pos++;
2884         }
2885
2886         os_free(config->p2p_pref_chan);
2887         config->p2p_pref_chan = pref;
2888         config->num_p2p_pref_chan = num;
2889         wpa_hexdump(MSG_DEBUG, "P2P: Preferred class/channel pairs",
2890                     (u8 *) config->p2p_pref_chan,
2891                     config->num_p2p_pref_chan * sizeof(struct p2p_channel));
2892
2893         return 0;
2894
2895 fail:
2896         os_free(pref);
2897         wpa_printf(MSG_ERROR, "Line %d: Invalid p2p_pref_chan list", line);
2898         return -1;
2899 }
2900 #endif /* CONFIG_P2P */
2901
2902
2903 static int wpa_config_process_hessid(
2904         const struct global_parse_data *data,
2905         struct wpa_config *config, int line, const char *pos)
2906 {
2907         if (hwaddr_aton2(pos, config->hessid) < 0) {
2908                 wpa_printf(MSG_ERROR, "Line %d: Invalid hessid '%s'",
2909                            line, pos);
2910                 return -1;
2911         }
2912
2913         return 0;
2914 }
2915
2916
2917 #ifdef OFFSET
2918 #undef OFFSET
2919 #endif /* OFFSET */
2920 /* OFFSET: Get offset of a variable within the wpa_config structure */
2921 #define OFFSET(v) ((void *) &((struct wpa_config *) 0)->v)
2922
2923 #define FUNC(f) #f, wpa_config_process_ ## f, OFFSET(f), NULL, NULL
2924 #define FUNC_NO_VAR(f) #f, wpa_config_process_ ## f, NULL, NULL, NULL
2925 #define _INT(f) #f, wpa_global_config_parse_int, OFFSET(f)
2926 #define INT(f) _INT(f), NULL, NULL
2927 #define INT_RANGE(f, min, max) _INT(f), (void *) min, (void *) max
2928 #define _STR(f) #f, wpa_global_config_parse_str, OFFSET(f)
2929 #define STR(f) _STR(f), NULL, NULL
2930 #define STR_RANGE(f, min, max) _STR(f), (void *) min, (void *) max
2931 #define BIN(f) #f, wpa_global_config_parse_bin, OFFSET(f), NULL, NULL
2932
2933 static const struct global_parse_data global_fields[] = {
2934 #ifdef CONFIG_CTRL_IFACE
2935         { STR(ctrl_interface), 0 },
2936         { STR(ctrl_interface_group), 0 } /* deprecated */,
2937 #endif /* CONFIG_CTRL_IFACE */
2938         { INT_RANGE(eapol_version, 1, 2), 0 },
2939         { INT(ap_scan), 0 },
2940         { INT(disable_scan_offload), 0 },
2941         { INT(fast_reauth), 0 },
2942         { STR(opensc_engine_path), 0 },
2943         { STR(pkcs11_engine_path), 0 },
2944         { STR(pkcs11_module_path), 0 },
2945         { STR(pcsc_reader), 0 },
2946         { STR(pcsc_pin), 0 },
2947         { STR(driver_param), 0 },
2948         { INT(dot11RSNAConfigPMKLifetime), 0 },
2949         { INT(dot11RSNAConfigPMKReauthThreshold), 0 },
2950         { INT(dot11RSNAConfigSATimeout), 0 },
2951 #ifndef CONFIG_NO_CONFIG_WRITE
2952         { INT(update_config), 0 },
2953 #endif /* CONFIG_NO_CONFIG_WRITE */
2954         { FUNC_NO_VAR(load_dynamic_eap), 0 },
2955 #ifdef CONFIG_WPS
2956         { FUNC(uuid), CFG_CHANGED_UUID },
2957         { STR_RANGE(device_name, 0, 32), CFG_CHANGED_DEVICE_NAME },
2958         { STR_RANGE(manufacturer, 0, 64), CFG_CHANGED_WPS_STRING },
2959         { STR_RANGE(model_name, 0, 32), CFG_CHANGED_WPS_STRING },
2960         { STR_RANGE(model_number, 0, 32), CFG_CHANGED_WPS_STRING },
2961         { STR_RANGE(serial_number, 0, 32), CFG_CHANGED_WPS_STRING },
2962         { FUNC(device_type), CFG_CHANGED_DEVICE_TYPE },
2963         { FUNC(os_version), CFG_CHANGED_OS_VERSION },
2964         { STR(config_methods), CFG_CHANGED_CONFIG_METHODS },
2965         { INT_RANGE(wps_cred_processing, 0, 2), 0 },
2966         { FUNC(wps_vendor_ext_m1), CFG_CHANGED_VENDOR_EXTENSION },
2967 #endif /* CONFIG_WPS */
2968 #ifdef CONFIG_P2P
2969         { FUNC(sec_device_type), CFG_CHANGED_SEC_DEVICE_TYPE },
2970         { INT(p2p_listen_reg_class), 0 },
2971         { INT(p2p_listen_channel), 0 },
2972         { INT(p2p_oper_reg_class), 0 },
2973         { INT(p2p_oper_channel), 0 },
2974         { INT_RANGE(p2p_go_intent, 0, 15), 0 },
2975         { STR(p2p_ssid_postfix), CFG_CHANGED_P2P_SSID_POSTFIX },
2976         { INT_RANGE(persistent_reconnect, 0, 1), 0 },
2977         { INT_RANGE(p2p_intra_bss, 0, 1), CFG_CHANGED_P2P_INTRA_BSS },
2978         { INT(p2p_group_idle), 0 },
2979         { FUNC(p2p_pref_chan), CFG_CHANGED_P2P_PREF_CHAN },
2980 #endif /* CONFIG_P2P */
2981         { FUNC(country), CFG_CHANGED_COUNTRY },
2982         { INT(bss_max_count), 0 },
2983         { INT(bss_expiration_age), 0 },
2984         { INT(bss_expiration_scan_count), 0 },
2985         { INT_RANGE(filter_ssids, 0, 1), 0 },
2986         { INT_RANGE(filter_rssi, -100, 0), 0 },
2987         { INT(max_num_sta), 0 },
2988         { INT_RANGE(disassoc_low_ack, 0, 1), 0 },
2989 #ifdef CONFIG_HS20
2990         { INT_RANGE(hs20, 0, 1), 0 },
2991 #endif /* CONFIG_HS20 */
2992         { INT_RANGE(interworking, 0, 1), 0 },
2993         { FUNC(hessid), 0 },
2994         { INT_RANGE(access_network_type, 0, 15), 0 },
2995         { INT_RANGE(pbc_in_m1, 0, 1), 0 },
2996         { STR(autoscan), 0 },
2997         { INT_RANGE(wps_nfc_dev_pw_id, 0x10, 0xffff), 0 },
2998         { BIN(wps_nfc_dh_pubkey), 0 },
2999         { BIN(wps_nfc_dh_privkey), 0 },
3000         { BIN(wps_nfc_dev_pw), 0 },
3001         { STR(ext_password_backend), CFG_CHANGED_EXT_PW_BACKEND },
3002         { INT(p2p_go_max_inactivity), 0 },
3003 };
3004
3005 #undef FUNC
3006 #undef _INT
3007 #undef INT
3008 #undef INT_RANGE
3009 #undef _STR
3010 #undef STR
3011 #undef STR_RANGE
3012 #undef BIN
3013 #define NUM_GLOBAL_FIELDS (sizeof(global_fields) / sizeof(global_fields[0]))
3014
3015
3016 int wpa_config_process_global(struct wpa_config *config, char *pos, int line)
3017 {
3018         size_t i;
3019         int ret = 0;
3020
3021         for (i = 0; i < NUM_GLOBAL_FIELDS; i++) {
3022                 const struct global_parse_data *field = &global_fields[i];
3023                 size_t flen = os_strlen(field->name);
3024                 if (os_strncmp(pos, field->name, flen) != 0 ||
3025                     pos[flen] != '=')
3026                         continue;
3027
3028                 if (field->parser(field, config, line, pos + flen + 1)) {
3029                         wpa_printf(MSG_ERROR, "Line %d: failed to "
3030                                    "parse '%s'.", line, pos);
3031                         ret = -1;
3032                 }
3033                 config->changed_parameters |= field->changed_flag;
3034                 break;
3035         }
3036         if (i == NUM_GLOBAL_FIELDS) {
3037 #ifdef CONFIG_AP
3038                 if (os_strncmp(pos, "wmm_ac_", 7) == 0) {
3039                         char *tmp = os_strchr(pos, '=');
3040                         if (tmp == NULL) {
3041                                 if (line < 0)
3042                                         return -1;
3043                                 wpa_printf(MSG_ERROR, "Line %d: invalid line "
3044                                            "'%s'", line, pos);
3045                                 return -1;
3046                         }
3047                         *tmp++ = '\0';
3048                         if (hostapd_config_wmm_ac(config->wmm_ac_params, pos,
3049                                                   tmp)) {
3050                                 wpa_printf(MSG_ERROR, "Line %d: invalid WMM "
3051                                            "AC item", line);
3052                                 return -1;
3053                         }
3054                 }
3055 #endif /* CONFIG_AP */
3056                 if (line < 0)
3057                         return -1;
3058                 wpa_printf(MSG_ERROR, "Line %d: unknown global field '%s'.",
3059                            line, pos);
3060                 ret = -1;
3061         }
3062
3063         return ret;
3064 }