2 * WPA Supplicant / Configuration parser and common functions
3 * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
18 #include "utils/uuid.h"
19 #include "crypto/sha1.h"
20 #include "rsn_supp/wpa.h"
21 #include "eap_peer/eap.h"
25 #if !defined(CONFIG_CTRL_IFACE) && defined(CONFIG_NO_CONFIG_WRITE)
26 #define NO_CONFIG_WRITE
30 * Structure for network configuration parsing. This data is used to implement
31 * a generic parser for each network block variable. The table of configuration
32 * variables is defined below in this file (ssid_fields[]).
35 /* Configuration variable name */
38 /* Parser function for this variable */
39 int (*parser
)(const struct parse_data
*data
, struct wpa_ssid
*ssid
,
40 int line
, const char *value
);
42 #ifndef NO_CONFIG_WRITE
43 /* Writer function (i.e., to get the variable in text format from
44 * internal presentation). */
45 char * (*writer
)(const struct parse_data
*data
, struct wpa_ssid
*ssid
);
46 #endif /* NO_CONFIG_WRITE */
48 /* Variable specific parameters for the parser. */
49 void *param1
, *param2
, *param3
, *param4
;
51 /* 0 = this variable can be included in debug output and ctrl_iface
52 * 1 = this variable contains key/private data and it must not be
53 * included in debug output unless explicitly requested. In
54 * addition, this variable will not be readable through the
61 static char * wpa_config_parse_string(const char *value
, size_t *len
)
67 pos
= os_strrchr(value
, '"');
68 if (pos
== NULL
|| pos
[1] != '\0')
71 str
= os_malloc(*len
+ 1);
74 os_memcpy(str
, value
, *len
);
79 size_t tlen
, hlen
= os_strlen(value
);
83 str
= os_malloc(tlen
+ 1);
86 if (hexstr2bin(value
, str
, tlen
)) {
97 static int wpa_config_parse_str(const struct parse_data
*data
,
98 struct wpa_ssid
*ssid
,
99 int line
, const char *value
)
101 size_t res_len
, *dst_len
;
104 if (os_strcmp(value
, "NULL") == 0) {
105 wpa_printf(MSG_DEBUG
, "Unset configuration string '%s'",
112 tmp
= wpa_config_parse_string(value
, &res_len
);
114 wpa_printf(MSG_ERROR
, "Line %d: failed to parse %s '%s'.",
116 data
->key_data
? "[KEY DATA REMOVED]" : value
);
120 if (data
->key_data
) {
121 wpa_hexdump_ascii_key(MSG_MSGDUMP
, data
->name
,
122 (u8
*) tmp
, res_len
);
124 wpa_hexdump_ascii(MSG_MSGDUMP
, data
->name
,
125 (u8
*) tmp
, res_len
);
128 if (data
->param3
&& res_len
< (size_t) data
->param3
) {
129 wpa_printf(MSG_ERROR
, "Line %d: too short %s (len=%lu "
130 "min_len=%ld)", line
, data
->name
,
131 (unsigned long) res_len
, (long) data
->param3
);
136 if (data
->param4
&& res_len
> (size_t) data
->param4
) {
137 wpa_printf(MSG_ERROR
, "Line %d: too long %s (len=%lu "
138 "max_len=%ld)", line
, data
->name
,
139 (unsigned long) res_len
, (long) data
->param4
);
145 dst
= (char **) (((u8
*) ssid
) + (long) data
->param1
);
146 dst_len
= (size_t *) (((u8
*) ssid
) + (long) data
->param2
);
156 #ifndef NO_CONFIG_WRITE
157 static int is_hex(const u8
*data
, size_t len
)
161 for (i
= 0; i
< len
; i
++) {
162 if (data
[i
] < 32 || data
[i
] >= 127)
169 static char * wpa_config_write_string_ascii(const u8
*value
, size_t len
)
173 buf
= os_malloc(len
+ 3);
177 os_memcpy(buf
+ 1, value
, len
);
185 static char * wpa_config_write_string_hex(const u8
*value
, size_t len
)
189 buf
= os_zalloc(2 * len
+ 1);
192 wpa_snprintf_hex(buf
, 2 * len
+ 1, value
, len
);
198 static char * wpa_config_write_string(const u8
*value
, size_t len
)
203 if (is_hex(value
, len
))
204 return wpa_config_write_string_hex(value
, len
);
206 return wpa_config_write_string_ascii(value
, len
);
210 static char * wpa_config_write_str(const struct parse_data
*data
,
211 struct wpa_ssid
*ssid
)
216 src
= (char **) (((u8
*) ssid
) + (long) data
->param1
);
221 len
= *((size_t *) (((u8
*) ssid
) + (long) data
->param2
));
223 len
= os_strlen(*src
);
225 return wpa_config_write_string((const u8
*) *src
, len
);
227 #endif /* NO_CONFIG_WRITE */
230 static int wpa_config_parse_int(const struct parse_data
*data
,
231 struct wpa_ssid
*ssid
,
232 int line
, const char *value
)
236 dst
= (int *) (((u8
*) ssid
) + (long) data
->param1
);
238 wpa_printf(MSG_MSGDUMP
, "%s=%d (0x%x)", data
->name
, *dst
, *dst
);
240 if (data
->param3
&& *dst
< (long) data
->param3
) {
241 wpa_printf(MSG_ERROR
, "Line %d: too small %s (value=%d "
242 "min_value=%ld)", line
, data
->name
, *dst
,
243 (long) data
->param3
);
244 *dst
= (long) data
->param3
;
248 if (data
->param4
&& *dst
> (long) data
->param4
) {
249 wpa_printf(MSG_ERROR
, "Line %d: too large %s (value=%d "
250 "max_value=%ld)", line
, data
->name
, *dst
,
251 (long) data
->param4
);
252 *dst
= (long) data
->param4
;
260 #ifndef NO_CONFIG_WRITE
261 static char * wpa_config_write_int(const struct parse_data
*data
,
262 struct wpa_ssid
*ssid
)
267 src
= (int *) (((u8
*) ssid
) + (long) data
->param1
);
269 value
= os_malloc(20);
272 res
= os_snprintf(value
, 20, "%d", *src
);
273 if (res
< 0 || res
>= 20) {
277 value
[20 - 1] = '\0';
280 #endif /* NO_CONFIG_WRITE */
283 static int wpa_config_parse_bssid(const struct parse_data
*data
,
284 struct wpa_ssid
*ssid
, int line
,
287 if (hwaddr_aton(value
, ssid
->bssid
)) {
288 wpa_printf(MSG_ERROR
, "Line %d: Invalid BSSID '%s'.",
293 wpa_hexdump(MSG_MSGDUMP
, "BSSID", ssid
->bssid
, ETH_ALEN
);
298 #ifndef NO_CONFIG_WRITE
299 static char * wpa_config_write_bssid(const struct parse_data
*data
,
300 struct wpa_ssid
*ssid
)
305 if (!ssid
->bssid_set
)
308 value
= os_malloc(20);
311 res
= os_snprintf(value
, 20, MACSTR
, MAC2STR(ssid
->bssid
));
312 if (res
< 0 || res
>= 20) {
316 value
[20 - 1] = '\0';
319 #endif /* NO_CONFIG_WRITE */
322 static int wpa_config_parse_psk(const struct parse_data
*data
,
323 struct wpa_ssid
*ssid
, int line
,
327 #ifndef CONFIG_NO_PBKDF2
332 pos
= os_strrchr(value
, '"');
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
);
343 wpa_hexdump_ascii_key(MSG_MSGDUMP
, "PSK (ASCII passphrase)",
345 if (ssid
->passphrase
&& os_strlen(ssid
->passphrase
) == len
&&
346 os_memcmp(ssid
->passphrase
, value
, len
) == 0)
349 os_free(ssid
->passphrase
);
350 ssid
->passphrase
= os_malloc(len
+ 1);
351 if (ssid
->passphrase
== NULL
)
353 os_memcpy(ssid
->passphrase
, value
, len
);
354 ssid
->passphrase
[len
] = '\0';
356 #else /* CONFIG_NO_PBKDF2 */
357 wpa_printf(MSG_ERROR
, "Line %d: ASCII passphrase not "
360 #endif /* CONFIG_NO_PBKDF2 */
363 if (hexstr2bin(value
, ssid
->psk
, PMK_LEN
) ||
364 value
[PMK_LEN
* 2] != '\0') {
365 wpa_printf(MSG_ERROR
, "Line %d: Invalid PSK '%s'.",
370 os_free(ssid
->passphrase
);
371 ssid
->passphrase
= NULL
;
374 wpa_hexdump_key(MSG_MSGDUMP
, "PSK", ssid
->psk
, PMK_LEN
);
379 #ifndef NO_CONFIG_WRITE
380 static char * wpa_config_write_psk(const struct parse_data
*data
,
381 struct wpa_ssid
*ssid
)
383 if (ssid
->passphrase
)
384 return wpa_config_write_string_ascii(
385 (const u8
*) ssid
->passphrase
,
386 os_strlen(ssid
->passphrase
));
389 return wpa_config_write_string_hex(ssid
->psk
, PMK_LEN
);
393 #endif /* NO_CONFIG_WRITE */
396 static int wpa_config_parse_proto(const struct parse_data
*data
,
397 struct wpa_ssid
*ssid
, int line
,
400 int val
= 0, last
, errors
= 0;
401 char *start
, *end
, *buf
;
403 buf
= os_strdup(value
);
408 while (*start
!= '\0') {
409 while (*start
== ' ' || *start
== '\t')
414 while (*end
!= ' ' && *end
!= '\t' && *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
;
424 wpa_printf(MSG_ERROR
, "Line %d: invalid proto '%s'",
436 wpa_printf(MSG_ERROR
,
437 "Line %d: no proto values configured.", line
);
441 wpa_printf(MSG_MSGDUMP
, "proto: 0x%x", val
);
443 return errors
? -1 : 0;
447 #ifndef NO_CONFIG_WRITE
448 static char * wpa_config_write_proto(const struct parse_data
*data
,
449 struct wpa_ssid
*ssid
)
452 char *buf
, *pos
, *end
;
454 pos
= buf
= os_zalloc(10);
459 if (ssid
->proto
& WPA_PROTO_WPA
) {
460 ret
= os_snprintf(pos
, end
- pos
, "%sWPA", first
? "" : " ");
461 if (ret
< 0 || ret
>= end
- pos
)
467 if (ssid
->proto
& WPA_PROTO_RSN
) {
468 ret
= os_snprintf(pos
, end
- pos
, "%sRSN", first
? "" : " ");
469 if (ret
< 0 || ret
>= end
- pos
)
477 #endif /* NO_CONFIG_WRITE */
480 static int wpa_config_parse_key_mgmt(const struct parse_data
*data
,
481 struct wpa_ssid
*ssid
, int line
,
484 int val
= 0, last
, errors
= 0;
485 char *start
, *end
, *buf
;
487 buf
= os_strdup(value
);
492 while (*start
!= '\0') {
493 while (*start
== ' ' || *start
== '\t')
498 while (*end
!= ' ' && *end
!= '\t' && *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 */
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 */
525 else if (os_strcmp(start
, "WPS") == 0)
526 val
|= WPA_KEY_MGMT_WPS
;
527 #endif /* CONFIG_WPS */
529 wpa_printf(MSG_ERROR
, "Line %d: invalid key_mgmt '%s'",
541 wpa_printf(MSG_ERROR
,
542 "Line %d: no key_mgmt values configured.", line
);
546 wpa_printf(MSG_MSGDUMP
, "key_mgmt: 0x%x", val
);
547 ssid
->key_mgmt
= val
;
548 return errors
? -1 : 0;
552 #ifndef NO_CONFIG_WRITE
553 static char * wpa_config_write_key_mgmt(const struct parse_data
*data
,
554 struct wpa_ssid
*ssid
)
556 char *buf
, *pos
, *end
;
559 pos
= buf
= os_zalloc(50);
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
) {
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
) {
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
) {
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
) {
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
) {
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
? "" : " ");
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 */
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
? "" : " ");
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 */
635 if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)
636 pos
+= os_snprintf(pos
, end
- pos
, "%sWPS",
637 pos
== buf
? "" : " ");
638 #endif /* CONFIG_WPS */
642 #endif /* NO_CONFIG_WRITE */
645 static int wpa_config_parse_cipher(int line
, const char *value
)
648 char *start
, *end
, *buf
;
650 buf
= os_strdup(value
);
655 while (*start
!= '\0') {
656 while (*start
== ' ' || *start
== '\t')
661 while (*end
!= ' ' && *end
!= '\t' && *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
;
676 wpa_printf(MSG_ERROR
, "Line %d: invalid cipher '%s'.",
689 wpa_printf(MSG_ERROR
, "Line %d: no cipher values configured.",
697 #ifndef NO_CONFIG_WRITE
698 static char * wpa_config_write_cipher(int cipher
)
700 char *buf
, *pos
, *end
;
703 pos
= buf
= os_zalloc(50);
708 if (cipher
& WPA_CIPHER_CCMP
) {
709 ret
= os_snprintf(pos
, end
- pos
, "%sCCMP",
710 pos
== buf
? "" : " ");
711 if (ret
< 0 || ret
>= end
- pos
) {
718 if (cipher
& WPA_CIPHER_TKIP
) {
719 ret
= os_snprintf(pos
, end
- pos
, "%sTKIP",
720 pos
== buf
? "" : " ");
721 if (ret
< 0 || ret
>= end
- pos
) {
728 if (cipher
& WPA_CIPHER_WEP104
) {
729 ret
= os_snprintf(pos
, end
- pos
, "%sWEP104",
730 pos
== buf
? "" : " ");
731 if (ret
< 0 || ret
>= end
- pos
) {
738 if (cipher
& WPA_CIPHER_WEP40
) {
739 ret
= os_snprintf(pos
, end
- pos
, "%sWEP40",
740 pos
== buf
? "" : " ");
741 if (ret
< 0 || ret
>= end
- pos
) {
748 if (cipher
& WPA_CIPHER_NONE
) {
749 ret
= os_snprintf(pos
, end
- pos
, "%sNONE",
750 pos
== buf
? "" : " ");
751 if (ret
< 0 || ret
>= end
- pos
) {
760 #endif /* NO_CONFIG_WRITE */
763 static int wpa_config_parse_pairwise(const struct parse_data
*data
,
764 struct wpa_ssid
*ssid
, int line
,
768 val
= wpa_config_parse_cipher(line
, value
);
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
);
777 wpa_printf(MSG_MSGDUMP
, "pairwise: 0x%x", val
);
778 ssid
->pairwise_cipher
= val
;
783 #ifndef NO_CONFIG_WRITE
784 static char * wpa_config_write_pairwise(const struct parse_data
*data
,
785 struct wpa_ssid
*ssid
)
787 return wpa_config_write_cipher(ssid
->pairwise_cipher
);
789 #endif /* NO_CONFIG_WRITE */
792 static int wpa_config_parse_group(const struct parse_data
*data
,
793 struct wpa_ssid
*ssid
, int line
,
797 val
= wpa_config_parse_cipher(line
, value
);
800 if (val
& ~(WPA_CIPHER_CCMP
| WPA_CIPHER_TKIP
| WPA_CIPHER_WEP104
|
802 wpa_printf(MSG_ERROR
, "Line %d: not allowed group cipher "
803 "(0x%x).", line
, val
);
807 wpa_printf(MSG_MSGDUMP
, "group: 0x%x", val
);
808 ssid
->group_cipher
= val
;
813 #ifndef NO_CONFIG_WRITE
814 static char * wpa_config_write_group(const struct parse_data
*data
,
815 struct wpa_ssid
*ssid
)
817 return wpa_config_write_cipher(ssid
->group_cipher
);
819 #endif /* NO_CONFIG_WRITE */
822 static int wpa_config_parse_auth_alg(const struct parse_data
*data
,
823 struct wpa_ssid
*ssid
, int line
,
826 int val
= 0, last
, errors
= 0;
827 char *start
, *end
, *buf
;
829 buf
= os_strdup(value
);
834 while (*start
!= '\0') {
835 while (*start
== ' ' || *start
== '\t')
840 while (*end
!= ' ' && *end
!= '\t' && *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
;
851 wpa_printf(MSG_ERROR
, "Line %d: invalid auth_alg '%s'",
863 wpa_printf(MSG_ERROR
,
864 "Line %d: no auth_alg values configured.", line
);
868 wpa_printf(MSG_MSGDUMP
, "auth_alg: 0x%x", val
);
869 ssid
->auth_alg
= val
;
870 return errors
? -1 : 0;
874 #ifndef NO_CONFIG_WRITE
875 static char * wpa_config_write_auth_alg(const struct parse_data
*data
,
876 struct wpa_ssid
*ssid
)
878 char *buf
, *pos
, *end
;
881 pos
= buf
= os_zalloc(30);
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
) {
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
) {
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
) {
918 #endif /* NO_CONFIG_WRITE */
921 static int * wpa_config_parse_freqs(const struct parse_data
*data
,
922 struct wpa_ssid
*ssid
, int line
,
931 freqs
= os_zalloc((len
+ 1) * sizeof(int));
942 n
= os_realloc(freqs
, (len
* 2 + 1) * sizeof(int));
947 for (i
= len
; i
<= len
* 2; i
++)
953 freqs
[used
] = atoi(pos
);
954 if (freqs
[used
] == 0)
957 pos
= os_strchr(pos
+ 1, ' ');
964 static int wpa_config_parse_scan_freq(const struct parse_data
*data
,
965 struct wpa_ssid
*ssid
, int line
,
970 freqs
= wpa_config_parse_freqs(data
, ssid
, line
, value
);
973 os_free(ssid
->scan_freq
);
974 ssid
->scan_freq
= freqs
;
980 static int wpa_config_parse_freq_list(const struct parse_data
*data
,
981 struct wpa_ssid
*ssid
, int line
,
986 freqs
= wpa_config_parse_freqs(data
, ssid
, line
, value
);
989 os_free(ssid
->freq_list
);
990 ssid
->freq_list
= freqs
;
996 #ifndef NO_CONFIG_WRITE
997 static char * wpa_config_write_freqs(const struct parse_data
*data
,
1000 char *buf
, *pos
, *end
;
1008 for (i
= 0; freqs
[i
]; i
++)
1011 pos
= buf
= os_zalloc(10 * count
+ 1);
1014 end
= buf
+ 10 * count
+ 1;
1016 for (i
= 0; freqs
[i
]; i
++) {
1017 ret
= os_snprintf(pos
, end
- pos
, "%s%u",
1018 i
== 0 ? "" : " ", freqs
[i
]);
1019 if (ret
< 0 || ret
>= end
- pos
) {
1030 static char * wpa_config_write_scan_freq(const struct parse_data
*data
,
1031 struct wpa_ssid
*ssid
)
1033 return wpa_config_write_freqs(data
, ssid
->scan_freq
);
1037 static char * wpa_config_write_freq_list(const struct parse_data
*data
,
1038 struct wpa_ssid
*ssid
)
1040 return wpa_config_write_freqs(data
, ssid
->freq_list
);
1042 #endif /* NO_CONFIG_WRITE */
1045 #ifdef IEEE8021X_EAPOL
1046 static int wpa_config_parse_eap(const struct parse_data
*data
,
1047 struct wpa_ssid
*ssid
, int line
,
1050 int last
, errors
= 0;
1051 char *start
, *end
, *buf
;
1052 struct eap_method_type
*methods
= NULL
, *tmp
;
1053 size_t num_methods
= 0;
1055 buf
= os_strdup(value
);
1060 while (*start
!= '\0') {
1061 while (*start
== ' ' || *start
== '\t')
1066 while (*end
!= ' ' && *end
!= '\t' && *end
!= '\0')
1068 last
= *end
== '\0';
1071 methods
= os_realloc(methods
,
1072 (num_methods
+ 1) * sizeof(*methods
));
1073 if (methods
== NULL
) {
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.");
1089 } else if (methods
[num_methods
].vendor
== EAP_VENDOR_IETF
&&
1090 methods
[num_methods
].method
== EAP_TYPE_LEAP
)
1102 methods
= os_realloc(methods
, (num_methods
+ 1) * sizeof(*methods
));
1103 if (methods
== NULL
) {
1107 methods
[num_methods
].vendor
= EAP_VENDOR_IETF
;
1108 methods
[num_methods
].method
= EAP_TYPE_NONE
;
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;
1118 static char * wpa_config_write_eap(const struct parse_data
*data
,
1119 struct wpa_ssid
*ssid
)
1122 char *buf
, *pos
, *end
;
1123 const struct eap_method_type
*eap_methods
= ssid
->eap
.eap_methods
;
1126 if (eap_methods
== NULL
)
1129 pos
= buf
= os_zalloc(100);
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
);
1139 ret
= os_snprintf(pos
, end
- pos
, "%s%s",
1140 pos
== buf
? "" : " ", name
);
1141 if (ret
< 0 || ret
>= end
- pos
)
1153 static int wpa_config_parse_password(const struct parse_data
*data
,
1154 struct wpa_ssid
*ssid
, int line
,
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;
1167 if (os_strncmp(value
, "hash:", 5) != 0) {
1171 tmp
= wpa_config_parse_string(value
, &res_len
);
1173 wpa_printf(MSG_ERROR
, "Line %d: failed to parse "
1177 wpa_hexdump_ascii_key(MSG_MSGDUMP
, data
->name
,
1178 (u8
*) tmp
, res_len
);
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
;
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
);
1196 hash
= os_malloc(16);
1200 if (hexstr2bin(value
+ 5, hash
, 16)) {
1202 wpa_printf(MSG_ERROR
, "Line %d: Invalid password hash", line
);
1206 wpa_hexdump_key(MSG_MSGDUMP
, data
->name
, hash
, 16);
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
;
1217 static char * wpa_config_write_password(const struct parse_data
*data
,
1218 struct wpa_ssid
*ssid
)
1222 if (ssid
->eap
.password
== NULL
)
1225 if (!(ssid
->eap
.flags
& EAP_CONFIG_FLAGS_PASSWORD_NTHASH
)) {
1226 return wpa_config_write_string(
1227 ssid
->eap
.password
, ssid
->eap
.password_len
);
1230 buf
= os_malloc(5 + 32 + 1);
1234 os_memcpy(buf
, "hash:", 5);
1235 wpa_snprintf_hex(buf
+ 5, 32 + 1, ssid
->eap
.password
, 16);
1239 #endif /* IEEE8021X_EAPOL */
1242 static int wpa_config_parse_wep_key(u8
*key
, size_t *len
, int line
,
1243 const char *value
, int idx
)
1245 char *buf
, title
[20];
1248 buf
= wpa_config_parse_string(value
, len
);
1250 wpa_printf(MSG_ERROR
, "Line %d: Invalid WEP key %d '%s'.",
1254 if (*len
> MAX_WEP_KEY_LEN
) {
1255 wpa_printf(MSG_ERROR
, "Line %d: Too long WEP key %d '%s'.",
1260 os_memcpy(key
, buf
, *len
);
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
);
1269 static int wpa_config_parse_wep_key0(const struct parse_data
*data
,
1270 struct wpa_ssid
*ssid
, int line
,
1273 return wpa_config_parse_wep_key(ssid
->wep_key
[0],
1274 &ssid
->wep_key_len
[0], line
,
1279 static int wpa_config_parse_wep_key1(const struct parse_data
*data
,
1280 struct wpa_ssid
*ssid
, int line
,
1283 return wpa_config_parse_wep_key(ssid
->wep_key
[1],
1284 &ssid
->wep_key_len
[1], line
,
1289 static int wpa_config_parse_wep_key2(const struct parse_data
*data
,
1290 struct wpa_ssid
*ssid
, int line
,
1293 return wpa_config_parse_wep_key(ssid
->wep_key
[2],
1294 &ssid
->wep_key_len
[2], line
,
1299 static int wpa_config_parse_wep_key3(const struct parse_data
*data
,
1300 struct wpa_ssid
*ssid
, int line
,
1303 return wpa_config_parse_wep_key(ssid
->wep_key
[3],
1304 &ssid
->wep_key_len
[3], line
,
1309 #ifndef NO_CONFIG_WRITE
1310 static char * wpa_config_write_wep_key(struct wpa_ssid
*ssid
, int idx
)
1312 if (ssid
->wep_key_len
[idx
] == 0)
1314 return wpa_config_write_string(ssid
->wep_key
[idx
],
1315 ssid
->wep_key_len
[idx
]);
1319 static char * wpa_config_write_wep_key0(const struct parse_data
*data
,
1320 struct wpa_ssid
*ssid
)
1322 return wpa_config_write_wep_key(ssid
, 0);
1326 static char * wpa_config_write_wep_key1(const struct parse_data
*data
,
1327 struct wpa_ssid
*ssid
)
1329 return wpa_config_write_wep_key(ssid
, 1);
1333 static char * wpa_config_write_wep_key2(const struct parse_data
*data
,
1334 struct wpa_ssid
*ssid
)
1336 return wpa_config_write_wep_key(ssid
, 2);
1340 static char * wpa_config_write_wep_key3(const struct parse_data
*data
,
1341 struct wpa_ssid
*ssid
)
1343 return wpa_config_write_wep_key(ssid
, 3);
1345 #endif /* NO_CONFIG_WRITE */
1348 /* Helper macros for network block parser */
1353 /* OFFSET: Get offset of a variable within the wpa_ssid structure */
1354 #define OFFSET(v) ((void *) &((struct wpa_ssid *) 0)->v)
1356 /* STR: Define a string variable for an ASCII string; f = field name */
1357 #ifdef NO_CONFIG_WRITE
1358 #define _STR(f) #f, wpa_config_parse_str, OFFSET(f)
1359 #define _STRe(f) #f, wpa_config_parse_str, OFFSET(eap.f)
1360 #else /* NO_CONFIG_WRITE */
1361 #define _STR(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(f)
1362 #define _STRe(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(eap.f)
1363 #endif /* NO_CONFIG_WRITE */
1364 #define STR(f) _STR(f), NULL, NULL, NULL, 0
1365 #define STRe(f) _STRe(f), NULL, NULL, NULL, 0
1366 #define STR_KEY(f) _STR(f), NULL, NULL, NULL, 1
1367 #define STR_KEYe(f) _STRe(f), NULL, NULL, NULL, 1
1369 /* STR_LEN: Define a string variable with a separate variable for storing the
1370 * data length. Unlike STR(), this can be used to store arbitrary binary data
1371 * (i.e., even nul termination character). */
1372 #define _STR_LEN(f) _STR(f), OFFSET(f ## _len)
1373 #define _STR_LENe(f) _STRe(f), OFFSET(eap.f ## _len)
1374 #define STR_LEN(f) _STR_LEN(f), NULL, NULL, 0
1375 #define STR_LENe(f) _STR_LENe(f), NULL, NULL, 0
1376 #define STR_LEN_KEY(f) _STR_LEN(f), NULL, NULL, 1
1378 /* STR_RANGE: Like STR_LEN(), but with minimum and maximum allowed length
1379 * explicitly specified. */
1380 #define _STR_RANGE(f, min, max) _STR_LEN(f), (void *) (min), (void *) (max)
1381 #define STR_RANGE(f, min, max) _STR_RANGE(f, min, max), 0
1382 #define STR_RANGE_KEY(f, min, max) _STR_RANGE(f, min, max), 1
1384 #ifdef NO_CONFIG_WRITE
1385 #define _INT(f) #f, wpa_config_parse_int, OFFSET(f), (void *) 0
1386 #define _INTe(f) #f, wpa_config_parse_int, OFFSET(eap.f), (void *) 0
1387 #else /* NO_CONFIG_WRITE */
1388 #define _INT(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1389 OFFSET(f), (void *) 0
1390 #define _INTe(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1391 OFFSET(eap.f), (void *) 0
1392 #endif /* NO_CONFIG_WRITE */
1394 /* INT: Define an integer variable */
1395 #define INT(f) _INT(f), NULL, NULL, 0
1396 #define INTe(f) _INTe(f), NULL, NULL, 0
1398 /* INT_RANGE: Define an integer variable with allowed value range */
1399 #define INT_RANGE(f, min, max) _INT(f), (void *) (min), (void *) (max), 0
1401 /* FUNC: Define a configuration variable that uses a custom function for
1402 * parsing and writing the value. */
1403 #ifdef NO_CONFIG_WRITE
1404 #define _FUNC(f) #f, wpa_config_parse_ ## f, NULL, NULL, NULL, NULL
1405 #else /* NO_CONFIG_WRITE */
1406 #define _FUNC(f) #f, wpa_config_parse_ ## f, wpa_config_write_ ## f, \
1407 NULL, NULL, NULL, NULL
1408 #endif /* NO_CONFIG_WRITE */
1409 #define FUNC(f) _FUNC(f), 0
1410 #define FUNC_KEY(f) _FUNC(f), 1
1413 * Table of network configuration variables. This table is used to parse each
1414 * network configuration variable, e.g., each line in wpa_supplicant.conf file
1415 * that is inside a network block.
1417 * This table is generated using the helper macros defined above and with
1418 * generous help from the C pre-processor. The field name is stored as a string
1419 * into .name and for STR and INT types, the offset of the target buffer within
1420 * struct wpa_ssid is stored in .param1. .param2 (if not NULL) is similar
1421 * offset to the field containing the length of the configuration variable.
1422 * .param3 and .param4 can be used to mark the allowed range (length for STR
1423 * and value for INT).
1425 * For each configuration line in wpa_supplicant.conf, the parser goes through
1426 * this table and select the entry that matches with the field name. The parser
1427 * function (.parser) is then called to parse the actual value of the field.
1429 * This kind of mechanism makes it easy to add new configuration parameters,
1430 * since only one line needs to be added into this table and into the
1431 * struct wpa_ssid definition if the new variable is either a string or
1432 * integer. More complex types will need to use their own parser and writer
1435 static const struct parse_data ssid_fields
[] = {
1436 { STR_RANGE(ssid
, 0, MAX_SSID_LEN
) },
1437 { INT_RANGE(scan_ssid
, 0, 1) },
1445 { FUNC(scan_freq
) },
1446 { FUNC(freq_list
) },
1447 #ifdef IEEE8021X_EAPOL
1449 { STR_LENe(identity
) },
1450 { STR_LENe(anonymous_identity
) },
1451 { FUNC_KEY(password
) },
1454 { STRe(client_cert
) },
1455 { STRe(private_key
) },
1456 { STR_KEYe(private_key_passwd
) },
1458 { STRe(subject_match
) },
1459 { STRe(altsubject_match
) },
1462 { STRe(client_cert2
) },
1463 { STRe(private_key2
) },
1464 { STR_KEYe(private_key2_passwd
) },
1466 { STRe(subject_match2
) },
1467 { STRe(altsubject_match2
) },
1472 { STRe(engine_id
) },
1475 { STRe(ca_cert_id
) },
1477 { STRe(engine2_id
) },
1480 { STRe(ca_cert2_id
) },
1483 { INT(eapol_flags
) },
1484 #endif /* IEEE8021X_EAPOL */
1485 { FUNC_KEY(wep_key0
) },
1486 { FUNC_KEY(wep_key1
) },
1487 { FUNC_KEY(wep_key2
) },
1488 { FUNC_KEY(wep_key3
) },
1489 { INT(wep_tx_keyidx
) },
1491 #ifdef IEEE8021X_EAPOL
1492 { INT(eap_workaround
) },
1494 { INTe(fragment_size
) },
1495 #endif /* IEEE8021X_EAPOL */
1496 { INT_RANGE(mode
, 0, 4) },
1497 { INT_RANGE(proactive_key_caching
, 0, 1) },
1498 { INT_RANGE(disabled
, 0, 1) },
1500 #ifdef CONFIG_IEEE80211W
1501 { INT_RANGE(ieee80211w
, 0, 2) },
1502 #endif /* CONFIG_IEEE80211W */
1503 { INT_RANGE(peerkey
, 0, 1) },
1504 { INT_RANGE(mixed_cell
, 0, 1) },
1505 { INT_RANGE(frequency
, 0, 10000) },
1506 { INT(wpa_ptk_rekey
) },
1519 #undef STR_RANGE_KEY
1526 #define NUM_SSID_FIELDS (sizeof(ssid_fields) / sizeof(ssid_fields[0]))
1530 * wpa_config_add_prio_network - Add a network to priority lists
1531 * @config: Configuration data from wpa_config_read()
1532 * @ssid: Pointer to the network configuration to be added to the list
1533 * Returns: 0 on success, -1 on failure
1535 * This function is used to add a network block to the priority list of
1536 * networks. This must be called for each network when reading in the full
1537 * configuration. In addition, this can be used indirectly when updating
1538 * priorities by calling wpa_config_update_prio_list().
1540 int wpa_config_add_prio_network(struct wpa_config
*config
,
1541 struct wpa_ssid
*ssid
)
1544 struct wpa_ssid
*prev
, **nlist
;
1547 * Add to an existing priority list if one is available for the
1548 * configured priority level for this network.
1550 for (prio
= 0; prio
< config
->num_prio
; prio
++) {
1551 prev
= config
->pssid
[prio
];
1552 if (prev
->priority
== ssid
->priority
) {
1560 /* First network for this priority - add a new priority list */
1561 nlist
= os_realloc(config
->pssid
,
1562 (config
->num_prio
+ 1) * sizeof(struct wpa_ssid
*));
1566 for (prio
= 0; prio
< config
->num_prio
; prio
++) {
1567 if (nlist
[prio
]->priority
< ssid
->priority
)
1571 os_memmove(&nlist
[prio
+ 1], &nlist
[prio
],
1572 (config
->num_prio
- prio
) * sizeof(struct wpa_ssid
*));
1576 config
->pssid
= nlist
;
1583 * wpa_config_update_prio_list - Update network priority list
1584 * @config: Configuration data from wpa_config_read()
1585 * Returns: 0 on success, -1 on failure
1587 * This function is called to update the priority list of networks in the
1588 * configuration when a network is being added or removed. This is also called
1589 * if a priority for a network is changed.
1591 int wpa_config_update_prio_list(struct wpa_config
*config
)
1593 struct wpa_ssid
*ssid
;
1596 os_free(config
->pssid
);
1597 config
->pssid
= NULL
;
1598 config
->num_prio
= 0;
1600 ssid
= config
->ssid
;
1603 if (wpa_config_add_prio_network(config
, ssid
) < 0)
1612 #ifdef IEEE8021X_EAPOL
1613 static void eap_peer_config_free(struct eap_peer_config
*eap
)
1615 os_free(eap
->eap_methods
);
1616 os_free(eap
->identity
);
1617 os_free(eap
->anonymous_identity
);
1618 os_free(eap
->password
);
1619 os_free(eap
->ca_cert
);
1620 os_free(eap
->ca_path
);
1621 os_free(eap
->client_cert
);
1622 os_free(eap
->private_key
);
1623 os_free(eap
->private_key_passwd
);
1624 os_free(eap
->dh_file
);
1625 os_free(eap
->subject_match
);
1626 os_free(eap
->altsubject_match
);
1627 os_free(eap
->ca_cert2
);
1628 os_free(eap
->ca_path2
);
1629 os_free(eap
->client_cert2
);
1630 os_free(eap
->private_key2
);
1631 os_free(eap
->private_key2_passwd
);
1632 os_free(eap
->dh_file2
);
1633 os_free(eap
->subject_match2
);
1634 os_free(eap
->altsubject_match2
);
1635 os_free(eap
->phase1
);
1636 os_free(eap
->phase2
);
1639 os_free(eap
->engine_id
);
1640 os_free(eap
->key_id
);
1641 os_free(eap
->cert_id
);
1642 os_free(eap
->ca_cert_id
);
1643 os_free(eap
->key2_id
);
1644 os_free(eap
->cert2_id
);
1645 os_free(eap
->ca_cert2_id
);
1647 os_free(eap
->engine2_id
);
1649 os_free(eap
->pending_req_otp
);
1650 os_free(eap
->pac_file
);
1651 os_free(eap
->new_password
);
1653 #endif /* IEEE8021X_EAPOL */
1657 * wpa_config_free_ssid - Free network/ssid configuration data
1658 * @ssid: Configuration data for the network
1660 * This function frees all resources allocated for the network configuration
1663 void wpa_config_free_ssid(struct wpa_ssid
*ssid
)
1665 os_free(ssid
->ssid
);
1666 os_free(ssid
->passphrase
);
1667 #ifdef IEEE8021X_EAPOL
1668 eap_peer_config_free(&ssid
->eap
);
1669 #endif /* IEEE8021X_EAPOL */
1670 os_free(ssid
->id_str
);
1671 os_free(ssid
->scan_freq
);
1672 os_free(ssid
->freq_list
);
1673 os_free(ssid
->bgscan
);
1679 * wpa_config_free - Free configuration data
1680 * @config: Configuration data from wpa_config_read()
1682 * This function frees all resources allocated for the configuration data by
1683 * wpa_config_read().
1685 void wpa_config_free(struct wpa_config
*config
)
1687 #ifndef CONFIG_NO_CONFIG_BLOBS
1688 struct wpa_config_blob
*blob
, *prevblob
;
1689 #endif /* CONFIG_NO_CONFIG_BLOBS */
1690 struct wpa_ssid
*ssid
, *prev
= NULL
;
1691 ssid
= config
->ssid
;
1695 wpa_config_free_ssid(prev
);
1698 #ifndef CONFIG_NO_CONFIG_BLOBS
1699 blob
= config
->blobs
;
1704 wpa_config_free_blob(prevblob
);
1706 #endif /* CONFIG_NO_CONFIG_BLOBS */
1708 os_free(config
->ctrl_interface
);
1709 os_free(config
->ctrl_interface_group
);
1710 os_free(config
->opensc_engine_path
);
1711 os_free(config
->pkcs11_engine_path
);
1712 os_free(config
->pkcs11_module_path
);
1713 os_free(config
->driver_param
);
1714 os_free(config
->device_name
);
1715 os_free(config
->manufacturer
);
1716 os_free(config
->model_name
);
1717 os_free(config
->model_number
);
1718 os_free(config
->serial_number
);
1719 os_free(config
->device_type
);
1720 os_free(config
->config_methods
);
1721 os_free(config
->pssid
);
1727 * wpa_config_get_network - Get configured network based on id
1728 * @config: Configuration data from wpa_config_read()
1729 * @id: Unique network id to search for
1730 * Returns: Network configuration or %NULL if not found
1732 struct wpa_ssid
* wpa_config_get_network(struct wpa_config
*config
, int id
)
1734 struct wpa_ssid
*ssid
;
1736 ssid
= config
->ssid
;
1748 * wpa_config_add_network - Add a new network with empty configuration
1749 * @config: Configuration data from wpa_config_read()
1750 * Returns: The new network configuration or %NULL if operation failed
1752 struct wpa_ssid
* wpa_config_add_network(struct wpa_config
*config
)
1755 struct wpa_ssid
*ssid
, *last
= NULL
;
1758 ssid
= config
->ssid
;
1767 ssid
= os_zalloc(sizeof(*ssid
));
1774 config
->ssid
= ssid
;
1776 wpa_config_update_prio_list(config
);
1783 * wpa_config_remove_network - Remove a configured network based on id
1784 * @config: Configuration data from wpa_config_read()
1785 * @id: Unique network id to search for
1786 * Returns: 0 on success, or -1 if the network was not found
1788 int wpa_config_remove_network(struct wpa_config
*config
, int id
)
1790 struct wpa_ssid
*ssid
, *prev
= NULL
;
1792 ssid
= config
->ssid
;
1804 prev
->next
= ssid
->next
;
1806 config
->ssid
= ssid
->next
;
1808 wpa_config_update_prio_list(config
);
1809 wpa_config_free_ssid(ssid
);
1815 * wpa_config_set_network_defaults - Set network default values
1816 * @ssid: Pointer to network configuration data
1818 void wpa_config_set_network_defaults(struct wpa_ssid
*ssid
)
1820 ssid
->proto
= DEFAULT_PROTO
;
1821 ssid
->pairwise_cipher
= DEFAULT_PAIRWISE
;
1822 ssid
->group_cipher
= DEFAULT_GROUP
;
1823 ssid
->key_mgmt
= DEFAULT_KEY_MGMT
;
1824 #ifdef IEEE8021X_EAPOL
1825 ssid
->eapol_flags
= DEFAULT_EAPOL_FLAGS
;
1826 ssid
->eap_workaround
= DEFAULT_EAP_WORKAROUND
;
1827 ssid
->eap
.fragment_size
= DEFAULT_FRAGMENT_SIZE
;
1828 #endif /* IEEE8021X_EAPOL */
1833 * wpa_config_set - Set a variable in network configuration
1834 * @ssid: Pointer to network configuration data
1835 * @var: Variable name, e.g., "ssid"
1836 * @value: Variable value
1837 * @line: Line number in configuration file or 0 if not used
1838 * Returns: 0 on success, -1 on failure
1840 * This function can be used to set network configuration variables based on
1841 * both the configuration file and management interface input. The value
1842 * parameter must be in the same format as the text-based configuration file is
1843 * using. For example, strings are using double quotation marks.
1845 int wpa_config_set(struct wpa_ssid
*ssid
, const char *var
, const char *value
,
1851 if (ssid
== NULL
|| var
== NULL
|| value
== NULL
)
1854 for (i
= 0; i
< NUM_SSID_FIELDS
; i
++) {
1855 const struct parse_data
*field
= &ssid_fields
[i
];
1856 if (os_strcmp(var
, field
->name
) != 0)
1859 if (field
->parser(field
, ssid
, line
, value
)) {
1861 wpa_printf(MSG_ERROR
, "Line %d: failed to "
1862 "parse %s '%s'.", line
, var
, value
);
1868 if (i
== NUM_SSID_FIELDS
) {
1870 wpa_printf(MSG_ERROR
, "Line %d: unknown network field "
1871 "'%s'.", line
, var
);
1881 * wpa_config_get_all - Get all options from network configuration
1882 * @ssid: Pointer to network configuration data
1883 * @get_keys: Determines if keys/passwords will be included in returned list
1884 * Returns: %NULL terminated list of all set keys and their values in the form
1885 * of [key1, val1, key2, val2, ... , NULL]
1887 * This function can be used to get list of all configured network properties.
1888 * The caller is responsible for freeing the returned list and all its
1891 char ** wpa_config_get_all(struct wpa_ssid
*ssid
, int get_keys
)
1893 const struct parse_data
*field
;
1899 props
= os_zalloc(sizeof(char *) * ((2 * NUM_SSID_FIELDS
) + 1));
1904 for (i
= 0; i
< NUM_SSID_FIELDS
; i
++) {
1905 field
= &ssid_fields
[i
];
1906 if (field
->key_data
&& !get_keys
)
1908 value
= field
->writer(field
, ssid
);
1911 if (os_strlen(value
) == 0) {
1916 key
= os_strdup(field
->name
);
1922 props
[fields_num
* 2] = key
;
1923 props
[fields_num
* 2 + 1] = value
;
1939 #ifndef NO_CONFIG_WRITE
1941 * wpa_config_get - Get a variable in network configuration
1942 * @ssid: Pointer to network configuration data
1943 * @var: Variable name, e.g., "ssid"
1944 * Returns: Value of the variable or %NULL on failure
1946 * This function can be used to get network configuration variables. The
1947 * returned value is a copy of the configuration variable in text format, i.e,.
1948 * the same format that the text-based configuration file and wpa_config_set()
1949 * are using for the value. The caller is responsible for freeing the returned
1952 char * wpa_config_get(struct wpa_ssid
*ssid
, const char *var
)
1956 if (ssid
== NULL
|| var
== NULL
)
1959 for (i
= 0; i
< NUM_SSID_FIELDS
; i
++) {
1960 const struct parse_data
*field
= &ssid_fields
[i
];
1961 if (os_strcmp(var
, field
->name
) == 0)
1962 return field
->writer(field
, ssid
);
1970 * wpa_config_get_no_key - Get a variable in network configuration (no keys)
1971 * @ssid: Pointer to network configuration data
1972 * @var: Variable name, e.g., "ssid"
1973 * Returns: Value of the variable or %NULL on failure
1975 * This function can be used to get network configuration variable like
1976 * wpa_config_get(). The only difference is that this functions does not expose
1977 * key/password material from the configuration. In case a key/password field
1978 * is requested, the returned value is an empty string or %NULL if the variable
1979 * is not set or "*" if the variable is set (regardless of its value). The
1980 * returned value is a copy of the configuration variable in text format, i.e,.
1981 * the same format that the text-based configuration file and wpa_config_set()
1982 * are using for the value. The caller is responsible for freeing the returned
1985 char * wpa_config_get_no_key(struct wpa_ssid
*ssid
, const char *var
)
1989 if (ssid
== NULL
|| var
== NULL
)
1992 for (i
= 0; i
< NUM_SSID_FIELDS
; i
++) {
1993 const struct parse_data
*field
= &ssid_fields
[i
];
1994 if (os_strcmp(var
, field
->name
) == 0) {
1995 char *res
= field
->writer(field
, ssid
);
1996 if (field
->key_data
) {
1997 if (res
&& res
[0]) {
1998 wpa_printf(MSG_DEBUG
, "Do not allow "
1999 "key_data field to be "
2002 return os_strdup("*");
2014 #endif /* NO_CONFIG_WRITE */
2018 * wpa_config_update_psk - Update WPA PSK based on passphrase and SSID
2019 * @ssid: Pointer to network configuration data
2021 * This function must be called to update WPA PSK when either SSID or the
2022 * passphrase has changed for the network configuration.
2024 void wpa_config_update_psk(struct wpa_ssid
*ssid
)
2026 #ifndef CONFIG_NO_PBKDF2
2027 pbkdf2_sha1(ssid
->passphrase
,
2028 (char *) ssid
->ssid
, ssid
->ssid_len
, 4096,
2029 ssid
->psk
, PMK_LEN
);
2030 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from passphrase)",
2031 ssid
->psk
, PMK_LEN
);
2033 #endif /* CONFIG_NO_PBKDF2 */
2037 #ifndef CONFIG_NO_CONFIG_BLOBS
2039 * wpa_config_get_blob - Get a named configuration blob
2040 * @config: Configuration data from wpa_config_read()
2041 * @name: Name of the blob
2042 * Returns: Pointer to blob data or %NULL if not found
2044 const struct wpa_config_blob
* wpa_config_get_blob(struct wpa_config
*config
,
2047 struct wpa_config_blob
*blob
= config
->blobs
;
2050 if (os_strcmp(blob
->name
, name
) == 0)
2059 * wpa_config_set_blob - Set or add a named configuration blob
2060 * @config: Configuration data from wpa_config_read()
2061 * @blob: New value for the blob
2063 * Adds a new configuration blob or replaces the current value of an existing
2066 void wpa_config_set_blob(struct wpa_config
*config
,
2067 struct wpa_config_blob
*blob
)
2069 wpa_config_remove_blob(config
, blob
->name
);
2070 blob
->next
= config
->blobs
;
2071 config
->blobs
= blob
;
2076 * wpa_config_free_blob - Free blob data
2077 * @blob: Pointer to blob to be freed
2079 void wpa_config_free_blob(struct wpa_config_blob
*blob
)
2082 os_free(blob
->name
);
2083 os_free(blob
->data
);
2090 * wpa_config_remove_blob - Remove a named configuration blob
2091 * @config: Configuration data from wpa_config_read()
2092 * @name: Name of the blob to remove
2093 * Returns: 0 if blob was removed or -1 if blob was not found
2095 int wpa_config_remove_blob(struct wpa_config
*config
, const char *name
)
2097 struct wpa_config_blob
*pos
= config
->blobs
, *prev
= NULL
;
2100 if (os_strcmp(pos
->name
, name
) == 0) {
2102 prev
->next
= pos
->next
;
2104 config
->blobs
= pos
->next
;
2105 wpa_config_free_blob(pos
);
2114 #endif /* CONFIG_NO_CONFIG_BLOBS */
2118 * wpa_config_alloc_empty - Allocate an empty configuration
2119 * @ctrl_interface: Control interface parameters, e.g., path to UNIX domain
2121 * @driver_param: Driver parameters
2122 * Returns: Pointer to allocated configuration data or %NULL on failure
2124 struct wpa_config
* wpa_config_alloc_empty(const char *ctrl_interface
,
2125 const char *driver_param
)
2127 struct wpa_config
*config
;
2129 config
= os_zalloc(sizeof(*config
));
2132 config
->eapol_version
= DEFAULT_EAPOL_VERSION
;
2133 config
->ap_scan
= DEFAULT_AP_SCAN
;
2134 config
->fast_reauth
= DEFAULT_FAST_REAUTH
;
2135 config
->bss_max_count
= DEFAULT_BSS_MAX_COUNT
;
2138 config
->ctrl_interface
= os_strdup(ctrl_interface
);
2140 config
->driver_param
= os_strdup(driver_param
);
2146 #ifndef CONFIG_NO_STDOUT_DEBUG
2148 * wpa_config_debug_dump_networks - Debug dump of configured networks
2149 * @config: Configuration data from wpa_config_read()
2151 void wpa_config_debug_dump_networks(struct wpa_config
*config
)
2154 struct wpa_ssid
*ssid
;
2156 for (prio
= 0; prio
< config
->num_prio
; prio
++) {
2157 ssid
= config
->pssid
[prio
];
2158 wpa_printf(MSG_DEBUG
, "Priority group %d",
2161 wpa_printf(MSG_DEBUG
, " id=%d ssid='%s'",
2163 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
2168 #endif /* CONFIG_NO_STDOUT_DEBUG */
2171 struct global_parse_data
{
2173 int (*parser
)(const struct global_parse_data
*data
,
2174 struct wpa_config
*config
, int line
, const char *value
);
2175 void *param1
, *param2
, *param3
;
2176 unsigned int changed_flag
;
2180 static int wpa_global_config_parse_int(const struct global_parse_data
*data
,
2181 struct wpa_config
*config
, int line
,
2185 dst
= (int *) (((u8
*) config
) + (long) data
->param1
);
2187 wpa_printf(MSG_DEBUG
, "%s=%d", data
->name
, *dst
);
2189 if (data
->param2
&& *dst
< (long) data
->param2
) {
2190 wpa_printf(MSG_ERROR
, "Line %d: too small %s (value=%d "
2191 "min_value=%ld)", line
, data
->name
, *dst
,
2192 (long) data
->param2
);
2193 *dst
= (long) data
->param2
;
2197 if (data
->param3
&& *dst
> (long) data
->param3
) {
2198 wpa_printf(MSG_ERROR
, "Line %d: too large %s (value=%d "
2199 "max_value=%ld)", line
, data
->name
, *dst
,
2200 (long) data
->param3
);
2201 *dst
= (long) data
->param3
;
2209 static int wpa_global_config_parse_str(const struct global_parse_data
*data
,
2210 struct wpa_config
*config
, int line
,
2216 len
= os_strlen(pos
);
2217 if (data
->param2
&& len
< (size_t) data
->param2
) {
2218 wpa_printf(MSG_ERROR
, "Line %d: too short %s (len=%lu "
2219 "min_len=%ld)", line
, data
->name
,
2220 (unsigned long) len
, (long) data
->param2
);
2224 if (data
->param3
&& len
> (size_t) data
->param3
) {
2225 wpa_printf(MSG_ERROR
, "Line %d: too long %s (len=%lu "
2226 "max_len=%ld)", line
, data
->name
,
2227 (unsigned long) len
, (long) data
->param3
);
2231 tmp
= os_strdup(pos
);
2235 dst
= (char **) (((u8
*) config
) + (long) data
->param1
);
2238 wpa_printf(MSG_DEBUG
, "%s='%s'", data
->name
, *dst
);
2244 static int wpa_config_process_country(const struct global_parse_data
*data
,
2245 struct wpa_config
*config
, int line
,
2248 if (!pos
[0] || !pos
[1]) {
2249 wpa_printf(MSG_DEBUG
, "Invalid country set");
2252 config
->country
[0] = pos
[0];
2253 config
->country
[1] = pos
[1];
2254 wpa_printf(MSG_DEBUG
, "country='%c%c'",
2255 config
->country
[0], config
->country
[1]);
2260 static int wpa_config_process_load_dynamic_eap(
2261 const struct global_parse_data
*data
, struct wpa_config
*config
,
2262 int line
, const char *so
)
2265 wpa_printf(MSG_DEBUG
, "load_dynamic_eap=%s", so
);
2266 ret
= eap_peer_method_load(so
);
2268 wpa_printf(MSG_DEBUG
, "This EAP type was already loaded - not "
2271 wpa_printf(MSG_ERROR
, "Line %d: Failed to load dynamic EAP "
2272 "method '%s'.", line
, so
);
2282 static int wpa_config_process_uuid(const struct global_parse_data
*data
,
2283 struct wpa_config
*config
, int line
,
2287 if (uuid_str2bin(pos
, config
->uuid
)) {
2288 wpa_printf(MSG_ERROR
, "Line %d: invalid UUID", line
);
2291 uuid_bin2str(config
->uuid
, buf
, sizeof(buf
));
2292 wpa_printf(MSG_DEBUG
, "uuid=%s", buf
);
2297 static int wpa_config_process_os_version(const struct global_parse_data
*data
,
2298 struct wpa_config
*config
, int line
,
2301 if (hexstr2bin(pos
, config
->os_version
, 4)) {
2302 wpa_printf(MSG_ERROR
, "Line %d: invalid os_version", line
);
2305 wpa_printf(MSG_DEBUG
, "os_version=%08x",
2306 WPA_GET_BE32(config
->os_version
));
2310 #endif /* CONFIG_WPS */
2316 /* OFFSET: Get offset of a variable within the wpa_config structure */
2317 #define OFFSET(v) ((void *) &((struct wpa_config *) 0)->v)
2319 #define FUNC(f) #f, wpa_config_process_ ## f, OFFSET(f), NULL, NULL
2320 #define FUNC_NO_VAR(f) #f, wpa_config_process_ ## f, NULL, NULL, NULL
2321 #define _INT(f) #f, wpa_global_config_parse_int, OFFSET(f)
2322 #define INT(f) _INT(f), NULL, NULL
2323 #define INT_RANGE(f, min, max) _INT(f), (void *) min, (void *) max
2324 #define _STR(f) #f, wpa_global_config_parse_str, OFFSET(f)
2325 #define STR(f) _STR(f), NULL, NULL
2326 #define STR_RANGE(f, min, max) _STR(f), (void *) min, (void *) max
2328 static const struct global_parse_data global_fields
[] = {
2329 #ifdef CONFIG_CTRL_IFACE
2330 { STR(ctrl_interface
), 0 },
2331 { STR(ctrl_interface_group
), 0 } /* deprecated */,
2332 #endif /* CONFIG_CTRL_IFACE */
2333 { INT_RANGE(eapol_version
, 1, 2), 0 },
2334 { INT(ap_scan
), 0 },
2335 { INT(fast_reauth
), 0 },
2336 { STR(opensc_engine_path
), 0 },
2337 { STR(pkcs11_engine_path
), 0 },
2338 { STR(pkcs11_module_path
), 0 },
2339 { STR(driver_param
), 0 },
2340 { INT(dot11RSNAConfigPMKLifetime
), 0 },
2341 { INT(dot11RSNAConfigPMKReauthThreshold
), 0 },
2342 { INT(dot11RSNAConfigSATimeout
), 0 },
2343 #ifndef CONFIG_NO_CONFIG_WRITE
2344 { INT(update_config
), 0 },
2345 #endif /* CONFIG_NO_CONFIG_WRITE */
2346 { FUNC_NO_VAR(load_dynamic_eap
), 0 },
2348 { FUNC(uuid
), CFG_CHANGED_UUID
},
2349 { STR_RANGE(device_name
, 0, 32), CFG_CHANGED_DEVICE_NAME
},
2350 { STR_RANGE(manufacturer
, 0, 64), 0 },
2351 { STR_RANGE(model_name
, 0, 32), 0 },
2352 { STR_RANGE(model_number
, 0, 32), 0 },
2353 { STR_RANGE(serial_number
, 0, 32), 0 },
2354 { STR(device_type
), CFG_CHANGED_DEVICE_TYPE
},
2355 { FUNC(os_version
), CFG_CHANGED_OS_VERSION
},
2356 { STR(config_methods
), CFG_CHANGED_CONFIG_METHODS
},
2357 { INT_RANGE(wps_cred_processing
, 0, 2), 0 },
2358 #endif /* CONFIG_WPS */
2359 { FUNC(country
), CFG_CHANGED_COUNTRY
},
2360 { INT(bss_max_count
), 0 },
2361 { INT_RANGE(filter_ssids
, 0, 1), 0 }
2371 #define NUM_GLOBAL_FIELDS (sizeof(global_fields) / sizeof(global_fields[0]))
2374 int wpa_config_process_global(struct wpa_config
*config
, char *pos
, int line
)
2379 for (i
= 0; i
< NUM_GLOBAL_FIELDS
; i
++) {
2380 const struct global_parse_data
*field
= &global_fields
[i
];
2381 size_t flen
= os_strlen(field
->name
);
2382 if (os_strncmp(pos
, field
->name
, flen
) != 0 ||
2386 if (field
->parser(field
, config
, line
, pos
+ flen
+ 1)) {
2387 wpa_printf(MSG_ERROR
, "Line %d: failed to "
2388 "parse '%s'.", line
, pos
);
2391 config
->changed_parameters
|= field
->changed_flag
;
2394 if (i
== NUM_GLOBAL_FIELDS
) {
2397 wpa_printf(MSG_ERROR
, "Line %d: unknown global field '%s'.",