xref: /netbsd/external/bsd/wpa/dist/src/utils/common.c (revision 0dddab58)
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