]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/config.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Check os_snprintf() result more consistently - success case
[thirdparty/hostap.git] / wpa_supplicant / config.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant / Configuration parser and common functions
f64adcd7 3 * Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 7 */
8
9#include "includes.h"
10
11#include "common.h"
121adf9c 12#include "utils/uuid.h"
25ef8529 13#include "utils/ip_addr.h"
03da66bd 14#include "crypto/sha1.h"
3acb5005 15#include "rsn_supp/wpa.h"
6fc6879b 16#include "eap_peer/eap.h"
21d996f7 17#include "p2p/p2p.h"
6fc6879b
JM		 18#include "config.h"
19
20
21#if !defined(CONFIG_CTRL_IFACE) && defined(CONFIG_NO_CONFIG_WRITE)
22#define NO_CONFIG_WRITE
23#endif
24
25/*
26 * Structure for network configuration parsing. This data is used to implement
27 * a generic parser for each network block variable. The table of configuration
28 * variables is defined below in this file (ssid_fields[]).
29 */
30struct parse_data {
31 /* Configuration variable name */
32 char *name;
33
34 /* Parser function for this variable */
35 int (*parser)(const struct parse_data *data, struct wpa_ssid *ssid,
36 int line, const char *value);
37
38#ifndef NO_CONFIG_WRITE
39 /* Writer function (i.e., to get the variable in text format from
40 * internal presentation). */
41 char * (*writer)(const struct parse_data *data, struct wpa_ssid *ssid);
42#endif /* NO_CONFIG_WRITE */
43
44 /* Variable specific parameters for the parser. */
45 void *param1, *param2, *param3, *param4;
46
47 /* 0 = this variable can be included in debug output and ctrl_iface
48 * 1 = this variable contains key/private data and it must not be
49 * included in debug output unless explicitly requested. In
50 * addition, this variable will not be readable through the
51 * ctrl_iface.
52 */
53 int key_data;
54};
55
56
6fc6879b
JM		 57static int wpa_config_parse_str(const struct parse_data *data,
58 struct wpa_ssid *ssid,
59 int line, const char *value)
60{
61 size_t res_len, *dst_len;
62 char **dst, *tmp;
63
b56c0546
JM		 64 if (os_strcmp(value, "NULL") == 0) {
65 wpa_printf(MSG_DEBUG, "Unset configuration string '%s'",
66 data->name);
67 tmp = NULL;
68 res_len = 0;
69 goto set;
70 }
71
6fc6879b
JM		 72 tmp = wpa_config_parse_string(value, &res_len);
73 if (tmp == NULL) {
74 wpa_printf(MSG_ERROR, "Line %d: failed to parse %s '%s'.",
75 line, data->name,
76 data->key_data ? "[KEY DATA REMOVED]" : value);
77 return -1;
78 }
79
80 if (data->key_data) {
81 wpa_hexdump_ascii_key(MSG_MSGDUMP, data->name,
82 (u8 *) tmp, res_len);
83 } else {
84 wpa_hexdump_ascii(MSG_MSGDUMP, data->name,
85 (u8 *) tmp, res_len);
86 }
87
88 if (data->param3 && res_len < (size_t) data->param3) {
89 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
90 "min_len=%ld)", line, data->name,
91 (unsigned long) res_len, (long) data->param3);
92 os_free(tmp);
93 return -1;
94 }
95
96 if (data->param4 && res_len > (size_t) data->param4) {
97 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
98 "max_len=%ld)", line, data->name,
99 (unsigned long) res_len, (long) data->param4);
100 os_free(tmp);
101 return -1;
102 }
103
b56c0546 104set:
6fc6879b
JM		 105 dst = (char **) (((u8 *) ssid) + (long) data->param1);
106 dst_len = (size_t *) (((u8 *) ssid) + (long) data->param2);
107 os_free(*dst);
108 *dst = tmp;
109 if (data->param2)
110 *dst_len = res_len;
111
112 return 0;
113}
114
115
116#ifndef NO_CONFIG_WRITE
6fc6879b
JM		 117static char * wpa_config_write_string_ascii(const u8 *value, size_t len)
118{
119 char *buf;
120
121 buf = os_malloc(len + 3);
122 if (buf == NULL)
123 return NULL;
124 buf[0] = '"';
125 os_memcpy(buf + 1, value, len);
126 buf[len + 1] = '"';
127 buf[len + 2] = '\0';
128
129 return buf;
130}
131
132
133static char * wpa_config_write_string_hex(const u8 *value, size_t len)
134{
135 char *buf;
136
137 buf = os_zalloc(2 * len + 1);
138 if (buf == NULL)
139 return NULL;
140 wpa_snprintf_hex(buf, 2 * len + 1, value, len);
141
142 return buf;
143}
144
145
146static char * wpa_config_write_string(const u8 *value, size_t len)
147{
148 if (value == NULL)
149 return NULL;
150
151 if (is_hex(value, len))
152 return wpa_config_write_string_hex(value, len);
153 else
154 return wpa_config_write_string_ascii(value, len);
155}
156
157
158static char * wpa_config_write_str(const struct parse_data *data,
159 struct wpa_ssid *ssid)
160{
161 size_t len;
162 char **src;
163
164 src = (char **) (((u8 *) ssid) + (long) data->param1);
165 if (*src == NULL)
166 return NULL;
167
168 if (data->param2)
169 len = *((size_t *) (((u8 *) ssid) + (long) data->param2));
170 else
171 len = os_strlen(*src);
172
173 return wpa_config_write_string((const u8 *) *src, len);
174}
175#endif /* NO_CONFIG_WRITE */
176
177
178static int wpa_config_parse_int(const struct parse_data *data,
179 struct wpa_ssid *ssid,
180 int line, const char *value)
181{
eae3a584
JB		 182 int val, *dst;
183 char *end;
6fc6879b
JM		 184
185 dst = (int *) (((u8 *) ssid) + (long) data->param1);
eae3a584
JB		 186 val = strtol(value, &end, 0);
187 if (*end) {
188 wpa_printf(MSG_ERROR, "Line %d: invalid number \"%s\"",
189 line, value);
190 return -1;
191 }
192 *dst = val;
6fc6879b
JM		 193 wpa_printf(MSG_MSGDUMP, "%s=%d (0x%x)", data->name, *dst, *dst);
194
195 if (data->param3 && *dst < (long) data->param3) {
196 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
197 "min_value=%ld)", line, data->name, *dst,
198 (long) data->param3);
199 *dst = (long) data->param3;
200 return -1;
201 }
202
203 if (data->param4 && *dst > (long) data->param4) {
204 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
205 "max_value=%ld)", line, data->name, *dst,
206 (long) data->param4);
207 *dst = (long) data->param4;
208 return -1;
209 }
210
211 return 0;
212}
213
214
215#ifndef NO_CONFIG_WRITE
216static char * wpa_config_write_int(const struct parse_data *data,
217 struct wpa_ssid *ssid)
218{
219 int *src, res;
220 char *value;
221
222 src = (int *) (((u8 *) ssid) + (long) data->param1);
223
224 value = os_malloc(20);
225 if (value == NULL)
226 return NULL;
227 res = os_snprintf(value, 20, "%d", *src);
228 if (res < 0 || res >= 20) {
229 os_free(value);
230 return NULL;
231 }
232 value[20 - 1] = '\0';
233 return value;
234}
235#endif /* NO_CONFIG_WRITE */
236
237
238static int wpa_config_parse_bssid(const struct parse_data *data,
239 struct wpa_ssid *ssid, int line,
240 const char *value)
241{
c0a321c5
WJL		 242 if (value[0] == '\0' || os_strcmp(value, "\"\"") == 0 ||
243 os_strcmp(value, "any") == 0) {
244 ssid->bssid_set = 0;
245 wpa_printf(MSG_MSGDUMP, "BSSID any");
246 return 0;
247 }
6fc6879b
JM		 248 if (hwaddr_aton(value, ssid->bssid)) {
249 wpa_printf(MSG_ERROR, "Line %d: Invalid BSSID '%s'.",
250 line, value);
251 return -1;
252 }
253 ssid->bssid_set = 1;
254 wpa_hexdump(MSG_MSGDUMP, "BSSID", ssid->bssid, ETH_ALEN);
255 return 0;
256}
257
258
259#ifndef NO_CONFIG_WRITE
260static char * wpa_config_write_bssid(const struct parse_data *data,
261 struct wpa_ssid *ssid)
262{
263 char *value;
264 int res;
265
266 if (!ssid->bssid_set)
267 return NULL;
268
269 value = os_malloc(20);
270 if (value == NULL)
271 return NULL;
272 res = os_snprintf(value, 20, MACSTR, MAC2STR(ssid->bssid));
273 if (res < 0 || res >= 20) {
274 os_free(value);
275 return NULL;
276 }
277 value[20 - 1] = '\0';
278 return value;
279}
280#endif /* NO_CONFIG_WRITE */
281
282
283static int wpa_config_parse_psk(const struct parse_data *data,
284 struct wpa_ssid *ssid, int line,
285 const char *value)
286{
9173b16f
JM		 287#ifdef CONFIG_EXT_PASSWORD
288 if (os_strncmp(value, "ext:", 4) == 0) {
19c48da0 289 str_clear_free(ssid->passphrase);
9173b16f
JM		 290 ssid->passphrase = NULL;
291 ssid->psk_set = 0;
292 os_free(ssid->ext_psk);
293 ssid->ext_psk = os_strdup(value + 4);
294 if (ssid->ext_psk == NULL)
295 return -1;
296 wpa_printf(MSG_DEBUG, "PSK: External password '%s'",
297 ssid->ext_psk);
298 return 0;
299 }
300#endif /* CONFIG_EXT_PASSWORD */
301
6fc6879b
JM		 302 if (*value == '"') {
303#ifndef CONFIG_NO_PBKDF2
304 const char *pos;
305 size_t len;
306
307 value++;
308 pos = os_strrchr(value, '"');
309 if (pos)
310 len = pos - value;
311 else
312 len = os_strlen(value);
313 if (len < 8 || len > 63) {
314 wpa_printf(MSG_ERROR, "Line %d: Invalid passphrase "
315 "length %lu (expected: 8..63) '%s'.",
316 line, (unsigned long) len, value);
317 return -1;
318 }
319 wpa_hexdump_ascii_key(MSG_MSGDUMP, "PSK (ASCII passphrase)",
320 (u8 *) value, len);
321 if (ssid->passphrase && os_strlen(ssid->passphrase) == len &&
322 os_memcmp(ssid->passphrase, value, len) == 0)
323 return 0;
324 ssid->psk_set = 0;
19c48da0 325 str_clear_free(ssid->passphrase);
5e24dc8a 326 ssid->passphrase = dup_binstr(value, len);
6fc6879b
JM		 327 if (ssid->passphrase == NULL)
328 return -1;
6fc6879b
JM		 329 return 0;
330#else /* CONFIG_NO_PBKDF2 */
331 wpa_printf(MSG_ERROR, "Line %d: ASCII passphrase not "
332 "supported.", line);
333 return -1;
334#endif /* CONFIG_NO_PBKDF2 */
335 }
336
337 if (hexstr2bin(value, ssid->psk, PMK_LEN) ||
338 value[PMK_LEN * 2] != '\0') {
339 wpa_printf(MSG_ERROR, "Line %d: Invalid PSK '%s'.",
340 line, value);
341 return -1;
342 }
343
19c48da0 344 str_clear_free(ssid->passphrase);
6fc6879b
JM		 345 ssid->passphrase = NULL;
346
347 ssid->psk_set = 1;
348 wpa_hexdump_key(MSG_MSGDUMP, "PSK", ssid->psk, PMK_LEN);
349 return 0;
350}
351
352
353#ifndef NO_CONFIG_WRITE
354static char * wpa_config_write_psk(const struct parse_data *data,
355 struct wpa_ssid *ssid)
356{
9173b16f
JM		 357#ifdef CONFIG_EXT_PASSWORD
358 if (ssid->ext_psk) {
359 size_t len = 4 + os_strlen(ssid->ext_psk) + 1;
360 char *buf = os_malloc(len);
361 if (buf == NULL)
362 return NULL;
363 os_snprintf(buf, len, "ext:%s", ssid->ext_psk);
364 return buf;
365 }
366#endif /* CONFIG_EXT_PASSWORD */
367
6fc6879b
JM		 368 if (ssid->passphrase)
369 return wpa_config_write_string_ascii(
370 (const u8 *) ssid->passphrase,
371 os_strlen(ssid->passphrase));
372
373 if (ssid->psk_set)
374 return wpa_config_write_string_hex(ssid->psk, PMK_LEN);
375
376 return NULL;
377}
378#endif /* NO_CONFIG_WRITE */
379
380
381static int wpa_config_parse_proto(const struct parse_data *data,
382 struct wpa_ssid *ssid, int line,
383 const char *value)
384{
385 int val = 0, last, errors = 0;
386 char *start, *end, *buf;
387
388 buf = os_strdup(value);
389 if (buf == NULL)
390 return -1;
391 start = buf;
392
393 while (*start != '\0') {
394 while (*start == ' ' || *start == '\t')
395 start++;
396 if (*start == '\0')
397 break;
398 end = start;
399 while (*end != ' ' && *end != '\t' && *end != '\0')
400 end++;
401 last = *end == '\0';
402 *end = '\0';
403 if (os_strcmp(start, "WPA") == 0)
404 val |= WPA_PROTO_WPA;
405 else if (os_strcmp(start, "RSN") == 0 ||
406 os_strcmp(start, "WPA2") == 0)
407 val |= WPA_PROTO_RSN;
df0f01d9
JM		 408 else if (os_strcmp(start, "OSEN") == 0)
409 val |= WPA_PROTO_OSEN;
6fc6879b
JM		 410 else {
411 wpa_printf(MSG_ERROR, "Line %d: invalid proto '%s'",
412 line, start);
413 errors++;
414 }
415
416 if (last)
417 break;
418 start = end + 1;
419 }
420 os_free(buf);
421
422 if (val == 0) {
423 wpa_printf(MSG_ERROR,
424 "Line %d: no proto values configured.", line);
425 errors++;
426 }
427
428 wpa_printf(MSG_MSGDUMP, "proto: 0x%x", val);
429 ssid->proto = val;
430 return errors ? -1 : 0;
431}
432
433
434#ifndef NO_CONFIG_WRITE
435static char * wpa_config_write_proto(const struct parse_data *data,
436 struct wpa_ssid *ssid)
437{
290ea6a7 438 int ret;
6fc6879b
JM		 439 char *buf, *pos, *end;
440
3141b82c 441 pos = buf = os_zalloc(20);
6fc6879b
JM		 442 if (buf == NULL)
443 return NULL;
3141b82c 444 end = buf + 20;
6fc6879b
JM		 445
446 if (ssid->proto & WPA_PROTO_WPA) {
290ea6a7
JM		 447 ret = os_snprintf(pos, end - pos, "%sWPA",
448 pos == buf ? "" : " ");
6fc6879b
JM		 449 if (ret < 0 || ret >= end - pos)
450 return buf;
451 pos += ret;
6fc6879b
JM		 452 }
453
454 if (ssid->proto & WPA_PROTO_RSN) {
290ea6a7
JM		 455 ret = os_snprintf(pos, end - pos, "%sRSN",
456 pos == buf ? "" : " ");
6fc6879b
JM		 457 if (ret < 0 || ret >= end - pos)
458 return buf;
459 pos += ret;
6fc6879b
JM		 460 }
461
3141b82c 462 if (ssid->proto & WPA_PROTO_OSEN) {
290ea6a7
JM		 463 ret = os_snprintf(pos, end - pos, "%sOSEN",
464 pos == buf ? "" : " ");
3141b82c
JM		 465 if (ret < 0 || ret >= end - pos)
466 return buf;
467 pos += ret;
3141b82c
JM		 468 }
469
a1e46f32
JM		 470 if (pos == buf) {
471 os_free(buf);
472 buf = NULL;
473 }
474
6fc6879b
JM		 475 return buf;
476}
477#endif /* NO_CONFIG_WRITE */
478
479
480static int wpa_config_parse_key_mgmt(const struct parse_data *data,
481 struct wpa_ssid *ssid, int line,
482 const char *value)
483{
484 int val = 0, last, errors = 0;
485 char *start, *end, *buf;
486
487 buf = os_strdup(value);
488 if (buf == NULL)
489 return -1;
490 start = buf;
491
492 while (*start != '\0') {
493 while (*start == ' ' || *start == '\t')
494 start++;
495 if (*start == '\0')
496 break;
497 end = start;
498 while (*end != ' ' && *end != '\t' && *end != '\0')
499 end++;
500 last = *end == '\0';
501 *end = '\0';
502 if (os_strcmp(start, "WPA-PSK") == 0)
503 val |= WPA_KEY_MGMT_PSK;
504 else if (os_strcmp(start, "WPA-EAP") == 0)
505 val |= WPA_KEY_MGMT_IEEE8021X;
506 else if (os_strcmp(start, "IEEE8021X") == 0)
507 val |= WPA_KEY_MGMT_IEEE8021X_NO_WPA;
508 else if (os_strcmp(start, "NONE") == 0)
509 val |= WPA_KEY_MGMT_NONE;
510 else if (os_strcmp(start, "WPA-NONE") == 0)
511 val |= WPA_KEY_MGMT_WPA_NONE;
512#ifdef CONFIG_IEEE80211R
513 else if (os_strcmp(start, "FT-PSK") == 0)
514 val |= WPA_KEY_MGMT_FT_PSK;
515 else if (os_strcmp(start, "FT-EAP") == 0)
516 val |= WPA_KEY_MGMT_FT_IEEE8021X;
517#endif /* CONFIG_IEEE80211R */
56586197
JM		 518#ifdef CONFIG_IEEE80211W
519 else if (os_strcmp(start, "WPA-PSK-SHA256") == 0)
520 val |= WPA_KEY_MGMT_PSK_SHA256;
521 else if (os_strcmp(start, "WPA-EAP-SHA256") == 0)
522 val |= WPA_KEY_MGMT_IEEE8021X_SHA256;
523#endif /* CONFIG_IEEE80211W */
ad08c363
JM		 524#ifdef CONFIG_WPS
525 else if (os_strcmp(start, "WPS") == 0)
526 val |= WPA_KEY_MGMT_WPS;
527#endif /* CONFIG_WPS */
c10347f2
JM		 528#ifdef CONFIG_SAE
529 else if (os_strcmp(start, "SAE") == 0)
530 val |= WPA_KEY_MGMT_SAE;
531 else if (os_strcmp(start, "FT-SAE") == 0)
532 val |= WPA_KEY_MGMT_FT_SAE;
533#endif /* CONFIG_SAE */
df0f01d9
JM		 534#ifdef CONFIG_HS20
535 else if (os_strcmp(start, "OSEN") == 0)
536 val |= WPA_KEY_MGMT_OSEN;
537#endif /* CONFIG_HS20 */
666497c8
JM		 538 else if (os_strcmp(start, "WPA-EAP-SUITE-B") == 0)
539 val |= WPA_KEY_MGMT_IEEE8021X_SUITE_B;
6fc6879b
JM		 540 else {
541 wpa_printf(MSG_ERROR, "Line %d: invalid key_mgmt '%s'",
542 line, start);
543 errors++;
544 }
545
546 if (last)
547 break;
548 start = end + 1;
549 }
550 os_free(buf);
551
552 if (val == 0) {
553 wpa_printf(MSG_ERROR,
554 "Line %d: no key_mgmt values configured.", line);
555 errors++;
556 }
557
558 wpa_printf(MSG_MSGDUMP, "key_mgmt: 0x%x", val);
559 ssid->key_mgmt = val;
560 return errors ? -1 : 0;
561}
562
563
564#ifndef NO_CONFIG_WRITE
565static char * wpa_config_write_key_mgmt(const struct parse_data *data,
566 struct wpa_ssid *ssid)
567{
568 char *buf, *pos, *end;
569 int ret;
570
50793929 571 pos = buf = os_zalloc(100);
6fc6879b
JM		 572 if (buf == NULL)
573 return NULL;
50793929 574 end = buf + 100;
6fc6879b
JM		 575
576 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
577 ret = os_snprintf(pos, end - pos, "%sWPA-PSK",
578 pos == buf ? "" : " ");
579 if (ret < 0 || ret >= end - pos) {
580 end[-1] = '\0';
581 return buf;
582 }
583 pos += ret;
584 }
585
586 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
587 ret = os_snprintf(pos, end - pos, "%sWPA-EAP",
588 pos == buf ? "" : " ");
589 if (ret < 0 || ret >= end - pos) {
590 end[-1] = '\0';
591 return buf;
592 }
593 pos += ret;
594 }
595
596 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
597 ret = os_snprintf(pos, end - pos, "%sIEEE8021X",
598 pos == buf ? "" : " ");
599 if (ret < 0 || ret >= end - pos) {
600 end[-1] = '\0';
601 return buf;
602 }
603 pos += ret;
604 }
605
606 if (ssid->key_mgmt & WPA_KEY_MGMT_NONE) {
607 ret = os_snprintf(pos, end - pos, "%sNONE",
608 pos == buf ? "" : " ");
609 if (ret < 0 || ret >= end - pos) {
610 end[-1] = '\0';
611 return buf;
612 }
613 pos += ret;
614 }
615
616 if (ssid->key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
617 ret = os_snprintf(pos, end - pos, "%sWPA-NONE",
618 pos == buf ? "" : " ");
619 if (ret < 0 || ret >= end - pos) {
620 end[-1] = '\0';
621 return buf;
622 }
623 pos += ret;
624 }
625
626#ifdef CONFIG_IEEE80211R
50793929
PF		 627 if (ssid->key_mgmt & WPA_KEY_MGMT_FT_PSK) {
628 ret = os_snprintf(pos, end - pos, "%sFT-PSK",
629 pos == buf ? "" : " ");
630 if (ret < 0 || ret >= end - pos) {
631 end[-1] = '\0';
632 return buf;
633 }
634 pos += ret;
635 }
6fc6879b 636
50793929
PF		 637 if (ssid->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
638 ret = os_snprintf(pos, end - pos, "%sFT-EAP",
639 pos == buf ? "" : " ");
640 if (ret < 0 || ret >= end - pos) {
641 end[-1] = '\0';
642 return buf;
643 }
644 pos += ret;
645 }
6fc6879b
JM		 646#endif /* CONFIG_IEEE80211R */
647
56586197 648#ifdef CONFIG_IEEE80211W
50793929
PF		 649 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
650 ret = os_snprintf(pos, end - pos, "%sWPA-PSK-SHA256",
651 pos == buf ? "" : " ");
652 if (ret < 0 || ret >= end - pos) {
653 end[-1] = '\0';
654 return buf;
655 }
656 pos += ret;
657 }
56586197 658
50793929
PF		 659 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
660 ret = os_snprintf(pos, end - pos, "%sWPA-EAP-SHA256",
661 pos == buf ? "" : " ");
662 if (ret < 0 || ret >= end - pos) {
663 end[-1] = '\0';
664 return buf;
665 }
666 pos += ret;
667 }
56586197
JM		 668#endif /* CONFIG_IEEE80211W */
669
728fae16 670#ifdef CONFIG_WPS
50793929
PF		 671 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
672 ret = os_snprintf(pos, end - pos, "%sWPS",
673 pos == buf ? "" : " ");
674 if (ret < 0 || ret >= end - pos) {
675 end[-1] = '\0';
676 return buf;
677 }
678 pos += ret;
679 }
728fae16
JM		 680#endif /* CONFIG_WPS */
681
d3fd563f
TP		 682#ifdef CONFIG_SAE
683 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) {
684 ret = os_snprintf(pos, end - pos, "%sSAE",
685 pos == buf ? "" : " ");
686 if (ret < 0 || ret >= end - pos) {
687 end[-1] = '\0';
688 return buf;
689 }
690 pos += ret;
691 }
692
693 if (ssid->key_mgmt & WPA_KEY_MGMT_FT_SAE) {
694 ret = os_snprintf(pos, end - pos, "%sFT-SAE",
695 pos == buf ? "" : " ");
696 if (ret < 0 || ret >= end - pos) {
697 end[-1] = '\0';
698 return buf;
699 }
700 pos += ret;
701 }
702#endif /* CONFIG_SAE */
703
2d6ee86f
JM		 704#ifdef CONFIG_HS20
705 if (ssid->key_mgmt & WPA_KEY_MGMT_OSEN) {
706 ret = os_snprintf(pos, end - pos, "%sOSEN",
707 pos == buf ? "" : " ");
708 if (ret < 0 || ret >= end - pos) {
709 end[-1] = '\0';
710 return buf;
711 }
712 pos += ret;
713 }
714#endif /* CONFIG_HS20 */
715
666497c8
JM		 716 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
717 ret = os_snprintf(pos, end - pos, "%sWPA-EAP-SUITE-B",
718 pos == buf ? "" : " ");
719 if (ret < 0 || ret >= end - pos) {
720 end[-1] = '\0';
721 return buf;
722 }
723 pos += ret;
724 }
725
a1e46f32
JM		 726 if (pos == buf) {
727 os_free(buf);
728 buf = NULL;
729 }
730
6fc6879b
JM		 731 return buf;
732}
733#endif /* NO_CONFIG_WRITE */
734
735
736static int wpa_config_parse_cipher(int line, const char *value)
737{
a39c78be
JM		 738 int val = wpa_parse_cipher(value);
739 if (val < 0) {
740 wpa_printf(MSG_ERROR, "Line %d: invalid cipher '%s'.",
741 line, value);
6fc6879b 742 return -1;
6fc6879b 743 }
6fc6879b
JM		 744 if (val == 0) {
745 wpa_printf(MSG_ERROR, "Line %d: no cipher values configured.",
746 line);
747 return -1;
748 }
749 return val;
750}
751
752
753#ifndef NO_CONFIG_WRITE
754static char * wpa_config_write_cipher(int cipher)
755{
0282a8c4 756 char *buf = os_zalloc(50);
6fc6879b
JM		 757 if (buf == NULL)
758 return NULL;
6fc6879b 759
0282a8c4
JM		 760 if (wpa_write_ciphers(buf, buf + 50, cipher, " ") < 0) {
761 os_free(buf);
762 return NULL;
6fc6879b
JM		 763 }
764
765 return buf;
766}
767#endif /* NO_CONFIG_WRITE */
768
769
770static int wpa_config_parse_pairwise(const struct parse_data *data,
771 struct wpa_ssid *ssid, int line,
772 const char *value)
773{
774 int val;
775 val = wpa_config_parse_cipher(line, value);
776 if (val == -1)
777 return -1;
03145326 778 if (val & ~WPA_ALLOWED_PAIRWISE_CIPHERS) {
6fc6879b
JM		 779 wpa_printf(MSG_ERROR, "Line %d: not allowed pairwise cipher "
780 "(0x%x).", line, val);
781 return -1;
782 }
783
784 wpa_printf(MSG_MSGDUMP, "pairwise: 0x%x", val);
785 ssid->pairwise_cipher = val;
786 return 0;
787}
788
789
790#ifndef NO_CONFIG_WRITE
791static char * wpa_config_write_pairwise(const struct parse_data *data,
792 struct wpa_ssid *ssid)
793{
794 return wpa_config_write_cipher(ssid->pairwise_cipher);
795}
796#endif /* NO_CONFIG_WRITE */
797
798
799static int wpa_config_parse_group(const struct parse_data *data,
800 struct wpa_ssid *ssid, int line,
801 const char *value)
802{
803 int val;
804 val = wpa_config_parse_cipher(line, value);
805 if (val == -1)
806 return -1;
03145326 807 if (val & ~WPA_ALLOWED_GROUP_CIPHERS) {
6fc6879b
JM		 808 wpa_printf(MSG_ERROR, "Line %d: not allowed group cipher "
809 "(0x%x).", line, val);
810 return -1;
811 }
812
813 wpa_printf(MSG_MSGDUMP, "group: 0x%x", val);
814 ssid->group_cipher = val;
815 return 0;
816}
817
818
819#ifndef NO_CONFIG_WRITE
820static char * wpa_config_write_group(const struct parse_data *data,
821 struct wpa_ssid *ssid)
822{
823 return wpa_config_write_cipher(ssid->group_cipher);
824}
825#endif /* NO_CONFIG_WRITE */
826
827
828static int wpa_config_parse_auth_alg(const struct parse_data *data,
829 struct wpa_ssid *ssid, int line,
830 const char *value)
831{
832 int val = 0, last, errors = 0;
833 char *start, *end, *buf;
834
835 buf = os_strdup(value);
836 if (buf == NULL)
837 return -1;
838 start = buf;
839
840 while (*start != '\0') {
841 while (*start == ' ' || *start == '\t')
842 start++;
843 if (*start == '\0')
844 break;
845 end = start;
846 while (*end != ' ' && *end != '\t' && *end != '\0')
847 end++;
848 last = *end == '\0';
849 *end = '\0';
850 if (os_strcmp(start, "OPEN") == 0)
851 val |= WPA_AUTH_ALG_OPEN;
852 else if (os_strcmp(start, "SHARED") == 0)
853 val |= WPA_AUTH_ALG_SHARED;
854 else if (os_strcmp(start, "LEAP") == 0)
855 val |= WPA_AUTH_ALG_LEAP;
856 else {
857 wpa_printf(MSG_ERROR, "Line %d: invalid auth_alg '%s'",
858 line, start);
859 errors++;
860 }
861
862 if (last)
863 break;
864 start = end + 1;
865 }
866 os_free(buf);
867
868 if (val == 0) {
869 wpa_printf(MSG_ERROR,
870 "Line %d: no auth_alg values configured.", line);
871 errors++;
872 }
873
874 wpa_printf(MSG_MSGDUMP, "auth_alg: 0x%x", val);
875 ssid->auth_alg = val;
876 return errors ? -1 : 0;
877}
878
879
880#ifndef NO_CONFIG_WRITE
881static char * wpa_config_write_auth_alg(const struct parse_data *data,
882 struct wpa_ssid *ssid)
883{
884 char *buf, *pos, *end;
885 int ret;
886
887 pos = buf = os_zalloc(30);
888 if (buf == NULL)
889 return NULL;
890 end = buf + 30;
891
892 if (ssid->auth_alg & WPA_AUTH_ALG_OPEN) {
893 ret = os_snprintf(pos, end - pos, "%sOPEN",
894 pos == buf ? "" : " ");
895 if (ret < 0 || ret >= end - pos) {
896 end[-1] = '\0';
897 return buf;
898 }
899 pos += ret;
900 }
901
902 if (ssid->auth_alg & WPA_AUTH_ALG_SHARED) {
903 ret = os_snprintf(pos, end - pos, "%sSHARED",
904 pos == buf ? "" : " ");
905 if (ret < 0 || ret >= end - pos) {
906 end[-1] = '\0';
907 return buf;
908 }
909 pos += ret;
910 }
911
912 if (ssid->auth_alg & WPA_AUTH_ALG_LEAP) {
913 ret = os_snprintf(pos, end - pos, "%sLEAP",
914 pos == buf ? "" : " ");
915 if (ret < 0 || ret >= end - pos) {
916 end[-1] = '\0';
917 return buf;
918 }
919 pos += ret;
920 }
921
a1e46f32
JM		 922 if (pos == buf) {
923 os_free(buf);
924 buf = NULL;
925 }
926
6fc6879b
JM		 927 return buf;
928}
929#endif /* NO_CONFIG_WRITE */
930
931
625f202a 932static int * wpa_config_parse_int_array(const char *value)
d3a98225
JM		 933{
934 int *freqs;
935 size_t used, len;
936 const char *pos;
937
938 used = 0;
939 len = 10;
f9884c09 940 freqs = os_calloc(len + 1, sizeof(int));
d3a98225 941 if (freqs == NULL)
b766a9a2 942 return NULL;
d3a98225
JM		 943
944 pos = value;
945 while (pos) {
946 while (*pos == ' ')
947 pos++;
948 if (used == len) {
949 int *n;
950 size_t i;
067ffa26 951 n = os_realloc_array(freqs, len * 2 + 1, sizeof(int));
d3a98225
JM		 952 if (n == NULL) {
953 os_free(freqs);
b766a9a2 954 return NULL;
d3a98225
JM		 955 }
956 for (i = len; i <= len * 2; i++)
957 n[i] = 0;
958 freqs = n;
959 len *= 2;
960 }
961
962 freqs[used] = atoi(pos);
963 if (freqs[used] == 0)
964 break;
965 used++;
966 pos = os_strchr(pos + 1, ' ');
967 }
968
b766a9a2
JM		 969 return freqs;
970}
971
972
973static int wpa_config_parse_scan_freq(const struct parse_data *data,
974 struct wpa_ssid *ssid, int line,
975 const char *value)
976{
977 int *freqs;
978
625f202a 979 freqs = wpa_config_parse_int_array(value);
b766a9a2
JM		 980 if (freqs == NULL)
981 return -1;
6668efda
JM		 982 if (freqs[0] == 0) {
983 os_free(freqs);
984 freqs = NULL;
985 }
d3a98225
JM		 986 os_free(ssid->scan_freq);
987 ssid->scan_freq = freqs;
988
989 return 0;
990}
991
992
b766a9a2
JM		 993static int wpa_config_parse_freq_list(const struct parse_data *data,
994 struct wpa_ssid *ssid, int line,
995 const char *value)
996{
997 int *freqs;
998
625f202a 999 freqs = wpa_config_parse_int_array(value);
b766a9a2
JM		 1000 if (freqs == NULL)
1001 return -1;
6668efda
JM		 1002 if (freqs[0] == 0) {
1003 os_free(freqs);
1004 freqs = NULL;
1005 }
b766a9a2
JM		 1006 os_free(ssid->freq_list);
1007 ssid->freq_list = freqs;
1008
1009 return 0;
1010}
1011
1012
d3a98225 1013#ifndef NO_CONFIG_WRITE
b766a9a2
JM		 1014static char * wpa_config_write_freqs(const struct parse_data *data,
1015 const int *freqs)
d3a98225
JM		 1016{
1017 char *buf, *pos, *end;
1018 int i, ret;
1019 size_t count;
1020
b766a9a2 1021 if (freqs == NULL)
d3a98225
JM		 1022 return NULL;
1023
1024 count = 0;
b766a9a2 1025 for (i = 0; freqs[i]; i++)
d3a98225
JM		 1026 count++;
1027
1028 pos = buf = os_zalloc(10 * count + 1);
1029 if (buf == NULL)
1030 return NULL;
1031 end = buf + 10 * count + 1;
1032
b766a9a2 1033 for (i = 0; freqs[i]; i++) {
d3a98225 1034 ret = os_snprintf(pos, end - pos, "%s%u",
b766a9a2 1035 i == 0 ? "" : " ", freqs[i]);
d3a98225
JM		 1036 if (ret < 0 || ret >= end - pos) {
1037 end[-1] = '\0';
1038 return buf;
1039 }
1040 pos += ret;
1041 }
1042
1043 return buf;
1044}
b766a9a2
JM		 1045
1046
1047static char * wpa_config_write_scan_freq(const struct parse_data *data,
1048 struct wpa_ssid *ssid)
1049{
1050 return wpa_config_write_freqs(data, ssid->scan_freq);
1051}
1052
1053
1054static char * wpa_config_write_freq_list(const struct parse_data *data,
1055 struct wpa_ssid *ssid)
1056{
1057 return wpa_config_write_freqs(data, ssid->freq_list);
1058}
d3a98225
JM		 1059#endif /* NO_CONFIG_WRITE */
1060
1061
6fc6879b
JM		 1062#ifdef IEEE8021X_EAPOL
1063static int wpa_config_parse_eap(const struct parse_data *data,
1064 struct wpa_ssid *ssid, int line,
1065 const char *value)
1066{
1067 int last, errors = 0;
1068 char *start, *end, *buf;
1069 struct eap_method_type *methods = NULL, *tmp;
1070 size_t num_methods = 0;
1071
1072 buf = os_strdup(value);
1073 if (buf == NULL)
1074 return -1;
1075 start = buf;
1076
1077 while (*start != '\0') {
1078 while (*start == ' ' || *start == '\t')
1079 start++;
1080 if (*start == '\0')
1081 break;
1082 end = start;
1083 while (*end != ' ' && *end != '\t' && *end != '\0')
1084 end++;
1085 last = *end == '\0';
1086 *end = '\0';
1087 tmp = methods;
067ffa26
JM		 1088 methods = os_realloc_array(methods, num_methods + 1,
1089 sizeof(*methods));
6fc6879b
JM		 1090 if (methods == NULL) {
1091 os_free(tmp);
1092 os_free(buf);
1093 return -1;
1094 }
1095 methods[num_methods].method = eap_peer_get_type(
1096 start, &methods[num_methods].vendor);
1097 if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
1098 methods[num_methods].method == EAP_TYPE_NONE) {
1099 wpa_printf(MSG_ERROR, "Line %d: unknown EAP method "
1100 "'%s'", line, start);
1101 wpa_printf(MSG_ERROR, "You may need to add support for"
1102 " this EAP method during wpa_supplicant\n"
1103 "build time configuration.\n"
1104 "See README for more information.");
1105 errors++;
1106 } else if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
1107 methods[num_methods].method == EAP_TYPE_LEAP)
1108 ssid->leap++;
1109 else
1110 ssid->non_leap++;
1111 num_methods++;
1112 if (last)
1113 break;
1114 start = end + 1;
1115 }
1116 os_free(buf);
1117
1118 tmp = methods;
067ffa26 1119 methods = os_realloc_array(methods, num_methods + 1, sizeof(*methods));
6fc6879b
JM		 1120 if (methods == NULL) {
1121 os_free(tmp);
1122 return -1;
1123 }
1124 methods[num_methods].vendor = EAP_VENDOR_IETF;
1125 methods[num_methods].method = EAP_TYPE_NONE;
1126 num_methods++;
1127
1128 wpa_hexdump(MSG_MSGDUMP, "eap methods",
1129 (u8 *) methods, num_methods * sizeof(*methods));
bb8b1bb0 1130 os_free(ssid->eap.eap_methods);
6fc6879b
JM		 1131 ssid->eap.eap_methods = methods;
1132 return errors ? -1 : 0;
1133}
1134
1135
1136static char * wpa_config_write_eap(const struct parse_data *data,
1137 struct wpa_ssid *ssid)
1138{
1139 int i, ret;
1140 char *buf, *pos, *end;
1141 const struct eap_method_type *eap_methods = ssid->eap.eap_methods;
1142 const char *name;
1143
1144 if (eap_methods == NULL)
1145 return NULL;
1146
1147 pos = buf = os_zalloc(100);
1148 if (buf == NULL)
1149 return NULL;
1150 end = buf + 100;
1151
1152 for (i = 0; eap_methods[i].vendor != EAP_VENDOR_IETF ||
1153 eap_methods[i].method != EAP_TYPE_NONE; i++) {
1154 name = eap_get_name(eap_methods[i].vendor,
1155 eap_methods[i].method);
1156 if (name) {
1157 ret = os_snprintf(pos, end - pos, "%s%s",
1158 pos == buf ? "" : " ", name);
1159 if (ret < 0 || ret >= end - pos)
1160 break;
1161 pos += ret;
1162 }
1163 }
1164
1165 end[-1] = '\0';
1166
1167 return buf;
1168}
1169
1170
1171static int wpa_config_parse_password(const struct parse_data *data,
1172 struct wpa_ssid *ssid, int line,
1173 const char *value)
1174{
1175 u8 *hash;
1176
b56c0546
JM		 1177 if (os_strcmp(value, "NULL") == 0) {
1178 wpa_printf(MSG_DEBUG, "Unset configuration string 'password'");
19c48da0 1179 bin_clear_free(ssid->eap.password, ssid->eap.password_len);
b56c0546
JM		 1180 ssid->eap.password = NULL;
1181 ssid->eap.password_len = 0;
1182 return 0;
1183 }
1184
0ebb23e3
JM		 1185#ifdef CONFIG_EXT_PASSWORD
1186 if (os_strncmp(value, "ext:", 4) == 0) {
1187 char *name = os_strdup(value + 4);
1188 if (name == NULL)
1189 return -1;
19c48da0 1190 bin_clear_free(ssid->eap.password, ssid->eap.password_len);
0ebb23e3
JM		 1191 ssid->eap.password = (u8 *) name;
1192 ssid->eap.password_len = os_strlen(name);
1193 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1194 ssid->eap.flags |= EAP_CONFIG_FLAGS_EXT_PASSWORD;
1195 return 0;
1196 }
1197#endif /* CONFIG_EXT_PASSWORD */
1198
6fc6879b
JM		 1199 if (os_strncmp(value, "hash:", 5) != 0) {
1200 char *tmp;
1201 size_t res_len;
1202
1203 tmp = wpa_config_parse_string(value, &res_len);
1204 if (tmp == NULL) {
1205 wpa_printf(MSG_ERROR, "Line %d: failed to parse "
1206 "password.", line);
1207 return -1;
1208 }
556f5a2a
HS		 1209 wpa_hexdump_ascii_key(MSG_MSGDUMP, data->name,
1210 (u8 *) tmp, res_len);
6fc6879b 1211
19c48da0 1212 bin_clear_free(ssid->eap.password, ssid->eap.password_len);
6fc6879b
JM		 1213 ssid->eap.password = (u8 *) tmp;
1214 ssid->eap.password_len = res_len;
1215 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
0ebb23e3 1216 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_EXT_PASSWORD;
6fc6879b
JM		 1217
1218 return 0;
1219 }
1220
1221
1222 /* NtPasswordHash: hash:<32 hex digits> */
1223 if (os_strlen(value + 5) != 2 * 16) {
1224 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash length "
1225 "(expected 32 hex digits)", line);
1226 return -1;
1227 }
1228
1229 hash = os_malloc(16);
1230 if (hash == NULL)
1231 return -1;
1232
1233 if (hexstr2bin(value + 5, hash, 16)) {
1234 os_free(hash);
1235 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash", line);
1236 return -1;
1237 }
1238
1239 wpa_hexdump_key(MSG_MSGDUMP, data->name, hash, 16);
1240
19c48da0 1241 bin_clear_free(ssid->eap.password, ssid->eap.password_len);
6fc6879b
JM		 1242 ssid->eap.password = hash;
1243 ssid->eap.password_len = 16;
1244 ssid->eap.flags |= EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
0ebb23e3 1245 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_EXT_PASSWORD;
6fc6879b
JM		 1246
1247 return 0;
1248}
1249
1250
1251static char * wpa_config_write_password(const struct parse_data *data,
1252 struct wpa_ssid *ssid)
1253{
1254 char *buf;
1255
1256 if (ssid->eap.password == NULL)
1257 return NULL;
1258
0ebb23e3
JM		 1259#ifdef CONFIG_EXT_PASSWORD
1260 if (ssid->eap.flags & EAP_CONFIG_FLAGS_EXT_PASSWORD) {
1261 buf = os_zalloc(4 + ssid->eap.password_len + 1);
1262 if (buf == NULL)
1263 return NULL;
1264 os_memcpy(buf, "ext:", 4);
1265 os_memcpy(buf + 4, ssid->eap.password, ssid->eap.password_len);
1266 return buf;
1267 }
1268#endif /* CONFIG_EXT_PASSWORD */
1269
6fc6879b
JM		 1270 if (!(ssid->eap.flags & EAP_CONFIG_FLAGS_PASSWORD_NTHASH)) {
1271 return wpa_config_write_string(
1272 ssid->eap.password, ssid->eap.password_len);
1273 }
1274
1275 buf = os_malloc(5 + 32 + 1);
1276 if (buf == NULL)
1277 return NULL;
1278
1279 os_memcpy(buf, "hash:", 5);
1280 wpa_snprintf_hex(buf + 5, 32 + 1, ssid->eap.password, 16);
1281
1282 return buf;
1283}
1284#endif /* IEEE8021X_EAPOL */
1285
1286
1287static int wpa_config_parse_wep_key(u8 *key, size_t *len, int line,
1288 const char *value, int idx)
1289{
1290 char *buf, title[20];
1291 int res;
1292
1293 buf = wpa_config_parse_string(value, len);
1294 if (buf == NULL) {
1295 wpa_printf(MSG_ERROR, "Line %d: Invalid WEP key %d '%s'.",
1296 line, idx, value);
1297 return -1;
1298 }
1299 if (*len > MAX_WEP_KEY_LEN) {
1300 wpa_printf(MSG_ERROR, "Line %d: Too long WEP key %d '%s'.",
1301 line, idx, value);
1302 os_free(buf);
1303 return -1;
1304 }
fea7c3a0
JM		 1305 if (*len && *len != 5 && *len != 13 && *len != 16) {
1306 wpa_printf(MSG_ERROR, "Line %d: Invalid WEP key length %u - "
1307 "this network block will be ignored",
1308 line, (unsigned int) *len);
1309 }
6fc6879b 1310 os_memcpy(key, buf, *len);
19c48da0 1311 str_clear_free(buf);
6fc6879b 1312 res = os_snprintf(title, sizeof(title), "wep_key%d", idx);
a80ba67a 1313 if (!os_snprintf_error(sizeof(title), res))
6fc6879b
JM		 1314 wpa_hexdump_key(MSG_MSGDUMP, title, key, *len);
1315 return 0;
1316}
1317
1318
1319static int wpa_config_parse_wep_key0(const struct parse_data *data,
1320 struct wpa_ssid *ssid, int line,
1321 const char *value)
1322{
1323 return wpa_config_parse_wep_key(ssid->wep_key[0],
1324 &ssid->wep_key_len[0], line,
1325 value, 0);
1326}
1327
1328
1329static int wpa_config_parse_wep_key1(const struct parse_data *data,
1330 struct wpa_ssid *ssid, int line,
1331 const char *value)
1332{
1333 return wpa_config_parse_wep_key(ssid->wep_key[1],
1334 &ssid->wep_key_len[1], line,
1335 value, 1);
1336}
1337
1338
1339static int wpa_config_parse_wep_key2(const struct parse_data *data,
1340 struct wpa_ssid *ssid, int line,
1341 const char *value)
1342{
1343 return wpa_config_parse_wep_key(ssid->wep_key[2],
1344 &ssid->wep_key_len[2], line,
1345 value, 2);
1346}
1347
1348
1349static int wpa_config_parse_wep_key3(const struct parse_data *data,
1350 struct wpa_ssid *ssid, int line,
1351 const char *value)
1352{
1353 return wpa_config_parse_wep_key(ssid->wep_key[3],
1354 &ssid->wep_key_len[3], line,
1355 value, 3);
1356}
1357
1358
1359#ifndef NO_CONFIG_WRITE
1360static char * wpa_config_write_wep_key(struct wpa_ssid *ssid, int idx)
1361{
1362 if (ssid->wep_key_len[idx] == 0)
1363 return NULL;
1364 return wpa_config_write_string(ssid->wep_key[idx],
1365 ssid->wep_key_len[idx]);
1366}
1367
1368
1369static char * wpa_config_write_wep_key0(const struct parse_data *data,
1370 struct wpa_ssid *ssid)
1371{
1372 return wpa_config_write_wep_key(ssid, 0);
1373}
1374
1375
1376static char * wpa_config_write_wep_key1(const struct parse_data *data,
1377 struct wpa_ssid *ssid)
1378{
1379 return wpa_config_write_wep_key(ssid, 1);
1380}
1381
1382
1383static char * wpa_config_write_wep_key2(const struct parse_data *data,
1384 struct wpa_ssid *ssid)
1385{
1386 return wpa_config_write_wep_key(ssid, 2);
1387}
1388
1389
1390static char * wpa_config_write_wep_key3(const struct parse_data *data,
1391 struct wpa_ssid *ssid)
1392{
1393 return wpa_config_write_wep_key(ssid, 3);
1394}
1395#endif /* NO_CONFIG_WRITE */
1396
1397
fbdcfd57
JM		 1398#ifdef CONFIG_P2P
1399
9ec87666
JM		 1400static int wpa_config_parse_go_p2p_dev_addr(const struct parse_data *data,
1401 struct wpa_ssid *ssid, int line,
1402 const char *value)
1403{
1404 if (value[0] == '\0' || os_strcmp(value, "\"\"") == 0 ||
1405 os_strcmp(value, "any") == 0) {
1406 os_memset(ssid->go_p2p_dev_addr, 0, ETH_ALEN);
1407 wpa_printf(MSG_MSGDUMP, "GO P2P Device Address any");
1408 return 0;
1409 }
1410 if (hwaddr_aton(value, ssid->go_p2p_dev_addr)) {
1411 wpa_printf(MSG_ERROR, "Line %d: Invalid GO P2P Device Address '%s'.",
1412 line, value);
1413 return -1;
1414 }
1415 ssid->bssid_set = 1;
1416 wpa_printf(MSG_MSGDUMP, "GO P2P Device Address " MACSTR,
1417 MAC2STR(ssid->go_p2p_dev_addr));
1418 return 0;
1419}
1420
1421
1422#ifndef NO_CONFIG_WRITE
1423static char * wpa_config_write_go_p2p_dev_addr(const struct parse_data *data,
1424 struct wpa_ssid *ssid)
1425{
1426 char *value;
1427 int res;
1428
1429 if (is_zero_ether_addr(ssid->go_p2p_dev_addr))
1430 return NULL;
1431
1432 value = os_malloc(20);
1433 if (value == NULL)
1434 return NULL;
1435 res = os_snprintf(value, 20, MACSTR, MAC2STR(ssid->go_p2p_dev_addr));
1436 if (res < 0 || res >= 20) {
1437 os_free(value);
1438 return NULL;
1439 }
1440 value[20 - 1] = '\0';
1441 return value;
1442}
1443#endif /* NO_CONFIG_WRITE */
1444
1445
fbdcfd57
JM		 1446static int wpa_config_parse_p2p_client_list(const struct parse_data *data,
1447 struct wpa_ssid *ssid, int line,
1448 const char *value)
1449{
1450 const char *pos;
1451 u8 *buf, *n, addr[ETH_ALEN];
1452 size_t count;
1453
1454 buf = NULL;
1455 count = 0;
1456
1457 pos = value;
1458 while (pos && *pos) {
1459 while (*pos == ' ')
1460 pos++;
1461
1462 if (hwaddr_aton(pos, addr)) {
22316795
JM		 1463 if (count == 0) {
1464 wpa_printf(MSG_ERROR, "Line %d: Invalid "
1465 "p2p_client_list address '%s'.",
1466 line, value);
1467 os_free(buf);
1468 return -1;
1469 }
1470 /* continue anyway since this could have been from a
1471 * truncated configuration file line */
1472 wpa_printf(MSG_INFO, "Line %d: Ignore likely "
1473 "truncated p2p_client_list address '%s'",
1474 line, pos);
fbdcfd57 1475 } else {
067ffa26 1476 n = os_realloc_array(buf, count + 1, ETH_ALEN);
fbdcfd57
JM		 1477 if (n == NULL) {
1478 os_free(buf);
1479 return -1;
1480 }
1481 buf = n;
22316795
JM		 1482 os_memmove(buf + ETH_ALEN, buf, count * ETH_ALEN);
1483 os_memcpy(buf, addr, ETH_ALEN);
fbdcfd57
JM		 1484 count++;
1485 wpa_hexdump(MSG_MSGDUMP, "p2p_client_list",
1486 addr, ETH_ALEN);
1487 }
1488
1489 pos = os_strchr(pos, ' ');
1490 }
1491
1492 os_free(ssid->p2p_client_list);
1493 ssid->p2p_client_list = buf;
1494 ssid->num_p2p_clients = count;
1495
1496 return 0;
1497}
1498
1499
1500#ifndef NO_CONFIG_WRITE
1501static char * wpa_config_write_p2p_client_list(const struct parse_data *data,
1502 struct wpa_ssid *ssid)
1503{
1504 char *value, *end, *pos;
1505 int res;
1506 size_t i;
1507
1508 if (ssid->p2p_client_list == NULL || ssid->num_p2p_clients == 0)
1509 return NULL;
1510
1511 value = os_malloc(20 * ssid->num_p2p_clients);
1512 if (value == NULL)
1513 return NULL;
1514 pos = value;
1515 end = value + 20 * ssid->num_p2p_clients;
1516
22316795 1517 for (i = ssid->num_p2p_clients; i > 0; i--) {
fbdcfd57
JM		 1518 res = os_snprintf(pos, end - pos, MACSTR " ",
1519 MAC2STR(ssid->p2p_client_list +
22316795 1520 (i - 1) * ETH_ALEN));
fbdcfd57
JM		 1521 if (res < 0 || res >= end - pos) {
1522 os_free(value);
1523 return NULL;
1524 }
1525 pos += res;
1526 }
1527
1528 if (pos > value)
1529 pos[-1] = '\0';
1530
1531 return value;
1532}
1533#endif /* NO_CONFIG_WRITE */
1534
01a57fe4
JM		 1535
1536static int wpa_config_parse_psk_list(const struct parse_data *data,
1537 struct wpa_ssid *ssid, int line,
1538 const char *value)
1539{
1540 struct psk_list_entry *p;
1541 const char *pos;
1542
1543 p = os_zalloc(sizeof(*p));
1544 if (p == NULL)
1545 return -1;
1546
1547 pos = value;
1548 if (os_strncmp(pos, "P2P-", 4) == 0) {
1549 p->p2p = 1;
1550 pos += 4;
1551 }
1552
1553 if (hwaddr_aton(pos, p->addr)) {
1554 wpa_printf(MSG_ERROR, "Line %d: Invalid psk_list address '%s'",
1555 line, pos);
1556 os_free(p);
1557 return -1;
1558 }
1559 pos += 17;
1560 if (*pos != '-') {
1561 wpa_printf(MSG_ERROR, "Line %d: Invalid psk_list '%s'",
1562 line, pos);
1563 os_free(p);
1564 return -1;
1565 }
1566 pos++;
1567
1568 if (hexstr2bin(pos, p->psk, PMK_LEN) || pos[PMK_LEN * 2] != '\0') {
1569 wpa_printf(MSG_ERROR, "Line %d: Invalid psk_list PSK '%s'",
1570 line, pos);
1571 os_free(p);
1572 return -1;
1573 }
1574
1575 dl_list_add(&ssid->psk_list, &p->list);
1576
1577 return 0;
1578}
1579
1580
1581#ifndef NO_CONFIG_WRITE
1582static char * wpa_config_write_psk_list(const struct parse_data *data,
1583 struct wpa_ssid *ssid)
1584{
1585 return NULL;
1586}
1587#endif /* NO_CONFIG_WRITE */
1588
fbdcfd57
JM		 1589#endif /* CONFIG_P2P */
1590
5cfb672d
JM		 1591
1592#ifdef CONFIG_MESH
1593
1594static int wpa_config_parse_mesh_ht_mode(const struct parse_data *data,
1595 struct wpa_ssid *ssid, int line,
1596 const char *value)
1597{
1598 int htval = 0;
1599
1600 if (os_strcmp(value, "NOHT") == 0)
1601 htval = CHAN_NO_HT;
1602 else if (os_strcmp(value, "HT20") == 0)
1603 htval = CHAN_HT20;
1604 else if (os_strcmp(value, "HT40-") == 0)
1605 htval = CHAN_HT40MINUS;
1606 else if (os_strcmp(value, "HT40+") == 0)
1607 htval = CHAN_HT40PLUS;
1608 else {
1609 wpa_printf(MSG_ERROR,
1610 "Line %d: no ht_mode configured.", line);
1611 return -1;
1612 }
1613
1614 wpa_printf(MSG_MSGDUMP, "mesh_ht_mode: 0x%x", htval);
1615 ssid->mesh_ht_mode = htval;
1616 return 0;
1617}
1618
1619
2b2bb5a8
MH		 1620static int wpa_config_parse_mesh_basic_rates(const struct parse_data *data,
1621 struct wpa_ssid *ssid, int line,
1622 const char *value)
1623{
1624 int *rates = wpa_config_parse_int_array(value);
1625
1626 if (rates == NULL) {
1627 wpa_printf(MSG_ERROR, "Line %d: Invalid mesh_basic_rates '%s'",
1628 line, value);
1629 return -1;
1630 }
1631 if (rates[0] == 0) {
1632 os_free(rates);
1633 rates = NULL;
1634 }
1635
1636 os_free(ssid->mesh_basic_rates);
1637 ssid->mesh_basic_rates = rates;
1638
1639 return 0;
1640}
1641
1642
5cfb672d 1643#ifndef NO_CONFIG_WRITE
2b2bb5a8 1644
5cfb672d
JM		 1645static char * wpa_config_write_mesh_ht_mode(const struct parse_data *data,
1646 struct wpa_ssid *ssid)
1647{
1648 char *val;
1649
1650 switch (ssid->mesh_ht_mode) {
1651 default:
1652 val = NULL;
1653 break;
1654 case CHAN_NO_HT:
1655 val = "NOHT";
1656 break;
1657 case CHAN_HT20:
1658 val = "HT20";
1659 break;
1660 case CHAN_HT40MINUS:
1661 val = "HT40-";
1662 break;
1663 case CHAN_HT40PLUS:
1664 val = "HT40+";
1665 break;
1666 }
1667 return val ? os_strdup(val) : NULL;
1668}
1669
2b2bb5a8
MH		 1670
1671static char * wpa_config_write_mesh_basic_rates(const struct parse_data *data,
1672 struct wpa_ssid *ssid)
1673{
1674 return wpa_config_write_freqs(data, ssid->mesh_basic_rates);
1675}
1676
5cfb672d
JM		 1677#endif /* NO_CONFIG_WRITE */
1678
1679#endif /* CONFIG_MESH */
1680
1681
6fc6879b
JM		 1682/* Helper macros for network block parser */
1683
1684#ifdef OFFSET
1685#undef OFFSET
1686#endif /* OFFSET */
1687/* OFFSET: Get offset of a variable within the wpa_ssid structure */
1688#define OFFSET(v) ((void *) &((struct wpa_ssid *) 0)->v)
1689
1690/* STR: Define a string variable for an ASCII string; f = field name */
1691#ifdef NO_CONFIG_WRITE
1692#define _STR(f) #f, wpa_config_parse_str, OFFSET(f)
1693#define _STRe(f) #f, wpa_config_parse_str, OFFSET(eap.f)
1694#else /* NO_CONFIG_WRITE */
1695#define _STR(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(f)
1696#define _STRe(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(eap.f)
1697#endif /* NO_CONFIG_WRITE */
1698#define STR(f) _STR(f), NULL, NULL, NULL, 0
1699#define STRe(f) _STRe(f), NULL, NULL, NULL, 0
1700#define STR_KEY(f) _STR(f), NULL, NULL, NULL, 1
1701#define STR_KEYe(f) _STRe(f), NULL, NULL, NULL, 1
1702
1703/* STR_LEN: Define a string variable with a separate variable for storing the
1704 * data length. Unlike STR(), this can be used to store arbitrary binary data
1705 * (i.e., even nul termination character). */
1706#define _STR_LEN(f) _STR(f), OFFSET(f ## _len)
1707#define _STR_LENe(f) _STRe(f), OFFSET(eap.f ## _len)
1708#define STR_LEN(f) _STR_LEN(f), NULL, NULL, 0
1709#define STR_LENe(f) _STR_LENe(f), NULL, NULL, 0
1710#define STR_LEN_KEY(f) _STR_LEN(f), NULL, NULL, 1
1711
1712/* STR_RANGE: Like STR_LEN(), but with minimum and maximum allowed length
1713 * explicitly specified. */
1714#define _STR_RANGE(f, min, max) _STR_LEN(f), (void *) (min), (void *) (max)
1715#define STR_RANGE(f, min, max) _STR_RANGE(f, min, max), 0
1716#define STR_RANGE_KEY(f, min, max) _STR_RANGE(f, min, max), 1
1717
1718#ifdef NO_CONFIG_WRITE
1719#define _INT(f) #f, wpa_config_parse_int, OFFSET(f), (void *) 0
1720#define _INTe(f) #f, wpa_config_parse_int, OFFSET(eap.f), (void *) 0
1721#else /* NO_CONFIG_WRITE */
1722#define _INT(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1723 OFFSET(f), (void *) 0
1724#define _INTe(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1725 OFFSET(eap.f), (void *) 0
1726#endif /* NO_CONFIG_WRITE */
1727
1728/* INT: Define an integer variable */
1729#define INT(f) _INT(f), NULL, NULL, 0
1730#define INTe(f) _INTe(f), NULL, NULL, 0
1731
1732/* INT_RANGE: Define an integer variable with allowed value range */
1733#define INT_RANGE(f, min, max) _INT(f), (void *) (min), (void *) (max), 0
1734
1735/* FUNC: Define a configuration variable that uses a custom function for
1736 * parsing and writing the value. */
1737#ifdef NO_CONFIG_WRITE
1738#define _FUNC(f) #f, wpa_config_parse_ ## f, NULL, NULL, NULL, NULL
1739#else /* NO_CONFIG_WRITE */
1740#define _FUNC(f) #f, wpa_config_parse_ ## f, wpa_config_write_ ## f, \
1741 NULL, NULL, NULL, NULL
1742#endif /* NO_CONFIG_WRITE */
1743#define FUNC(f) _FUNC(f), 0
1744#define FUNC_KEY(f) _FUNC(f), 1
1745
1746/*
1747 * Table of network configuration variables. This table is used to parse each
1748 * network configuration variable, e.g., each line in wpa_supplicant.conf file
1749 * that is inside a network block.
1750 *
1751 * This table is generated using the helper macros defined above and with
1752 * generous help from the C pre-processor. The field name is stored as a string
1753 * into .name and for STR and INT types, the offset of the target buffer within
1754 * struct wpa_ssid is stored in .param1. .param2 (if not NULL) is similar
1755 * offset to the field containing the length of the configuration variable.
1756 * .param3 and .param4 can be used to mark the allowed range (length for STR
1757 * and value for INT).
1758 *
1759 * For each configuration line in wpa_supplicant.conf, the parser goes through
1760 * this table and select the entry that matches with the field name. The parser
1761 * function (.parser) is then called to parse the actual value of the field.
1762 *
1763 * This kind of mechanism makes it easy to add new configuration parameters,
1764 * since only one line needs to be added into this table and into the
1765 * struct wpa_ssid definition if the new variable is either a string or
1766 * integer. More complex types will need to use their own parser and writer
1767 * functions.
1768 */
1769static const struct parse_data ssid_fields[] = {
1770 { STR_RANGE(ssid, 0, MAX_SSID_LEN) },
1771 { INT_RANGE(scan_ssid, 0, 1) },
1772 { FUNC(bssid) },
1773 { FUNC_KEY(psk) },
1774 { FUNC(proto) },
1775 { FUNC(key_mgmt) },
1f6c0ab8 1776 { INT(bg_scan_period) },
6fc6879b
JM		 1777 { FUNC(pairwise) },
1778 { FUNC(group) },
1779 { FUNC(auth_alg) },
d3a98225 1780 { FUNC(scan_freq) },
b766a9a2 1781 { FUNC(freq_list) },
6fc6879b
JM		 1782#ifdef IEEE8021X_EAPOL
1783 { FUNC(eap) },
1784 { STR_LENe(identity) },
1785 { STR_LENe(anonymous_identity) },
556f5a2a 1786 { FUNC_KEY(password) },
6fc6879b
JM		 1787 { STRe(ca_cert) },
1788 { STRe(ca_path) },
1789 { STRe(client_cert) },
1790 { STRe(private_key) },
1791 { STR_KEYe(private_key_passwd) },
1792 { STRe(dh_file) },
1793 { STRe(subject_match) },
1794 { STRe(altsubject_match) },
01f809c7 1795 { STRe(domain_suffix_match) },
6fc6879b
JM		 1796 { STRe(ca_cert2) },
1797 { STRe(ca_path2) },
1798 { STRe(client_cert2) },
1799 { STRe(private_key2) },
1800 { STR_KEYe(private_key2_passwd) },
1801 { STRe(dh_file2) },
1802 { STRe(subject_match2) },
1803 { STRe(altsubject_match2) },
01f809c7 1804 { STRe(domain_suffix_match2) },
6fc6879b
JM		 1805 { STRe(phase1) },
1806 { STRe(phase2) },
1807 { STRe(pcsc) },
1808 { STR_KEYe(pin) },
1809 { STRe(engine_id) },
1810 { STRe(key_id) },
61ee0f71
DS		 1811 { STRe(cert_id) },
1812 { STRe(ca_cert_id) },
98842d51
CL		 1813 { STR_KEYe(pin2) },
1814 { STRe(engine2_id) },
61ee0f71
DS		 1815 { STRe(key2_id) },
1816 { STRe(cert2_id) },
1817 { STRe(ca_cert2_id) },
6fc6879b 1818 { INTe(engine) },
98842d51 1819 { INTe(engine2) },
6fc6879b 1820 { INT(eapol_flags) },
13f6a07e 1821 { INTe(sim_num) },
07e2de31 1822 { STRe(openssl_ciphers) },
02a8d45a 1823 { INTe(erp) },
6fc6879b
JM		 1824#endif /* IEEE8021X_EAPOL */
1825 { FUNC_KEY(wep_key0) },
1826 { FUNC_KEY(wep_key1) },
1827 { FUNC_KEY(wep_key2) },
1828 { FUNC_KEY(wep_key3) },
1829 { INT(wep_tx_keyidx) },
1830 { INT(priority) },
1831#ifdef IEEE8021X_EAPOL
1832 { INT(eap_workaround) },
1833 { STRe(pac_file) },
1834 { INTe(fragment_size) },
080585c0 1835 { INTe(ocsp) },
6fc6879b 1836#endif /* IEEE8021X_EAPOL */
476e6bb6
TP		 1837#ifdef CONFIG_MESH
1838 { INT_RANGE(mode, 0, 5) },
07cb45cc 1839 { INT_RANGE(no_auto_peer, 0, 1) },
476e6bb6 1840#else /* CONFIG_MESH */
2c5d725c 1841 { INT_RANGE(mode, 0, 4) },
476e6bb6 1842#endif /* CONFIG_MESH */
6fc6879b 1843 { INT_RANGE(proactive_key_caching, 0, 1) },
4dac0245 1844 { INT_RANGE(disabled, 0, 2) },
6fc6879b
JM		 1845 { STR(id_str) },
1846#ifdef CONFIG_IEEE80211W
1847 { INT_RANGE(ieee80211w, 0, 2) },
1848#endif /* CONFIG_IEEE80211W */
1849 { INT_RANGE(peerkey, 0, 1) },
1850 { INT_RANGE(mixed_cell, 0, 1) },
7829894c 1851 { INT_RANGE(frequency, 0, 65000) },
5cfb672d
JM		 1852#ifdef CONFIG_MESH
1853 { FUNC(mesh_ht_mode) },
2b2bb5a8 1854 { FUNC(mesh_basic_rates) },
e6096799
MH		 1855 { INT(dot11MeshMaxRetries) },
1856 { INT(dot11MeshRetryTimeout) },
1857 { INT(dot11MeshConfirmTimeout) },
1858 { INT(dot11MeshHoldingTimeout) },
5cfb672d 1859#endif /* CONFIG_MESH */
60b94c98
JM		 1860 { INT(wpa_ptk_rekey) },
1861 { STR(bgscan) },
e62f4ed0 1862 { INT_RANGE(ignore_broadcast_ssid, 0, 2) },
fbdcfd57 1863#ifdef CONFIG_P2P
9ec87666 1864 { FUNC(go_p2p_dev_addr) },
fbdcfd57 1865 { FUNC(p2p_client_list) },
01a57fe4 1866 { FUNC(psk_list) },
fbdcfd57 1867#endif /* CONFIG_P2P */
80e8a5ee
BG		 1868#ifdef CONFIG_HT_OVERRIDES
1869 { INT_RANGE(disable_ht, 0, 1) },
1870 { INT_RANGE(disable_ht40, -1, 1) },
a90497f8 1871 { INT_RANGE(disable_sgi, 0, 1) },
39a5800f 1872 { INT_RANGE(disable_ldpc, 0, 1) },
d41cc8cc 1873 { INT_RANGE(ht40_intolerant, 0, 1) },
80e8a5ee
BG		 1874 { INT_RANGE(disable_max_amsdu, -1, 1) },
1875 { INT_RANGE(ampdu_factor, -1, 3) },
1876 { INT_RANGE(ampdu_density, -1, 7) },
1877 { STR(ht_mcs) },
1878#endif /* CONFIG_HT_OVERRIDES */
e9ee8dc3
JB		 1879#ifdef CONFIG_VHT_OVERRIDES
1880 { INT_RANGE(disable_vht, 0, 1) },
1881 { INT(vht_capa) },
1882 { INT(vht_capa_mask) },
1883 { INT_RANGE(vht_rx_mcs_nss_1, -1, 3) },
1884 { INT_RANGE(vht_rx_mcs_nss_2, -1, 3) },
1885 { INT_RANGE(vht_rx_mcs_nss_3, -1, 3) },
1886 { INT_RANGE(vht_rx_mcs_nss_4, -1, 3) },
1887 { INT_RANGE(vht_rx_mcs_nss_5, -1, 3) },
1888 { INT_RANGE(vht_rx_mcs_nss_6, -1, 3) },
1889 { INT_RANGE(vht_rx_mcs_nss_7, -1, 3) },
1890 { INT_RANGE(vht_rx_mcs_nss_8, -1, 3) },
1891 { INT_RANGE(vht_tx_mcs_nss_1, -1, 3) },
1892 { INT_RANGE(vht_tx_mcs_nss_2, -1, 3) },
1893 { INT_RANGE(vht_tx_mcs_nss_3, -1, 3) },
1894 { INT_RANGE(vht_tx_mcs_nss_4, -1, 3) },
1895 { INT_RANGE(vht_tx_mcs_nss_5, -1, 3) },
1896 { INT_RANGE(vht_tx_mcs_nss_6, -1, 3) },
1897 { INT_RANGE(vht_tx_mcs_nss_7, -1, 3) },
1898 { INT_RANGE(vht_tx_mcs_nss_8, -1, 3) },
1899#endif /* CONFIG_VHT_OVERRIDES */
07f53b8c 1900 { INT(ap_max_inactivity) },
fdfb1c8b 1901 { INT(dtim_period) },
18206e02 1902 { INT(beacon_int) },
dd10abcc
HW		 1903#ifdef CONFIG_MACSEC
1904 { INT_RANGE(macsec_policy, 0, 1) },
1905#endif /* CONFIG_MACSEC */
e376290c
DS		 1906#ifdef CONFIG_HS20
1907 { INT(update_identifier) },
1908#endif /* CONFIG_HS20 */
a313d17d 1909 { INT_RANGE(mac_addr, 0, 2) },
6fc6879b
JM		 1910};
1911
1912#undef OFFSET
1913#undef _STR
1914#undef STR
1915#undef STR_KEY
1916#undef _STR_LEN
1917#undef STR_LEN
1918#undef STR_LEN_KEY
1919#undef _STR_RANGE
1920#undef STR_RANGE
1921#undef STR_RANGE_KEY
1922#undef _INT
1923#undef INT
1924#undef INT_RANGE
1925#undef _FUNC
1926#undef FUNC
1927#undef FUNC_KEY
e7ecab4a 1928#define NUM_SSID_FIELDS ARRAY_SIZE(ssid_fields)
6fc6879b
JM		 1929
1930
1931/**
1932 * wpa_config_add_prio_network - Add a network to priority lists
1933 * @config: Configuration data from wpa_config_read()
1934 * @ssid: Pointer to the network configuration to be added to the list
1935 * Returns: 0 on success, -1 on failure
1936 *
1937 * This function is used to add a network block to the priority list of
1938 * networks. This must be called for each network when reading in the full
1939 * configuration. In addition, this can be used indirectly when updating
1940 * priorities by calling wpa_config_update_prio_list().
1941 */
1942int wpa_config_add_prio_network(struct wpa_config *config,
1943 struct wpa_ssid *ssid)
1944{
1945 int prio;
1946 struct wpa_ssid *prev, **nlist;
1947
1948 /*
1949 * Add to an existing priority list if one is available for the
1950 * configured priority level for this network.
1951 */
1952 for (prio = 0; prio < config->num_prio; prio++) {
1953 prev = config->pssid[prio];
1954 if (prev->priority == ssid->priority) {
1955 while (prev->pnext)
1956 prev = prev->pnext;
1957 prev->pnext = ssid;
1958 return 0;
1959 }
1960 }
1961
1962 /* First network for this priority - add a new priority list */
067ffa26
JM		 1963 nlist = os_realloc_array(config->pssid, config->num_prio + 1,
1964 sizeof(struct wpa_ssid *));
6fc6879b
JM		 1965 if (nlist == NULL)
1966 return -1;
1967
1968 for (prio = 0; prio < config->num_prio; prio++) {
2c60ca73
JM		 1969 if (nlist[prio]->priority < ssid->priority) {
1970 os_memmove(&nlist[prio + 1], &nlist[prio],
1971 (config->num_prio - prio) *
1972 sizeof(struct wpa_ssid *));
6fc6879b 1973 break;
2c60ca73 1974 }
6fc6879b
JM		 1975 }
1976
6fc6879b
JM		 1977 nlist[prio] = ssid;
1978 config->num_prio++;
1979 config->pssid = nlist;
1980
1981 return 0;
1982}
1983
1984
1985/**
1986 * wpa_config_update_prio_list - Update network priority list
1987 * @config: Configuration data from wpa_config_read()
1988 * Returns: 0 on success, -1 on failure
1989 *
1990 * This function is called to update the priority list of networks in the
1991 * configuration when a network is being added or removed. This is also called
1992 * if a priority for a network is changed.
1993 */
aa53509f 1994int wpa_config_update_prio_list(struct wpa_config *config)
6fc6879b
JM		 1995{
1996 struct wpa_ssid *ssid;
1997 int ret = 0;
1998
1999 os_free(config->pssid);
2000 config->pssid = NULL;
2001 config->num_prio = 0;
2002
2003 ssid = config->ssid;
2004 while (ssid) {
2005 ssid->pnext = NULL;
2006 if (wpa_config_add_prio_network(config, ssid) < 0)
2007 ret = -1;
2008 ssid = ssid->next;
2009 }
2010
2011 return ret;
2012}
2013
2014
2015#ifdef IEEE8021X_EAPOL
2016static void eap_peer_config_free(struct eap_peer_config *eap)
2017{
2018 os_free(eap->eap_methods);
19c48da0 2019 bin_clear_free(eap->identity, eap->identity_len);
6fc6879b 2020 os_free(eap->anonymous_identity);
19c48da0 2021 bin_clear_free(eap->password, eap->password_len);
6fc6879b
JM		 2022 os_free(eap->ca_cert);
2023 os_free(eap->ca_path);
2024 os_free(eap->client_cert);
2025 os_free(eap->private_key);
19c48da0 2026 str_clear_free(eap->private_key_passwd);
6fc6879b
JM		 2027 os_free(eap->dh_file);
2028 os_free(eap->subject_match);
2029 os_free(eap->altsubject_match);
01f809c7 2030 os_free(eap->domain_suffix_match);
6fc6879b
JM		 2031 os_free(eap->ca_cert2);
2032 os_free(eap->ca_path2);
2033 os_free(eap->client_cert2);
2034 os_free(eap->private_key2);
19c48da0 2035 str_clear_free(eap->private_key2_passwd);
6fc6879b
JM		 2036 os_free(eap->dh_file2);
2037 os_free(eap->subject_match2);
2038 os_free(eap->altsubject_match2);
01f809c7 2039 os_free(eap->domain_suffix_match2);
6fc6879b
JM		 2040 os_free(eap->phase1);
2041 os_free(eap->phase2);
2042 os_free(eap->pcsc);
19c48da0 2043 str_clear_free(eap->pin);
6fc6879b
JM		 2044 os_free(eap->engine_id);
2045 os_free(eap->key_id);
61ee0f71
DS		 2046 os_free(eap->cert_id);
2047 os_free(eap->ca_cert_id);
2048 os_free(eap->key2_id);
2049 os_free(eap->cert2_id);
2050 os_free(eap->ca_cert2_id);
19c48da0 2051 str_clear_free(eap->pin2);
98842d51 2052 os_free(eap->engine2_id);
6fc6879b
JM		 2053 os_free(eap->otp);
2054 os_free(eap->pending_req_otp);
2055 os_free(eap->pac_file);
19c48da0
JM		 2056 bin_clear_free(eap->new_password, eap->new_password_len);
2057 str_clear_free(eap->external_sim_resp);
07e2de31 2058 os_free(eap->openssl_ciphers);
6fc6879b
JM		 2059}
2060#endif /* IEEE8021X_EAPOL */
2061
2062
2063/**
2064 * wpa_config_free_ssid - Free network/ssid configuration data
2065 * @ssid: Configuration data for the network
2066 *
2067 * This function frees all resources allocated for the network configuration
2068 * data.
2069 */
2070void wpa_config_free_ssid(struct wpa_ssid *ssid)
2071{
01a57fe4
JM		 2072 struct psk_list_entry *psk;
2073
6fc6879b 2074 os_free(ssid->ssid);
19c48da0
JM		 2075 os_memset(ssid->psk, 0, sizeof(ssid->psk));
2076 str_clear_free(ssid->passphrase);
9173b16f 2077 os_free(ssid->ext_psk);
6fc6879b
JM		 2078#ifdef IEEE8021X_EAPOL
2079 eap_peer_config_free(&ssid->eap);
2080#endif /* IEEE8021X_EAPOL */
2081 os_free(ssid->id_str);
d3a98225 2082 os_free(ssid->scan_freq);
b766a9a2 2083 os_free(ssid->freq_list);
60b94c98 2084 os_free(ssid->bgscan);
fbdcfd57 2085 os_free(ssid->p2p_client_list);
80e8a5ee
BG		 2086#ifdef CONFIG_HT_OVERRIDES
2087 os_free(ssid->ht_mcs);
2088#endif /* CONFIG_HT_OVERRIDES */
2b2bb5a8
MH		 2089#ifdef CONFIG_MESH
2090 os_free(ssid->mesh_basic_rates);
2091#endif /* CONFIG_MESH */
01a57fe4
JM		 2092 while ((psk = dl_list_first(&ssid->psk_list, struct psk_list_entry,
2093 list))) {
2094 dl_list_del(&psk->list);
2095 os_free(psk);
2096 }
6fc6879b
JM		 2097 os_free(ssid);
2098}
2099
2100
1bb7b8e8
JM		 2101void wpa_config_free_cred(struct wpa_cred *cred)
2102{
463c8ffb
JM		 2103 size_t i;
2104
1bb7b8e8 2105 os_free(cred->realm);
19c48da0
JM		 2106 str_clear_free(cred->username);
2107 str_clear_free(cred->password);
1bb7b8e8 2108 os_free(cred->ca_cert);
11e4f46a
JM		 2109 os_free(cred->client_cert);
2110 os_free(cred->private_key);
19c48da0 2111 str_clear_free(cred->private_key_passwd);
1bb7b8e8 2112 os_free(cred->imsi);
19c48da0 2113 str_clear_free(cred->milenage);
463c8ffb
JM		 2114 for (i = 0; i < cred->num_domain; i++)
2115 os_free(cred->domain[i]);
1bb7b8e8 2116 os_free(cred->domain);
ac1bc549 2117 os_free(cred->domain_suffix_match);
8ca93c59
JM		 2118 os_free(cred->eap_method);
2119 os_free(cred->phase1);
2120 os_free(cred->phase2);
dbea8ac7 2121 os_free(cred->excluded_ssid);
bc00053c 2122 os_free(cred->roaming_partner);
aa26ba68 2123 os_free(cred->provisioning_sp);
33fb8c52
JM		 2124 for (i = 0; i < cred->num_req_conn_capab; i++)
2125 os_free(cred->req_conn_capab_port[i]);
2126 os_free(cred->req_conn_capab_port);
2127 os_free(cred->req_conn_capab_proto);
1bb7b8e8
JM		 2128 os_free(cred);
2129}
2130
2131
d9bb2821
JM		 2132void wpa_config_flush_blobs(struct wpa_config *config)
2133{
2134#ifndef CONFIG_NO_CONFIG_BLOBS
2135 struct wpa_config_blob *blob, *prev;
2136
2137 blob = config->blobs;
2138 config->blobs = NULL;
2139 while (blob) {
2140 prev = blob;
2141 blob = blob->next;
2142 wpa_config_free_blob(prev);
2143 }
2144#endif /* CONFIG_NO_CONFIG_BLOBS */
2145}
2146
2147
6fc6879b
JM		 2148/**
2149 * wpa_config_free - Free configuration data
2150 * @config: Configuration data from wpa_config_read()
2151 *
2152 * This function frees all resources allocated for the configuration data by
2153 * wpa_config_read().
2154 */
2155void wpa_config_free(struct wpa_config *config)
2156{
6fc6879b 2157 struct wpa_ssid *ssid, *prev = NULL;
1bb7b8e8 2158 struct wpa_cred *cred, *cprev;
e3768e7c 2159
6fc6879b
JM		 2160 ssid = config->ssid;
2161 while (ssid) {
2162 prev = ssid;
2163 ssid = ssid->next;
2164 wpa_config_free_ssid(prev);
2165 }
2166
1bb7b8e8
JM		 2167 cred = config->cred;
2168 while (cred) {
2169 cprev = cred;
2170 cred = cred->next;
2171 wpa_config_free_cred(cprev);
2172 }
2173
d9bb2821 2174 wpa_config_flush_blobs(config);
6fc6879b 2175
71dd3b78 2176 wpabuf_free(config->wps_vendor_ext_m1);
6fc6879b
JM		 2177 os_free(config->ctrl_interface);
2178 os_free(config->ctrl_interface_group);
6fc6879b
JM		 2179 os_free(config->opensc_engine_path);
2180 os_free(config->pkcs11_engine_path);
2181 os_free(config->pkcs11_module_path);
07e2de31 2182 os_free(config->openssl_ciphers);
f64adcd7 2183 os_free(config->pcsc_reader);
19c48da0 2184 str_clear_free(config->pcsc_pin);
6fc6879b 2185 os_free(config->driver_param);
3c0b7aa4
JM		 2186 os_free(config->device_name);
2187 os_free(config->manufacturer);
2188 os_free(config->model_name);
2189 os_free(config->model_number);
2190 os_free(config->serial_number);
c0e4dd9e 2191 os_free(config->config_methods);
e3768e7c 2192 os_free(config->p2p_ssid_postfix);
6fc6879b 2193 os_free(config->pssid);
21d996f7 2194 os_free(config->p2p_pref_chan);
556b30da 2195 os_free(config->p2p_no_go_freq.range);
b0786fba 2196 os_free(config->autoscan);
f5ffc348 2197 os_free(config->freq_list);
3f2c8ba6
JM		 2198 wpabuf_free(config->wps_nfc_dh_pubkey);
2199 wpabuf_free(config->wps_nfc_dh_privkey);
2200 wpabuf_free(config->wps_nfc_dev_pw);
306ae225 2201 os_free(config->ext_password_backend);
625f202a 2202 os_free(config->sae_groups);
18a2eaab 2203 wpabuf_free(config->ap_vendor_elements);
b572df86 2204 os_free(config->osu_dir);
e4fa8b12 2205 os_free(config->wowlan_triggers);
6fc6879b
JM		 2206 os_free(config);
2207}
2208
2209
7c49fdd0
SL		 2210/**
2211 * wpa_config_foreach_network - Iterate over each configured network
2212 * @config: Configuration data from wpa_config_read()
2213 * @func: Callback function to process each network
2214 * @arg: Opaque argument to pass to callback function
2215 *
2216 * Iterate over the set of configured networks calling the specified
2217 * function for each item. We guard against callbacks removing the
2218 * supplied network.
2219 */
2220void wpa_config_foreach_network(struct wpa_config *config,
2221 void (*func)(void *, struct wpa_ssid *),
2222 void *arg)
2223{
2224 struct wpa_ssid *ssid, *next;
2225
2226 ssid = config->ssid;
2227 while (ssid) {
2228 next = ssid->next;
2229 func(arg, ssid);
2230 ssid = next;
2231 }
2232}
2233
2234
6fc6879b
JM		 2235/**
2236 * wpa_config_get_network - Get configured network based on id
2237 * @config: Configuration data from wpa_config_read()
2238 * @id: Unique network id to search for
2239 * Returns: Network configuration or %NULL if not found
2240 */
2241struct wpa_ssid * wpa_config_get_network(struct wpa_config *config, int id)
2242{
2243 struct wpa_ssid *ssid;
2244
2245 ssid = config->ssid;
2246 while (ssid) {
2247 if (id == ssid->id)
2248 break;
2249 ssid = ssid->next;
2250 }
2251
2252 return ssid;
2253}
2254
2255
2256/**
2257 * wpa_config_add_network - Add a new network with empty configuration
2258 * @config: Configuration data from wpa_config_read()
2259 * Returns: The new network configuration or %NULL if operation failed
2260 */
2261struct wpa_ssid * wpa_config_add_network(struct wpa_config *config)
2262{
2263 int id;
2264 struct wpa_ssid *ssid, *last = NULL;
2265
2266 id = -1;
2267 ssid = config->ssid;
2268 while (ssid) {
2269 if (ssid->id > id)
2270 id = ssid->id;
2271 last = ssid;
2272 ssid = ssid->next;
2273 }
2274 id++;
2275
2276 ssid = os_zalloc(sizeof(*ssid));
2277 if (ssid == NULL)
2278 return NULL;
2279 ssid->id = id;
01a57fe4 2280 dl_list_init(&ssid->psk_list);
6fc6879b
JM		 2281 if (last)
2282 last->next = ssid;
2283 else
2284 config->ssid = ssid;
2285
2286 wpa_config_update_prio_list(config);
2287
2288 return ssid;
2289}
2290
2291
2292/**
2293 * wpa_config_remove_network - Remove a configured network based on id
2294 * @config: Configuration data from wpa_config_read()
2295 * @id: Unique network id to search for
2296 * Returns: 0 on success, or -1 if the network was not found
2297 */
2298int wpa_config_remove_network(struct wpa_config *config, int id)
2299{
2300 struct wpa_ssid *ssid, *prev = NULL;
2301
2302 ssid = config->ssid;
2303 while (ssid) {
2304 if (id == ssid->id)
2305 break;
2306 prev = ssid;
2307 ssid = ssid->next;
2308 }
2309
2310 if (ssid == NULL)
2311 return -1;
2312
2313 if (prev)
2314 prev->next = ssid->next;
2315 else
2316 config->ssid = ssid->next;
2317
2318 wpa_config_update_prio_list(config);
2319 wpa_config_free_ssid(ssid);
2320 return 0;
2321}
2322
2323
2324/**
2325 * wpa_config_set_network_defaults - Set network default values
2326 * @ssid: Pointer to network configuration data
2327 */
2328void wpa_config_set_network_defaults(struct wpa_ssid *ssid)
2329{
2330 ssid->proto = DEFAULT_PROTO;
2331 ssid->pairwise_cipher = DEFAULT_PAIRWISE;
2332 ssid->group_cipher = DEFAULT_GROUP;
2333 ssid->key_mgmt = DEFAULT_KEY_MGMT;
1f6c0ab8 2334 ssid->bg_scan_period = DEFAULT_BG_SCAN_PERIOD;
6fc6879b
JM		 2335#ifdef IEEE8021X_EAPOL
2336 ssid->eapol_flags = DEFAULT_EAPOL_FLAGS;
2337 ssid->eap_workaround = DEFAULT_EAP_WORKAROUND;
2338 ssid->eap.fragment_size = DEFAULT_FRAGMENT_SIZE;
13f6a07e 2339 ssid->eap.sim_num = DEFAULT_USER_SELECTED_SIM;
6fc6879b 2340#endif /* IEEE8021X_EAPOL */
5cfb672d
JM		 2341#ifdef CONFIG_MESH
2342 ssid->mesh_ht_mode = DEFAULT_MESH_HT_MODE;
e6096799
MH		 2343 ssid->dot11MeshMaxRetries = DEFAULT_MESH_MAX_RETRIES;
2344 ssid->dot11MeshRetryTimeout = DEFAULT_MESH_RETRY_TIMEOUT;
2345 ssid->dot11MeshConfirmTimeout = DEFAULT_MESH_CONFIRM_TIMEOUT;
2346 ssid->dot11MeshHoldingTimeout = DEFAULT_MESH_HOLDING_TIMEOUT;
5cfb672d 2347#endif /* CONFIG_MESH */
80e8a5ee
BG		 2348#ifdef CONFIG_HT_OVERRIDES
2349 ssid->disable_ht = DEFAULT_DISABLE_HT;
2350 ssid->disable_ht40 = DEFAULT_DISABLE_HT40;
a90497f8 2351 ssid->disable_sgi = DEFAULT_DISABLE_SGI;
39a5800f 2352 ssid->disable_ldpc = DEFAULT_DISABLE_LDPC;
80e8a5ee
BG		 2353 ssid->disable_max_amsdu = DEFAULT_DISABLE_MAX_AMSDU;
2354 ssid->ampdu_factor = DEFAULT_AMPDU_FACTOR;
2355 ssid->ampdu_density = DEFAULT_AMPDU_DENSITY;
2356#endif /* CONFIG_HT_OVERRIDES */
e9ee8dc3
JB		 2357#ifdef CONFIG_VHT_OVERRIDES
2358 ssid->vht_rx_mcs_nss_1 = -1;
2359 ssid->vht_rx_mcs_nss_2 = -1;
2360 ssid->vht_rx_mcs_nss_3 = -1;
2361 ssid->vht_rx_mcs_nss_4 = -1;
2362 ssid->vht_rx_mcs_nss_5 = -1;
2363 ssid->vht_rx_mcs_nss_6 = -1;
2364 ssid->vht_rx_mcs_nss_7 = -1;
2365 ssid->vht_rx_mcs_nss_8 = -1;
2366 ssid->vht_tx_mcs_nss_1 = -1;
2367 ssid->vht_tx_mcs_nss_2 = -1;
2368 ssid->vht_tx_mcs_nss_3 = -1;
2369 ssid->vht_tx_mcs_nss_4 = -1;
2370 ssid->vht_tx_mcs_nss_5 = -1;
2371 ssid->vht_tx_mcs_nss_6 = -1;
2372 ssid->vht_tx_mcs_nss_7 = -1;
2373 ssid->vht_tx_mcs_nss_8 = -1;
2374#endif /* CONFIG_VHT_OVERRIDES */
6e202021 2375 ssid->proactive_key_caching = -1;
62d49803
JM		 2376#ifdef CONFIG_IEEE80211W
2377 ssid->ieee80211w = MGMT_FRAME_PROTECTION_DEFAULT;
2378#endif /* CONFIG_IEEE80211W */
c267753b 2379 ssid->mac_addr = -1;
6fc6879b
JM		 2380}
2381
2382
2383/**
2384 * wpa_config_set - Set a variable in network configuration
2385 * @ssid: Pointer to network configuration data
2386 * @var: Variable name, e.g., "ssid"
2387 * @value: Variable value
2388 * @line: Line number in configuration file or 0 if not used
2389 * Returns: 0 on success, -1 on failure
2390 *
2391 * This function can be used to set network configuration variables based on
2392 * both the configuration file and management interface input. The value
2393 * parameter must be in the same format as the text-based configuration file is
2394 * using. For example, strings are using double quotation marks.
2395 */
2396int wpa_config_set(struct wpa_ssid *ssid, const char *var, const char *value,
2397 int line)
2398{
2399 size_t i;
2400 int ret = 0;
2401
2402 if (ssid == NULL || var == NULL || value == NULL)
2403 return -1;
2404
2405 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2406 const struct parse_data *field = &ssid_fields[i];
2407 if (os_strcmp(var, field->name) != 0)
2408 continue;
2409
2410 if (field->parser(field, ssid, line, value)) {
2411 if (line) {
2412 wpa_printf(MSG_ERROR, "Line %d: failed to "
2413 "parse %s '%s'.", line, var, value);
2414 }
2415 ret = -1;
2416 }
2417 break;
2418 }
2419 if (i == NUM_SSID_FIELDS) {
2420 if (line) {
2421 wpa_printf(MSG_ERROR, "Line %d: unknown network field "
2422 "'%s'.", line, var);
2423 }
2424 ret = -1;
2425 }
2426
2427 return ret;
2428}
2429
2430
67e1b984
JM		 2431int wpa_config_set_quoted(struct wpa_ssid *ssid, const char *var,
2432 const char *value)
2433{
2434 size_t len;
2435 char *buf;
2436 int ret;
2437
2438 len = os_strlen(value);
2439 buf = os_malloc(len + 3);
2440 if (buf == NULL)
2441 return -1;
2442 buf[0] = '"';
2443 os_memcpy(buf + 1, value, len);
2444 buf[len + 1] = '"';
2445 buf[len + 2] = '\0';
2446 ret = wpa_config_set(ssid, var, buf, 0);
2447 os_free(buf);
2448 return ret;
2449}
2450
2451
3d3d3056
WS		 2452/**
2453 * wpa_config_get_all - Get all options from network configuration
2454 * @ssid: Pointer to network configuration data
2455 * @get_keys: Determines if keys/passwords will be included in returned list
d1c8ac88 2456 * (if they may be exported)
3d3d3056
WS		 2457 * Returns: %NULL terminated list of all set keys and their values in the form
2458 * of [key1, val1, key2, val2, ... , NULL]
2459 *
2460 * This function can be used to get list of all configured network properties.
2461 * The caller is responsible for freeing the returned list and all its
2462 * elements.
2463 */
2464char ** wpa_config_get_all(struct wpa_ssid *ssid, int get_keys)
2465{
2466 const struct parse_data *field;
2467 char *key, *value;
2468 size_t i;
2469 char **props;
2470 int fields_num;
2471
d1c8ac88
JB		 2472 get_keys = get_keys && ssid->export_keys;
2473
f9884c09 2474 props = os_calloc(2 * NUM_SSID_FIELDS + 1, sizeof(char *));
3d3d3056
WS		 2475 if (!props)
2476 return NULL;
2477
2478 fields_num = 0;
2479 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2480 field = &ssid_fields[i];
2481 if (field->key_data && !get_keys)
2482 continue;
2483 value = field->writer(field, ssid);
04746865 2484 if (value == NULL)
3d3d3056 2485 continue;
04746865
JM		 2486 if (os_strlen(value) == 0) {
2487 os_free(value);
2488 continue;
2489 }
3d3d3056
WS		 2490
2491 key = os_strdup(field->name);
04746865
JM		 2492 if (key == NULL) {
2493 os_free(value);
3d3d3056 2494 goto err;
04746865 2495 }
3d3d3056
WS		 2496
2497 props[fields_num * 2] = key;
2498 props[fields_num * 2 + 1] = value;
2499
2500 fields_num++;
2501 }
2502
2503 return props;
2504
2505err:
2506 value = *props;
2507 while (value)
2508 os_free(value++);
2509 os_free(props);
2510 return NULL;
2511}
2512
2513
6fc6879b
JM		 2514#ifndef NO_CONFIG_WRITE
2515/**
2516 * wpa_config_get - Get a variable in network configuration
2517 * @ssid: Pointer to network configuration data
2518 * @var: Variable name, e.g., "ssid"
2519 * Returns: Value of the variable or %NULL on failure
2520 *
2521 * This function can be used to get network configuration variables. The
2522 * returned value is a copy of the configuration variable in text format, i.e,.
2523 * the same format that the text-based configuration file and wpa_config_set()
2524 * are using for the value. The caller is responsible for freeing the returned
2525 * value.
2526 */
2527char * wpa_config_get(struct wpa_ssid *ssid, const char *var)
2528{
2529 size_t i;
2530
2531 if (ssid == NULL || var == NULL)
2532 return NULL;
2533
2534 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2535 const struct parse_data *field = &ssid_fields[i];
2536 if (os_strcmp(var, field->name) == 0)
2537 return field->writer(field, ssid);
2538 }
2539
2540 return NULL;
2541}
2542
2543
2544/**
2545 * wpa_config_get_no_key - Get a variable in network configuration (no keys)
2546 * @ssid: Pointer to network configuration data
2547 * @var: Variable name, e.g., "ssid"
2548 * Returns: Value of the variable or %NULL on failure
2549 *
2550 * This function can be used to get network configuration variable like
2551 * wpa_config_get(). The only difference is that this functions does not expose
2552 * key/password material from the configuration. In case a key/password field
2553 * is requested, the returned value is an empty string or %NULL if the variable
2554 * is not set or "*" if the variable is set (regardless of its value). The
2555 * returned value is a copy of the configuration variable in text format, i.e,.
2556 * the same format that the text-based configuration file and wpa_config_set()
2557 * are using for the value. The caller is responsible for freeing the returned
2558 * value.
2559 */
2560char * wpa_config_get_no_key(struct wpa_ssid *ssid, const char *var)
2561{
2562 size_t i;
2563
2564 if (ssid == NULL || var == NULL)
2565 return NULL;
2566
2567 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2568 const struct parse_data *field = &ssid_fields[i];
2569 if (os_strcmp(var, field->name) == 0) {
2570 char *res = field->writer(field, ssid);
2571 if (field->key_data) {
2572 if (res && res[0]) {
2573 wpa_printf(MSG_DEBUG, "Do not allow "
2574 "key_data field to be "
2575 "exposed");
19c48da0 2576 str_clear_free(res);
6fc6879b
JM		 2577 return os_strdup("*");
2578 }
2579
2580 os_free(res);
2581 return NULL;
2582 }
2583 return res;
2584 }
2585 }
2586
2587 return NULL;
2588}
2589#endif /* NO_CONFIG_WRITE */
2590
2591
2592/**
2593 * wpa_config_update_psk - Update WPA PSK based on passphrase and SSID
2594 * @ssid: Pointer to network configuration data
2595 *
2596 * This function must be called to update WPA PSK when either SSID or the
2597 * passphrase has changed for the network configuration.
2598 */
2599void wpa_config_update_psk(struct wpa_ssid *ssid)
2600{
2601#ifndef CONFIG_NO_PBKDF2
986de33d 2602 pbkdf2_sha1(ssid->passphrase, ssid->ssid, ssid->ssid_len, 4096,
6fc6879b
JM		 2603 ssid->psk, PMK_LEN);
2604 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
2605 ssid->psk, PMK_LEN);
2606 ssid->psk_set = 1;
2607#endif /* CONFIG_NO_PBKDF2 */
2608}
2609
2610
33fb8c52
JM		 2611static int wpa_config_set_cred_req_conn_capab(struct wpa_cred *cred,
2612 const char *value)
2613{
2614 u8 *proto;
2615 int **port;
2616 int *ports, *nports;
2617 const char *pos;
2618 unsigned int num_ports;
2619
2620 proto = os_realloc_array(cred->req_conn_capab_proto,
2621 cred->num_req_conn_capab + 1, sizeof(u8));
2622 if (proto == NULL)
2623 return -1;
2624 cred->req_conn_capab_proto = proto;
2625
2626 port = os_realloc_array(cred->req_conn_capab_port,
2627 cred->num_req_conn_capab + 1, sizeof(int *));
2628 if (port == NULL)
2629 return -1;
2630 cred->req_conn_capab_port = port;
2631
2632 proto[cred->num_req_conn_capab] = atoi(value);
2633
2634 pos = os_strchr(value, ':');
2635 if (pos == NULL) {
2636 port[cred->num_req_conn_capab] = NULL;
2637 cred->num_req_conn_capab++;
2638 return 0;
2639 }
2640 pos++;
2641
2642 ports = NULL;
2643 num_ports = 0;
2644
2645 while (*pos) {
2646 nports = os_realloc_array(ports, num_ports + 1, sizeof(int));
2647 if (nports == NULL) {
2648 os_free(ports);
2649 return -1;
2650 }
2651 ports = nports;
2652 ports[num_ports++] = atoi(pos);
2653
2654 pos = os_strchr(pos, ',');
2655 if (pos == NULL)
2656 break;
2657 pos++;
2658 }
2659
2660 nports = os_realloc_array(ports, num_ports + 1, sizeof(int));
2661 if (nports == NULL) {
2662 os_free(ports);
2663 return -1;
2664 }
2665 ports = nports;
2666 ports[num_ports] = -1;
2667
2668 port[cred->num_req_conn_capab] = ports;
2669 cred->num_req_conn_capab++;
2670 return 0;
2671}
2672
2673
1bb7b8e8
JM		 2674int wpa_config_set_cred(struct wpa_cred *cred, const char *var,
2675 const char *value, int line)
2676{
2677 char *val;
2678 size_t len;
2679
03ed3324
JM		 2680 if (os_strcmp(var, "temporary") == 0) {
2681 cred->temporary = atoi(value);
2682 return 0;
2683 }
2684
1a712d2f
JM		 2685 if (os_strcmp(var, "priority") == 0) {
2686 cred->priority = atoi(value);
2687 return 0;
2688 }
2689
74794891
JM		 2690 if (os_strcmp(var, "sp_priority") == 0) {
2691 int prio = atoi(value);
2692 if (prio < 0 || prio > 255)
2693 return -1;
2694 cred->sp_priority = prio;
2695 return 0;
2696 }
2697
d7b01abd
JM		 2698 if (os_strcmp(var, "pcsc") == 0) {
2699 cred->pcsc = atoi(value);
2700 return 0;
2701 }
2702
8ca93c59
JM		 2703 if (os_strcmp(var, "eap") == 0) {
2704 struct eap_method_type method;
2705 method.method = eap_peer_get_type(value, &method.vendor);
2706 if (method.vendor == EAP_VENDOR_IETF &&
2707 method.method == EAP_TYPE_NONE) {
2708 wpa_printf(MSG_ERROR, "Line %d: unknown EAP type '%s' "
2709 "for a credential", line, value);
2710 return -1;
2711 }
2712 os_free(cred->eap_method);
2713 cred->eap_method = os_malloc(sizeof(*cred->eap_method));
2714 if (cred->eap_method == NULL)
2715 return -1;
2716 os_memcpy(cred->eap_method, &method, sizeof(method));
2717 return 0;
2718 }
2719
02af9c90
JM		 2720 if (os_strcmp(var, "password") == 0 &&
2721 os_strncmp(value, "ext:", 4) == 0) {
19c48da0 2722 str_clear_free(cred->password);
02af9c90
JM		 2723 cred->password = os_strdup(value);
2724 cred->ext_password = 1;
2725 return 0;
2726 }
2727
f9cd147d
JM		 2728 if (os_strcmp(var, "update_identifier") == 0) {
2729 cred->update_identifier = atoi(value);
2730 return 0;
2731 }
2732
4cad9df1
JM		 2733 if (os_strcmp(var, "min_dl_bandwidth_home") == 0) {
2734 cred->min_dl_bandwidth_home = atoi(value);
2735 return 0;
2736 }
2737
2738 if (os_strcmp(var, "min_ul_bandwidth_home") == 0) {
2739 cred->min_ul_bandwidth_home = atoi(value);
2740 return 0;
2741 }
2742
2743 if (os_strcmp(var, "min_dl_bandwidth_roaming") == 0) {
2744 cred->min_dl_bandwidth_roaming = atoi(value);
2745 return 0;
2746 }
2747
2748 if (os_strcmp(var, "min_ul_bandwidth_roaming") == 0) {
2749 cred->min_ul_bandwidth_roaming = atoi(value);
2750 return 0;
2751 }
2752
a45b2dc5
JM		 2753 if (os_strcmp(var, "max_bss_load") == 0) {
2754 cred->max_bss_load = atoi(value);
2755 return 0;
2756 }
2757
33fb8c52
JM		 2758 if (os_strcmp(var, "req_conn_capab") == 0)
2759 return wpa_config_set_cred_req_conn_capab(cred, value);
2760
cf6d08a6
JM		 2761 if (os_strcmp(var, "ocsp") == 0) {
2762 cred->ocsp = atoi(value);
2763 return 0;
2764 }
2765
13f6a07e
NJ		 2766 if (os_strcmp(var, "sim_num") == 0) {
2767 cred->sim_num = atoi(value);
2768 return 0;
2769 }
2770
1bb7b8e8 2771 val = wpa_config_parse_string(value, &len);
7d86e537
JM		 2772 if (val == NULL) {
2773 wpa_printf(MSG_ERROR, "Line %d: invalid field '%s' string "
2774 "value '%s'.", line, var, value);
1bb7b8e8 2775 return -1;
7d86e537 2776 }
1bb7b8e8
JM		 2777
2778 if (os_strcmp(var, "realm") == 0) {
2779 os_free(cred->realm);
2780 cred->realm = val;
2781 return 0;
2782 }
2783
2784 if (os_strcmp(var, "username") == 0) {
19c48da0 2785 str_clear_free(cred->username);
1bb7b8e8
JM		 2786 cred->username = val;
2787 return 0;
2788 }
2789
2790 if (os_strcmp(var, "password") == 0) {
19c48da0 2791 str_clear_free(cred->password);
1bb7b8e8 2792 cred->password = val;
02af9c90 2793 cred->ext_password = 0;
1bb7b8e8
JM		 2794 return 0;
2795 }
2796
2797 if (os_strcmp(var, "ca_cert") == 0) {
2798 os_free(cred->ca_cert);
2799 cred->ca_cert = val;
2800 return 0;
2801 }
2802
11e4f46a
JM		 2803 if (os_strcmp(var, "client_cert") == 0) {
2804 os_free(cred->client_cert);
2805 cred->client_cert = val;
2806 return 0;
2807 }
2808
2809 if (os_strcmp(var, "private_key") == 0) {
2810 os_free(cred->private_key);
2811 cred->private_key = val;
2812 return 0;
2813 }
2814
2815 if (os_strcmp(var, "private_key_passwd") == 0) {
19c48da0 2816 str_clear_free(cred->private_key_passwd);
11e4f46a
JM		 2817 cred->private_key_passwd = val;
2818 return 0;
2819 }
2820
1bb7b8e8
JM		 2821 if (os_strcmp(var, "imsi") == 0) {
2822 os_free(cred->imsi);
2823 cred->imsi = val;
2824 return 0;
2825 }
2826
2827 if (os_strcmp(var, "milenage") == 0) {
19c48da0 2828 str_clear_free(cred->milenage);
1bb7b8e8
JM		 2829 cred->milenage = val;
2830 return 0;
2831 }
2832
ac1bc549
JM		 2833 if (os_strcmp(var, "domain_suffix_match") == 0) {
2834 os_free(cred->domain_suffix_match);
2835 cred->domain_suffix_match = val;
2836 return 0;
2837 }
2838
1bb7b8e8 2839 if (os_strcmp(var, "domain") == 0) {
463c8ffb
JM		 2840 char **new_domain;
2841 new_domain = os_realloc_array(cred->domain,
2842 cred->num_domain + 1,
2843 sizeof(char *));
2844 if (new_domain == NULL) {
2845 os_free(val);
2846 return -1;
2847 }
2848 new_domain[cred->num_domain++] = val;
2849 cred->domain = new_domain;
1bb7b8e8
JM		 2850 return 0;
2851 }
2852
8ca93c59
JM		 2853 if (os_strcmp(var, "phase1") == 0) {
2854 os_free(cred->phase1);
2855 cred->phase1 = val;
2856 return 0;
2857 }
2858
2859 if (os_strcmp(var, "phase2") == 0) {
2860 os_free(cred->phase2);
2861 cred->phase2 = val;
2862 return 0;
2863 }
2864
955567bc
JM		 2865 if (os_strcmp(var, "roaming_consortium") == 0) {
2866 if (len < 3 || len > sizeof(cred->roaming_consortium)) {
2867 wpa_printf(MSG_ERROR, "Line %d: invalid "
2868 "roaming_consortium length %d (3..15 "
2869 "expected)", line, (int) len);
2870 os_free(val);
2871 return -1;
2872 }
2873 os_memcpy(cred->roaming_consortium, val, len);
2874 cred->roaming_consortium_len = len;
2875 os_free(val);
2876 return 0;
2877 }
2878
f47c1452
JM		 2879 if (os_strcmp(var, "required_roaming_consortium") == 0) {
2880 if (len < 3 || len > sizeof(cred->required_roaming_consortium))
2881 {
2882 wpa_printf(MSG_ERROR, "Line %d: invalid "
2883 "required_roaming_consortium length %d "
2884 "(3..15 expected)", line, (int) len);
2885 os_free(val);
2886 return -1;
2887 }
2888 os_memcpy(cred->required_roaming_consortium, val, len);
2889 cred->required_roaming_consortium_len = len;
2890 os_free(val);
2891 return 0;
2892 }
2893
dbea8ac7
JM		 2894 if (os_strcmp(var, "excluded_ssid") == 0) {
2895 struct excluded_ssid *e;
2896
2897 if (len > MAX_SSID_LEN) {
2898 wpa_printf(MSG_ERROR, "Line %d: invalid "
2899 "excluded_ssid length %d", line, (int) len);
2900 os_free(val);
2901 return -1;
2902 }
2903
2904 e = os_realloc_array(cred->excluded_ssid,
2905 cred->num_excluded_ssid + 1,
2906 sizeof(struct excluded_ssid));
2907 if (e == NULL) {
2908 os_free(val);
2909 return -1;
2910 }
2911 cred->excluded_ssid = e;
2912
2913 e = &cred->excluded_ssid[cred->num_excluded_ssid++];
2914 os_memcpy(e->ssid, val, len);
2915 e->ssid_len = len;
2916
2917 os_free(val);
2918
2919 return 0;
2920 }
2921
bc00053c
JM		 2922 if (os_strcmp(var, "roaming_partner") == 0) {
2923 struct roaming_partner *p;
2924 char *pos;
2925
2926 p = os_realloc_array(cred->roaming_partner,
2927 cred->num_roaming_partner + 1,
2928 sizeof(struct roaming_partner));
2929 if (p == NULL) {
2930 os_free(val);
2931 return -1;
2932 }
2933 cred->roaming_partner = p;
2934
2935 p = &cred->roaming_partner[cred->num_roaming_partner];
2936
2937 pos = os_strchr(val, ',');
2938 if (pos == NULL) {
2939 os_free(val);
2940 return -1;
2941 }
2942 *pos++ = '\0';
2943 if (pos - val - 1 >= (int) sizeof(p->fqdn)) {
2944 os_free(val);
2945 return -1;
2946 }
2947 os_memcpy(p->fqdn, val, pos - val);
2948
2949 p->exact_match = atoi(pos);
2950
2951 pos = os_strchr(pos, ',');
2952 if (pos == NULL) {
2953 os_free(val);
2954 return -1;
2955 }
2956 *pos++ = '\0';
2957
2958 p->priority = atoi(pos);
2959
2960 pos = os_strchr(pos, ',');
2961 if (pos == NULL) {
2962 os_free(val);
2963 return -1;
2964 }
2965 *pos++ = '\0';
2966
2967 if (os_strlen(pos) >= sizeof(p->country)) {
2968 os_free(val);
2969 return -1;
2970 }
2971 os_memcpy(p->country, pos, os_strlen(pos) + 1);
2972
2973 cred->num_roaming_partner++;
2974 os_free(val);
2975
2976 return 0;
2977 }
2978
aa26ba68
JM		 2979 if (os_strcmp(var, "provisioning_sp") == 0) {
2980 os_free(cred->provisioning_sp);
2981 cred->provisioning_sp = val;
2982 return 0;
2983 }
2984
1bb7b8e8
JM		 2985 if (line) {
2986 wpa_printf(MSG_ERROR, "Line %d: unknown cred field '%s'.",
2987 line, var);
2988 }
2989
f4b2d69b
JM		 2990 os_free(val);
2991
1bb7b8e8
JM		 2992 return -1;
2993}
2994
2995
8f03ac90 2996static char * alloc_int_str(int val)
c880ab87
JM		 2997{
2998 char *buf;
2999
3000 buf = os_malloc(20);
3001 if (buf == NULL)
3002 return NULL;
3003 os_snprintf(buf, 20, "%d", val);
3004 return buf;
3005}
3006
3007
8f03ac90 3008static char * alloc_strdup(const char *str)
c880ab87
JM		 3009{
3010 if (str == NULL)
3011 return NULL;
3012 return os_strdup(str);
3013}
3014
3015
3016char * wpa_config_get_cred_no_key(struct wpa_cred *cred, const char *var)
3017{
3018 if (os_strcmp(var, "temporary") == 0)
3019 return alloc_int_str(cred->temporary);
3020
3021 if (os_strcmp(var, "priority") == 0)
3022 return alloc_int_str(cred->priority);
3023
3024 if (os_strcmp(var, "sp_priority") == 0)
3025 return alloc_int_str(cred->sp_priority);
3026
3027 if (os_strcmp(var, "pcsc") == 0)
3028 return alloc_int_str(cred->pcsc);
3029
3030 if (os_strcmp(var, "eap") == 0) {
3031 if (!cred->eap_method)
3032 return NULL;
3033 return alloc_strdup(eap_get_name(cred->eap_method[0].vendor,
3034 cred->eap_method[0].method));
3035 }
3036
3037 if (os_strcmp(var, "update_identifier") == 0)
3038 return alloc_int_str(cred->update_identifier);
3039
3040 if (os_strcmp(var, "min_dl_bandwidth_home") == 0)
3041 return alloc_int_str(cred->min_dl_bandwidth_home);
3042
3043 if (os_strcmp(var, "min_ul_bandwidth_home") == 0)
3044 return alloc_int_str(cred->min_ul_bandwidth_home);
3045
3046 if (os_strcmp(var, "min_dl_bandwidth_roaming") == 0)
3047 return alloc_int_str(cred->min_dl_bandwidth_roaming);
3048
3049 if (os_strcmp(var, "min_ul_bandwidth_roaming") == 0)
3050 return alloc_int_str(cred->min_ul_bandwidth_roaming);
3051
3052 if (os_strcmp(var, "max_bss_load") == 0)
3053 return alloc_int_str(cred->max_bss_load);
3054
3055 if (os_strcmp(var, "req_conn_capab") == 0) {
3056 unsigned int i;
3057 char *buf, *end, *pos;
3058 int ret;
3059
3060 if (!cred->num_req_conn_capab)
3061 return NULL;
3062
3063 buf = os_malloc(4000);
3064 if (buf == NULL)
3065 return NULL;
3066 pos = buf;
3067 end = pos + 4000;
3068 for (i = 0; i < cred->num_req_conn_capab; i++) {
3069 int *ports;
3070
3071 ret = os_snprintf(pos, end - pos, "%s%u",
3072 i > 0 ? "\n" : "",
3073 cred->req_conn_capab_proto[i]);
3074 if (ret < 0 || ret >= end - pos)
3075 return buf;
3076 pos += ret;
3077
3078 ports = cred->req_conn_capab_port[i];
3079 if (ports) {
3080 int j;
3081 for (j = 0; ports[j] != -1; j++) {
3082 ret = os_snprintf(pos, end - pos,
3083 "%s%d",
3084 j > 0 ? "," : ":",
3085 ports[j]);
3086 if (ret < 0 || ret >= end - pos)
3087 return buf;
3088 pos += ret;
3089 }
3090 }
3091 }
3092
3093 return buf;
3094 }
3095
3096 if (os_strcmp(var, "ocsp") == 0)
3097 return alloc_int_str(cred->ocsp);
3098
3099 if (os_strcmp(var, "realm") == 0)
3100 return alloc_strdup(cred->realm);
3101
3102 if (os_strcmp(var, "username") == 0)
3103 return alloc_strdup(cred->username);
3104
3105 if (os_strcmp(var, "password") == 0) {
3106 if (!cred->password)
3107 return NULL;
3108 return alloc_strdup("*");
3109 }
3110
3111 if (os_strcmp(var, "ca_cert") == 0)
3112 return alloc_strdup(cred->ca_cert);
3113
3114 if (os_strcmp(var, "client_cert") == 0)
3115 return alloc_strdup(cred->client_cert);
3116
3117 if (os_strcmp(var, "private_key") == 0)
3118 return alloc_strdup(cred->private_key);
3119
3120 if (os_strcmp(var, "private_key_passwd") == 0) {
3121 if (!cred->private_key_passwd)
3122 return NULL;
3123 return alloc_strdup("*");
3124 }
3125
3126 if (os_strcmp(var, "imsi") == 0)
3127 return alloc_strdup(cred->imsi);
3128
3129 if (os_strcmp(var, "milenage") == 0) {
3130 if (!(cred->milenage))
3131 return NULL;
3132 return alloc_strdup("*");
3133 }
3134
3135 if (os_strcmp(var, "domain_suffix_match") == 0)
3136 return alloc_strdup(cred->domain_suffix_match);
3137
3138 if (os_strcmp(var, "domain") == 0) {
3139 unsigned int i;
3140 char *buf, *end, *pos;
3141 int ret;
3142
3143 if (!cred->num_domain)
3144 return NULL;
3145
3146 buf = os_malloc(4000);
3147 if (buf == NULL)
3148 return NULL;
3149 pos = buf;
3150 end = pos + 4000;
3151
3152 for (i = 0; i < cred->num_domain; i++) {
3153 ret = os_snprintf(pos, end - pos, "%s%s",
3154 i > 0 ? "\n" : "", cred->domain[i]);
3155 if (ret < 0 || ret >= end - pos)
3156 return buf;
3157 pos += ret;
3158 }
3159
3160 return buf;
3161 }
3162
3163 if (os_strcmp(var, "phase1") == 0)
3164 return alloc_strdup(cred->phase1);
3165
3166 if (os_strcmp(var, "phase2") == 0)
3167 return alloc_strdup(cred->phase2);
3168
3169 if (os_strcmp(var, "roaming_consortium") == 0) {
3170 size_t buflen;
3171 char *buf;
3172
3173 if (!cred->roaming_consortium_len)
3174 return NULL;
3175 buflen = cred->roaming_consortium_len * 2 + 1;
3176 buf = os_malloc(buflen);
3177 if (buf == NULL)
3178 return NULL;
3179 wpa_snprintf_hex(buf, buflen, cred->roaming_consortium,
3180 cred->roaming_consortium_len);
3181 return buf;
3182 }
3183
3184 if (os_strcmp(var, "required_roaming_consortium") == 0) {
3185 size_t buflen;
3186 char *buf;
3187
3188 if (!cred->required_roaming_consortium_len)
3189 return NULL;
3190 buflen = cred->required_roaming_consortium_len * 2 + 1;
3191 buf = os_malloc(buflen);
3192 if (buf == NULL)
3193 return NULL;
3194 wpa_snprintf_hex(buf, buflen, cred->required_roaming_consortium,
3195 cred->required_roaming_consortium_len);
3196 return buf;
3197 }
3198
3199 if (os_strcmp(var, "excluded_ssid") == 0) {
3200 unsigned int i;
3201 char *buf, *end, *pos;
3202
3203 if (!cred->num_excluded_ssid)
3204 return NULL;
3205
3206 buf = os_malloc(4000);
3207 if (buf == NULL)
3208 return NULL;
3209 pos = buf;
3210 end = pos + 4000;
3211
3212 for (i = 0; i < cred->num_excluded_ssid; i++) {
3213 struct excluded_ssid *e;
3214 int ret;
3215
3216 e = &cred->excluded_ssid[i];
3217 ret = os_snprintf(pos, end - pos, "%s%s",
3218 i > 0 ? "\n" : "",
3219 wpa_ssid_txt(e->ssid, e->ssid_len));
3220 if (ret < 0 || ret >= end - pos)
3221 return buf;
3222 pos += ret;
3223 }
3224
3225 return buf;
3226 }
3227
3228 if (os_strcmp(var, "roaming_partner") == 0) {
3229 unsigned int i;
3230 char *buf, *end, *pos;
3231
3232 if (!cred->num_roaming_partner)
3233 return NULL;
3234
3235 buf = os_malloc(4000);
3236 if (buf == NULL)
3237 return NULL;
3238 pos = buf;
3239 end = pos + 4000;
3240
3241 for (i = 0; i < cred->num_roaming_partner; i++) {
3242 struct roaming_partner *p;
3243 int ret;
3244
3245 p = &cred->roaming_partner[i];
3246 ret = os_snprintf(pos, end - pos, "%s%s,%d,%u,%s",
3247 i > 0 ? "\n" : "",
3248 p->fqdn, p->exact_match, p->priority,
3249 p->country);
3250 if (ret < 0 || ret >= end - pos)
3251 return buf;
3252 pos += ret;
3253 }
3254
3255 return buf;
3256 }
3257
3258 if (os_strcmp(var, "provisioning_sp") == 0)
3259 return alloc_strdup(cred->provisioning_sp);
3260
3261 return NULL;
3262}
3263
3264
d94c9ee6
JM		 3265struct wpa_cred * wpa_config_get_cred(struct wpa_config *config, int id)
3266{
3267 struct wpa_cred *cred;
3268
3269 cred = config->cred;
3270 while (cred) {
3271 if (id == cred->id)
3272 break;
3273 cred = cred->next;
3274 }
3275
3276 return cred;
3277}
3278
3279
3280struct wpa_cred * wpa_config_add_cred(struct wpa_config *config)
3281{
3282 int id;
3283 struct wpa_cred *cred, *last = NULL;
3284
3285 id = -1;
3286 cred = config->cred;
3287 while (cred) {
3288 if (cred->id > id)
3289 id = cred->id;
3290 last = cred;
3291 cred = cred->next;
3292 }
3293 id++;
3294
3295 cred = os_zalloc(sizeof(*cred));
3296 if (cred == NULL)
3297 return NULL;
3298 cred->id = id;
13f6a07e 3299 cred->sim_num = DEFAULT_USER_SELECTED_SIM;
d94c9ee6
JM		 3300 if (last)
3301 last->next = cred;
3302 else
3303 config->cred = cred;
3304
3305 return cred;
3306}
3307
3308
3309int wpa_config_remove_cred(struct wpa_config *config, int id)
3310{
3311 struct wpa_cred *cred, *prev = NULL;
3312
3313 cred = config->cred;
3314 while (cred) {
3315 if (id == cred->id)
3316 break;
3317 prev = cred;
3318 cred = cred->next;
3319 }
3320
3321 if (cred == NULL)
3322 return -1;
3323
3324 if (prev)
3325 prev->next = cred->next;
3326 else
3327 config->cred = cred->next;
3328
3329 wpa_config_free_cred(cred);
3330 return 0;
3331}
3332
3333
6fc6879b
JM		 3334#ifndef CONFIG_NO_CONFIG_BLOBS
3335/**
3336 * wpa_config_get_blob - Get a named configuration blob
3337 * @config: Configuration data from wpa_config_read()
3338 * @name: Name of the blob
3339 * Returns: Pointer to blob data or %NULL if not found
3340 */
3341const struct wpa_config_blob * wpa_config_get_blob(struct wpa_config *config,
3342 const char *name)
3343{
3344 struct wpa_config_blob *blob = config->blobs;
3345
3346 while (blob) {
3347 if (os_strcmp(blob->name, name) == 0)
3348 return blob;
3349 blob = blob->next;
3350 }
3351 return NULL;
3352}
3353
3354
3355/**
3356 * wpa_config_set_blob - Set or add a named configuration blob
3357 * @config: Configuration data from wpa_config_read()
3358 * @blob: New value for the blob
3359 *
3360 * Adds a new configuration blob or replaces the current value of an existing
3361 * blob.
3362 */
3363void wpa_config_set_blob(struct wpa_config *config,
3364 struct wpa_config_blob *blob)
3365{
3366 wpa_config_remove_blob(config, blob->name);
3367 blob->next = config->blobs;
3368 config->blobs = blob;
3369}
3370
3371
3372/**
3373 * wpa_config_free_blob - Free blob data
3374 * @blob: Pointer to blob to be freed
3375 */
3376void wpa_config_free_blob(struct wpa_config_blob *blob)
3377{
3378 if (blob) {
3379 os_free(blob->name);
19c48da0 3380 bin_clear_free(blob->data, blob->len);
6fc6879b
JM		 3381 os_free(blob);
3382 }
3383}
3384
3385
3386/**
3387 * wpa_config_remove_blob - Remove a named configuration blob
3388 * @config: Configuration data from wpa_config_read()
3389 * @name: Name of the blob to remove
3390 * Returns: 0 if blob was removed or -1 if blob was not found
3391 */
3392int wpa_config_remove_blob(struct wpa_config *config, const char *name)
3393{
3394 struct wpa_config_blob *pos = config->blobs, *prev = NULL;
3395
3396 while (pos) {
3397 if (os_strcmp(pos->name, name) == 0) {
3398 if (prev)
3399 prev->next = pos->next;
3400 else
3401 config->blobs = pos->next;
3402 wpa_config_free_blob(pos);
3403 return 0;
3404 }
3405 prev = pos;
3406 pos = pos->next;
3407 }
3408
3409 return -1;
3410}
3411#endif /* CONFIG_NO_CONFIG_BLOBS */
3412
3413
3414/**
3415 * wpa_config_alloc_empty - Allocate an empty configuration
3416 * @ctrl_interface: Control interface parameters, e.g., path to UNIX domain
3417 * socket
3418 * @driver_param: Driver parameters
3419 * Returns: Pointer to allocated configuration data or %NULL on failure
3420 */
3421struct wpa_config * wpa_config_alloc_empty(const char *ctrl_interface,
3422 const char *driver_param)
3423{
3424 struct wpa_config *config;
c26effe1
YD		 3425 const int aCWmin = 4, aCWmax = 10;
3426 const struct hostapd_wmm_ac_params ac_bk =
3427 { aCWmin, aCWmax, 7, 0, 0 }; /* background traffic */
3428 const struct hostapd_wmm_ac_params ac_be =
3429 { aCWmin, aCWmax, 3, 0, 0 }; /* best effort traffic */
3430 const struct hostapd_wmm_ac_params ac_vi = /* video traffic */
623ecdd5 3431 { aCWmin - 1, aCWmin, 2, 3000 / 32, 0 };
c26effe1 3432 const struct hostapd_wmm_ac_params ac_vo = /* voice traffic */
623ecdd5 3433 { aCWmin - 2, aCWmin - 1, 2, 1500 / 32, 0 };
6fc6879b
JM		 3434
3435 config = os_zalloc(sizeof(*config));
3436 if (config == NULL)
3437 return NULL;
3438 config->eapol_version = DEFAULT_EAPOL_VERSION;
3439 config->ap_scan = DEFAULT_AP_SCAN;
e45e8989 3440 config->user_mpm = DEFAULT_USER_MPM;
6fc6879b 3441 config->fast_reauth = DEFAULT_FAST_REAUTH;
e3768e7c 3442 config->p2p_go_intent = DEFAULT_P2P_GO_INTENT;
0f66abd2 3443 config->p2p_intra_bss = DEFAULT_P2P_INTRA_BSS;
462a7439 3444 config->p2p_go_max_inactivity = DEFAULT_P2P_GO_MAX_INACTIVITY;
e3bd6e9d 3445 config->p2p_optimize_listen_chan = DEFAULT_P2P_OPTIMIZE_LISTEN_CHAN;
c9c38b09 3446 config->bss_max_count = DEFAULT_BSS_MAX_COUNT;
78633c37
SL		 3447 config->bss_expiration_age = DEFAULT_BSS_EXPIRATION_AGE;
3448 config->bss_expiration_scan_count = DEFAULT_BSS_EXPIRATION_SCAN_COUNT;
dae608d5 3449 config->max_num_sta = DEFAULT_MAX_NUM_STA;
11540c0b 3450 config->access_network_type = DEFAULT_ACCESS_NETWORK_TYPE;
6124e858 3451 config->scan_cur_freq = DEFAULT_SCAN_CUR_FREQ;
c26effe1
YD		 3452 config->wmm_ac_params[0] = ac_be;
3453 config->wmm_ac_params[1] = ac_bk;
3454 config->wmm_ac_params[2] = ac_vi;
3455 config->wmm_ac_params[3] = ac_vo;
d3b20469 3456 config->p2p_search_delay = DEFAULT_P2P_SEARCH_DELAY;
c267753b 3457 config->rand_addr_lifetime = DEFAULT_RAND_ADDR_LIFETIME;
b41f2684 3458 config->key_mgmt_offload = DEFAULT_KEY_MGMT_OFFLOAD;
6fc6879b
JM		 3459
3460 if (ctrl_interface)
3461 config->ctrl_interface = os_strdup(ctrl_interface);
3462 if (driver_param)
3463 config->driver_param = os_strdup(driver_param);
3464
3465 return config;
3466}
3467
3468
3469#ifndef CONFIG_NO_STDOUT_DEBUG
3470/**
3471 * wpa_config_debug_dump_networks - Debug dump of configured networks
3472 * @config: Configuration data from wpa_config_read()
3473 */
3474void wpa_config_debug_dump_networks(struct wpa_config *config)
3475{
3476 int prio;
3477 struct wpa_ssid *ssid;
3478
3479 for (prio = 0; prio < config->num_prio; prio++) {
3480 ssid = config->pssid[prio];
3481 wpa_printf(MSG_DEBUG, "Priority group %d",
3482 ssid->priority);
3483 while (ssid) {
3484 wpa_printf(MSG_DEBUG, " id=%d ssid='%s'",
3485 ssid->id,
3486 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
3487 ssid = ssid->pnext;
3488 }
3489 }
3490}
3491#endif /* CONFIG_NO_STDOUT_DEBUG */
121adf9c
JM		 3492
3493
3494struct global_parse_data {
3495 char *name;
3496 int (*parser)(const struct global_parse_data *data,
3497 struct wpa_config *config, int line, const char *value);
3498 void *param1, *param2, *param3;
1d47214a 3499 unsigned int changed_flag;
121adf9c
JM		 3500};
3501
3502
3503static int wpa_global_config_parse_int(const struct global_parse_data *data,
3504 struct wpa_config *config, int line,
3505 const char *pos)
3506{
eae3a584
JB		 3507 int val, *dst;
3508 char *end;
3509
121adf9c 3510 dst = (int *) (((u8 *) config) + (long) data->param1);
eae3a584
JB		 3511 val = strtol(pos, &end, 0);
3512 if (*end) {
3513 wpa_printf(MSG_ERROR, "Line %d: invalid number \"%s\"",
3514 line, pos);
3515 return -1;
3516 }
3517 *dst = val;
3518
121adf9c
JM		 3519 wpa_printf(MSG_DEBUG, "%s=%d", data->name, *dst);
3520
3521 if (data->param2 && *dst < (long) data->param2) {
3522 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
3523 "min_value=%ld)", line, data->name, *dst,
3524 (long) data->param2);
3525 *dst = (long) data->param2;
3526 return -1;
3527 }
3528
3529 if (data->param3 && *dst > (long) data->param3) {
3530 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
3531 "max_value=%ld)", line, data->name, *dst,
3532 (long) data->param3);
3533 *dst = (long) data->param3;
3534 return -1;
3535 }
3536
3537 return 0;
3538}
3539
3540
3541static int wpa_global_config_parse_str(const struct global_parse_data *data,
3542 struct wpa_config *config, int line,
3543 const char *pos)
3544{
3545 size_t len;
3546 char **dst, *tmp;
3547
3548 len = os_strlen(pos);
3549 if (data->param2 && len < (size_t) data->param2) {
3550 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
3551 "min_len=%ld)", line, data->name,
3552 (unsigned long) len, (long) data->param2);
3553 return -1;
3554 }
3555
3556 if (data->param3 && len > (size_t) data->param3) {
3557 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
3558 "max_len=%ld)", line, data->name,
3559 (unsigned long) len, (long) data->param3);
3560 return -1;
3561 }
3562
3563 tmp = os_strdup(pos);
3564 if (tmp == NULL)
3565 return -1;
3566
3567 dst = (char **) (((u8 *) config) + (long) data->param1);
3568 os_free(*dst);
3569 *dst = tmp;
3570 wpa_printf(MSG_DEBUG, "%s='%s'", data->name, *dst);
3571
3572 return 0;
3573}
3574
3575
31392709
HD		 3576static int wpa_config_process_bgscan(const struct global_parse_data *data,
3577 struct wpa_config *config, int line,
3578 const char *pos)
3579{
3580 size_t len;
3581 char *tmp;
04c366cb 3582 int res;
31392709
HD		 3583
3584 tmp = wpa_config_parse_string(pos, &len);
3585 if (tmp == NULL) {
3586 wpa_printf(MSG_ERROR, "Line %d: failed to parse %s",
3587 line, data->name);
3588 return -1;
3589 }
3590
04c366cb
EL		 3591 res = wpa_global_config_parse_str(data, config, line, tmp);
3592 os_free(tmp);
3593 return res;
31392709
HD		 3594}
3595
3596
3f2c8ba6
JM		 3597static int wpa_global_config_parse_bin(const struct global_parse_data *data,
3598 struct wpa_config *config, int line,
3599 const char *pos)
3600{
3601 size_t len;
3602 struct wpabuf **dst, *tmp;
3603
3604 len = os_strlen(pos);
3605 if (len & 0x01)
3606 return -1;
3607
3608 tmp = wpabuf_alloc(len / 2);
3609 if (tmp == NULL)
3610 return -1;
3611
3612 if (hexstr2bin(pos, wpabuf_put(tmp, len / 2), len / 2)) {
3613 wpabuf_free(tmp);
3614 return -1;
3615 }
3616
3617 dst = (struct wpabuf **) (((u8 *) config) + (long) data->param1);
3618 wpabuf_free(*dst);
3619 *dst = tmp;
3620 wpa_printf(MSG_DEBUG, "%s", data->name);
3621
3622 return 0;
3623}
3624
3625
f5ffc348
BG		 3626static int wpa_config_process_freq_list(const struct global_parse_data *data,
3627 struct wpa_config *config, int line,
3628 const char *value)
3629{
3630 int *freqs;
3631
3632 freqs = wpa_config_parse_int_array(value);
3633 if (freqs == NULL)
3634 return -1;
6668efda
JM		 3635 if (freqs[0] == 0) {
3636 os_free(freqs);
3637 freqs = NULL;
3638 }
f5ffc348
BG		 3639 os_free(config->freq_list);
3640 config->freq_list = freqs;
3641 return 0;
3642}
3643
3644
25ef8529
JM		 3645#ifdef CONFIG_P2P
3646static int wpa_global_config_parse_ipv4(const struct global_parse_data *data,
3647 struct wpa_config *config, int line,
3648 const char *pos)
3649{
3650 u32 *dst;
3651 struct hostapd_ip_addr addr;
3652
3653 if (hostapd_parse_ip_addr(pos, &addr) < 0)
3654 return -1;
3655 if (addr.af != AF_INET)
3656 return -1;
3657
3658 dst = (u32 *) (((u8 *) config) + (long) data->param1);
3659 os_memcpy(dst, &addr.u.v4.s_addr, 4);
3660 wpa_printf(MSG_DEBUG, "%s = 0x%x", data->name,
3661 WPA_GET_BE32((u8 *) dst));
3662
3663 return 0;
3664}
3665#endif /* CONFIG_P2P */
3666
3667
121adf9c
JM		 3668static int wpa_config_process_country(const struct global_parse_data *data,
3669 struct wpa_config *config, int line,
3670 const char *pos)
3671{
3672 if (!pos[0] || !pos[1]) {
3673 wpa_printf(MSG_DEBUG, "Invalid country set");
3674 return -1;
3675 }
3676 config->country[0] = pos[0];
3677 config->country[1] = pos[1];
3678 wpa_printf(MSG_DEBUG, "country='%c%c'",
3679 config->country[0], config->country[1]);
3680 return 0;
3681}
3682
3683
3684static int wpa_config_process_load_dynamic_eap(
3685 const struct global_parse_data *data, struct wpa_config *config,
3686 int line, const char *so)
3687{
3688 int ret;
3689 wpa_printf(MSG_DEBUG, "load_dynamic_eap=%s", so);
3690 ret = eap_peer_method_load(so);
3691 if (ret == -2) {
3692 wpa_printf(MSG_DEBUG, "This EAP type was already loaded - not "
3693 "reloading.");
3694 } else if (ret) {
3695 wpa_printf(MSG_ERROR, "Line %d: Failed to load dynamic EAP "
3696 "method '%s'.", line, so);
3697 return -1;
3698 }
3699
3700 return 0;
3701}
3702
3703
3704#ifdef CONFIG_WPS
3705
3706static int wpa_config_process_uuid(const struct global_parse_data *data,
3707 struct wpa_config *config, int line,
3708 const char *pos)
3709{
3710 char buf[40];
3711 if (uuid_str2bin(pos, config->uuid)) {
3712 wpa_printf(MSG_ERROR, "Line %d: invalid UUID", line);
3713 return -1;
3714 }
3715 uuid_bin2str(config->uuid, buf, sizeof(buf));
3716 wpa_printf(MSG_DEBUG, "uuid=%s", buf);
3717 return 0;
3718}
3719
3720
2f646b6e
JB		 3721static int wpa_config_process_device_type(
3722 const struct global_parse_data *data,
3723 struct wpa_config *config, int line, const char *pos)
3724{
3725 return wps_dev_type_str2bin(pos, config->device_type);
3726}
3727
3728
121adf9c
JM		 3729static int wpa_config_process_os_version(const struct global_parse_data *data,
3730 struct wpa_config *config, int line,
3731 const char *pos)
3732{
3733 if (hexstr2bin(pos, config->os_version, 4)) {
3734 wpa_printf(MSG_ERROR, "Line %d: invalid os_version", line);
3735 return -1;
3736 }
3737 wpa_printf(MSG_DEBUG, "os_version=%08x",
3738 WPA_GET_BE32(config->os_version));
3739 return 0;
3740}
3741
71dd3b78
AS		 3742
3743static int wpa_config_process_wps_vendor_ext_m1(
3744 const struct global_parse_data *data,
3745 struct wpa_config *config, int line, const char *pos)
3746{
3747 struct wpabuf *tmp;
3748 int len = os_strlen(pos) / 2;
3749 u8 *p;
3750
3751 if (!len) {
3752 wpa_printf(MSG_ERROR, "Line %d: "
3753 "invalid wps_vendor_ext_m1", line);
3754 return -1;
3755 }
3756
3757 tmp = wpabuf_alloc(len);
3758 if (tmp) {
3759 p = wpabuf_put(tmp, len);
3760
3761 if (hexstr2bin(pos, p, len)) {
3762 wpa_printf(MSG_ERROR, "Line %d: "
3763 "invalid wps_vendor_ext_m1", line);
3764 wpabuf_free(tmp);
3765 return -1;
3766 }
3767
3768 wpabuf_free(config->wps_vendor_ext_m1);
3769 config->wps_vendor_ext_m1 = tmp;
3770 } else {
3771 wpa_printf(MSG_ERROR, "Can not allocate "
3772 "memory for wps_vendor_ext_m1");
3773 return -1;
3774 }
3775
3776 return 0;
3777}
3778
121adf9c
JM		 3779#endif /* CONFIG_WPS */
3780
e3768e7c
JM		 3781#ifdef CONFIG_P2P
3782static int wpa_config_process_sec_device_type(
3783 const struct global_parse_data *data,
3784 struct wpa_config *config, int line, const char *pos)
3785{
3786 int idx;
3787
2f646b6e 3788 if (config->num_sec_device_types >= MAX_SEC_DEVICE_TYPES) {
e3768e7c
JM		 3789 wpa_printf(MSG_ERROR, "Line %d: too many sec_device_type "
3790 "items", line);
3791 return -1;
3792 }
3793
2f646b6e
JB		 3794 idx = config->num_sec_device_types;
3795
3796 if (wps_dev_type_str2bin(pos, config->sec_device_type[idx]))
e3768e7c 3797 return -1;
2f646b6e
JB		 3798
3799 config->num_sec_device_types++;
e3768e7c
JM		 3800 return 0;
3801}
21d996f7
JM		 3802
3803
3804static int wpa_config_process_p2p_pref_chan(
3805 const struct global_parse_data *data,
3806 struct wpa_config *config, int line, const char *pos)
3807{
3808 struct p2p_channel *pref = NULL, *n;
3809 unsigned int num = 0;
3810 const char *pos2;
3811 u8 op_class, chan;
3812
3813 /* format: class:chan,class:chan,... */
3814
3815 while (*pos) {
3816 op_class = atoi(pos);
3817 pos2 = os_strchr(pos, ':');
3818 if (pos2 == NULL)
3819 goto fail;
3820 pos2++;
3821 chan = atoi(pos2);
3822
067ffa26
JM		 3823 n = os_realloc_array(pref, num + 1,
3824 sizeof(struct p2p_channel));
21d996f7
JM		 3825 if (n == NULL)
3826 goto fail;
3827 pref = n;
3828 pref[num].op_class = op_class;
3829 pref[num].chan = chan;
3830 num++;
3831
3832 pos = os_strchr(pos2, ',');
3833 if (pos == NULL)
3834 break;
3835 pos++;
3836 }
3837
3838 os_free(config->p2p_pref_chan);
3839 config->p2p_pref_chan = pref;
3840 config->num_p2p_pref_chan = num;
3841 wpa_hexdump(MSG_DEBUG, "P2P: Preferred class/channel pairs",
3842 (u8 *) config->p2p_pref_chan,
3843 config->num_p2p_pref_chan * sizeof(struct p2p_channel));
3844
3845 return 0;
3846
3847fail:
3848 os_free(pref);
3849 wpa_printf(MSG_ERROR, "Line %d: Invalid p2p_pref_chan list", line);
3850 return -1;
3851}
556b30da
JM		 3852
3853
3854static int wpa_config_process_p2p_no_go_freq(
3855 const struct global_parse_data *data,
3856 struct wpa_config *config, int line, const char *pos)
3857{
3858 int ret;
3859
3860 ret = freq_range_list_parse(&config->p2p_no_go_freq, pos);
3861 if (ret < 0) {
3862 wpa_printf(MSG_ERROR, "Line %d: Invalid p2p_no_go_freq", line);
3863 return -1;
3864 }
3865
3866 wpa_printf(MSG_DEBUG, "P2P: p2p_no_go_freq with %u items",
3867 config->p2p_no_go_freq.num);
3868
3869 return 0;
3870}
3871
e3768e7c
JM		 3872#endif /* CONFIG_P2P */
3873
121adf9c 3874
46ee0427
JM		 3875static int wpa_config_process_hessid(
3876 const struct global_parse_data *data,
3877 struct wpa_config *config, int line, const char *pos)
3878{
3879 if (hwaddr_aton2(pos, config->hessid) < 0) {
3880 wpa_printf(MSG_ERROR, "Line %d: Invalid hessid '%s'",
3881 line, pos);
3882 return -1;
3883 }
3884
3885 return 0;
3886}
3887
3888
625f202a
JM		 3889static int wpa_config_process_sae_groups(
3890 const struct global_parse_data *data,
3891 struct wpa_config *config, int line, const char *pos)
3892{
3893 int *groups = wpa_config_parse_int_array(pos);
3894 if (groups == NULL) {
3895 wpa_printf(MSG_ERROR, "Line %d: Invalid sae_groups '%s'",
3896 line, pos);
3897 return -1;
3898 }
3899
3900 os_free(config->sae_groups);
3901 config->sae_groups = groups;
3902
3903 return 0;
3904}
3905
3906
18a2eaab
JM		 3907static int wpa_config_process_ap_vendor_elements(
3908 const struct global_parse_data *data,
3909 struct wpa_config *config, int line, const char *pos)
3910{
3911 struct wpabuf *tmp;
3912 int len = os_strlen(pos) / 2;
3913 u8 *p;
3914
3915 if (!len) {
3916 wpa_printf(MSG_ERROR, "Line %d: invalid ap_vendor_elements",
3917 line);
3918 return -1;
3919 }
3920
3921 tmp = wpabuf_alloc(len);
3922 if (tmp) {
3923 p = wpabuf_put(tmp, len);
3924
3925 if (hexstr2bin(pos, p, len)) {
3926 wpa_printf(MSG_ERROR, "Line %d: invalid "
3927 "ap_vendor_elements", line);
3928 wpabuf_free(tmp);
3929 return -1;
3930 }
3931
3932 wpabuf_free(config->ap_vendor_elements);
3933 config->ap_vendor_elements = tmp;
3934 } else {
3935 wpa_printf(MSG_ERROR, "Cannot allocate memory for "
3936 "ap_vendor_elements");
3937 return -1;
3938 }
3939
3940 return 0;
3941}
3942
3943
298f5185 3944#ifdef CONFIG_CTRL_IFACE
ea61aa1d
JM		 3945static int wpa_config_process_no_ctrl_interface(
3946 const struct global_parse_data *data,
3947 struct wpa_config *config, int line, const char *pos)
3948{
3949 wpa_printf(MSG_DEBUG, "no_ctrl_interface -> ctrl_interface=NULL");
3950 os_free(config->ctrl_interface);
3951 config->ctrl_interface = NULL;
3952 return 0;
3953}
298f5185 3954#endif /* CONFIG_CTRL_IFACE */
ea61aa1d
JM		 3955
3956
121adf9c
JM		 3957#ifdef OFFSET
3958#undef OFFSET
3959#endif /* OFFSET */
3960/* OFFSET: Get offset of a variable within the wpa_config structure */
3961#define OFFSET(v) ((void *) &((struct wpa_config *) 0)->v)
3962
3963#define FUNC(f) #f, wpa_config_process_ ## f, OFFSET(f), NULL, NULL
3964#define FUNC_NO_VAR(f) #f, wpa_config_process_ ## f, NULL, NULL, NULL
3965#define _INT(f) #f, wpa_global_config_parse_int, OFFSET(f)
3966#define INT(f) _INT(f), NULL, NULL
3967#define INT_RANGE(f, min, max) _INT(f), (void *) min, (void *) max
3968#define _STR(f) #f, wpa_global_config_parse_str, OFFSET(f)
3969#define STR(f) _STR(f), NULL, NULL
3970#define STR_RANGE(f, min, max) _STR(f), (void *) min, (void *) max
3f2c8ba6 3971#define BIN(f) #f, wpa_global_config_parse_bin, OFFSET(f), NULL, NULL
25ef8529 3972#define IPV4(f) #f, wpa_global_config_parse_ipv4, OFFSET(f), NULL, NULL
121adf9c
JM		 3973
3974static const struct global_parse_data global_fields[] = {
3975#ifdef CONFIG_CTRL_IFACE
1d47214a 3976 { STR(ctrl_interface), 0 },
ea61aa1d 3977 { FUNC_NO_VAR(no_ctrl_interface), 0 },
1d47214a 3978 { STR(ctrl_interface_group), 0 } /* deprecated */,
121adf9c 3979#endif /* CONFIG_CTRL_IFACE */
0836c04b
HW		 3980#ifdef CONFIG_MACSEC
3981 { INT_RANGE(eapol_version, 1, 3), 0 },
3982#else /* CONFIG_MACSEC */
1d47214a 3983 { INT_RANGE(eapol_version, 1, 2), 0 },
0836c04b 3984#endif /* CONFIG_MACSEC */
1d47214a 3985 { INT(ap_scan), 0 },
31392709 3986 { FUNC(bgscan), 0 },
e45e8989
TP		 3987#ifdef CONFIG_MESH
3988 { INT(user_mpm), 0 },
3989#endif /* CONFIG_MESH */
54ddd743 3990 { INT(disable_scan_offload), 0 },
1d47214a
JM		 3991 { INT(fast_reauth), 0 },
3992 { STR(opensc_engine_path), 0 },
3993 { STR(pkcs11_engine_path), 0 },
3994 { STR(pkcs11_module_path), 0 },
07e2de31 3995 { STR(openssl_ciphers), 0 },
f64adcd7
JM		 3996 { STR(pcsc_reader), 0 },
3997 { STR(pcsc_pin), 0 },
a5d44ac0 3998 { INT(external_sim), 0 },
1d47214a
JM		 3999 { STR(driver_param), 0 },
4000 { INT(dot11RSNAConfigPMKLifetime), 0 },
4001 { INT(dot11RSNAConfigPMKReauthThreshold), 0 },
4002 { INT(dot11RSNAConfigSATimeout), 0 },
121adf9c 4003#ifndef CONFIG_NO_CONFIG_WRITE
1d47214a 4004 { INT(update_config), 0 },
121adf9c 4005#endif /* CONFIG_NO_CONFIG_WRITE */
1d47214a 4006 { FUNC_NO_VAR(load_dynamic_eap), 0 },
121adf9c 4007#ifdef CONFIG_WPS
1d47214a
JM		 4008 { FUNC(uuid), CFG_CHANGED_UUID },
4009 { STR_RANGE(device_name, 0, 32), CFG_CHANGED_DEVICE_NAME },
1c9cb49f
JM		 4010 { STR_RANGE(manufacturer, 0, 64), CFG_CHANGED_WPS_STRING },
4011 { STR_RANGE(model_name, 0, 32), CFG_CHANGED_WPS_STRING },
4012 { STR_RANGE(model_number, 0, 32), CFG_CHANGED_WPS_STRING },
4013 { STR_RANGE(serial_number, 0, 32), CFG_CHANGED_WPS_STRING },
2f646b6e 4014 { FUNC(device_type), CFG_CHANGED_DEVICE_TYPE },
1d47214a
JM		 4015 { FUNC(os_version), CFG_CHANGED_OS_VERSION },
4016 { STR(config_methods), CFG_CHANGED_CONFIG_METHODS },
4017 { INT_RANGE(wps_cred_processing, 0, 2), 0 },
71dd3b78 4018 { FUNC(wps_vendor_ext_m1), CFG_CHANGED_VENDOR_EXTENSION },
121adf9c 4019#endif /* CONFIG_WPS */
e3768e7c
JM		 4020#ifdef CONFIG_P2P
4021 { FUNC(sec_device_type), CFG_CHANGED_SEC_DEVICE_TYPE },
4022 { INT(p2p_listen_reg_class), 0 },
4023 { INT(p2p_listen_channel), 0 },
00eb2993
JM		 4024 { INT(p2p_oper_reg_class), CFG_CHANGED_P2P_OPER_CHANNEL },
4025 { INT(p2p_oper_channel), CFG_CHANGED_P2P_OPER_CHANNEL },
e3768e7c
JM		 4026 { INT_RANGE(p2p_go_intent, 0, 15), 0 },
4027 { STR(p2p_ssid_postfix), CFG_CHANGED_P2P_SSID_POSTFIX },
4028 { INT_RANGE(persistent_reconnect, 0, 1), 0 },
0f66abd2 4029 { INT_RANGE(p2p_intra_bss, 0, 1), CFG_CHANGED_P2P_INTRA_BSS },
3071e181 4030 { INT(p2p_group_idle), 0 },
1b928f96
JM		 4031 { INT_RANGE(p2p_passphrase_len, 8, 63),
4032 CFG_CHANGED_P2P_PASSPHRASE_LEN },
21d996f7 4033 { FUNC(p2p_pref_chan), CFG_CHANGED_P2P_PREF_CHAN },
556b30da 4034 { FUNC(p2p_no_go_freq), CFG_CHANGED_P2P_PREF_CHAN },
51e9f228 4035 { INT_RANGE(p2p_add_cli_chan, 0, 1), 0 },
e3bd6e9d 4036 { INT_RANGE(p2p_optimize_listen_chan, 0, 1), 0 },
a93a15bb 4037 { INT(p2p_go_ht40), 0 },
20ea1ca4 4038 { INT(p2p_go_vht), 0 },
7a808c7e 4039 { INT(p2p_disabled), 0 },
d76cd41a 4040 { INT(p2p_no_group_iface), 0 },
b277a2be 4041 { INT_RANGE(p2p_ignore_shared_freq, 0, 1), 0 },
25ef8529
JM		 4042 { IPV4(ip_addr_go), 0 },
4043 { IPV4(ip_addr_mask), 0 },
4044 { IPV4(ip_addr_start), 0 },
4045 { IPV4(ip_addr_end), 0 },
e3768e7c 4046#endif /* CONFIG_P2P */
1d47214a
JM		 4047 { FUNC(country), CFG_CHANGED_COUNTRY },
4048 { INT(bss_max_count), 0 },
78633c37
SL		 4049 { INT(bss_expiration_age), 0 },
4050 { INT(bss_expiration_scan_count), 0 },
dae608d5 4051 { INT_RANGE(filter_ssids, 0, 1), 0 },
bf8d6d24 4052 { INT_RANGE(filter_rssi, -100, 0), 0 },
0d7e5a3a 4053 { INT(max_num_sta), 0 },
46ee0427 4054 { INT_RANGE(disassoc_low_ack, 0, 1), 0 },
66aadbd7
JK		 4055#ifdef CONFIG_HS20
4056 { INT_RANGE(hs20, 0, 1), 0 },
4057#endif /* CONFIG_HS20 */
46ee0427 4058 { INT_RANGE(interworking, 0, 1), 0 },
11540c0b 4059 { FUNC(hessid), 0 },
1298c145 4060 { INT_RANGE(access_network_type, 0, 15), 0 },
b0786fba 4061 { INT_RANGE(pbc_in_m1, 0, 1), 0 },
3f2c8ba6 4062 { STR(autoscan), 0 },
042ec551
JM		 4063 { INT_RANGE(wps_nfc_dev_pw_id, 0x10, 0xffff),
4064 CFG_CHANGED_NFC_PASSWORD_TOKEN },
4065 { BIN(wps_nfc_dh_pubkey), CFG_CHANGED_NFC_PASSWORD_TOKEN },
4066 { BIN(wps_nfc_dh_privkey), CFG_CHANGED_NFC_PASSWORD_TOKEN },
4067 { BIN(wps_nfc_dev_pw), CFG_CHANGED_NFC_PASSWORD_TOKEN },
462a7439
ES		 4068 { STR(ext_password_backend), CFG_CHANGED_EXT_PW_BACKEND },
4069 { INT(p2p_go_max_inactivity), 0 },
4d5bda5f 4070 { INT_RANGE(auto_interworking, 0, 1), 0 },
6e202021 4071 { INT(okc), 0 },
62d49803 4072 { INT(pmf), 0 },
625f202a 4073 { FUNC(sae_groups), 0 },
18206e02
JM		 4074 { INT(dtim_period), 0 },
4075 { INT(beacon_int), 0 },
18a2eaab 4076 { FUNC(ap_vendor_elements), 0 },
4342326f 4077 { INT_RANGE(ignore_old_scan_res, 0, 1), 0 },
f5ffc348 4078 { FUNC(freq_list), 0 },
6124e858 4079 { INT(scan_cur_freq), 0 },
4aa81868 4080 { INT(sched_scan_interval), 0 },
800d5872 4081 { INT(tdls_external_control), 0},
b572df86 4082 { STR(osu_dir), 0 },
e4fa8b12 4083 { STR(wowlan_triggers), 0 },
d3b20469 4084 { INT(p2p_search_delay), 0},
c267753b
JM		 4085 { INT(mac_addr), 0 },
4086 { INT(rand_addr_lifetime), 0 },
4087 { INT(preassoc_mac_addr), 0 },
b41f2684 4088 { INT(key_mgmt_offload), 0},
121adf9c
JM		 4089};
4090
4091#undef FUNC
4092#undef _INT
4093#undef INT
4094#undef INT_RANGE
4095#undef _STR
4096#undef STR
4097#undef STR_RANGE
3f2c8ba6 4098#undef BIN
25ef8529 4099#undef IPV4
e7ecab4a 4100#define NUM_GLOBAL_FIELDS ARRAY_SIZE(global_fields)
121adf9c
JM		 4101
4102
4103int wpa_config_process_global(struct wpa_config *config, char *pos, int line)
4104{
4105 size_t i;
4106 int ret = 0;
4107
4108 for (i = 0; i < NUM_GLOBAL_FIELDS; i++) {
4109 const struct global_parse_data *field = &global_fields[i];
4110 size_t flen = os_strlen(field->name);
4111 if (os_strncmp(pos, field->name, flen) != 0 ||
4112 pos[flen] != '=')
4113 continue;
4114
4115 if (field->parser(field, config, line, pos + flen + 1)) {
4116 wpa_printf(MSG_ERROR, "Line %d: failed to "
4117 "parse '%s'.", line, pos);
4118 ret = -1;
4119 }
042ec551
JM		 4120 if (field->changed_flag == CFG_CHANGED_NFC_PASSWORD_TOKEN)
4121 config->wps_nfc_pw_from_config = 1;
1d47214a 4122 config->changed_parameters |= field->changed_flag;
121adf9c
JM		 4123 break;
4124 }
4125 if (i == NUM_GLOBAL_FIELDS) {
c26effe1
YD		 4126#ifdef CONFIG_AP
4127 if (os_strncmp(pos, "wmm_ac_", 7) == 0) {
4128 char *tmp = os_strchr(pos, '=');
4129 if (tmp == NULL) {
4130 if (line < 0)
4131 return -1;
4132 wpa_printf(MSG_ERROR, "Line %d: invalid line "
4133 "'%s'", line, pos);
4134 return -1;
4135 }
4136 *tmp++ = '\0';
4137 if (hostapd_config_wmm_ac(config->wmm_ac_params, pos,
4138 tmp)) {
4139 wpa_printf(MSG_ERROR, "Line %d: invalid WMM "
4140 "AC item", line);
4141 return -1;
4142 }
4143 }
4144#endif /* CONFIG_AP */
1d47214a
JM		 4145 if (line < 0)
4146 return -1;
121adf9c
JM		 4147 wpa_printf(MSG_ERROR, "Line %d: unknown global field '%s'.",
4148 line, pos);
4149 ret = -1;
4150 }
4151
4152 return ret;
4153}
Unnamed repository; edit this file 'description' to name the repository.