]> 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
Interworking: Use 3gppnetwork.org for matching home SP for SIM/USIM
[thirdparty/hostap.git] / wpa_supplicant / config.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant / Configuration parser and common functions
56586197 3 * Copyright (c) 2003-2008, 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) },
fbdcfd57
JM		 1592#ifdef CONFIG_P2P
1593 { FUNC(p2p_client_list) },
1594#endif /* CONFIG_P2P */
80e8a5ee
BG		 1595#ifdef CONFIG_HT_OVERRIDES
1596 { INT_RANGE(disable_ht, 0, 1) },
1597 { INT_RANGE(disable_ht40, -1, 1) },
1598 { INT_RANGE(disable_max_amsdu, -1, 1) },
1599 { INT_RANGE(ampdu_factor, -1, 3) },
1600 { INT_RANGE(ampdu_density, -1, 7) },
1601 { STR(ht_mcs) },
1602#endif /* CONFIG_HT_OVERRIDES */
6fc6879b
JM		 1603};
1604
1605#undef OFFSET
1606#undef _STR
1607#undef STR
1608#undef STR_KEY
1609#undef _STR_LEN
1610#undef STR_LEN
1611#undef STR_LEN_KEY
1612#undef _STR_RANGE
1613#undef STR_RANGE
1614#undef STR_RANGE_KEY
1615#undef _INT
1616#undef INT
1617#undef INT_RANGE
1618#undef _FUNC
1619#undef FUNC
1620#undef FUNC_KEY
1621#define NUM_SSID_FIELDS (sizeof(ssid_fields) / sizeof(ssid_fields[0]))
1622
1623
1624/**
1625 * wpa_config_add_prio_network - Add a network to priority lists
1626 * @config: Configuration data from wpa_config_read()
1627 * @ssid: Pointer to the network configuration to be added to the list
1628 * Returns: 0 on success, -1 on failure
1629 *
1630 * This function is used to add a network block to the priority list of
1631 * networks. This must be called for each network when reading in the full
1632 * configuration. In addition, this can be used indirectly when updating
1633 * priorities by calling wpa_config_update_prio_list().
1634 */
1635int wpa_config_add_prio_network(struct wpa_config *config,
1636 struct wpa_ssid *ssid)
1637{
1638 int prio;
1639 struct wpa_ssid *prev, **nlist;
1640
1641 /*
1642 * Add to an existing priority list if one is available for the
1643 * configured priority level for this network.
1644 */
1645 for (prio = 0; prio < config->num_prio; prio++) {
1646 prev = config->pssid[prio];
1647 if (prev->priority == ssid->priority) {
1648 while (prev->pnext)
1649 prev = prev->pnext;
1650 prev->pnext = ssid;
1651 return 0;
1652 }
1653 }
1654
1655 /* First network for this priority - add a new priority list */
1656 nlist = os_realloc(config->pssid,
1657 (config->num_prio + 1) * sizeof(struct wpa_ssid *));
1658 if (nlist == NULL)
1659 return -1;
1660
1661 for (prio = 0; prio < config->num_prio; prio++) {
1662 if (nlist[prio]->priority < ssid->priority)
1663 break;
1664 }
1665
1666 os_memmove(&nlist[prio + 1], &nlist[prio],
1667 (config->num_prio - prio) * sizeof(struct wpa_ssid *));
1668
1669 nlist[prio] = ssid;
1670 config->num_prio++;
1671 config->pssid = nlist;
1672
1673 return 0;
1674}
1675
1676
1677/**
1678 * wpa_config_update_prio_list - Update network priority list
1679 * @config: Configuration data from wpa_config_read()
1680 * Returns: 0 on success, -1 on failure
1681 *
1682 * This function is called to update the priority list of networks in the
1683 * configuration when a network is being added or removed. This is also called
1684 * if a priority for a network is changed.
1685 */
aa53509f 1686int wpa_config_update_prio_list(struct wpa_config *config)
6fc6879b
JM		 1687{
1688 struct wpa_ssid *ssid;
1689 int ret = 0;
1690
1691 os_free(config->pssid);
1692 config->pssid = NULL;
1693 config->num_prio = 0;
1694
1695 ssid = config->ssid;
1696 while (ssid) {
1697 ssid->pnext = NULL;
1698 if (wpa_config_add_prio_network(config, ssid) < 0)
1699 ret = -1;
1700 ssid = ssid->next;
1701 }
1702
1703 return ret;
1704}
1705
1706
1707#ifdef IEEE8021X_EAPOL
1708static void eap_peer_config_free(struct eap_peer_config *eap)
1709{
1710 os_free(eap->eap_methods);
1711 os_free(eap->identity);
1712 os_free(eap->anonymous_identity);
1713 os_free(eap->password);
1714 os_free(eap->ca_cert);
1715 os_free(eap->ca_path);
1716 os_free(eap->client_cert);
1717 os_free(eap->private_key);
1718 os_free(eap->private_key_passwd);
1719 os_free(eap->dh_file);
1720 os_free(eap->subject_match);
1721 os_free(eap->altsubject_match);
1722 os_free(eap->ca_cert2);
1723 os_free(eap->ca_path2);
1724 os_free(eap->client_cert2);
1725 os_free(eap->private_key2);
1726 os_free(eap->private_key2_passwd);
1727 os_free(eap->dh_file2);
1728 os_free(eap->subject_match2);
1729 os_free(eap->altsubject_match2);
1730 os_free(eap->phase1);
1731 os_free(eap->phase2);
1732 os_free(eap->pcsc);
1733 os_free(eap->pin);
1734 os_free(eap->engine_id);
1735 os_free(eap->key_id);
61ee0f71
DS		 1736 os_free(eap->cert_id);
1737 os_free(eap->ca_cert_id);
1738 os_free(eap->key2_id);
1739 os_free(eap->cert2_id);
1740 os_free(eap->ca_cert2_id);
98842d51
CL		 1741 os_free(eap->pin2);
1742 os_free(eap->engine2_id);
6fc6879b
JM		 1743 os_free(eap->otp);
1744 os_free(eap->pending_req_otp);
1745 os_free(eap->pac_file);
1746 os_free(eap->new_password);
1747}
1748#endif /* IEEE8021X_EAPOL */
1749
1750
1751/**
1752 * wpa_config_free_ssid - Free network/ssid configuration data
1753 * @ssid: Configuration data for the network
1754 *
1755 * This function frees all resources allocated for the network configuration
1756 * data.
1757 */
1758void wpa_config_free_ssid(struct wpa_ssid *ssid)
1759{
1760 os_free(ssid->ssid);
1761 os_free(ssid->passphrase);
1762#ifdef IEEE8021X_EAPOL
1763 eap_peer_config_free(&ssid->eap);
1764#endif /* IEEE8021X_EAPOL */
1765 os_free(ssid->id_str);
d3a98225 1766 os_free(ssid->scan_freq);
b766a9a2 1767 os_free(ssid->freq_list);
60b94c98 1768 os_free(ssid->bgscan);
fbdcfd57 1769 os_free(ssid->p2p_client_list);
80e8a5ee
BG		 1770#ifdef CONFIG_HT_OVERRIDES
1771 os_free(ssid->ht_mcs);
1772#endif /* CONFIG_HT_OVERRIDES */
6fc6879b
JM		 1773 os_free(ssid);
1774}
1775
1776
1777/**
1778 * wpa_config_free - Free configuration data
1779 * @config: Configuration data from wpa_config_read()
1780 *
1781 * This function frees all resources allocated for the configuration data by
1782 * wpa_config_read().
1783 */
1784void wpa_config_free(struct wpa_config *config)
1785{
1786#ifndef CONFIG_NO_CONFIG_BLOBS
1787 struct wpa_config_blob *blob, *prevblob;
1788#endif /* CONFIG_NO_CONFIG_BLOBS */
1789 struct wpa_ssid *ssid, *prev = NULL;
e3768e7c 1790
6fc6879b
JM		 1791 ssid = config->ssid;
1792 while (ssid) {
1793 prev = ssid;
1794 ssid = ssid->next;
1795 wpa_config_free_ssid(prev);
1796 }
1797
1798#ifndef CONFIG_NO_CONFIG_BLOBS
1799 blob = config->blobs;
1800 prevblob = NULL;
1801 while (blob) {
1802 prevblob = blob;
1803 blob = blob->next;
1804 wpa_config_free_blob(prevblob);
1805 }
1806#endif /* CONFIG_NO_CONFIG_BLOBS */
1807
1808 os_free(config->ctrl_interface);
1809 os_free(config->ctrl_interface_group);
6fc6879b
JM		 1810 os_free(config->opensc_engine_path);
1811 os_free(config->pkcs11_engine_path);
1812 os_free(config->pkcs11_module_path);
6fc6879b 1813 os_free(config->driver_param);
3c0b7aa4
JM		 1814 os_free(config->device_name);
1815 os_free(config->manufacturer);
1816 os_free(config->model_name);
1817 os_free(config->model_number);
1818 os_free(config->serial_number);
c0e4dd9e 1819 os_free(config->config_methods);
e3768e7c 1820 os_free(config->p2p_ssid_postfix);
6fc6879b 1821 os_free(config->pssid);
73c41a8f 1822 os_free(config->home_realm);
67e1b984
JM		 1823 os_free(config->home_username);
1824 os_free(config->home_password);
1825 os_free(config->home_ca_cert);
3b840b67
JM		 1826 os_free(config->home_imsi);
1827 os_free(config->home_milenage);
00bf219d 1828 os_free(config->home_domain);
6fc6879b
JM		 1829 os_free(config);
1830}
1831
1832
7c49fdd0
SL		 1833/**
1834 * wpa_config_foreach_network - Iterate over each configured network
1835 * @config: Configuration data from wpa_config_read()
1836 * @func: Callback function to process each network
1837 * @arg: Opaque argument to pass to callback function
1838 *
1839 * Iterate over the set of configured networks calling the specified
1840 * function for each item. We guard against callbacks removing the
1841 * supplied network.
1842 */
1843void wpa_config_foreach_network(struct wpa_config *config,
1844 void (*func)(void *, struct wpa_ssid *),
1845 void *arg)
1846{
1847 struct wpa_ssid *ssid, *next;
1848
1849 ssid = config->ssid;
1850 while (ssid) {
1851 next = ssid->next;
1852 func(arg, ssid);
1853 ssid = next;
1854 }
1855}
1856
1857
6fc6879b
JM		 1858/**
1859 * wpa_config_get_network - Get configured network based on id
1860 * @config: Configuration data from wpa_config_read()
1861 * @id: Unique network id to search for
1862 * Returns: Network configuration or %NULL if not found
1863 */
1864struct wpa_ssid * wpa_config_get_network(struct wpa_config *config, int id)
1865{
1866 struct wpa_ssid *ssid;
1867
1868 ssid = config->ssid;
1869 while (ssid) {
1870 if (id == ssid->id)
1871 break;
1872 ssid = ssid->next;
1873 }
1874
1875 return ssid;
1876}
1877
1878
1879/**
1880 * wpa_config_add_network - Add a new network with empty configuration
1881 * @config: Configuration data from wpa_config_read()
1882 * Returns: The new network configuration or %NULL if operation failed
1883 */
1884struct wpa_ssid * wpa_config_add_network(struct wpa_config *config)
1885{
1886 int id;
1887 struct wpa_ssid *ssid, *last = NULL;
1888
1889 id = -1;
1890 ssid = config->ssid;
1891 while (ssid) {
1892 if (ssid->id > id)
1893 id = ssid->id;
1894 last = ssid;
1895 ssid = ssid->next;
1896 }
1897 id++;
1898
1899 ssid = os_zalloc(sizeof(*ssid));
1900 if (ssid == NULL)
1901 return NULL;
1902 ssid->id = id;
1903 if (last)
1904 last->next = ssid;
1905 else
1906 config->ssid = ssid;
1907
1908 wpa_config_update_prio_list(config);
1909
1910 return ssid;
1911}
1912
1913
1914/**
1915 * wpa_config_remove_network - Remove a configured network based on id
1916 * @config: Configuration data from wpa_config_read()
1917 * @id: Unique network id to search for
1918 * Returns: 0 on success, or -1 if the network was not found
1919 */
1920int wpa_config_remove_network(struct wpa_config *config, int id)
1921{
1922 struct wpa_ssid *ssid, *prev = NULL;
1923
1924 ssid = config->ssid;
1925 while (ssid) {
1926 if (id == ssid->id)
1927 break;
1928 prev = ssid;
1929 ssid = ssid->next;
1930 }
1931
1932 if (ssid == NULL)
1933 return -1;
1934
1935 if (prev)
1936 prev->next = ssid->next;
1937 else
1938 config->ssid = ssid->next;
1939
1940 wpa_config_update_prio_list(config);
1941 wpa_config_free_ssid(ssid);
1942 return 0;
1943}
1944
1945
1946/**
1947 * wpa_config_set_network_defaults - Set network default values
1948 * @ssid: Pointer to network configuration data
1949 */
1950void wpa_config_set_network_defaults(struct wpa_ssid *ssid)
1951{
1952 ssid->proto = DEFAULT_PROTO;
1953 ssid->pairwise_cipher = DEFAULT_PAIRWISE;
1954 ssid->group_cipher = DEFAULT_GROUP;
1955 ssid->key_mgmt = DEFAULT_KEY_MGMT;
1956#ifdef IEEE8021X_EAPOL
1957 ssid->eapol_flags = DEFAULT_EAPOL_FLAGS;
1958 ssid->eap_workaround = DEFAULT_EAP_WORKAROUND;
1959 ssid->eap.fragment_size = DEFAULT_FRAGMENT_SIZE;
1960#endif /* IEEE8021X_EAPOL */
80e8a5ee
BG		 1961#ifdef CONFIG_HT_OVERRIDES
1962 ssid->disable_ht = DEFAULT_DISABLE_HT;
1963 ssid->disable_ht40 = DEFAULT_DISABLE_HT40;
1964 ssid->disable_max_amsdu = DEFAULT_DISABLE_MAX_AMSDU;
1965 ssid->ampdu_factor = DEFAULT_AMPDU_FACTOR;
1966 ssid->ampdu_density = DEFAULT_AMPDU_DENSITY;
1967#endif /* CONFIG_HT_OVERRIDES */
6fc6879b
JM		 1968}
1969
1970
1971/**
1972 * wpa_config_set - Set a variable in network configuration
1973 * @ssid: Pointer to network configuration data
1974 * @var: Variable name, e.g., "ssid"
1975 * @value: Variable value
1976 * @line: Line number in configuration file or 0 if not used
1977 * Returns: 0 on success, -1 on failure
1978 *
1979 * This function can be used to set network configuration variables based on
1980 * both the configuration file and management interface input. The value
1981 * parameter must be in the same format as the text-based configuration file is
1982 * using. For example, strings are using double quotation marks.
1983 */
1984int wpa_config_set(struct wpa_ssid *ssid, const char *var, const char *value,
1985 int line)
1986{
1987 size_t i;
1988 int ret = 0;
1989
1990 if (ssid == NULL || var == NULL || value == NULL)
1991 return -1;
1992
1993 for (i = 0; i < NUM_SSID_FIELDS; i++) {
1994 const struct parse_data *field = &ssid_fields[i];
1995 if (os_strcmp(var, field->name) != 0)
1996 continue;
1997
1998 if (field->parser(field, ssid, line, value)) {
1999 if (line) {
2000 wpa_printf(MSG_ERROR, "Line %d: failed to "
2001 "parse %s '%s'.", line, var, value);
2002 }
2003 ret = -1;
2004 }
2005 break;
2006 }
2007 if (i == NUM_SSID_FIELDS) {
2008 if (line) {
2009 wpa_printf(MSG_ERROR, "Line %d: unknown network field "
2010 "'%s'.", line, var);
2011 }
2012 ret = -1;
2013 }
2014
2015 return ret;
2016}
2017
2018
67e1b984
JM		 2019int wpa_config_set_quoted(struct wpa_ssid *ssid, const char *var,
2020 const char *value)
2021{
2022 size_t len;
2023 char *buf;
2024 int ret;
2025
2026 len = os_strlen(value);
2027 buf = os_malloc(len + 3);
2028 if (buf == NULL)
2029 return -1;
2030 buf[0] = '"';
2031 os_memcpy(buf + 1, value, len);
2032 buf[len + 1] = '"';
2033 buf[len + 2] = '\0';
2034 ret = wpa_config_set(ssid, var, buf, 0);
2035 os_free(buf);
2036 return ret;
2037}
2038
2039
3d3d3056
WS		 2040/**
2041 * wpa_config_get_all - Get all options from network configuration
2042 * @ssid: Pointer to network configuration data
2043 * @get_keys: Determines if keys/passwords will be included in returned list
d1c8ac88 2044 * (if they may be exported)
3d3d3056
WS		 2045 * Returns: %NULL terminated list of all set keys and their values in the form
2046 * of [key1, val1, key2, val2, ... , NULL]
2047 *
2048 * This function can be used to get list of all configured network properties.
2049 * The caller is responsible for freeing the returned list and all its
2050 * elements.
2051 */
2052char ** wpa_config_get_all(struct wpa_ssid *ssid, int get_keys)
2053{
2054 const struct parse_data *field;
2055 char *key, *value;
2056 size_t i;
2057 char **props;
2058 int fields_num;
2059
d1c8ac88
JB		 2060 get_keys = get_keys && ssid->export_keys;
2061
3d3d3056
WS		 2062 props = os_zalloc(sizeof(char *) * ((2 * NUM_SSID_FIELDS) + 1));
2063 if (!props)
2064 return NULL;
2065
2066 fields_num = 0;
2067 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2068 field = &ssid_fields[i];
2069 if (field->key_data && !get_keys)
2070 continue;
2071 value = field->writer(field, ssid);
04746865 2072 if (value == NULL)
3d3d3056 2073 continue;
04746865
JM		 2074 if (os_strlen(value) == 0) {
2075 os_free(value);
2076 continue;
2077 }
3d3d3056
WS		 2078
2079 key = os_strdup(field->name);
04746865
JM		 2080 if (key == NULL) {
2081 os_free(value);
3d3d3056 2082 goto err;
04746865 2083 }
3d3d3056
WS		 2084
2085 props[fields_num * 2] = key;
2086 props[fields_num * 2 + 1] = value;
2087
2088 fields_num++;
2089 }
2090
2091 return props;
2092
2093err:
2094 value = *props;
2095 while (value)
2096 os_free(value++);
2097 os_free(props);
2098 return NULL;
2099}
2100
2101
6fc6879b
JM		 2102#ifndef NO_CONFIG_WRITE
2103/**
2104 * wpa_config_get - Get a variable in network configuration
2105 * @ssid: Pointer to network configuration data
2106 * @var: Variable name, e.g., "ssid"
2107 * Returns: Value of the variable or %NULL on failure
2108 *
2109 * This function can be used to get network configuration variables. The
2110 * returned value is a copy of the configuration variable in text format, i.e,.
2111 * the same format that the text-based configuration file and wpa_config_set()
2112 * are using for the value. The caller is responsible for freeing the returned
2113 * value.
2114 */
2115char * wpa_config_get(struct wpa_ssid *ssid, const char *var)
2116{
2117 size_t i;
2118
2119 if (ssid == NULL || var == NULL)
2120 return NULL;
2121
2122 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2123 const struct parse_data *field = &ssid_fields[i];
2124 if (os_strcmp(var, field->name) == 0)
2125 return field->writer(field, ssid);
2126 }
2127
2128 return NULL;
2129}
2130
2131
2132/**
2133 * wpa_config_get_no_key - Get a variable in network configuration (no keys)
2134 * @ssid: Pointer to network configuration data
2135 * @var: Variable name, e.g., "ssid"
2136 * Returns: Value of the variable or %NULL on failure
2137 *
2138 * This function can be used to get network configuration variable like
2139 * wpa_config_get(). The only difference is that this functions does not expose
2140 * key/password material from the configuration. In case a key/password field
2141 * is requested, the returned value is an empty string or %NULL if the variable
2142 * is not set or "*" if the variable is set (regardless of its value). The
2143 * returned value is a copy of the configuration variable in text format, i.e,.
2144 * the same format that the text-based configuration file and wpa_config_set()
2145 * are using for the value. The caller is responsible for freeing the returned
2146 * value.
2147 */
2148char * wpa_config_get_no_key(struct wpa_ssid *ssid, const char *var)
2149{
2150 size_t i;
2151
2152 if (ssid == NULL || var == NULL)
2153 return NULL;
2154
2155 for (i = 0; i < NUM_SSID_FIELDS; i++) {
2156 const struct parse_data *field = &ssid_fields[i];
2157 if (os_strcmp(var, field->name) == 0) {
2158 char *res = field->writer(field, ssid);
2159 if (field->key_data) {
2160 if (res && res[0]) {
2161 wpa_printf(MSG_DEBUG, "Do not allow "
2162 "key_data field to be "
2163 "exposed");
2164 os_free(res);
2165 return os_strdup("*");
2166 }
2167
2168 os_free(res);
2169 return NULL;
2170 }
2171 return res;
2172 }
2173 }
2174
2175 return NULL;
2176}
2177#endif /* NO_CONFIG_WRITE */
2178
2179
2180/**
2181 * wpa_config_update_psk - Update WPA PSK based on passphrase and SSID
2182 * @ssid: Pointer to network configuration data
2183 *
2184 * This function must be called to update WPA PSK when either SSID or the
2185 * passphrase has changed for the network configuration.
2186 */
2187void wpa_config_update_psk(struct wpa_ssid *ssid)
2188{
2189#ifndef CONFIG_NO_PBKDF2
2190 pbkdf2_sha1(ssid->passphrase,
2191 (char *) ssid->ssid, ssid->ssid_len, 4096,
2192 ssid->psk, PMK_LEN);
2193 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
2194 ssid->psk, PMK_LEN);
2195 ssid->psk_set = 1;
2196#endif /* CONFIG_NO_PBKDF2 */
2197}
2198
2199
2200#ifndef CONFIG_NO_CONFIG_BLOBS
2201/**
2202 * wpa_config_get_blob - Get a named configuration blob
2203 * @config: Configuration data from wpa_config_read()
2204 * @name: Name of the blob
2205 * Returns: Pointer to blob data or %NULL if not found
2206 */
2207const struct wpa_config_blob * wpa_config_get_blob(struct wpa_config *config,
2208 const char *name)
2209{
2210 struct wpa_config_blob *blob = config->blobs;
2211
2212 while (blob) {
2213 if (os_strcmp(blob->name, name) == 0)
2214 return blob;
2215 blob = blob->next;
2216 }
2217 return NULL;
2218}
2219
2220
2221/**
2222 * wpa_config_set_blob - Set or add a named configuration blob
2223 * @config: Configuration data from wpa_config_read()
2224 * @blob: New value for the blob
2225 *
2226 * Adds a new configuration blob or replaces the current value of an existing
2227 * blob.
2228 */
2229void wpa_config_set_blob(struct wpa_config *config,
2230 struct wpa_config_blob *blob)
2231{
2232 wpa_config_remove_blob(config, blob->name);
2233 blob->next = config->blobs;
2234 config->blobs = blob;
2235}
2236
2237
2238/**
2239 * wpa_config_free_blob - Free blob data
2240 * @blob: Pointer to blob to be freed
2241 */
2242void wpa_config_free_blob(struct wpa_config_blob *blob)
2243{
2244 if (blob) {
2245 os_free(blob->name);
2246 os_free(blob->data);
2247 os_free(blob);
2248 }
2249}
2250
2251
2252/**
2253 * wpa_config_remove_blob - Remove a named configuration blob
2254 * @config: Configuration data from wpa_config_read()
2255 * @name: Name of the blob to remove
2256 * Returns: 0 if blob was removed or -1 if blob was not found
2257 */
2258int wpa_config_remove_blob(struct wpa_config *config, const char *name)
2259{
2260 struct wpa_config_blob *pos = config->blobs, *prev = NULL;
2261
2262 while (pos) {
2263 if (os_strcmp(pos->name, name) == 0) {
2264 if (prev)
2265 prev->next = pos->next;
2266 else
2267 config->blobs = pos->next;
2268 wpa_config_free_blob(pos);
2269 return 0;
2270 }
2271 prev = pos;
2272 pos = pos->next;
2273 }
2274
2275 return -1;
2276}
2277#endif /* CONFIG_NO_CONFIG_BLOBS */
2278
2279
2280/**
2281 * wpa_config_alloc_empty - Allocate an empty configuration
2282 * @ctrl_interface: Control interface parameters, e.g., path to UNIX domain
2283 * socket
2284 * @driver_param: Driver parameters
2285 * Returns: Pointer to allocated configuration data or %NULL on failure
2286 */
2287struct wpa_config * wpa_config_alloc_empty(const char *ctrl_interface,
2288 const char *driver_param)
2289{
2290 struct wpa_config *config;
2291
2292 config = os_zalloc(sizeof(*config));
2293 if (config == NULL)
2294 return NULL;
2295 config->eapol_version = DEFAULT_EAPOL_VERSION;
2296 config->ap_scan = DEFAULT_AP_SCAN;
2297 config->fast_reauth = DEFAULT_FAST_REAUTH;
e3768e7c 2298 config->p2p_go_intent = DEFAULT_P2P_GO_INTENT;
0f66abd2 2299 config->p2p_intra_bss = DEFAULT_P2P_INTRA_BSS;
c9c38b09 2300 config->bss_max_count = DEFAULT_BSS_MAX_COUNT;
78633c37
SL		 2301 config->bss_expiration_age = DEFAULT_BSS_EXPIRATION_AGE;
2302 config->bss_expiration_scan_count = DEFAULT_BSS_EXPIRATION_SCAN_COUNT;
dae608d5 2303 config->max_num_sta = DEFAULT_MAX_NUM_STA;
11540c0b 2304 config->access_network_type = DEFAULT_ACCESS_NETWORK_TYPE;
6fc6879b
JM		 2305
2306 if (ctrl_interface)
2307 config->ctrl_interface = os_strdup(ctrl_interface);
2308 if (driver_param)
2309 config->driver_param = os_strdup(driver_param);
2310
2311 return config;
2312}
2313
2314
2315#ifndef CONFIG_NO_STDOUT_DEBUG
2316/**
2317 * wpa_config_debug_dump_networks - Debug dump of configured networks
2318 * @config: Configuration data from wpa_config_read()
2319 */
2320void wpa_config_debug_dump_networks(struct wpa_config *config)
2321{
2322 int prio;
2323 struct wpa_ssid *ssid;
2324
2325 for (prio = 0; prio < config->num_prio; prio++) {
2326 ssid = config->pssid[prio];
2327 wpa_printf(MSG_DEBUG, "Priority group %d",
2328 ssid->priority);
2329 while (ssid) {
2330 wpa_printf(MSG_DEBUG, " id=%d ssid='%s'",
2331 ssid->id,
2332 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2333 ssid = ssid->pnext;
2334 }
2335 }
2336}
2337#endif /* CONFIG_NO_STDOUT_DEBUG */
121adf9c
JM		 2338
2339
2340struct global_parse_data {
2341 char *name;
2342 int (*parser)(const struct global_parse_data *data,
2343 struct wpa_config *config, int line, const char *value);
2344 void *param1, *param2, *param3;
1d47214a 2345 unsigned int changed_flag;
121adf9c
JM		 2346};
2347
2348
2349static int wpa_global_config_parse_int(const struct global_parse_data *data,
2350 struct wpa_config *config, int line,
2351 const char *pos)
2352{
2353 int *dst;
2354 dst = (int *) (((u8 *) config) + (long) data->param1);
2355 *dst = atoi(pos);
2356 wpa_printf(MSG_DEBUG, "%s=%d", data->name, *dst);
2357
2358 if (data->param2 && *dst < (long) data->param2) {
2359 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
2360 "min_value=%ld)", line, data->name, *dst,
2361 (long) data->param2);
2362 *dst = (long) data->param2;
2363 return -1;
2364 }
2365
2366 if (data->param3 && *dst > (long) data->param3) {
2367 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
2368 "max_value=%ld)", line, data->name, *dst,
2369 (long) data->param3);
2370 *dst = (long) data->param3;
2371 return -1;
2372 }
2373
2374 return 0;
2375}
2376
2377
2378static int wpa_global_config_parse_str(const struct global_parse_data *data,
2379 struct wpa_config *config, int line,
2380 const char *pos)
2381{
2382 size_t len;
2383 char **dst, *tmp;
2384
2385 len = os_strlen(pos);
2386 if (data->param2 && len < (size_t) data->param2) {
2387 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
2388 "min_len=%ld)", line, data->name,
2389 (unsigned long) len, (long) data->param2);
2390 return -1;
2391 }
2392
2393 if (data->param3 && len > (size_t) data->param3) {
2394 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
2395 "max_len=%ld)", line, data->name,
2396 (unsigned long) len, (long) data->param3);
2397 return -1;
2398 }
2399
2400 tmp = os_strdup(pos);
2401 if (tmp == NULL)
2402 return -1;
2403
2404 dst = (char **) (((u8 *) config) + (long) data->param1);
2405 os_free(*dst);
2406 *dst = tmp;
2407 wpa_printf(MSG_DEBUG, "%s='%s'", data->name, *dst);
2408
2409 return 0;
2410}
2411
2412
2413static int wpa_config_process_country(const struct global_parse_data *data,
2414 struct wpa_config *config, int line,
2415 const char *pos)
2416{
2417 if (!pos[0] || !pos[1]) {
2418 wpa_printf(MSG_DEBUG, "Invalid country set");
2419 return -1;
2420 }
2421 config->country[0] = pos[0];
2422 config->country[1] = pos[1];
2423 wpa_printf(MSG_DEBUG, "country='%c%c'",
2424 config->country[0], config->country[1]);
2425 return 0;
2426}
2427
2428
2429static int wpa_config_process_load_dynamic_eap(
2430 const struct global_parse_data *data, struct wpa_config *config,
2431 int line, const char *so)
2432{
2433 int ret;
2434 wpa_printf(MSG_DEBUG, "load_dynamic_eap=%s", so);
2435 ret = eap_peer_method_load(so);
2436 if (ret == -2) {
2437 wpa_printf(MSG_DEBUG, "This EAP type was already loaded - not "
2438 "reloading.");
2439 } else if (ret) {
2440 wpa_printf(MSG_ERROR, "Line %d: Failed to load dynamic EAP "
2441 "method '%s'.", line, so);
2442 return -1;
2443 }
2444
2445 return 0;
2446}
2447
2448
2449#ifdef CONFIG_WPS
2450
2451static int wpa_config_process_uuid(const struct global_parse_data *data,
2452 struct wpa_config *config, int line,
2453 const char *pos)
2454{
2455 char buf[40];
2456 if (uuid_str2bin(pos, config->uuid)) {
2457 wpa_printf(MSG_ERROR, "Line %d: invalid UUID", line);
2458 return -1;
2459 }
2460 uuid_bin2str(config->uuid, buf, sizeof(buf));
2461 wpa_printf(MSG_DEBUG, "uuid=%s", buf);
2462 return 0;
2463}
2464
2465
2f646b6e
JB		 2466static int wpa_config_process_device_type(
2467 const struct global_parse_data *data,
2468 struct wpa_config *config, int line, const char *pos)
2469{
2470 return wps_dev_type_str2bin(pos, config->device_type);
2471}
2472
2473
121adf9c
JM		 2474static int wpa_config_process_os_version(const struct global_parse_data *data,
2475 struct wpa_config *config, int line,
2476 const char *pos)
2477{
2478 if (hexstr2bin(pos, config->os_version, 4)) {
2479 wpa_printf(MSG_ERROR, "Line %d: invalid os_version", line);
2480 return -1;
2481 }
2482 wpa_printf(MSG_DEBUG, "os_version=%08x",
2483 WPA_GET_BE32(config->os_version));
2484 return 0;
2485}
2486
2487#endif /* CONFIG_WPS */
2488
e3768e7c
JM		 2489#ifdef CONFIG_P2P
2490static int wpa_config_process_sec_device_type(
2491 const struct global_parse_data *data,
2492 struct wpa_config *config, int line, const char *pos)
2493{
2494 int idx;
2495
2f646b6e 2496 if (config->num_sec_device_types >= MAX_SEC_DEVICE_TYPES) {
e3768e7c
JM		 2497 wpa_printf(MSG_ERROR, "Line %d: too many sec_device_type "
2498 "items", line);
2499 return -1;
2500 }
2501
2f646b6e
JB		 2502 idx = config->num_sec_device_types;
2503
2504 if (wps_dev_type_str2bin(pos, config->sec_device_type[idx]))
e3768e7c 2505 return -1;
2f646b6e
JB		 2506
2507 config->num_sec_device_types++;
e3768e7c
JM		 2508 return 0;
2509}
2510#endif /* CONFIG_P2P */
2511
121adf9c 2512
46ee0427
JM		 2513static int wpa_config_process_hessid(
2514 const struct global_parse_data *data,
2515 struct wpa_config *config, int line, const char *pos)
2516{
2517 if (hwaddr_aton2(pos, config->hessid) < 0) {
2518 wpa_printf(MSG_ERROR, "Line %d: Invalid hessid '%s'",
2519 line, pos);
2520 return -1;
2521 }
2522
2523 return 0;
2524}
2525
2526
121adf9c
JM		 2527#ifdef OFFSET
2528#undef OFFSET
2529#endif /* OFFSET */
2530/* OFFSET: Get offset of a variable within the wpa_config structure */
2531#define OFFSET(v) ((void *) &((struct wpa_config *) 0)->v)
2532
2533#define FUNC(f) #f, wpa_config_process_ ## f, OFFSET(f), NULL, NULL
2534#define FUNC_NO_VAR(f) #f, wpa_config_process_ ## f, NULL, NULL, NULL
2535#define _INT(f) #f, wpa_global_config_parse_int, OFFSET(f)
2536#define INT(f) _INT(f), NULL, NULL
2537#define INT_RANGE(f, min, max) _INT(f), (void *) min, (void *) max
2538#define _STR(f) #f, wpa_global_config_parse_str, OFFSET(f)
2539#define STR(f) _STR(f), NULL, NULL
2540#define STR_RANGE(f, min, max) _STR(f), (void *) min, (void *) max
2541
2542static const struct global_parse_data global_fields[] = {
2543#ifdef CONFIG_CTRL_IFACE
1d47214a
JM		 2544 { STR(ctrl_interface), 0 },
2545 { STR(ctrl_interface_group), 0 } /* deprecated */,
121adf9c 2546#endif /* CONFIG_CTRL_IFACE */
1d47214a
JM		 2547 { INT_RANGE(eapol_version, 1, 2), 0 },
2548 { INT(ap_scan), 0 },
2549 { INT(fast_reauth), 0 },
2550 { STR(opensc_engine_path), 0 },
2551 { STR(pkcs11_engine_path), 0 },
2552 { STR(pkcs11_module_path), 0 },
2553 { STR(driver_param), 0 },
2554 { INT(dot11RSNAConfigPMKLifetime), 0 },
2555 { INT(dot11RSNAConfigPMKReauthThreshold), 0 },
2556 { INT(dot11RSNAConfigSATimeout), 0 },
121adf9c 2557#ifndef CONFIG_NO_CONFIG_WRITE
1d47214a 2558 { INT(update_config), 0 },
121adf9c 2559#endif /* CONFIG_NO_CONFIG_WRITE */
1d47214a 2560 { FUNC_NO_VAR(load_dynamic_eap), 0 },
121adf9c 2561#ifdef CONFIG_WPS
1d47214a
JM		 2562 { FUNC(uuid), CFG_CHANGED_UUID },
2563 { STR_RANGE(device_name, 0, 32), CFG_CHANGED_DEVICE_NAME },
1c9cb49f
JM		 2564 { STR_RANGE(manufacturer, 0, 64), CFG_CHANGED_WPS_STRING },
2565 { STR_RANGE(model_name, 0, 32), CFG_CHANGED_WPS_STRING },
2566 { STR_RANGE(model_number, 0, 32), CFG_CHANGED_WPS_STRING },
2567 { STR_RANGE(serial_number, 0, 32), CFG_CHANGED_WPS_STRING },
2f646b6e 2568 { FUNC(device_type), CFG_CHANGED_DEVICE_TYPE },
1d47214a
JM		 2569 { FUNC(os_version), CFG_CHANGED_OS_VERSION },
2570 { STR(config_methods), CFG_CHANGED_CONFIG_METHODS },
2571 { INT_RANGE(wps_cred_processing, 0, 2), 0 },
121adf9c 2572#endif /* CONFIG_WPS */
e3768e7c
JM		 2573#ifdef CONFIG_P2P
2574 { FUNC(sec_device_type), CFG_CHANGED_SEC_DEVICE_TYPE },
2575 { INT(p2p_listen_reg_class), 0 },
2576 { INT(p2p_listen_channel), 0 },
2577 { INT(p2p_oper_reg_class), 0 },
2578 { INT(p2p_oper_channel), 0 },
2579 { INT_RANGE(p2p_go_intent, 0, 15), 0 },
2580 { STR(p2p_ssid_postfix), CFG_CHANGED_P2P_SSID_POSTFIX },
2581 { INT_RANGE(persistent_reconnect, 0, 1), 0 },
0f66abd2 2582 { INT_RANGE(p2p_intra_bss, 0, 1), CFG_CHANGED_P2P_INTRA_BSS },
3071e181 2583 { INT(p2p_group_idle), 0 },
e3768e7c 2584#endif /* CONFIG_P2P */
1d47214a
JM		 2585 { FUNC(country), CFG_CHANGED_COUNTRY },
2586 { INT(bss_max_count), 0 },
78633c37
SL		 2587 { INT(bss_expiration_age), 0 },
2588 { INT(bss_expiration_scan_count), 0 },
dae608d5 2589 { INT_RANGE(filter_ssids, 0, 1), 0 },
0d7e5a3a 2590 { INT(max_num_sta), 0 },
46ee0427 2591 { INT_RANGE(disassoc_low_ack, 0, 1), 0 },
73c41a8f 2592 { STR(home_realm), 0 },
67e1b984
JM		 2593 { STR(home_username), 0 },
2594 { STR(home_password), 0 },
2595 { STR(home_ca_cert), 0 },
3b840b67
JM		 2596 { STR(home_imsi), 0 },
2597 { STR(home_milenage), 0 },
00bf219d 2598 { STR(home_domain), 0 },
46ee0427 2599 { INT_RANGE(interworking, 0, 1), 0 },
11540c0b
JM		 2600 { FUNC(hessid), 0 },
2601 { INT_RANGE(access_network_type, 0, 15), 0 }
121adf9c
JM		 2602};
2603
2604#undef FUNC
2605#undef _INT
2606#undef INT
2607#undef INT_RANGE
2608#undef _STR
2609#undef STR
2610#undef STR_RANGE
2611#define NUM_GLOBAL_FIELDS (sizeof(global_fields) / sizeof(global_fields[0]))
2612
2613
2614int wpa_config_process_global(struct wpa_config *config, char *pos, int line)
2615{
2616 size_t i;
2617 int ret = 0;
2618
2619 for (i = 0; i < NUM_GLOBAL_FIELDS; i++) {
2620 const struct global_parse_data *field = &global_fields[i];
2621 size_t flen = os_strlen(field->name);
2622 if (os_strncmp(pos, field->name, flen) != 0 ||
2623 pos[flen] != '=')
2624 continue;
2625
2626 if (field->parser(field, config, line, pos + flen + 1)) {
2627 wpa_printf(MSG_ERROR, "Line %d: failed to "
2628 "parse '%s'.", line, pos);
2629 ret = -1;
2630 }
1d47214a 2631 config->changed_parameters |= field->changed_flag;
121adf9c
JM		 2632 break;
2633 }
2634 if (i == NUM_GLOBAL_FIELDS) {
1d47214a
JM		 2635 if (line < 0)
2636 return -1;
121adf9c
JM		 2637 wpa_printf(MSG_ERROR, "Line %d: unknown global field '%s'.",
2638 line, pos);
2639 ret = -1;
2640 }
2641
2642 return ret;
2643}
Unnamed repository; edit this file 'description' to name the repository.