?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / dist / wpa / wpa_supplicant / config.c
blob22255d920372443b1fc088fdc102d9106cbeb8ed
1 /*
2 * WPA Supplicant / Configuration parser and common functions
3 * Copyright (c) 2003-2007, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16
17 #include "common.h"
18 #include "wpa.h"
19 #include "sha1.h"
20 #include "eap_peer/eap.h"
21 #include "config.h"
22
23
24 #if !defined(CONFIG_CTRL_IFACE) && defined(CONFIG_NO_CONFIG_WRITE)
25 #define NO_CONFIG_WRITE
26 #endif
27
28 /*
29 * Structure for network configuration parsing. This data is used to implement
30 * a generic parser for each network block variable. The table of configuration
31 * variables is defined below in this file (ssid_fields[]).
32 */
33 struct parse_data {
34 /* Configuration variable name */
35 char *name;
36
37 /* Parser function for this variable */
38 int (*parser)(const struct parse_data *data, struct wpa_ssid *ssid,
39 int line, const char *value);
40
41 #ifndef NO_CONFIG_WRITE
42 /* Writer function (i.e., to get the variable in text format from
43 * internal presentation). */
44 char * (*writer)(const struct parse_data *data, struct wpa_ssid *ssid);
45 #endif /* NO_CONFIG_WRITE */
46
47 /* Variable specific parameters for the parser. */
48 void *param1, *param2, *param3, *param4;
49
50 /* 0 = this variable can be included in debug output and ctrl_iface
51 * 1 = this variable contains key/private data and it must not be
52 * included in debug output unless explicitly requested. In
53 * addition, this variable will not be readable through the
54 * ctrl_iface.
55 */
56 int key_data;
57 };
58
59
60 static char * wpa_config_parse_string(const char *value, size_t *len)
61 {
62 if (*value == '"') {
63 char *pos;
64 value++;
65 pos = os_strrchr(value, '"');
66 if (pos == NULL || pos[1] != '\0')
67 return NULL;
68 *pos = '\0';
69 *len = os_strlen(value);
70 return os_strdup(value);
71 } else {
72 u8 *str;
73 size_t tlen, hlen = os_strlen(value);
74 if (hlen & 1)
75 return NULL;
76 tlen = hlen / 2;
77 str = os_malloc(tlen + 1);
78 if (str == NULL)
79 return NULL;
80 if (hexstr2bin(value, str, tlen)) {
81 os_free(str);
82 return NULL;
83 }
84 str[tlen] = '\0';
85 *len = tlen;
86 return (char *) str;
87 }
88 }
89
90
91 static int wpa_config_parse_str(const struct parse_data *data,
92 struct wpa_ssid *ssid,
93 int line, const char *value)
94 {
95 size_t res_len, *dst_len;
96 char **dst, *tmp;
97
98 tmp = wpa_config_parse_string(value, &res_len);
99 if (tmp == NULL) {
100 wpa_printf(MSG_ERROR, "Line %d: failed to parse %s '%s'.",
101 line, data->name,
102 data->key_data ? "[KEY DATA REMOVED]" : value);
103 return -1;
104 }
105
106 if (data->key_data) {
107 wpa_hexdump_ascii_key(MSG_MSGDUMP, data->name,
108 (u8 *) tmp, res_len);
109 } else {
110 wpa_hexdump_ascii(MSG_MSGDUMP, data->name,
111 (u8 *) tmp, res_len);
112 }
113
114 if (data->param3 && res_len < (size_t) data->param3) {
115 wpa_printf(MSG_ERROR, "Line %d: too short %s (len=%lu "
116 "min_len=%ld)", line, data->name,
117 (unsigned long) res_len, (long) data->param3);
118 os_free(tmp);
119 return -1;
120 }
121
122 if (data->param4 && res_len > (size_t) data->param4) {
123 wpa_printf(MSG_ERROR, "Line %d: too long %s (len=%lu "
124 "max_len=%ld)", line, data->name,
125 (unsigned long) res_len, (long) data->param4);
126 os_free(tmp);
127 return -1;
128 }
129
130 dst = (char **) (((u8 *) ssid) + (long) data->param1);
131 dst_len = (size_t *) (((u8 *) ssid) + (long) data->param2);
132 os_free(*dst);
133 *dst = tmp;
134 if (data->param2)
135 *dst_len = res_len;
136
137 return 0;
138 }
139
140
141 #ifndef NO_CONFIG_WRITE
142 static int is_hex(const u8 *data, size_t len)
143 {
144 size_t i;
145
146 for (i = 0; i < len; i++) {
147 if (data[i] < 32 || data[i] >= 127)
148 return 1;
149 }
150 return 0;
151 }
152
153
154 static char * wpa_config_write_string_ascii(const u8 *value, size_t len)
155 {
156 char *buf;
157
158 buf = os_malloc(len + 3);
159 if (buf == NULL)
160 return NULL;
161 buf[0] = '"';
162 os_memcpy(buf + 1, value, len);
163 buf[len + 1] = '"';
164 buf[len + 2] = '\0';
165
166 return buf;
167 }
168
169
170 static char * wpa_config_write_string_hex(const u8 *value, size_t len)
171 {
172 char *buf;
173
174 buf = os_zalloc(2 * len + 1);
175 if (buf == NULL)
176 return NULL;
177 wpa_snprintf_hex(buf, 2 * len + 1, value, len);
178
179 return buf;
180 }
181
182
183 static char * wpa_config_write_string(const u8 *value, size_t len)
184 {
185 if (value == NULL)
186 return NULL;
187
188 if (is_hex(value, len))
189 return wpa_config_write_string_hex(value, len);
190 else
191 return wpa_config_write_string_ascii(value, len);
192 }
193
194
195 static char * wpa_config_write_str(const struct parse_data *data,
196 struct wpa_ssid *ssid)
197 {
198 size_t len;
199 char **src;
200
201 src = (char **) (((u8 *) ssid) + (long) data->param1);
202 if (*src == NULL)
203 return NULL;
204
205 if (data->param2)
206 len = *((size_t *) (((u8 *) ssid) + (long) data->param2));
207 else
208 len = os_strlen(*src);
209
210 return wpa_config_write_string((const u8 *) *src, len);
211 }
212 #endif /* NO_CONFIG_WRITE */
213
214
215 static int wpa_config_parse_int(const struct parse_data *data,
216 struct wpa_ssid *ssid,
217 int line, const char *value)
218 {
219 int *dst;
220
221 dst = (int *) (((u8 *) ssid) + (long) data->param1);
222 *dst = atoi(value);
223 wpa_printf(MSG_MSGDUMP, "%s=%d (0x%x)", data->name, *dst, *dst);
224
225 if (data->param3 && *dst < (long) data->param3) {
226 wpa_printf(MSG_ERROR, "Line %d: too small %s (value=%d "
227 "min_value=%ld)", line, data->name, *dst,
228 (long) data->param3);
229 *dst = (long) data->param3;
230 return -1;
231 }
232
233 if (data->param4 && *dst > (long) data->param4) {
234 wpa_printf(MSG_ERROR, "Line %d: too large %s (value=%d "
235 "max_value=%ld)", line, data->name, *dst,
236 (long) data->param4);
237 *dst = (long) data->param4;
238 return -1;
239 }
240
241 return 0;
242 }
243
244
245 #ifndef NO_CONFIG_WRITE
246 static char * wpa_config_write_int(const struct parse_data *data,
247 struct wpa_ssid *ssid)
248 {
249 int *src, res;
250 char *value;
251
252 src = (int *) (((u8 *) ssid) + (long) data->param1);
253
254 value = os_malloc(20);
255 if (value == NULL)
256 return NULL;
257 res = os_snprintf(value, 20, "%d", *src);
258 if (res < 0 || res >= 20) {
259 os_free(value);
260 return NULL;
261 }
262 value[20 - 1] = '\0';
263 return value;
264 }
265 #endif /* NO_CONFIG_WRITE */
266
267
268 static int wpa_config_parse_bssid(const struct parse_data *data,
269 struct wpa_ssid *ssid, int line,
270 const char *value)
271 {
272 if (hwaddr_aton(value, ssid->bssid)) {
273 wpa_printf(MSG_ERROR, "Line %d: Invalid BSSID '%s'.",
274 line, value);
275 return -1;
276 }
277 ssid->bssid_set = 1;
278 wpa_hexdump(MSG_MSGDUMP, "BSSID", ssid->bssid, ETH_ALEN);
279 return 0;
280 }
281
282
283 #ifndef NO_CONFIG_WRITE
284 static char * wpa_config_write_bssid(const struct parse_data *data,
285 struct wpa_ssid *ssid)
286 {
287 char *value;
288 int res;
289
290 if (!ssid->bssid_set)
291 return NULL;
292
293 value = os_malloc(20);
294 if (value == NULL)
295 return NULL;
296 res = os_snprintf(value, 20, MACSTR, MAC2STR(ssid->bssid));
297 if (res < 0 || res >= 20) {
298 os_free(value);
299 return NULL;
300 }
301 value[20 - 1] = '\0';
302 return value;
303 }
304 #endif /* NO_CONFIG_WRITE */
305
306
307 static int wpa_config_parse_psk(const struct parse_data *data,
308 struct wpa_ssid *ssid, int line,
309 const char *value)
310 {
311 if (*value == '"') {
312 #ifndef CONFIG_NO_PBKDF2
313 const char *pos;
314 size_t len;
315
316 value++;
317 pos = os_strrchr(value, '"');
318 if (pos)
319 len = pos - value;
320 else
321 len = os_strlen(value);
322 if (len < 8 || len > 63) {
323 wpa_printf(MSG_ERROR, "Line %d: Invalid passphrase "
324 "length %lu (expected: 8..63) '%s'.",
325 line, (unsigned long) len, value);
326 return -1;
327 }
328 wpa_hexdump_ascii_key(MSG_MSGDUMP, "PSK (ASCII passphrase)",
329 (u8 *) value, len);
330 if (ssid->passphrase && os_strlen(ssid->passphrase) == len &&
331 os_memcmp(ssid->passphrase, value, len) == 0)
332 return 0;
333 ssid->psk_set = 0;
334 os_free(ssid->passphrase);
335 ssid->passphrase = os_malloc(len + 1);
336 if (ssid->passphrase == NULL)
337 return -1;
338 os_memcpy(ssid->passphrase, value, len);
339 ssid->passphrase[len] = '\0';
340 return 0;
341 #else /* CONFIG_NO_PBKDF2 */
342 wpa_printf(MSG_ERROR, "Line %d: ASCII passphrase not "
343 "supported.", line);
344 return -1;
345 #endif /* CONFIG_NO_PBKDF2 */
346 }
347
348 if (hexstr2bin(value, ssid->psk, PMK_LEN) ||
349 value[PMK_LEN * 2] != '\0') {
350 wpa_printf(MSG_ERROR, "Line %d: Invalid PSK '%s'.",
351 line, value);
352 return -1;
353 }
354
355 os_free(ssid->passphrase);
356 ssid->passphrase = NULL;
357
358 ssid->psk_set = 1;
359 wpa_hexdump_key(MSG_MSGDUMP, "PSK", ssid->psk, PMK_LEN);
360 return 0;
361 }
362
363
364 #ifndef NO_CONFIG_WRITE
365 static char * wpa_config_write_psk(const struct parse_data *data,
366 struct wpa_ssid *ssid)
367 {
368 if (ssid->passphrase)
369 return wpa_config_write_string_ascii(
370 (const u8 *) ssid->passphrase,
371 os_strlen(ssid->passphrase));
372
373 if (ssid->psk_set)
374 return wpa_config_write_string_hex(ssid->psk, PMK_LEN);
375
376 return NULL;
377 }
378 #endif /* NO_CONFIG_WRITE */
379
380
381 static int wpa_config_parse_proto(const struct parse_data *data,
382 struct wpa_ssid *ssid, int line,
383 const char *value)
384 {
385 int val = 0, last, errors = 0;
386 char *start, *end, *buf;
387
388 buf = os_strdup(value);
389 if (buf == NULL)
390 return -1;
391 start = buf;
392
393 while (*start != '\0') {
394 while (*start == ' ' || *start == '\t')
395 start++;
396 if (*start == '\0')
397 break;
398 end = start;
399 while (*end != ' ' && *end != '\t' && *end != '\0')
400 end++;
401 last = *end == '\0';
402 *end = '\0';
403 if (os_strcmp(start, "WPA") == 0)
404 val |= WPA_PROTO_WPA;
405 else if (os_strcmp(start, "RSN") == 0 ||
406 os_strcmp(start, "WPA2") == 0)
407 val |= WPA_PROTO_RSN;
408 else {
409 wpa_printf(MSG_ERROR, "Line %d: invalid proto '%s'",
410 line, start);
411 errors++;
412 }
413
414 if (last)
415 break;
416 start = end + 1;
417 }
418 os_free(buf);
419
420 if (val == 0) {
421 wpa_printf(MSG_ERROR,
422 "Line %d: no proto values configured.", line);
423 errors++;
424 }
425
426 wpa_printf(MSG_MSGDUMP, "proto: 0x%x", val);
427 ssid->proto = val;
428 return errors ? -1 : 0;
429 }
430
431
432 #ifndef NO_CONFIG_WRITE
433 static char * wpa_config_write_proto(const struct parse_data *data,
434 struct wpa_ssid *ssid)
435 {
436 int first = 1, ret;
437 char *buf, *pos, *end;
438
439 pos = buf = os_zalloc(10);
440 if (buf == NULL)
441 return NULL;
442 end = buf + 10;
443
444 if (ssid->proto & WPA_PROTO_WPA) {
445 ret = os_snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
446 if (ret < 0 || ret >= end - pos)
447 return buf;
448 pos += ret;
449 first = 0;
450 }
451
452 if (ssid->proto & WPA_PROTO_RSN) {
453 ret = os_snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
454 if (ret < 0 || ret >= end - pos)
455 return buf;
456 pos += ret;
457 first = 0;
458 }
459
460 return buf;
461 }
462 #endif /* NO_CONFIG_WRITE */
463
464
465 static int wpa_config_parse_key_mgmt(const struct parse_data *data,
466 struct wpa_ssid *ssid, int line,
467 const char *value)
468 {
469 int val = 0, last, errors = 0;
470 char *start, *end, *buf;
471
472 buf = os_strdup(value);
473 if (buf == NULL)
474 return -1;
475 start = buf;
476
477 while (*start != '\0') {
478 while (*start == ' ' || *start == '\t')
479 start++;
480 if (*start == '\0')
481 break;
482 end = start;
483 while (*end != ' ' && *end != '\t' && *end != '\0')
484 end++;
485 last = *end == '\0';
486 *end = '\0';
487 if (os_strcmp(start, "WPA-PSK") == 0)
488 val |= WPA_KEY_MGMT_PSK;
489 else if (os_strcmp(start, "WPA-EAP") == 0)
490 val |= WPA_KEY_MGMT_IEEE8021X;
491 else if (os_strcmp(start, "IEEE8021X") == 0)
492 val |= WPA_KEY_MGMT_IEEE8021X_NO_WPA;
493 else if (os_strcmp(start, "NONE") == 0)
494 val |= WPA_KEY_MGMT_NONE;
495 else if (os_strcmp(start, "WPA-NONE") == 0)
496 val |= WPA_KEY_MGMT_WPA_NONE;
497 #ifdef CONFIG_IEEE80211R
498 else if (os_strcmp(start, "FT-PSK") == 0)
499 val |= WPA_KEY_MGMT_FT_PSK;
500 else if (os_strcmp(start, "FT-EAP") == 0)
501 val |= WPA_KEY_MGMT_FT_IEEE8021X;
502 #endif /* CONFIG_IEEE80211R */
503 else {
504 wpa_printf(MSG_ERROR, "Line %d: invalid key_mgmt '%s'",
505 line, start);
506 errors++;
507 }
508
509 if (last)
510 break;
511 start = end + 1;
512 }
513 os_free(buf);
514
515 if (val == 0) {
516 wpa_printf(MSG_ERROR,
517 "Line %d: no key_mgmt values configured.", line);
518 errors++;
519 }
520
521 wpa_printf(MSG_MSGDUMP, "key_mgmt: 0x%x", val);
522 ssid->key_mgmt = val;
523 return errors ? -1 : 0;
524 }
525
526
527 #ifndef NO_CONFIG_WRITE
528 static char * wpa_config_write_key_mgmt(const struct parse_data *data,
529 struct wpa_ssid *ssid)
530 {
531 char *buf, *pos, *end;
532 int ret;
533
534 pos = buf = os_zalloc(50);
535 if (buf == NULL)
536 return NULL;
537 end = buf + 50;
538
539 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
540 ret = os_snprintf(pos, end - pos, "%sWPA-PSK",
541 pos == buf ? "" : " ");
542 if (ret < 0 || ret >= end - pos) {
543 end[-1] = '\0';
544 return buf;
545 }
546 pos += ret;
547 }
548
549 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
550 ret = os_snprintf(pos, end - pos, "%sWPA-EAP",
551 pos == buf ? "" : " ");
552 if (ret < 0 || ret >= end - pos) {
553 end[-1] = '\0';
554 return buf;
555 }
556 pos += ret;
557 }
558
559 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
560 ret = os_snprintf(pos, end - pos, "%sIEEE8021X",
561 pos == buf ? "" : " ");
562 if (ret < 0 || ret >= end - pos) {
563 end[-1] = '\0';
564 return buf;
565 }
566 pos += ret;
567 }
568
569 if (ssid->key_mgmt & WPA_KEY_MGMT_NONE) {
570 ret = os_snprintf(pos, end - pos, "%sNONE",
571 pos == buf ? "" : " ");
572 if (ret < 0 || ret >= end - pos) {
573 end[-1] = '\0';
574 return buf;
575 }
576 pos += ret;
577 }
578
579 if (ssid->key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
580 ret = os_snprintf(pos, end - pos, "%sWPA-NONE",
581 pos == buf ? "" : " ");
582 if (ret < 0 || ret >= end - pos) {
583 end[-1] = '\0';
584 return buf;
585 }
586 pos += ret;
587 }
588
589 #ifdef CONFIG_IEEE80211R
590 if (ssid->key_mgmt & WPA_KEY_MGMT_FT_PSK)
591 pos += os_snprintf(pos, end - pos, "%sFT-PSK",
592 pos == buf ? "" : " ");
593
594 if (ssid->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
595 pos += os_snprintf(pos, end - pos, "%sFT-EAP",
596 pos == buf ? "" : " ");
597 #endif /* CONFIG_IEEE80211R */
598
599 return buf;
600 }
601 #endif /* NO_CONFIG_WRITE */
602
603
604 static int wpa_config_parse_cipher(int line, const char *value)
605 {
606 int val = 0, last;
607 char *start, *end, *buf;
608
609 buf = os_strdup(value);
610 if (buf == NULL)
611 return -1;
612 start = buf;
613
614 while (*start != '\0') {
615 while (*start == ' ' || *start == '\t')
616 start++;
617 if (*start == '\0')
618 break;
619 end = start;
620 while (*end != ' ' && *end != '\t' && *end != '\0')
621 end++;
622 last = *end == '\0';
623 *end = '\0';
624 if (os_strcmp(start, "CCMP") == 0)
625 val |= WPA_CIPHER_CCMP;
626 else if (os_strcmp(start, "TKIP") == 0)
627 val |= WPA_CIPHER_TKIP;
628 else if (os_strcmp(start, "WEP104") == 0)
629 val |= WPA_CIPHER_WEP104;
630 else if (os_strcmp(start, "WEP40") == 0)
631 val |= WPA_CIPHER_WEP40;
632 else if (os_strcmp(start, "NONE") == 0)
633 val |= WPA_CIPHER_NONE;
634 else {
635 wpa_printf(MSG_ERROR, "Line %d: invalid cipher '%s'.",
636 line, start);
637 os_free(buf);
638 return -1;
639 }
640
641 if (last)
642 break;
643 start = end + 1;
644 }
645 os_free(buf);
646
647 if (val == 0) {
648 wpa_printf(MSG_ERROR, "Line %d: no cipher values configured.",
649 line);
650 return -1;
651 }
652 return val;
653 }
654
655
656 #ifndef NO_CONFIG_WRITE
657 static char * wpa_config_write_cipher(int cipher)
658 {
659 char *buf, *pos, *end;
660 int ret;
661
662 pos = buf = os_zalloc(50);
663 if (buf == NULL)
664 return NULL;
665 end = buf + 50;
666
667 if (cipher & WPA_CIPHER_CCMP) {
668 ret = os_snprintf(pos, end - pos, "%sCCMP",
669 pos == buf ? "" : " ");
670 if (ret < 0 || ret >= end - pos) {
671 end[-1] = '\0';
672 return buf;
673 }
674 pos += ret;
675 }
676
677 if (cipher & WPA_CIPHER_TKIP) {
678 ret = os_snprintf(pos, end - pos, "%sTKIP",
679 pos == buf ? "" : " ");
680 if (ret < 0 || ret >= end - pos) {
681 end[-1] = '\0';
682 return buf;
683 }
684 pos += ret;
685 }
686
687 if (cipher & WPA_CIPHER_WEP104) {
688 ret = os_snprintf(pos, end - pos, "%sWEP104",
689 pos == buf ? "" : " ");
690 if (ret < 0 || ret >= end - pos) {
691 end[-1] = '\0';
692 return buf;
693 }
694 pos += ret;
695 }
696
697 if (cipher & WPA_CIPHER_WEP40) {
698 ret = os_snprintf(pos, end - pos, "%sWEP40",
699 pos == buf ? "" : " ");
700 if (ret < 0 || ret >= end - pos) {
701 end[-1] = '\0';
702 return buf;
703 }
704 pos += ret;
705 }
706
707 if (cipher & WPA_CIPHER_NONE) {
708 ret = os_snprintf(pos, end - pos, "%sNONE",
709 pos == buf ? "" : " ");
710 if (ret < 0 || ret >= end - pos) {
711 end[-1] = '\0';
712 return buf;
713 }
714 pos += ret;
715 }
716
717 return buf;
718 }
719 #endif /* NO_CONFIG_WRITE */
720
721
722 static int wpa_config_parse_pairwise(const struct parse_data *data,
723 struct wpa_ssid *ssid, int line,
724 const char *value)
725 {
726 int val;
727 val = wpa_config_parse_cipher(line, value);
728 if (val == -1)
729 return -1;
730 if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_TKIP | WPA_CIPHER_NONE)) {
731 wpa_printf(MSG_ERROR, "Line %d: not allowed pairwise cipher "
732 "(0x%x).", line, val);
733 return -1;
734 }
735
736 wpa_printf(MSG_MSGDUMP, "pairwise: 0x%x", val);
737 ssid->pairwise_cipher = val;
738 return 0;
739 }
740
741
742 #ifndef NO_CONFIG_WRITE
743 static char * wpa_config_write_pairwise(const struct parse_data *data,
744 struct wpa_ssid *ssid)
745 {
746 return wpa_config_write_cipher(ssid->pairwise_cipher);
747 }
748 #endif /* NO_CONFIG_WRITE */
749
750
751 static int wpa_config_parse_group(const struct parse_data *data,
752 struct wpa_ssid *ssid, int line,
753 const char *value)
754 {
755 int val;
756 val = wpa_config_parse_cipher(line, value);
757 if (val == -1)
758 return -1;
759 if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_TKIP | WPA_CIPHER_WEP104 |
760 WPA_CIPHER_WEP40)) {
761 wpa_printf(MSG_ERROR, "Line %d: not allowed group cipher "
762 "(0x%x).", line, val);
763 return -1;
764 }
765
766 wpa_printf(MSG_MSGDUMP, "group: 0x%x", val);
767 ssid->group_cipher = val;
768 return 0;
769 }
770
771
772 #ifndef NO_CONFIG_WRITE
773 static char * wpa_config_write_group(const struct parse_data *data,
774 struct wpa_ssid *ssid)
775 {
776 return wpa_config_write_cipher(ssid->group_cipher);
777 }
778 #endif /* NO_CONFIG_WRITE */
779
780
781 static int wpa_config_parse_auth_alg(const struct parse_data *data,
782 struct wpa_ssid *ssid, int line,
783 const char *value)
784 {
785 int val = 0, last, errors = 0;
786 char *start, *end, *buf;
787
788 buf = os_strdup(value);
789 if (buf == NULL)
790 return -1;
791 start = buf;
792
793 while (*start != '\0') {
794 while (*start == ' ' || *start == '\t')
795 start++;
796 if (*start == '\0')
797 break;
798 end = start;
799 while (*end != ' ' && *end != '\t' && *end != '\0')
800 end++;
801 last = *end == '\0';
802 *end = '\0';
803 if (os_strcmp(start, "OPEN") == 0)
804 val |= WPA_AUTH_ALG_OPEN;
805 else if (os_strcmp(start, "SHARED") == 0)
806 val |= WPA_AUTH_ALG_SHARED;
807 else if (os_strcmp(start, "LEAP") == 0)
808 val |= WPA_AUTH_ALG_LEAP;
809 else {
810 wpa_printf(MSG_ERROR, "Line %d: invalid auth_alg '%s'",
811 line, start);
812 errors++;
813 }
814
815 if (last)
816 break;
817 start = end + 1;
818 }
819 os_free(buf);
820
821 if (val == 0) {
822 wpa_printf(MSG_ERROR,
823 "Line %d: no auth_alg values configured.", line);
824 errors++;
825 }
826
827 wpa_printf(MSG_MSGDUMP, "auth_alg: 0x%x", val);
828 ssid->auth_alg = val;
829 return errors ? -1 : 0;
830 }
831
832
833 #ifndef NO_CONFIG_WRITE
834 static char * wpa_config_write_auth_alg(const struct parse_data *data,
835 struct wpa_ssid *ssid)
836 {
837 char *buf, *pos, *end;
838 int ret;
839
840 pos = buf = os_zalloc(30);
841 if (buf == NULL)
842 return NULL;
843 end = buf + 30;
844
845 if (ssid->auth_alg & WPA_AUTH_ALG_OPEN) {
846 ret = os_snprintf(pos, end - pos, "%sOPEN",
847 pos == buf ? "" : " ");
848 if (ret < 0 || ret >= end - pos) {
849 end[-1] = '\0';
850 return buf;
851 }
852 pos += ret;
853 }
854
855 if (ssid->auth_alg & WPA_AUTH_ALG_SHARED) {
856 ret = os_snprintf(pos, end - pos, "%sSHARED",
857 pos == buf ? "" : " ");
858 if (ret < 0 || ret >= end - pos) {
859 end[-1] = '\0';
860 return buf;
861 }
862 pos += ret;
863 }
864
865 if (ssid->auth_alg & WPA_AUTH_ALG_LEAP) {
866 ret = os_snprintf(pos, end - pos, "%sLEAP",
867 pos == buf ? "" : " ");
868 if (ret < 0 || ret >= end - pos) {
869 end[-1] = '\0';
870 return buf;
871 }
872 pos += ret;
873 }
874
875 return buf;
876 }
877 #endif /* NO_CONFIG_WRITE */
878
879
880 #ifdef IEEE8021X_EAPOL
881 static int wpa_config_parse_eap(const struct parse_data *data,
882 struct wpa_ssid *ssid, int line,
883 const char *value)
884 {
885 int last, errors = 0;
886 char *start, *end, *buf;
887 struct eap_method_type *methods = NULL, *tmp;
888 size_t num_methods = 0;
889
890 buf = os_strdup(value);
891 if (buf == NULL)
892 return -1;
893 start = buf;
894
895 while (*start != '\0') {
896 while (*start == ' ' || *start == '\t')
897 start++;
898 if (*start == '\0')
899 break;
900 end = start;
901 while (*end != ' ' && *end != '\t' && *end != '\0')
902 end++;
903 last = *end == '\0';
904 *end = '\0';
905 tmp = methods;
906 methods = os_realloc(methods,
907 (num_methods + 1) * sizeof(*methods));
908 if (methods == NULL) {
909 os_free(tmp);
910 os_free(buf);
911 return -1;
912 }
913 methods[num_methods].method = eap_peer_get_type(
914 start, &methods[num_methods].vendor);
915 if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
916 methods[num_methods].method == EAP_TYPE_NONE) {
917 wpa_printf(MSG_ERROR, "Line %d: unknown EAP method "
918 "'%s'", line, start);
919 wpa_printf(MSG_ERROR, "You may need to add support for"
920 " this EAP method during wpa_supplicant\n"
921 "build time configuration.\n"
922 "See README for more information.");
923 errors++;
924 } else if (methods[num_methods].vendor == EAP_VENDOR_IETF &&
925 methods[num_methods].method == EAP_TYPE_LEAP)
926 ssid->leap++;
927 else
928 ssid->non_leap++;
929 num_methods++;
930 if (last)
931 break;
932 start = end + 1;
933 }
934 os_free(buf);
935
936 tmp = methods;
937 methods = os_realloc(methods, (num_methods + 1) * sizeof(*methods));
938 if (methods == NULL) {
939 os_free(tmp);
940 return -1;
941 }
942 methods[num_methods].vendor = EAP_VENDOR_IETF;
943 methods[num_methods].method = EAP_TYPE_NONE;
944 num_methods++;
945
946 wpa_hexdump(MSG_MSGDUMP, "eap methods",
947 (u8 *) methods, num_methods * sizeof(*methods));
948 ssid->eap.eap_methods = methods;
949 return errors ? -1 : 0;
950 }
951
952
953 static char * wpa_config_write_eap(const struct parse_data *data,
954 struct wpa_ssid *ssid)
955 {
956 int i, ret;
957 char *buf, *pos, *end;
958 const struct eap_method_type *eap_methods = ssid->eap.eap_methods;
959 const char *name;
960
961 if (eap_methods == NULL)
962 return NULL;
963
964 pos = buf = os_zalloc(100);
965 if (buf == NULL)
966 return NULL;
967 end = buf + 100;
968
969 for (i = 0; eap_methods[i].vendor != EAP_VENDOR_IETF ||
970 eap_methods[i].method != EAP_TYPE_NONE; i++) {
971 name = eap_get_name(eap_methods[i].vendor,
972 eap_methods[i].method);
973 if (name) {
974 ret = os_snprintf(pos, end - pos, "%s%s",
975 pos == buf ? "" : " ", name);
976 if (ret < 0 || ret >= end - pos)
977 break;
978 pos += ret;
979 }
980 }
981
982 end[-1] = '\0';
983
984 return buf;
985 }
986
987
988 static int wpa_config_parse_password(const struct parse_data *data,
989 struct wpa_ssid *ssid, int line,
990 const char *value)
991 {
992 u8 *hash;
993
994 if (os_strncmp(value, "hash:", 5) != 0) {
995 char *tmp;
996 size_t res_len;
997
998 tmp = wpa_config_parse_string(value, &res_len);
999 if (tmp == NULL) {
1000 wpa_printf(MSG_ERROR, "Line %d: failed to parse "
1001 "password.", line);
1002 return -1;
1003 }
1004 wpa_hexdump_ascii(MSG_MSGDUMP, data->name,
1005 (u8 *) tmp, res_len);
1006
1007 os_free(ssid->eap.password);
1008 ssid->eap.password = (u8 *) tmp;
1009 ssid->eap.password_len = res_len;
1010 ssid->eap.flags &= ~EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1011
1012 return 0;
1013 }
1014
1015
1016 /* NtPasswordHash: hash:<32 hex digits> */
1017 if (os_strlen(value + 5) != 2 * 16) {
1018 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash length "
1019 "(expected 32 hex digits)", line);
1020 return -1;
1021 }
1022
1023 hash = os_malloc(16);
1024 if (hash == NULL)
1025 return -1;
1026
1027 if (hexstr2bin(value + 5, hash, 16)) {
1028 os_free(hash);
1029 wpa_printf(MSG_ERROR, "Line %d: Invalid password hash", line);
1030 return -1;
1031 }
1032
1033 wpa_hexdump_key(MSG_MSGDUMP, data->name, hash, 16);
1034
1035 os_free(ssid->eap.password);
1036 ssid->eap.password = hash;
1037 ssid->eap.password_len = 16;
1038 ssid->eap.flags |= EAP_CONFIG_FLAGS_PASSWORD_NTHASH;
1039
1040 return 0;
1041 }
1042
1043
1044 static char * wpa_config_write_password(const struct parse_data *data,
1045 struct wpa_ssid *ssid)
1046 {
1047 char *buf;
1048
1049 if (ssid->eap.password == NULL)
1050 return NULL;
1051
1052 if (!(ssid->eap.flags & EAP_CONFIG_FLAGS_PASSWORD_NTHASH)) {
1053 return wpa_config_write_string(
1054 ssid->eap.password, ssid->eap.password_len);
1055 }
1056
1057 buf = os_malloc(5 + 32 + 1);
1058 if (buf == NULL)
1059 return NULL;
1060
1061 os_memcpy(buf, "hash:", 5);
1062 wpa_snprintf_hex(buf + 5, 32 + 1, ssid->eap.password, 16);
1063
1064 return buf;
1065 }
1066 #endif /* IEEE8021X_EAPOL */
1067
1068
1069 static int wpa_config_parse_wep_key(u8 *key, size_t *len, int line,
1070 const char *value, int idx)
1071 {
1072 char *buf, title[20];
1073 int res;
1074
1075 buf = wpa_config_parse_string(value, len);
1076 if (buf == NULL) {
1077 wpa_printf(MSG_ERROR, "Line %d: Invalid WEP key %d '%s'.",
1078 line, idx, value);
1079 return -1;
1080 }
1081 if (*len > MAX_WEP_KEY_LEN) {
1082 wpa_printf(MSG_ERROR, "Line %d: Too long WEP key %d '%s'.",
1083 line, idx, value);
1084 os_free(buf);
1085 return -1;
1086 }
1087 os_memcpy(key, buf, *len);
1088 os_free(buf);
1089 res = os_snprintf(title, sizeof(title), "wep_key%d", idx);
1090 if (res >= 0 && (size_t) res < sizeof(title))
1091 wpa_hexdump_key(MSG_MSGDUMP, title, key, *len);
1092 return 0;
1093 }
1094
1095
1096 static int wpa_config_parse_wep_key0(const struct parse_data *data,
1097 struct wpa_ssid *ssid, int line,
1098 const char *value)
1099 {
1100 return wpa_config_parse_wep_key(ssid->wep_key[0],
1101 &ssid->wep_key_len[0], line,
1102 value, 0);
1103 }
1104
1105
1106 static int wpa_config_parse_wep_key1(const struct parse_data *data,
1107 struct wpa_ssid *ssid, int line,
1108 const char *value)
1109 {
1110 return wpa_config_parse_wep_key(ssid->wep_key[1],
1111 &ssid->wep_key_len[1], line,
1112 value, 1);
1113 }
1114
1115
1116 static int wpa_config_parse_wep_key2(const struct parse_data *data,
1117 struct wpa_ssid *ssid, int line,
1118 const char *value)
1119 {
1120 return wpa_config_parse_wep_key(ssid->wep_key[2],
1121 &ssid->wep_key_len[2], line,
1122 value, 2);
1123 }
1124
1125
1126 static int wpa_config_parse_wep_key3(const struct parse_data *data,
1127 struct wpa_ssid *ssid, int line,
1128 const char *value)
1129 {
1130 return wpa_config_parse_wep_key(ssid->wep_key[3],
1131 &ssid->wep_key_len[3], line,
1132 value, 3);
1133 }
1134
1135
1136 #ifndef NO_CONFIG_WRITE
1137 static char * wpa_config_write_wep_key(struct wpa_ssid *ssid, int idx)
1138 {
1139 if (ssid->wep_key_len[idx] == 0)
1140 return NULL;
1141 return wpa_config_write_string(ssid->wep_key[idx],
1142 ssid->wep_key_len[idx]);
1143 }
1144
1145
1146 static char * wpa_config_write_wep_key0(const struct parse_data *data,
1147 struct wpa_ssid *ssid)
1148 {
1149 return wpa_config_write_wep_key(ssid, 0);
1150 }
1151
1152
1153 static char * wpa_config_write_wep_key1(const struct parse_data *data,
1154 struct wpa_ssid *ssid)
1155 {
1156 return wpa_config_write_wep_key(ssid, 1);
1157 }
1158
1159
1160 static char * wpa_config_write_wep_key2(const struct parse_data *data,
1161 struct wpa_ssid *ssid)
1162 {
1163 return wpa_config_write_wep_key(ssid, 2);
1164 }
1165
1166
1167 static char * wpa_config_write_wep_key3(const struct parse_data *data,
1168 struct wpa_ssid *ssid)
1169 {
1170 return wpa_config_write_wep_key(ssid, 3);
1171 }
1172 #endif /* NO_CONFIG_WRITE */
1173
1174
1175 /* Helper macros for network block parser */
1176
1177 #ifdef OFFSET
1178 #undef OFFSET
1179 #endif /* OFFSET */
1180 /* OFFSET: Get offset of a variable within the wpa_ssid structure */
1181 #define OFFSET(v) ((void *) &((struct wpa_ssid *) 0)->v)
1182
1183 /* STR: Define a string variable for an ASCII string; f = field name */
1184 #ifdef NO_CONFIG_WRITE
1185 #define _STR(f) #f, wpa_config_parse_str, OFFSET(f)
1186 #define _STRe(f) #f, wpa_config_parse_str, OFFSET(eap.f)
1187 #else /* NO_CONFIG_WRITE */
1188 #define _STR(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(f)
1189 #define _STRe(f) #f, wpa_config_parse_str, wpa_config_write_str, OFFSET(eap.f)
1190 #endif /* NO_CONFIG_WRITE */
1191 #define STR(f) _STR(f), NULL, NULL, NULL, 0
1192 #define STRe(f) _STRe(f), NULL, NULL, NULL, 0
1193 #define STR_KEY(f) _STR(f), NULL, NULL, NULL, 1
1194 #define STR_KEYe(f) _STRe(f), NULL, NULL, NULL, 1
1195
1196 /* STR_LEN: Define a string variable with a separate variable for storing the
1197 * data length. Unlike STR(), this can be used to store arbitrary binary data
1198 * (i.e., even nul termination character). */
1199 #define _STR_LEN(f) _STR(f), OFFSET(f ## _len)
1200 #define _STR_LENe(f) _STRe(f), OFFSET(eap.f ## _len)
1201 #define STR_LEN(f) _STR_LEN(f), NULL, NULL, 0
1202 #define STR_LENe(f) _STR_LENe(f), NULL, NULL, 0
1203 #define STR_LEN_KEY(f) _STR_LEN(f), NULL, NULL, 1
1204
1205 /* STR_RANGE: Like STR_LEN(), but with minimum and maximum allowed length
1206 * explicitly specified. */
1207 #define _STR_RANGE(f, min, max) _STR_LEN(f), (void *) (min), (void *) (max)
1208 #define STR_RANGE(f, min, max) _STR_RANGE(f, min, max), 0
1209 #define STR_RANGE_KEY(f, min, max) _STR_RANGE(f, min, max), 1
1210
1211 #ifdef NO_CONFIG_WRITE
1212 #define _INT(f) #f, wpa_config_parse_int, OFFSET(f), (void *) 0
1213 #define _INTe(f) #f, wpa_config_parse_int, OFFSET(eap.f), (void *) 0
1214 #else /* NO_CONFIG_WRITE */
1215 #define _INT(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1216 OFFSET(f), (void *) 0
1217 #define _INTe(f) #f, wpa_config_parse_int, wpa_config_write_int, \
1218 OFFSET(eap.f), (void *) 0
1219 #endif /* NO_CONFIG_WRITE */
1220
1221 /* INT: Define an integer variable */
1222 #define INT(f) _INT(f), NULL, NULL, 0
1223 #define INTe(f) _INTe(f), NULL, NULL, 0
1224
1225 /* INT_RANGE: Define an integer variable with allowed value range */
1226 #define INT_RANGE(f, min, max) _INT(f), (void *) (min), (void *) (max), 0
1227
1228 /* FUNC: Define a configuration variable that uses a custom function for
1229 * parsing and writing the value. */
1230 #ifdef NO_CONFIG_WRITE
1231 #define _FUNC(f) #f, wpa_config_parse_ ## f, NULL, NULL, NULL, NULL
1232 #else /* NO_CONFIG_WRITE */
1233 #define _FUNC(f) #f, wpa_config_parse_ ## f, wpa_config_write_ ## f, \
1234 NULL, NULL, NULL, NULL
1235 #endif /* NO_CONFIG_WRITE */
1236 #define FUNC(f) _FUNC(f), 0
1237 #define FUNC_KEY(f) _FUNC(f), 1
1238
1239 /*
1240 * Table of network configuration variables. This table is used to parse each
1241 * network configuration variable, e.g., each line in wpa_supplicant.conf file
1242 * that is inside a network block.
1243 *
1244 * This table is generated using the helper macros defined above and with
1245 * generous help from the C pre-processor. The field name is stored as a string
1246 * into .name and for STR and INT types, the offset of the target buffer within
1247 * struct wpa_ssid is stored in .param1. .param2 (if not NULL) is similar
1248 * offset to the field containing the length of the configuration variable.
1249 * .param3 and .param4 can be used to mark the allowed range (length for STR
1250 * and value for INT).
1251 *
1252 * For each configuration line in wpa_supplicant.conf, the parser goes through
1253 * this table and select the entry that matches with the field name. The parser
1254 * function (.parser) is then called to parse the actual value of the field.
1255 *
1256 * This kind of mechanism makes it easy to add new configuration parameters,
1257 * since only one line needs to be added into this table and into the
1258 * struct wpa_ssid definition if the new variable is either a string or
1259 * integer. More complex types will need to use their own parser and writer
1260 * functions.
1261 */
1262 static const struct parse_data ssid_fields[] = {
1263 { STR_RANGE(ssid, 0, MAX_SSID_LEN) },
1264 { INT_RANGE(scan_ssid, 0, 1) },
1265 { FUNC(bssid) },
1266 { FUNC_KEY(psk) },
1267 { FUNC(proto) },
1268 { FUNC(key_mgmt) },
1269 { FUNC(pairwise) },
1270 { FUNC(group) },
1271 { FUNC(auth_alg) },
1272 #ifdef IEEE8021X_EAPOL
1273 { FUNC(eap) },
1274 { STR_LENe(identity) },
1275 { STR_LENe(anonymous_identity) },
1276 { FUNC(password) },
1277 { STRe(ca_cert) },
1278 { STRe(ca_path) },
1279 { STRe(client_cert) },
1280 { STRe(private_key) },
1281 { STR_KEYe(private_key_passwd) },
1282 { STRe(dh_file) },
1283 { STRe(subject_match) },
1284 { STRe(altsubject_match) },
1285 { STRe(ca_cert2) },
1286 { STRe(ca_path2) },
1287 { STRe(client_cert2) },
1288 { STRe(private_key2) },
1289 { STR_KEYe(private_key2_passwd) },
1290 { STRe(dh_file2) },
1291 { STRe(subject_match2) },
1292 { STRe(altsubject_match2) },
1293 { STRe(phase1) },
1294 { STRe(phase2) },
1295 { STRe(pcsc) },
1296 { STR_KEYe(pin) },
1297 { STRe(engine_id) },
1298 { STRe(key_id) },
1299 { STRe(cert_id) },
1300 { STRe(ca_cert_id) },
1301 { STRe(key2_id) },
1302 { STRe(cert2_id) },
1303 { STRe(ca_cert2_id) },
1304 { INTe(engine) },
1305 { INT(eapol_flags) },
1306 #endif /* IEEE8021X_EAPOL */
1307 { FUNC_KEY(wep_key0) },
1308 { FUNC_KEY(wep_key1) },
1309 { FUNC_KEY(wep_key2) },
1310 { FUNC_KEY(wep_key3) },
1311 { INT(wep_tx_keyidx) },
1312 { INT(priority) },
1313 #ifdef IEEE8021X_EAPOL
1314 { INT(eap_workaround) },
1315 { STRe(pac_file) },
1316 { INTe(fragment_size) },
1317 #endif /* IEEE8021X_EAPOL */
1318 { INT_RANGE(mode, 0, 1) },
1319 { INT_RANGE(proactive_key_caching, 0, 1) },
1320 { INT_RANGE(disabled, 0, 1) },
1321 { STR(id_str) },
1322 #ifdef CONFIG_IEEE80211W
1323 { INT_RANGE(ieee80211w, 0, 2) },
1324 #endif /* CONFIG_IEEE80211W */
1325 { INT_RANGE(peerkey, 0, 1) },
1326 { INT_RANGE(mixed_cell, 0, 1) },
1327 { INT_RANGE(frequency, 0, 10000) }
1328 };
1329
1330 #undef OFFSET
1331 #undef _STR
1332 #undef STR
1333 #undef STR_KEY
1334 #undef _STR_LEN
1335 #undef STR_LEN
1336 #undef STR_LEN_KEY
1337 #undef _STR_RANGE
1338 #undef STR_RANGE
1339 #undef STR_RANGE_KEY
1340 #undef _INT
1341 #undef INT
1342 #undef INT_RANGE
1343 #undef _FUNC
1344 #undef FUNC
1345 #undef FUNC_KEY
1346 #define NUM_SSID_FIELDS (sizeof(ssid_fields) / sizeof(ssid_fields[0]))
1347
1348
1349 /**
1350 * wpa_config_add_prio_network - Add a network to priority lists
1351 * @config: Configuration data from wpa_config_read()
1352 * @ssid: Pointer to the network configuration to be added to the list
1353 * Returns: 0 on success, -1 on failure
1354 *
1355 * This function is used to add a network block to the priority list of
1356 * networks. This must be called for each network when reading in the full
1357 * configuration. In addition, this can be used indirectly when updating
1358 * priorities by calling wpa_config_update_prio_list().
1359 */
1360 int wpa_config_add_prio_network(struct wpa_config *config,
1361 struct wpa_ssid *ssid)
1362 {
1363 int prio;
1364 struct wpa_ssid *prev, **nlist;
1365
1366 /*
1367 * Add to an existing priority list if one is available for the
1368 * configured priority level for this network.
1369 */
1370 for (prio = 0; prio < config->num_prio; prio++) {
1371 prev = config->pssid[prio];
1372 if (prev->priority == ssid->priority) {
1373 while (prev->pnext)
1374 prev = prev->pnext;
1375 prev->pnext = ssid;
1376 return 0;
1377 }
1378 }
1379
1380 /* First network for this priority - add a new priority list */
1381 nlist = os_realloc(config->pssid,
1382 (config->num_prio + 1) * sizeof(struct wpa_ssid *));
1383 if (nlist == NULL)
1384 return -1;
1385
1386 for (prio = 0; prio < config->num_prio; prio++) {
1387 if (nlist[prio]->priority < ssid->priority)
1388 break;
1389 }
1390
1391 os_memmove(&nlist[prio + 1], &nlist[prio],
1392 (config->num_prio - prio) * sizeof(struct wpa_ssid *));
1393
1394 nlist[prio] = ssid;
1395 config->num_prio++;
1396 config->pssid = nlist;
1397
1398 return 0;
1399 }
1400
1401
1402 /**
1403 * wpa_config_update_prio_list - Update network priority list
1404 * @config: Configuration data from wpa_config_read()
1405 * Returns: 0 on success, -1 on failure
1406 *
1407 * This function is called to update the priority list of networks in the
1408 * configuration when a network is being added or removed. This is also called
1409 * if a priority for a network is changed.
1410 */
1411 static int wpa_config_update_prio_list(struct wpa_config *config)
1412 {
1413 struct wpa_ssid *ssid;
1414 int ret = 0;
1415
1416 os_free(config->pssid);
1417 config->pssid = NULL;
1418 config->num_prio = 0;
1419
1420 ssid = config->ssid;
1421 while (ssid) {
1422 ssid->pnext = NULL;
1423 if (wpa_config_add_prio_network(config, ssid) < 0)
1424 ret = -1;
1425 ssid = ssid->next;
1426 }
1427
1428 return ret;
1429 }
1430
1431
1432 #ifdef IEEE8021X_EAPOL
1433 static void eap_peer_config_free(struct eap_peer_config *eap)
1434 {
1435 os_free(eap->eap_methods);
1436 os_free(eap->identity);
1437 os_free(eap->anonymous_identity);
1438 os_free(eap->password);
1439 os_free(eap->ca_cert);
1440 os_free(eap->ca_path);
1441 os_free(eap->client_cert);
1442 os_free(eap->private_key);
1443 os_free(eap->private_key_passwd);
1444 os_free(eap->dh_file);
1445 os_free(eap->subject_match);
1446 os_free(eap->altsubject_match);
1447 os_free(eap->ca_cert2);
1448 os_free(eap->ca_path2);
1449 os_free(eap->client_cert2);
1450 os_free(eap->private_key2);
1451 os_free(eap->private_key2_passwd);
1452 os_free(eap->dh_file2);
1453 os_free(eap->subject_match2);
1454 os_free(eap->altsubject_match2);
1455 os_free(eap->phase1);
1456 os_free(eap->phase2);
1457 os_free(eap->pcsc);
1458 os_free(eap->pin);
1459 os_free(eap->engine_id);
1460 os_free(eap->key_id);
1461 os_free(eap->cert_id);
1462 os_free(eap->ca_cert_id);
1463 os_free(eap->key2_id);
1464 os_free(eap->cert2_id);
1465 os_free(eap->ca_cert2_id);
1466 os_free(eap->otp);
1467 os_free(eap->pending_req_otp);
1468 os_free(eap->pac_file);
1469 os_free(eap->new_password);
1470 }
1471 #endif /* IEEE8021X_EAPOL */
1472
1473
1474 /**
1475 * wpa_config_free_ssid - Free network/ssid configuration data
1476 * @ssid: Configuration data for the network
1477 *
1478 * This function frees all resources allocated for the network configuration
1479 * data.
1480 */
1481 void wpa_config_free_ssid(struct wpa_ssid *ssid)
1482 {
1483 os_free(ssid->ssid);
1484 os_free(ssid->passphrase);
1485 #ifdef IEEE8021X_EAPOL
1486 eap_peer_config_free(&ssid->eap);
1487 #endif /* IEEE8021X_EAPOL */
1488 os_free(ssid->id_str);
1489 os_free(ssid);
1490 }
1491
1492
1493 /**
1494 * wpa_config_free - Free configuration data
1495 * @config: Configuration data from wpa_config_read()
1496 *
1497 * This function frees all resources allocated for the configuration data by
1498 * wpa_config_read().
1499 */
1500 void wpa_config_free(struct wpa_config *config)
1501 {
1502 #ifndef CONFIG_NO_CONFIG_BLOBS
1503 struct wpa_config_blob *blob, *prevblob;
1504 #endif /* CONFIG_NO_CONFIG_BLOBS */
1505 struct wpa_ssid *ssid, *prev = NULL;
1506 ssid = config->ssid;
1507 while (ssid) {
1508 prev = ssid;
1509 ssid = ssid->next;
1510 wpa_config_free_ssid(prev);
1511 }
1512
1513 #ifndef CONFIG_NO_CONFIG_BLOBS
1514 blob = config->blobs;
1515 prevblob = NULL;
1516 while (blob) {
1517 prevblob = blob;
1518 blob = blob->next;
1519 wpa_config_free_blob(prevblob);
1520 }
1521 #endif /* CONFIG_NO_CONFIG_BLOBS */
1522
1523 os_free(config->ctrl_interface);
1524 os_free(config->ctrl_interface_group);
1525 #ifdef EAP_TLS_OPENSSL
1526 os_free(config->opensc_engine_path);
1527 os_free(config->pkcs11_engine_path);
1528 os_free(config->pkcs11_module_path);
1529 #endif /* EAP_TLS_OPENSSL */
1530 os_free(config->driver_param);
1531 os_free(config->pssid);
1532 os_free(config);
1533 }
1534
1535
1536 /**
1537 * wpa_config_get_network - Get configured network based on id
1538 * @config: Configuration data from wpa_config_read()
1539 * @id: Unique network id to search for
1540 * Returns: Network configuration or %NULL if not found
1541 */
1542 struct wpa_ssid * wpa_config_get_network(struct wpa_config *config, int id)
1543 {
1544 struct wpa_ssid *ssid;
1545
1546 ssid = config->ssid;
1547 while (ssid) {
1548 if (id == ssid->id)
1549 break;
1550 ssid = ssid->next;
1551 }
1552
1553 return ssid;
1554 }
1555
1556
1557 /**
1558 * wpa_config_add_network - Add a new network with empty configuration
1559 * @config: Configuration data from wpa_config_read()
1560 * Returns: The new network configuration or %NULL if operation failed
1561 */
1562 struct wpa_ssid * wpa_config_add_network(struct wpa_config *config)
1563 {
1564 int id;
1565 struct wpa_ssid *ssid, *last = NULL;
1566
1567 id = -1;
1568 ssid = config->ssid;
1569 while (ssid) {
1570 if (ssid->id > id)
1571 id = ssid->id;
1572 last = ssid;
1573 ssid = ssid->next;
1574 }
1575 id++;
1576
1577 ssid = os_zalloc(sizeof(*ssid));
1578 if (ssid == NULL)
1579 return NULL;
1580 ssid->id = id;
1581 if (last)
1582 last->next = ssid;
1583 else
1584 config->ssid = ssid;
1585
1586 wpa_config_update_prio_list(config);
1587
1588 return ssid;
1589 }
1590
1591
1592 /**
1593 * wpa_config_remove_network - Remove a configured network based on id
1594 * @config: Configuration data from wpa_config_read()
1595 * @id: Unique network id to search for
1596 * Returns: 0 on success, or -1 if the network was not found
1597 */
1598 int wpa_config_remove_network(struct wpa_config *config, int id)
1599 {
1600 struct wpa_ssid *ssid, *prev = NULL;
1601
1602 ssid = config->ssid;
1603 while (ssid) {
1604 if (id == ssid->id)
1605 break;
1606 prev = ssid;
1607 ssid = ssid->next;
1608 }
1609
1610 if (ssid == NULL)
1611 return -1;
1612
1613 if (prev)
1614 prev->next = ssid->next;
1615 else
1616 config->ssid = ssid->next;
1617
1618 wpa_config_update_prio_list(config);
1619 wpa_config_free_ssid(ssid);
1620 return 0;
1621 }
1622
1623
1624 /**
1625 * wpa_config_set_network_defaults - Set network default values
1626 * @ssid: Pointer to network configuration data
1627 */
1628 void wpa_config_set_network_defaults(struct wpa_ssid *ssid)
1629 {
1630 ssid->proto = DEFAULT_PROTO;
1631 ssid->pairwise_cipher = DEFAULT_PAIRWISE;
1632 ssid->group_cipher = DEFAULT_GROUP;
1633 ssid->key_mgmt = DEFAULT_KEY_MGMT;
1634 #ifdef IEEE8021X_EAPOL
1635 ssid->eapol_flags = DEFAULT_EAPOL_FLAGS;
1636 ssid->eap_workaround = DEFAULT_EAP_WORKAROUND;
1637 ssid->eap.fragment_size = DEFAULT_FRAGMENT_SIZE;
1638 #endif /* IEEE8021X_EAPOL */
1639 }
1640
1641
1642 /**
1643 * wpa_config_set - Set a variable in network configuration
1644 * @ssid: Pointer to network configuration data
1645 * @var: Variable name, e.g., "ssid"
1646 * @value: Variable value
1647 * @line: Line number in configuration file or 0 if not used
1648 * Returns: 0 on success, -1 on failure
1649 *
1650 * This function can be used to set network configuration variables based on
1651 * both the configuration file and management interface input. The value
1652 * parameter must be in the same format as the text-based configuration file is
1653 * using. For example, strings are using double quotation marks.
1654 */
1655 int wpa_config_set(struct wpa_ssid *ssid, const char *var, const char *value,
1656 int line)
1657 {
1658 size_t i;
1659 int ret = 0;
1660
1661 if (ssid == NULL || var == NULL || value == NULL)
1662 return -1;
1663
1664 for (i = 0; i < NUM_SSID_FIELDS; i++) {
1665 const struct parse_data *field = &ssid_fields[i];
1666 if (os_strcmp(var, field->name) != 0)
1667 continue;
1668
1669 if (field->parser(field, ssid, line, value)) {
1670 if (line) {
1671 wpa_printf(MSG_ERROR, "Line %d: failed to "
1672 "parse %s '%s'.", line, var, value);
1673 }
1674 ret = -1;
1675 }
1676 break;
1677 }
1678 if (i == NUM_SSID_FIELDS) {
1679 if (line) {
1680 wpa_printf(MSG_ERROR, "Line %d: unknown network field "
1681 "'%s'.", line, var);
1682 }
1683 ret = -1;
1684 }
1685
1686 return ret;
1687 }
1688
1689
1690 #ifndef NO_CONFIG_WRITE
1691 /**
1692 * wpa_config_get - Get a variable in network configuration
1693 * @ssid: Pointer to network configuration data
1694 * @var: Variable name, e.g., "ssid"
1695 * Returns: Value of the variable or %NULL on failure
1696 *
1697 * This function can be used to get network configuration variables. The
1698 * returned value is a copy of the configuration variable in text format, i.e,.
1699 * the same format that the text-based configuration file and wpa_config_set()
1700 * are using for the value. The caller is responsible for freeing the returned
1701 * value.
1702 */
1703 char * wpa_config_get(struct wpa_ssid *ssid, const char *var)
1704 {
1705 size_t i;
1706
1707 if (ssid == NULL || var == NULL)
1708 return NULL;
1709
1710 for (i = 0; i < NUM_SSID_FIELDS; i++) {
1711 const struct parse_data *field = &ssid_fields[i];
1712 if (os_strcmp(var, field->name) == 0)
1713 return field->writer(field, ssid);
1714 }
1715
1716 return NULL;
1717 }
1718
1719
1720 /**
1721 * wpa_config_get_no_key - Get a variable in network configuration (no keys)
1722 * @ssid: Pointer to network configuration data
1723 * @var: Variable name, e.g., "ssid"
1724 * Returns: Value of the variable or %NULL on failure
1725 *
1726 * This function can be used to get network configuration variable like
1727 * wpa_config_get(). The only difference is that this functions does not expose
1728 * key/password material from the configuration. In case a key/password field
1729 * is requested, the returned value is an empty string or %NULL if the variable
1730 * is not set or "*" if the variable is set (regardless of its value). The
1731 * returned value is a copy of the configuration variable in text format, i.e,.
1732 * the same format that the text-based configuration file and wpa_config_set()
1733 * are using for the value. The caller is responsible for freeing the returned
1734 * value.
1735 */
1736 char * wpa_config_get_no_key(struct wpa_ssid *ssid, const char *var)
1737 {
1738 size_t i;
1739
1740 if (ssid == NULL || var == NULL)
1741 return NULL;
1742
1743 for (i = 0; i < NUM_SSID_FIELDS; i++) {
1744 const struct parse_data *field = &ssid_fields[i];
1745 if (os_strcmp(var, field->name) == 0) {
1746 char *res = field->writer(field, ssid);
1747 if (field->key_data) {
1748 if (res && res[0]) {
1749 wpa_printf(MSG_DEBUG, "Do not allow "
1750 "key_data field to be "
1751 "exposed");
1752 os_free(res);
1753 return os_strdup("*");
1754 }
1755
1756 os_free(res);
1757 return NULL;
1758 }
1759 return res;
1760 }
1761 }
1762
1763 return NULL;
1764 }
1765 #endif /* NO_CONFIG_WRITE */
1766
1767
1768 /**
1769 * wpa_config_update_psk - Update WPA PSK based on passphrase and SSID
1770 * @ssid: Pointer to network configuration data
1771 *
1772 * This function must be called to update WPA PSK when either SSID or the
1773 * passphrase has changed for the network configuration.
1774 */
1775 void wpa_config_update_psk(struct wpa_ssid *ssid)
1776 {
1777 #ifndef CONFIG_NO_PBKDF2
1778 pbkdf2_sha1(ssid->passphrase,
1779 (char *) ssid->ssid, ssid->ssid_len, 4096,
1780 ssid->psk, PMK_LEN);
1781 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1782 ssid->psk, PMK_LEN);
1783 ssid->psk_set = 1;
1784 #endif /* CONFIG_NO_PBKDF2 */
1785 }
1786
1787
1788 #ifndef CONFIG_NO_CONFIG_BLOBS
1789 /**
1790 * wpa_config_get_blob - Get a named configuration blob
1791 * @config: Configuration data from wpa_config_read()
1792 * @name: Name of the blob
1793 * Returns: Pointer to blob data or %NULL if not found
1794 */
1795 const struct wpa_config_blob * wpa_config_get_blob(struct wpa_config *config,
1796 const char *name)
1797 {
1798 struct wpa_config_blob *blob = config->blobs;
1799
1800 while (blob) {
1801 if (os_strcmp(blob->name, name) == 0)
1802 return blob;
1803 blob = blob->next;
1804 }
1805 return NULL;
1806 }
1807
1808
1809 /**
1810 * wpa_config_set_blob - Set or add a named configuration blob
1811 * @config: Configuration data from wpa_config_read()
1812 * @blob: New value for the blob
1813 *
1814 * Adds a new configuration blob or replaces the current value of an existing
1815 * blob.
1816 */
1817 void wpa_config_set_blob(struct wpa_config *config,
1818 struct wpa_config_blob *blob)
1819 {
1820 wpa_config_remove_blob(config, blob->name);
1821 blob->next = config->blobs;
1822 config->blobs = blob;
1823 }
1824
1825
1826 /**
1827 * wpa_config_free_blob - Free blob data
1828 * @blob: Pointer to blob to be freed
1829 */
1830 void wpa_config_free_blob(struct wpa_config_blob *blob)
1831 {
1832 if (blob) {
1833 os_free(blob->name);
1834 os_free(blob->data);
1835 os_free(blob);
1836 }
1837 }
1838
1839
1840 /**
1841 * wpa_config_remove_blob - Remove a named configuration blob
1842 * @config: Configuration data from wpa_config_read()
1843 * @name: Name of the blob to remove
1844 * Returns: 0 if blob was removed or -1 if blob was not found
1845 */
1846 int wpa_config_remove_blob(struct wpa_config *config, const char *name)
1847 {
1848 struct wpa_config_blob *pos = config->blobs, *prev = NULL;
1849
1850 while (pos) {
1851 if (os_strcmp(pos->name, name) == 0) {
1852 if (prev)
1853 prev->next = pos->next;
1854 else
1855 config->blobs = pos->next;
1856 wpa_config_free_blob(pos);
1857 return 0;
1858 }
1859 prev = pos;
1860 pos = pos->next;
1861 }
1862
1863 return -1;
1864 }
1865 #endif /* CONFIG_NO_CONFIG_BLOBS */
1866
1867
1868 /**
1869 * wpa_config_alloc_empty - Allocate an empty configuration
1870 * @ctrl_interface: Control interface parameters, e.g., path to UNIX domain
1871 * socket
1872 * @driver_param: Driver parameters
1873 * Returns: Pointer to allocated configuration data or %NULL on failure
1874 */
1875 struct wpa_config * wpa_config_alloc_empty(const char *ctrl_interface,
1876 const char *driver_param)
1877 {
1878 struct wpa_config *config;
1879
1880 config = os_zalloc(sizeof(*config));
1881 if (config == NULL)
1882 return NULL;
1883 config->eapol_version = DEFAULT_EAPOL_VERSION;
1884 config->ap_scan = DEFAULT_AP_SCAN;
1885 config->fast_reauth = DEFAULT_FAST_REAUTH;
1886
1887 if (ctrl_interface)
1888 config->ctrl_interface = os_strdup(ctrl_interface);
1889 if (driver_param)
1890 config->driver_param = os_strdup(driver_param);
1891
1892 return config;
1893 }
1894
1895
1896 #ifndef CONFIG_NO_STDOUT_DEBUG
1897 /**
1898 * wpa_config_debug_dump_networks - Debug dump of configured networks
1899 * @config: Configuration data from wpa_config_read()
1900 */
1901 void wpa_config_debug_dump_networks(struct wpa_config *config)
1902 {
1903 int prio;
1904 struct wpa_ssid *ssid;
1905
1906 for (prio = 0; prio < config->num_prio; prio++) {
1907 ssid = config->pssid[prio];
1908 wpa_printf(MSG_DEBUG, "Priority group %d",
1909 ssid->priority);
1910 while (ssid) {
1911 wpa_printf(MSG_DEBUG, " id=%d ssid='%s'",
1912 ssid->id,
1913 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1914 ssid = ssid->pnext;
1915 }
1916 }
1917 }
1918 #endif /* CONFIG_NO_STDOUT_DEBUG */
NetBSD on the FriendlyARM MINI2440