1 /*
2 * wpa_supplicant/hostapd / common helper functions, etc.
3 * Copyright (c) 2002-2019, 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/ieee802_11_defs.h"
12 #include "common.h"
13
14
hex2num(char c)15 static int hex2num(char c)
16 {
17 if (c >= '0' && c <= '9')
18 return c - '0';
19 if (c >= 'a' && c <= 'f')
20 return c - 'a' + 10;
21 if (c >= 'A' && c <= 'F')
22 return c - 'A' + 10;
23 return -1;
24 }
25
26
hex2byte(const char * hex)27 int hex2byte(const char *hex)
28 {
29 int a, b;
30 a = hex2num(*hex++);
31 if (a < 0)
32 return -1;
33 b = hex2num(*hex++);
34 if (b < 0)
35 return -1;
36 return (a << 4) | b;
37 }
38
39
hwaddr_parse(const char * txt,u8 * addr)40 static const char * hwaddr_parse(const char *txt, u8 *addr)
41 {
42 size_t i;
43
44 for (i = 0; i < ETH_ALEN; i++) {
45 int a;
46
47 a = hex2byte(txt);
48 if (a < 0)
49 return NULL;
50 txt += 2;
51 addr[i] = a;
52 if (i < ETH_ALEN - 1 && *txt++ != ':')
53 return NULL;
54 }
55 return txt;
56 }
57
58
59 /**
60 * hwaddr_aton - Convert ASCII string to MAC address (colon-delimited format)
61 * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
62 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
63 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
64 */
hwaddr_aton(const char * txt,u8 * addr)65 int hwaddr_aton(const char *txt, u8 *addr)
66 {
67 return hwaddr_parse(txt, addr) ? 0 : -1;
68 }
69
70
71 /**
72 * hwaddr_masked_aton - Convert ASCII string with optional mask to MAC address (colon-delimited format)
73 * @txt: MAC address with optional mask as a string (e.g., "00:11:22:33:44:55/ff:ff:ff:ff:00:00")
74 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
75 * @mask: Buffer for the MAC address mask (ETH_ALEN = 6 bytes)
76 * @maskable: Flag to indicate whether a mask is allowed
77 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
78 */
hwaddr_masked_aton(const char * txt,u8 * addr,u8 * mask,u8 maskable)79 int hwaddr_masked_aton(const char *txt, u8 *addr, u8 *mask, u8 maskable)
80 {
81 const char *r;
82
83 /* parse address part */
84 r = hwaddr_parse(txt, addr);
85 if (!r)
86 return -1;
87
88 /* check for optional mask */
89 if (*r == '\0' || isspace((unsigned char) *r)) {
90 /* no mask specified, assume default */
91 os_memset(mask, 0xff, ETH_ALEN);
92 } else if (maskable && *r == '/') {
93 /* mask specified and allowed */
94 r = hwaddr_parse(r + 1, mask);
95 /* parser error? */
96 if (!r)
97 return -1;
98 } else {
99 /* mask specified but not allowed or trailing garbage */
100 return -1;
101 }
102
103 return 0;
104 }
105
106
107 /**
108 * hwaddr_compact_aton - Convert ASCII string to MAC address (no colon delimitors format)
109 * @txt: MAC address as a string (e.g., "001122334455")
110 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
111 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
112 */
hwaddr_compact_aton(const char * txt,u8 * addr)113 int hwaddr_compact_aton(const char *txt, u8 *addr)
114 {
115 int i;
116
117 for (i = 0; i < 6; i++) {
118 int a, b;
119
120 a = hex2num(*txt++);
121 if (a < 0)
122 return -1;
123 b = hex2num(*txt++);
124 if (b < 0)
125 return -1;
126 *addr++ = (a << 4) | b;
127 }
128
129 return 0;
130 }
131
132 /**
133 * hwaddr_aton2 - Convert ASCII string to MAC address (in any known format)
134 * @txt: MAC address as a string (e.g., 00:11:22:33:44:55 or 0011.2233.4455)
135 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
136 * Returns: Characters used (> 0) on success, -1 on failure
137 */
hwaddr_aton2(const char * txt,u8 * addr)138 int hwaddr_aton2(const char *txt, u8 *addr)
139 {
140 int i;
141 const char *pos = txt;
142
143 for (i = 0; i < 6; i++) {
144 int a, b;
145
146 while (*pos == ':' || *pos == '.' || *pos == '-')
147 pos++;
148
149 a = hex2num(*pos++);
150 if (a < 0)
151 return -1;
152 b = hex2num(*pos++);
153 if (b < 0)
154 return -1;
155 *addr++ = (a << 4) | b;
156 }
157
158 return pos - txt;
159 }
160
161
162 /**
163 * hexstr2bin - Convert ASCII hex string into binary data
164 * @hex: ASCII hex string (e.g., "01ab")
165 * @buf: Buffer for the binary data
166 * @len: Length of the text to convert in bytes (of buf); hex will be double
167 * this size
168 * Returns: 0 on success, -1 on failure (invalid hex string)
169 */
hexstr2bin(const char * hex,u8 * buf,size_t len)170 int hexstr2bin(const char *hex, u8 *buf, size_t len)
171 {
172 size_t i;
173 int a;
174 const char *ipos = hex;
175 u8 *opos = buf;
176
177 for (i = 0; i < len; i++) {
178 a = hex2byte(ipos);
179 if (a < 0)
180 return -1;
181 *opos++ = a;
182 ipos += 2;
183 }
184 return 0;
185 }
186
187
hwaddr_mask_txt(char * buf,size_t len,const u8 * addr,const u8 * mask)188 int hwaddr_mask_txt(char *buf, size_t len, const u8 *addr, const u8 *mask)
189 {
190 size_t i;
191 int print_mask = 0;
192 int res;
193
194 for (i = 0; i < ETH_ALEN; i++) {
195 if (mask[i] != 0xff) {
196 print_mask = 1;
197 break;
198 }
199 }
200
201 if (print_mask)
202 res = os_snprintf(buf, len, MACSTR "/" MACSTR,
203 MAC2STR(addr), MAC2STR(mask));
204 else
205 res = os_snprintf(buf, len, MACSTR, MAC2STR(addr));
206 if (os_snprintf_error(len, res))
207 return -1;
208 return res;
209 }
210
211
212 /**
213 * inc_byte_array - Increment arbitrary length byte array by one
214 * @counter: Pointer to byte array
215 * @len: Length of the counter in bytes
216 *
217 * This function increments the last byte of the counter by one and continues
218 * rolling over to more significant bytes if the byte was incremented from
219 * 0xff to 0x00.
220 */
inc_byte_array(u8 * counter,size_t len)221 void inc_byte_array(u8 *counter, size_t len)
222 {
223 int pos = len - 1;
224 while (pos >= 0) {
225 counter[pos]++;
226 if (counter[pos] != 0)
227 break;
228 pos--;
229 }
230 }
231
232
buf_shift_right(u8 * buf,size_t len,size_t bits)233 void buf_shift_right(u8 *buf, size_t len, size_t bits)
234 {
235 size_t i;
236
237 for (i = len - 1; i > 0; i--)
238 buf[i] = (buf[i - 1] << (8 - bits)) | (buf[i] >> bits);
239 buf[0] >>= bits;
240 }
241
242
wpa_get_ntp_timestamp(u8 * buf)243 void wpa_get_ntp_timestamp(u8 *buf)
244 {
245 struct os_time now;
246 u32 sec, usec;
247 be32 tmp;
248
249 /* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
250 os_get_time(&now);
251 sec = now.sec + 2208988800U; /* Epoch to 1900 */
252 /* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
253 usec = now.usec;
254 usec = 4295 * usec - (usec >> 5) - (usec >> 9);
255 tmp = host_to_be32(sec);
256 os_memcpy(buf, (u8 *) &tmp, 4);
257 tmp = host_to_be32(usec);
258 os_memcpy(buf + 4, (u8 *) &tmp, 4);
259 }
260
261 /**
262 * wpa_scnprintf - Simpler-to-use snprintf function
263 * @buf: Output buffer
264 * @size: Buffer size
265 * @fmt: format
266 *
267 * Simpler snprintf version that doesn't require further error checks - the
268 * return value only indicates how many bytes were actually written, excluding
269 * the NULL byte (i.e., 0 on error, size-1 if buffer is not big enough).
270 */
wpa_scnprintf(char * buf,size_t size,const char * fmt,...)271 int wpa_scnprintf(char *buf, size_t size, const char *fmt, ...)
272 {
273 va_list ap;
274 int ret;
275
276 if (!size)
277 return 0;
278
279 va_start(ap, fmt);
280 ret = vsnprintf(buf, size, fmt, ap);
281 va_end(ap);
282
283 if (ret < 0)
284 return 0;
285 if ((size_t) ret >= size)
286 return size - 1;
287
288 return ret;
289 }
290
291
wpa_snprintf_hex_sep(char * buf,size_t buf_size,const u8 * data,size_t len,char sep)292 int wpa_snprintf_hex_sep(char *buf, size_t buf_size, const u8 *data, size_t len,
293 char sep)
294 {
295 size_t i;
296 char *pos = buf, *end = buf + buf_size;
297 int ret;
298
299 if (buf_size == 0)
300 return 0;
301
302 for (i = 0; i < len; i++) {
303 ret = os_snprintf(pos, end - pos, "%02x%c",
304 data[i], sep);
305 if (os_snprintf_error(end - pos, ret)) {
306 end[-1] = '\0';
307 return pos - buf;
308 }
309 pos += ret;
310 }
311 pos[-1] = '\0';
312 return pos - buf;
313 }
314
315
_wpa_snprintf_hex(char * buf,size_t buf_size,const u8 * data,size_t len,int uppercase)316 static inline int _wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data,
317 size_t len, int uppercase)
318 {
319 size_t i;
320 char *pos = buf, *end = buf + buf_size;
321 int ret;
322 if (buf_size == 0)
323 return 0;
324 for (i = 0; i < len; i++) {
325 ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
326 data[i]);
327 if (os_snprintf_error(end - pos, ret)) {
328 end[-1] = '\0';
329 return pos - buf;
330 }
331 pos += ret;
332 }
333 end[-1] = '\0';
334 return pos - buf;
335 }
336
337 /**
338 * wpa_snprintf_hex - Print data as a hex string into a buffer
339 * @buf: Memory area to use as the output buffer
340 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
341 * @data: Data to be printed
342 * @len: Length of data in bytes
343 * Returns: Number of bytes written
344 */
wpa_snprintf_hex(char * buf,size_t buf_size,const u8 * data,size_t len)345 int wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data, size_t len)
346 {
347 return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
348 }
349
350
351 /**
352 * wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
353 * @buf: Memory area to use as the output buffer
354 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
355 * @data: Data to be printed
356 * @len: Length of data in bytes
357 * Returns: Number of bytes written
358 */
wpa_snprintf_hex_uppercase(char * buf,size_t buf_size,const u8 * data,size_t len)359 int wpa_snprintf_hex_uppercase(char *buf, size_t buf_size, const u8 *data,
360 size_t len)
361 {
362 return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
363 }
364
365
366 #ifdef CONFIG_ANSI_C_EXTRA
367
368 #ifdef _WIN32_WCE
perror(const char * s)369 void perror(const char *s)
370 {
371 wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
372 s, (int) GetLastError());
373 }
374 #endif /* _WIN32_WCE */
375
376
377 int optind = 1;
378 int optopt;
379 char *optarg;
380
getopt(int argc,char * const argv[],const char * optstring)381 int getopt(int argc, char *const argv[], const char *optstring)
382 {
383 static int optchr = 1;
384 char *cp;
385
386 if (optchr == 1) {
387 if (optind >= argc) {
388 /* all arguments processed */
389 return EOF;
390 }
391
392 if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
393 /* no option characters */
394 return EOF;
395 }
396 }
397
398 if (os_strcmp(argv[optind], "--") == 0) {
399 /* no more options */
400 optind++;
401 return EOF;
402 }
403
404 optopt = argv[optind][optchr];
405 cp = os_strchr(optstring, optopt);
406 if (cp == NULL || optopt == ':') {
407 if (argv[optind][++optchr] == '\0') {
408 optchr = 1;
409 optind++;
410 }
411 return '?';
412 }
413
414 if (cp[1] == ':') {
415 /* Argument required */
416 optchr = 1;
417 if (argv[optind][optchr + 1]) {
418 /* No space between option and argument */
419 optarg = &argv[optind++][optchr + 1];
420 } else if (++optind >= argc) {
421 /* option requires an argument */
422 return '?';
423 } else {
424 /* Argument in the next argv */
425 optarg = argv[optind++];
426 }
427 } else {
428 /* No argument */
429 if (argv[optind][++optchr] == '\0') {
430 optchr = 1;
431 optind++;
432 }
433 optarg = NULL;
434 }
435 return *cp;
436 }
437 #endif /* CONFIG_ANSI_C_EXTRA */
438
439
440 #ifdef CONFIG_NATIVE_WINDOWS
441 /**
442 * wpa_unicode2ascii_inplace - Convert unicode string into ASCII
443 * @str: Pointer to string to convert
444 *
445 * This function converts a unicode string to ASCII using the same
446 * buffer for output. If UNICODE is not set, the buffer is not
447 * modified.
448 */
wpa_unicode2ascii_inplace(TCHAR * str)449 void wpa_unicode2ascii_inplace(TCHAR *str)
450 {
451 #ifdef UNICODE
452 char *dst = (char *) str;
453 while (*str)
454 *dst++ = (char) *str++;
455 *dst = '\0';
456 #endif /* UNICODE */
457 }
458
459
wpa_strdup_tchar(const char * str)460 TCHAR * wpa_strdup_tchar(const char *str)
461 {
462 #ifdef UNICODE
463 TCHAR *buf;
464 buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
465 if (buf == NULL)
466 return NULL;
467 wsprintf(buf, L"%S", str);
468 return buf;
469 #else /* UNICODE */
470 return os_strdup(str);
471 #endif /* UNICODE */
472 }
473 #endif /* CONFIG_NATIVE_WINDOWS */
474
475
printf_encode(char * txt,size_t maxlen,const u8 * data,size_t len)476 void printf_encode(char *txt, size_t maxlen, const u8 *data, size_t len)
477 {
478 char *end = txt + maxlen;
479 size_t i;
480
481 for (i = 0; i < len; i++) {
482 if (txt + 4 >= end)
483 break;
484
485 switch (data[i]) {
486 case '\"':
487 *txt++ = '\\';
488 *txt++ = '\"';
489 break;
490 case '\\':
491 *txt++ = '\\';
492 *txt++ = '\\';
493 break;
494 case '\033':
495 *txt++ = '\\';
496 *txt++ = 'e';
497 break;
498 case '\n':
499 *txt++ = '\\';
500 *txt++ = 'n';
501 break;
502 case '\r':
503 *txt++ = '\\';
504 *txt++ = 'r';
505 break;
506 case '\t':
507 *txt++ = '\\';
508 *txt++ = 't';
509 break;
510 default:
511 if (data[i] >= 32 && data[i] <= 126) {
512 *txt++ = data[i];
513 } else {
514 txt += os_snprintf(txt, end - txt, "\\x%02x",
515 data[i]);
516 }
517 break;
518 }
519 }
520
521 *txt = '\0';
522 }
523
524
printf_decode(u8 * buf,size_t maxlen,const char * str)525 size_t printf_decode(u8 *buf, size_t maxlen, const char *str)
526 {
527 const char *pos = str;
528 size_t len = 0;
529 int val;
530
531 while (*pos) {
532 if (len + 1 >= maxlen)
533 break;
534 switch (*pos) {
535 case '\\':
536 pos++;
537 switch (*pos) {
538 case '\\':
539 buf[len++] = '\\';
540 pos++;
541 break;
542 case '"':
543 buf[len++] = '"';
544 pos++;
545 break;
546 case 'n':
547 buf[len++] = '\n';
548 pos++;
549 break;
550 case 'r':
551 buf[len++] = '\r';
552 pos++;
553 break;
554 case 't':
555 buf[len++] = '\t';
556 pos++;
557 break;
558 case 'e':
559 buf[len++] = '\033';
560 pos++;
561 break;
562 case 'x':
563 pos++;
564 val = hex2byte(pos);
565 if (val < 0) {
566 val = hex2num(*pos);
567 if (val < 0)
568 break;
569 buf[len++] = val;
570 pos++;
571 } else {
572 buf[len++] = val;
573 pos += 2;
574 }
575 break;
576 case '0':
577 case '1':
578 case '2':
579 case '3':
580 case '4':
581 case '5':
582 case '6':
583 case '7':
584 val = *pos++ - '0';
585 if (*pos >= '0' && *pos <= '7')
586 val = val * 8 + (*pos++ - '0');
587 if (*pos >= '0' && *pos <= '7')
588 val = val * 8 + (*pos++ - '0');
589 buf[len++] = val;
590 break;
591 default:
592 break;
593 }
594 break;
595 default:
596 buf[len++] = *pos++;
597 break;
598 }
599 }
600 if (maxlen > len)
601 buf[len] = '\0';
602
603 return len;
604 }
605
606
607 /**
608 * wpa_ssid_txt - Convert SSID to a printable string
609 * @ssid: SSID (32-octet string)
610 * @ssid_len: Length of ssid in octets
611 * Returns: Pointer to a printable string
612 *
613 * This function can be used to convert SSIDs into printable form. In most
614 * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
615 * does not limit the used character set, so anything could be used in an SSID.
616 *
617 * This function uses a static buffer, so only one call can be used at the
618 * time, i.e., this is not re-entrant and the returned buffer must be used
619 * before calling this again.
620 */
wpa_ssid_txt(const u8 * ssid,size_t ssid_len)621 const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
622 {
623 static char ssid_txt[SSID_MAX_LEN * 4 + 1];
624
625 if (ssid == NULL) {
626 ssid_txt[0] = '\0';
627 return ssid_txt;
628 }
629
630 printf_encode(ssid_txt, sizeof(ssid_txt), ssid, ssid_len);
631 return ssid_txt;
632 }
633
634
__hide_aliasing_typecast(void * foo)635 void * __hide_aliasing_typecast(void *foo)
636 {
637 return foo;
638 }
639
640
wpa_config_parse_string(const char * value,size_t * len)641 char * wpa_config_parse_string(const char *value, size_t *len)
642 {
643 if (*value == '"') {
644 const char *pos;
645 char *str;
646 value++;
647 pos = os_strrchr(value, '"');
648 if (pos == NULL || pos[1] != '\0')
649 return NULL;
650 *len = pos - value;
651 str = dup_binstr(value, *len);
652 if (str == NULL)
653 return NULL;
654 return str;
655 } else if (*value == 'P' && value[1] == '"') {
656 const char *pos;
657 char *tstr, *str;
658 size_t tlen;
659 value += 2;
660 pos = os_strrchr(value, '"');
661 if (pos == NULL || pos[1] != '\0')
662 return NULL;
663 tlen = pos - value;
664 tstr = dup_binstr(value, tlen);
665 if (tstr == NULL)
666 return NULL;
667
668 str = os_malloc(tlen + 1);
669 if (str == NULL) {
670 os_free(tstr);
671 return NULL;
672 }
673
674 *len = printf_decode((u8 *) str, tlen + 1, tstr);
675 os_free(tstr);
676
677 return str;
678 } else {
679 u8 *str;
680 size_t tlen, hlen = os_strlen(value);
681 if (hlen & 1)
682 return NULL;
683 tlen = hlen / 2;
684 str = os_malloc(tlen + 1);
685 if (str == NULL)
686 return NULL;
687 if (hexstr2bin(value, str, tlen)) {
688 os_free(str);
689 return NULL;
690 }
691 str[tlen] = '\0';
692 *len = tlen;
693 return (char *) str;
694 }
695 }
696
697
is_hex(const u8 * data,size_t len)698 int is_hex(const u8 *data, size_t len)
699 {
700 size_t i;
701
702 for (i = 0; i < len; i++) {
703 if (data[i] < 32 || data[i] >= 127)
704 return 1;
705 }
706 return 0;
707 }
708
709
has_ctrl_char(const u8 * data,size_t len)710 int has_ctrl_char(const u8 *data, size_t len)
711 {
712 size_t i;
713
714 for (i = 0; i < len; i++) {
715 if (data[i] < 32 || data[i] == 127)
716 return 1;
717 }
718 return 0;
719 }
720
721
has_newline(const char * str)722 int has_newline(const char *str)
723 {
724 while (*str) {
725 if (*str == '\n' || *str == '\r')
726 return 1;
727 str++;
728 }
729 return 0;
730 }
731
732
merge_byte_arrays(u8 * res,size_t res_len,const u8 * src1,size_t src1_len,const u8 * src2,size_t src2_len)733 size_t merge_byte_arrays(u8 *res, size_t res_len,
734 const u8 *src1, size_t src1_len,
735 const u8 *src2, size_t src2_len)
736 {
737 size_t len = 0;
738
739 os_memset(res, 0, res_len);
740
741 if (src1) {
742 if (src1_len >= res_len) {
743 os_memcpy(res, src1, res_len);
744 return res_len;
745 }
746
747 os_memcpy(res, src1, src1_len);
748 len += src1_len;
749 }
750
751 if (src2) {
752 if (len + src2_len >= res_len) {
753 os_memcpy(res + len, src2, res_len - len);
754 return res_len;
755 }
756
757 os_memcpy(res + len, src2, src2_len);
758 len += src2_len;
759 }
760
761 return len;
762 }
763
764
dup_binstr(const void * src,size_t len)765 char * dup_binstr(const void *src, size_t len)
766 {
767 char *res;
768
769 if (src == NULL)
770 return NULL;
771 res = os_malloc(len + 1);
772 if (res == NULL)
773 return NULL;
774 os_memcpy(res, src, len);
775 res[len] = '\0';
776
777 return res;
778 }
779
780
freq_range_list_parse(struct wpa_freq_range_list * res,const char * value)781 int freq_range_list_parse(struct wpa_freq_range_list *res, const char *value)
782 {
783 struct wpa_freq_range *freq = NULL, *n;
784 unsigned int count = 0;
785 const char *pos, *pos2, *pos3;
786
787 /*
788 * Comma separated list of frequency ranges.
789 * For example: 2412-2432,2462,5000-6000
790 */
791 pos = value;
792 while (pos && pos[0]) {
793 n = os_realloc_array(freq, count + 1,
794 sizeof(struct wpa_freq_range));
795 if (n == NULL) {
796 os_free(freq);
797 return -1;
798 }
799 freq = n;
800 freq[count].min = atoi(pos);
801 pos2 = os_strchr(pos, '-');
802 pos3 = os_strchr(pos, ',');
803 if (pos2 && (!pos3 || pos2 < pos3)) {
804 pos2++;
805 freq[count].max = atoi(pos2);
806 } else
807 freq[count].max = freq[count].min;
808 pos = pos3;
809 if (pos)
810 pos++;
811 count++;
812 }
813
814 os_free(res->range);
815 res->range = freq;
816 res->num = count;
817
818 return 0;
819 }
820
821
freq_range_list_includes(const struct wpa_freq_range_list * list,unsigned int freq)822 int freq_range_list_includes(const struct wpa_freq_range_list *list,
823 unsigned int freq)
824 {
825 unsigned int i;
826
827 if (list == NULL)
828 return 0;
829
830 for (i = 0; i < list->num; i++) {
831 if (freq >= list->range[i].min && freq <= list->range[i].max)
832 return 1;
833 }
834
835 return 0;
836 }
837
838
freq_range_list_str(const struct wpa_freq_range_list * list)839 char * freq_range_list_str(const struct wpa_freq_range_list *list)
840 {
841 char *buf, *pos, *end;
842 size_t maxlen;
843 unsigned int i;
844 int res;
845
846 if (list->num == 0)
847 return NULL;
848
849 maxlen = list->num * 30;
850 buf = os_malloc(maxlen);
851 if (buf == NULL)
852 return NULL;
853 pos = buf;
854 end = buf + maxlen;
855
856 for (i = 0; i < list->num; i++) {
857 struct wpa_freq_range *range = &list->range[i];
858
859 if (range->min == range->max)
860 res = os_snprintf(pos, end - pos, "%s%u",
861 i == 0 ? "" : ",", range->min);
862 else
863 res = os_snprintf(pos, end - pos, "%s%u-%u",
864 i == 0 ? "" : ",",
865 range->min, range->max);
866 if (os_snprintf_error(end - pos, res)) {
867 os_free(buf);
868 return NULL;
869 }
870 pos += res;
871 }
872
873 return buf;
874 }
875
876
int_array_len(const int * a)877 int int_array_len(const int *a)
878 {
879 int i;
880 for (i = 0; a && a[i]; i++)
881 ;
882 return i;
883 }
884
885
int_array_concat(int ** res,const int * a)886 void int_array_concat(int **res, const int *a)
887 {
888 int reslen, alen, i;
889 int *n;
890
891 reslen = int_array_len(*res);
892 alen = int_array_len(a);
893
894 n = os_realloc_array(*res, reslen + alen + 1, sizeof(int));
895 if (n == NULL) {
896 os_free(*res);
897 *res = NULL;
898 return;
899 }
900 for (i = 0; i <= alen; i++)
901 n[reslen + i] = a[i];
902 *res = n;
903 }
904
905
freq_cmp(const void * a,const void * b)906 static int freq_cmp(const void *a, const void *b)
907 {
908 int _a = *(int *) a;
909 int _b = *(int *) b;
910
911 if (_a == 0)
912 return 1;
913 if (_b == 0)
914 return -1;
915 return _a - _b;
916 }
917
918
int_array_sort_unique(int * a)919 void int_array_sort_unique(int *a)
920 {
921 int alen;
922 int i, j;
923
924 if (a == NULL)
925 return;
926
927 alen = int_array_len(a);
928 qsort(a, alen, sizeof(int), freq_cmp);
929
930 i = 0;
931 j = 1;
932 while (a[i] && a[j]) {
933 if (a[i] == a[j]) {
934 j++;
935 continue;
936 }
937 a[++i] = a[j++];
938 }
939 if (a[i])
940 i++;
941 a[i] = 0;
942 }
943
944
int_array_add_unique(int ** res,int a)945 void int_array_add_unique(int **res, int a)
946 {
947 int reslen;
948 int *n;
949
950 for (reslen = 0; *res && (*res)[reslen]; reslen++) {
951 if ((*res)[reslen] == a)
952 return; /* already in the list */
953 }
954
955 n = os_realloc_array(*res, reslen + 2, sizeof(int));
956 if (n == NULL) {
957 os_free(*res);
958 *res = NULL;
959 return;
960 }
961
962 n[reslen] = a;
963 n[reslen + 1] = 0;
964
965 *res = n;
966 }
967
968
str_clear_free(char * str)969 void str_clear_free(char *str)
970 {
971 if (str) {
972 size_t len = os_strlen(str);
973 forced_memzero(str, len);
974 os_free(str);
975 }
976 }
977
978
bin_clear_free(void * bin,size_t len)979 void bin_clear_free(void *bin, size_t len)
980 {
981 if (bin) {
982 forced_memzero(bin, len);
983 os_free(bin);
984 }
985 }
986
987
random_mac_addr(u8 * addr)988 int random_mac_addr(u8 *addr)
989 {
990 if (os_get_random(addr, ETH_ALEN) < 0)
991 return -1;
992 addr[0] &= 0xfe; /* unicast */
993 addr[0] |= 0x02; /* locally administered */
994 return 0;
995 }
996
997
random_mac_addr_keep_oui(u8 * addr)998 int random_mac_addr_keep_oui(u8 *addr)
999 {
1000 if (os_get_random(addr + 3, 3) < 0)
1001 return -1;
1002 addr[0] &= 0xfe; /* unicast */
1003 addr[0] |= 0x02; /* locally administered */
1004 return 0;
1005 }
1006
1007
1008 /**
1009 * cstr_token - Get next token from const char string
1010 * @str: a constant string to tokenize
1011 * @delim: a string of delimiters
1012 * @last: a pointer to a character following the returned token
1013 * It has to be set to NULL for the first call and passed for any
1014 * further call.
1015 * Returns: a pointer to token position in str or NULL
1016 *
1017 * This function is similar to str_token, but it can be used with both
1018 * char and const char strings. Differences:
1019 * - The str buffer remains unmodified
1020 * - The returned token is not a NULL terminated string, but a token
1021 * position in str buffer. If a return value is not NULL a size
1022 * of the returned token could be calculated as (last - token).
1023 */
cstr_token(const char * str,const char * delim,const char ** last)1024 const char * cstr_token(const char *str, const char *delim, const char **last)
1025 {
1026 const char *end, *token = str;
1027
1028 if (!str || !delim || !last)
1029 return NULL;
1030
1031 if (*last)
1032 token = *last;
1033
1034 while (*token && os_strchr(delim, *token))
1035 token++;
1036
1037 if (!*token)
1038 return NULL;
1039
1040 end = token + 1;
1041
1042 while (*end && !os_strchr(delim, *end))
1043 end++;
1044
1045 *last = end;
1046 return token;
1047 }
1048
1049
1050 /**
1051 * str_token - Get next token from a string
1052 * @buf: String to tokenize. Note that the string might be modified.
1053 * @delim: String of delimiters
1054 * @context: Pointer to save our context. Should be initialized with
1055 * NULL on the first call, and passed for any further call.
1056 * Returns: The next token, NULL if there are no more valid tokens.
1057 */
str_token(char * str,const char * delim,char ** context)1058 char * str_token(char *str, const char *delim, char **context)
1059 {
1060 char *token = (char *) cstr_token(str, delim, (const char **) context);
1061
1062 if (token && **context)
1063 *(*context)++ = '\0';
1064
1065 return token;
1066 }
1067
1068
utf8_unescape(const char * inp,size_t in_size,char * outp,size_t out_size)1069 size_t utf8_unescape(const char *inp, size_t in_size,
1070 char *outp, size_t out_size)
1071 {
1072 size_t res_size = 0;
1073
1074 if (!inp || !outp)
1075 return 0;
1076
1077 if (!in_size)
1078 in_size = os_strlen(inp);
1079
1080 /* Advance past leading single quote */
1081 if (*inp == '\'' && in_size) {
1082 inp++;
1083 in_size--;
1084 }
1085
1086 while (in_size) {
1087 in_size--;
1088 if (res_size >= out_size)
1089 return 0;
1090
1091 switch (*inp) {
1092 case '\'':
1093 /* Terminate on bare single quote */
1094 *outp = '\0';
1095 return res_size;
1096
1097 case '\\':
1098 if (!in_size)
1099 return 0;
1100 in_size--;
1101 inp++;
1102 /* fall through */
1103
1104 default:
1105 *outp++ = *inp++;
1106 res_size++;
1107 }
1108 }
1109
1110 /* NUL terminate if space allows */
1111 if (res_size < out_size)
1112 *outp = '\0';
1113
1114 return res_size;
1115 }
1116
1117
utf8_escape(const char * inp,size_t in_size,char * outp,size_t out_size)1118 size_t utf8_escape(const char *inp, size_t in_size,
1119 char *outp, size_t out_size)
1120 {
1121 size_t res_size = 0;
1122
1123 if (!inp || !outp)
1124 return 0;
1125
1126 /* inp may or may not be NUL terminated, but must be if 0 size
1127 * is specified */
1128 if (!in_size)
1129 in_size = os_strlen(inp);
1130
1131 while (in_size) {
1132 in_size--;
1133 if (res_size++ >= out_size)
1134 return 0;
1135
1136 switch (*inp) {
1137 case '\\':
1138 case '\'':
1139 if (res_size++ >= out_size)
1140 return 0;
1141 *outp++ = '\\';
1142 /* fall through */
1143
1144 default:
1145 *outp++ = *inp++;
1146 break;
1147 }
1148 }
1149
1150 /* NUL terminate if space allows */
1151 if (res_size < out_size)
1152 *outp = '\0';
1153
1154 return res_size;
1155 }
1156
1157
is_ctrl_char(char c)1158 int is_ctrl_char(char c)
1159 {
1160 return c > 0 && c < 32;
1161 }
1162
1163
1164 /**
1165 * ssid_parse - Parse a string that contains SSID in hex or text format
1166 * @buf: Input NULL terminated string that contains the SSID
1167 * @ssid: Output SSID
1168 * Returns: 0 on success, -1 otherwise
1169 *
1170 * The SSID has to be enclosed in double quotes for the text format or space
1171 * or NULL terminated string of hex digits for the hex format. buf can include
1172 * additional arguments after the SSID.
1173 */
ssid_parse(const char * buf,struct wpa_ssid_value * ssid)1174 int ssid_parse(const char *buf, struct wpa_ssid_value *ssid)
1175 {
1176 char *tmp, *res, *end;
1177 size_t len;
1178
1179 ssid->ssid_len = 0;
1180
1181 tmp = os_strdup(buf);
1182 if (!tmp)
1183 return -1;
1184
1185 if (*tmp != '"') {
1186 end = os_strchr(tmp, ' ');
1187 if (end)
1188 *end = '\0';
1189 } else {
1190 end = os_strchr(tmp + 1, '"');
1191 if (!end) {
1192 os_free(tmp);
1193 return -1;
1194 }
1195
1196 end[1] = '\0';
1197 }
1198
1199 res = wpa_config_parse_string(tmp, &len);
1200 if (res && len <= SSID_MAX_LEN) {
1201 ssid->ssid_len = len;
1202 os_memcpy(ssid->ssid, res, len);
1203 }
1204
1205 os_free(tmp);
1206 os_free(res);
1207
1208 return ssid->ssid_len ? 0 : -1;
1209 }
1210
1211
str_starts(const char * str,const char * start)1212 int str_starts(const char *str, const char *start)
1213 {
1214 return os_strncmp(str, start, os_strlen(start)) == 0;
1215 }
1216
1217
1218 /**
1219 * rssi_to_rcpi - Convert RSSI to RCPI
1220 * @rssi: RSSI to convert
1221 * Returns: RCPI corresponding to the given RSSI value, or 255 if not available.
1222 *
1223 * It's possible to estimate RCPI based on RSSI in dBm. This calculation will
1224 * not reflect the correct value for high rates, but it's good enough for Action
1225 * frames which are transmitted with up to 24 Mbps rates.
1226 */
rssi_to_rcpi(int rssi)1227 u8 rssi_to_rcpi(int rssi)
1228 {
1229 if (!rssi)
1230 return 255; /* not available */
1231 if (rssi < -110)
1232 return 0;
1233 if (rssi > 0)
1234 return 220;
1235 return (rssi + 110) * 2;
1236 }
1237
1238
get_param(const char * cmd,const char * param)1239 char * get_param(const char *cmd, const char *param)
1240 {
1241 const char *pos, *end;
1242 char *val;
1243 size_t len;
1244
1245 pos = os_strstr(cmd, param);
1246 if (!pos)
1247 return NULL;
1248
1249 pos += os_strlen(param);
1250 end = os_strchr(pos, ' ');
1251 if (end)
1252 len = end - pos;
1253 else
1254 len = os_strlen(pos);
1255 val = os_malloc(len + 1);
1256 if (!val)
1257 return NULL;
1258 os_memcpy(val, pos, len);
1259 val[len] = '\0';
1260 return val;
1261 }
1262
1263
1264 /* Try to prevent most compilers from optimizing out clearing of memory that
1265 * becomes unaccessible after this function is called. This is mostly the case
1266 * for clearing local stack variables at the end of a function. This is not
1267 * exactly perfect, i.e., someone could come up with a compiler that figures out
1268 * the pointer is pointing to memset and then end up optimizing the call out, so
1269 * try go a bit further by storing the first octet (now zero) to make this even
1270 * a bit more difficult to optimize out. Once memset_s() is available, that
1271 * could be used here instead. */
1272 static void * (* const volatile memset_func)(void *, int, size_t) = memset;
1273 static u8 forced_memzero_val;
1274
forced_memzero(void * ptr,size_t len)1275 void forced_memzero(void *ptr, size_t len)
1276 {
1277 memset_func(ptr, 0, len);
1278 if (len)
1279 forced_memzero_val = ((u8 *) ptr)[0];
1280 }
1281