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