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