1/*
2 * wpa_supplicant/hostapd / common helper functions, etc.
3 * Copyright (c) 2002-2007, 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
15static 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
27int 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
40static 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 */
65int 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 */
79int 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 */
113int 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 */
138int 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 */
170int 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
188int 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 */
221void 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
233void wpa_get_ntp_timestamp(u8 *buf)
234{
235	struct os_time now;
236	u32 sec, usec;
237	be32 tmp;
238
239	/* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
240	os_get_time(&now);
241	sec = now.sec + 2208988800U; /* Epoch to 1900 */
242	/* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
243	usec = now.usec;
244	usec = 4295 * usec - (usec >> 5) - (usec >> 9);
245	tmp = host_to_be32(sec);
246	os_memcpy(buf, (u8 *) &tmp, 4);
247	tmp = host_to_be32(usec);
248	os_memcpy(buf + 4, (u8 *) &tmp, 4);
249}
250
251/**
252 * wpa_scnprintf - Simpler-to-use snprintf function
253 * @buf: Output buffer
254 * @size: Buffer size
255 * @fmt: format
256 *
257 * Simpler snprintf version that doesn't require further error checks - the
258 * return value only indicates how many bytes were actually written, excluding
259 * the NULL byte (i.e., 0 on error, size-1 if buffer is not big enough).
260 */
261int wpa_scnprintf(char *buf, size_t size, const char *fmt, ...)
262{
263	va_list ap;
264	int ret;
265
266	if (!size)
267		return 0;
268
269	va_start(ap, fmt);
270	ret = vsnprintf(buf, size, fmt, ap);
271	va_end(ap);
272
273	if (ret < 0)
274		return 0;
275	if ((size_t) ret >= size)
276		return size - 1;
277
278	return ret;
279}
280
281
282int wpa_snprintf_hex_sep(char *buf, size_t buf_size, const u8 *data, size_t len,
283			 char sep)
284{
285	size_t i;
286	char *pos = buf, *end = buf + buf_size;
287	int ret;
288
289	if (buf_size == 0)
290		return 0;
291
292	for (i = 0; i < len; i++) {
293		ret = os_snprintf(pos, end - pos, "%02x%c",
294				  data[i], sep);
295		if (os_snprintf_error(end - pos, ret)) {
296			end[-1] = '\0';
297			return pos - buf;
298		}
299		pos += ret;
300	}
301	pos[-1] = '\0';
302	return pos - buf;
303}
304
305
306static inline int _wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data,
307				    size_t len, int uppercase)
308{
309	size_t i;
310	char *pos = buf, *end = buf + buf_size;
311	int ret;
312	if (buf_size == 0)
313		return 0;
314	for (i = 0; i < len; i++) {
315		ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
316				  data[i]);
317		if (os_snprintf_error(end - pos, ret)) {
318			end[-1] = '\0';
319			return pos - buf;
320		}
321		pos += ret;
322	}
323	end[-1] = '\0';
324	return pos - buf;
325}
326
327/**
328 * wpa_snprintf_hex - Print data as a hex string into a buffer
329 * @buf: Memory area to use as the output buffer
330 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
331 * @data: Data to be printed
332 * @len: Length of data in bytes
333 * Returns: Number of bytes written
334 */
335int wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data, size_t len)
336{
337	return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
338}
339
340
341/**
342 * wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
343 * @buf: Memory area to use as the output buffer
344 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
345 * @data: Data to be printed
346 * @len: Length of data in bytes
347 * Returns: Number of bytes written
348 */
349int wpa_snprintf_hex_uppercase(char *buf, size_t buf_size, const u8 *data,
350			       size_t len)
351{
352	return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
353}
354
355
356#ifdef CONFIG_ANSI_C_EXTRA
357
358#ifdef _WIN32_WCE
359void perror(const char *s)
360{
361	wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
362		   s, (int) GetLastError());
363}
364#endif /* _WIN32_WCE */
365
366
367int optind = 1;
368int optopt;
369char *optarg;
370
371int getopt(int argc, char *const argv[], const char *optstring)
372{
373	static int optchr = 1;
374	char *cp;
375
376	if (optchr == 1) {
377		if (optind >= argc) {
378			/* all arguments processed */
379			return EOF;
380		}
381
382		if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
383			/* no option characters */
384			return EOF;
385		}
386	}
387
388	if (os_strcmp(argv[optind], "--") == 0) {
389		/* no more options */
390		optind++;
391		return EOF;
392	}
393
394	optopt = argv[optind][optchr];
395	cp = os_strchr(optstring, optopt);
396	if (cp == NULL || optopt == ':') {
397		if (argv[optind][++optchr] == '\0') {
398			optchr = 1;
399			optind++;
400		}
401		return '?';
402	}
403
404	if (cp[1] == ':') {
405		/* Argument required */
406		optchr = 1;
407		if (argv[optind][optchr + 1]) {
408			/* No space between option and argument */
409			optarg = &argv[optind++][optchr + 1];
410		} else if (++optind >= argc) {
411			/* option requires an argument */
412			return '?';
413		} else {
414			/* Argument in the next argv */
415			optarg = argv[optind++];
416		}
417	} else {
418		/* No argument */
419		if (argv[optind][++optchr] == '\0') {
420			optchr = 1;
421			optind++;
422		}
423		optarg = NULL;
424	}
425	return *cp;
426}
427#endif /* CONFIG_ANSI_C_EXTRA */
428
429
430#ifdef CONFIG_NATIVE_WINDOWS
431/**
432 * wpa_unicode2ascii_inplace - Convert unicode string into ASCII
433 * @str: Pointer to string to convert
434 *
435 * This function converts a unicode string to ASCII using the same
436 * buffer for output. If UNICODE is not set, the buffer is not
437 * modified.
438 */
439void wpa_unicode2ascii_inplace(TCHAR *str)
440{
441#ifdef UNICODE
442	char *dst = (char *) str;
443	while (*str)
444		*dst++ = (char) *str++;
445	*dst = '\0';
446#endif /* UNICODE */
447}
448
449
450TCHAR * wpa_strdup_tchar(const char *str)
451{
452#ifdef UNICODE
453	TCHAR *buf;
454	buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
455	if (buf == NULL)
456		return NULL;
457	wsprintf(buf, L"%S", str);
458	return buf;
459#else /* UNICODE */
460	return os_strdup(str);
461#endif /* UNICODE */
462}
463#endif /* CONFIG_NATIVE_WINDOWS */
464
465
466void printf_encode(char *txt, size_t maxlen, const u8 *data, size_t len)
467{
468	char *end = txt + maxlen;
469	size_t i;
470
471	for (i = 0; i < len; i++) {
472		if (txt + 4 >= end)
473			break;
474
475		switch (data[i]) {
476		case '\"':
477			*txt++ = '\\';
478			*txt++ = '\"';
479			break;
480		case '\\':
481			*txt++ = '\\';
482			*txt++ = '\\';
483			break;
484		case '\033':
485			*txt++ = '\\';
486			*txt++ = 'e';
487			break;
488		case '\n':
489			*txt++ = '\\';
490			*txt++ = 'n';
491			break;
492		case '\r':
493			*txt++ = '\\';
494			*txt++ = 'r';
495			break;
496		case '\t':
497			*txt++ = '\\';
498			*txt++ = 't';
499			break;
500		default:
501			if (data[i] >= 32 && data[i] <= 126) {
502				*txt++ = data[i];
503			} else {
504				txt += os_snprintf(txt, end - txt, "\\x%02x",
505						   data[i]);
506			}
507			break;
508		}
509	}
510
511	*txt = '\0';
512}
513
514
515size_t printf_decode(u8 *buf, size_t maxlen, const char *str)
516{
517	const char *pos = str;
518	size_t len = 0;
519	int val;
520
521	while (*pos) {
522		if (len + 1 >= maxlen)
523			break;
524		switch (*pos) {
525		case '\\':
526			pos++;
527			switch (*pos) {
528			case '\\':
529				buf[len++] = '\\';
530				pos++;
531				break;
532			case '"':
533				buf[len++] = '"';
534				pos++;
535				break;
536			case 'n':
537				buf[len++] = '\n';
538				pos++;
539				break;
540			case 'r':
541				buf[len++] = '\r';
542				pos++;
543				break;
544			case 't':
545				buf[len++] = '\t';
546				pos++;
547				break;
548			case 'e':
549				buf[len++] = '\033';
550				pos++;
551				break;
552			case 'x':
553				pos++;
554				val = hex2byte(pos);
555				if (val < 0) {
556					val = hex2num(*pos);
557					if (val < 0)
558						break;
559					buf[len++] = val;
560					pos++;
561				} else {
562					buf[len++] = val;
563					pos += 2;
564				}
565				break;
566			case '0':
567			case '1':
568			case '2':
569			case '3':
570			case '4':
571			case '5':
572			case '6':
573			case '7':
574				val = *pos++ - '0';
575				if (*pos >= '0' && *pos <= '7')
576					val = val * 8 + (*pos++ - '0');
577				if (*pos >= '0' && *pos <= '7')
578					val = val * 8 + (*pos++ - '0');
579				buf[len++] = val;
580				break;
581			default:
582				break;
583			}
584			break;
585		default:
586			buf[len++] = *pos++;
587			break;
588		}
589	}
590	if (maxlen > len)
591		buf[len] = '\0';
592
593	return len;
594}
595
596
597/**
598 * wpa_ssid_txt - Convert SSID to a printable string
599 * @ssid: SSID (32-octet string)
600 * @ssid_len: Length of ssid in octets
601 * Returns: Pointer to a printable string
602 *
603 * This function can be used to convert SSIDs into printable form. In most
604 * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
605 * does not limit the used character set, so anything could be used in an SSID.
606 *
607 * This function uses a static buffer, so only one call can be used at the
608 * time, i.e., this is not re-entrant and the returned buffer must be used
609 * before calling this again.
610 */
611const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
612{
613	static char ssid_txt[SSID_MAX_LEN * 4 + 1];
614
615	if (ssid == NULL) {
616		ssid_txt[0] = '\0';
617		return ssid_txt;
618	}
619
620	printf_encode(ssid_txt, sizeof(ssid_txt), ssid, ssid_len);
621	return ssid_txt;
622}
623
624
625void * __hide_aliasing_typecast(void *foo)
626{
627	return foo;
628}
629
630
631char * wpa_config_parse_string(const char *value, size_t *len)
632{
633	if (*value == '"') {
634		const char *pos;
635		char *str;
636		value++;
637		pos = os_strrchr(value, '"');
638		if (pos == NULL || pos[1] != '\0')
639			return NULL;
640		*len = pos - value;
641		str = dup_binstr(value, *len);
642		if (str == NULL)
643			return NULL;
644		return str;
645	} else if (*value == 'P' && value[1] == '"') {
646		const char *pos;
647		char *tstr, *str;
648		size_t tlen;
649		value += 2;
650		pos = os_strrchr(value, '"');
651		if (pos == NULL || pos[1] != '\0')
652			return NULL;
653		tlen = pos - value;
654		tstr = dup_binstr(value, tlen);
655		if (tstr == NULL)
656			return NULL;
657
658		str = os_malloc(tlen + 1);
659		if (str == NULL) {
660			os_free(tstr);
661			return NULL;
662		}
663
664		*len = printf_decode((u8 *) str, tlen + 1, tstr);
665		os_free(tstr);
666
667		return str;
668	} else {
669		u8 *str;
670		size_t tlen, hlen = os_strlen(value);
671		if (hlen & 1)
672			return NULL;
673		tlen = hlen / 2;
674		str = os_malloc(tlen + 1);
675		if (str == NULL)
676			return NULL;
677		if (hexstr2bin(value, str, tlen)) {
678			os_free(str);
679			return NULL;
680		}
681		str[tlen] = '\0';
682		*len = tlen;
683		return (char *) str;
684	}
685}
686
687
688int is_hex(const u8 *data, size_t len)
689{
690	size_t i;
691
692	for (i = 0; i < len; i++) {
693		if (data[i] < 32 || data[i] >= 127)
694			return 1;
695	}
696	return 0;
697}
698
699
700size_t merge_byte_arrays(u8 *res, size_t res_len,
701			 const u8 *src1, size_t src1_len,
702			 const u8 *src2, size_t src2_len)
703{
704	size_t len = 0;
705
706	os_memset(res, 0, res_len);
707
708	if (src1) {
709		if (src1_len >= res_len) {
710			os_memcpy(res, src1, res_len);
711			return res_len;
712		}
713
714		os_memcpy(res, src1, src1_len);
715		len += src1_len;
716	}
717
718	if (src2) {
719		if (len + src2_len >= res_len) {
720			os_memcpy(res + len, src2, res_len - len);
721			return res_len;
722		}
723
724		os_memcpy(res + len, src2, src2_len);
725		len += src2_len;
726	}
727
728	return len;
729}
730
731
732char * dup_binstr(const void *src, size_t len)
733{
734	char *res;
735
736	if (src == NULL)
737		return NULL;
738	res = os_malloc(len + 1);
739	if (res == NULL)
740		return NULL;
741	os_memcpy(res, src, len);
742	res[len] = '\0';
743
744	return res;
745}
746
747
748int freq_range_list_parse(struct wpa_freq_range_list *res, const char *value)
749{
750	struct wpa_freq_range *freq = NULL, *n;
751	unsigned int count = 0;
752	const char *pos, *pos2, *pos3;
753
754	/*
755	 * Comma separated list of frequency ranges.
756	 * For example: 2412-2432,2462,5000-6000
757	 */
758	pos = value;
759	while (pos && pos[0]) {
760		n = os_realloc_array(freq, count + 1,
761				     sizeof(struct wpa_freq_range));
762		if (n == NULL) {
763			os_free(freq);
764			return -1;
765		}
766		freq = n;
767		freq[count].min = atoi(pos);
768		pos2 = os_strchr(pos, '-');
769		pos3 = os_strchr(pos, ',');
770		if (pos2 && (!pos3 || pos2 < pos3)) {
771			pos2++;
772			freq[count].max = atoi(pos2);
773		} else
774			freq[count].max = freq[count].min;
775		pos = pos3;
776		if (pos)
777			pos++;
778		count++;
779	}
780
781	os_free(res->range);
782	res->range = freq;
783	res->num = count;
784
785	return 0;
786}
787
788
789int freq_range_list_includes(const struct wpa_freq_range_list *list,
790			     unsigned int freq)
791{
792	unsigned int i;
793
794	if (list == NULL)
795		return 0;
796
797	for (i = 0; i < list->num; i++) {
798		if (freq >= list->range[i].min && freq <= list->range[i].max)
799			return 1;
800	}
801
802	return 0;
803}
804
805
806char * freq_range_list_str(const struct wpa_freq_range_list *list)
807{
808	char *buf, *pos, *end;
809	size_t maxlen;
810	unsigned int i;
811	int res;
812
813	if (list->num == 0)
814		return NULL;
815
816	maxlen = list->num * 30;
817	buf = os_malloc(maxlen);
818	if (buf == NULL)
819		return NULL;
820	pos = buf;
821	end = buf + maxlen;
822
823	for (i = 0; i < list->num; i++) {
824		struct wpa_freq_range *range = &list->range[i];
825
826		if (range->min == range->max)
827			res = os_snprintf(pos, end - pos, "%s%u",
828					  i == 0 ? "" : ",", range->min);
829		else
830			res = os_snprintf(pos, end - pos, "%s%u-%u",
831					  i == 0 ? "" : ",",
832					  range->min, range->max);
833		if (os_snprintf_error(end - pos, res)) {
834			os_free(buf);
835			return NULL;
836		}
837		pos += res;
838	}
839
840	return buf;
841}
842
843
844int int_array_len(const int *a)
845{
846	int i;
847	for (i = 0; a && a[i]; i++)
848		;
849	return i;
850}
851
852
853void int_array_concat(int **res, const int *a)
854{
855	int reslen, alen, i;
856	int *n;
857
858	reslen = int_array_len(*res);
859	alen = int_array_len(a);
860
861	n = os_realloc_array(*res, reslen + alen + 1, sizeof(int));
862	if (n == NULL) {
863		os_free(*res);
864		*res = NULL;
865		return;
866	}
867	for (i = 0; i <= alen; i++)
868		n[reslen + i] = a[i];
869	*res = n;
870}
871
872
873static int freq_cmp(const void *a, const void *b)
874{
875	int _a = *(int *) a;
876	int _b = *(int *) b;
877
878	if (_a == 0)
879		return 1;
880	if (_b == 0)
881		return -1;
882	return _a - _b;
883}
884
885
886void int_array_sort_unique(int *a)
887{
888	int alen;
889	int i, j;
890
891	if (a == NULL)
892		return;
893
894	alen = int_array_len(a);
895	qsort(a, alen, sizeof(int), freq_cmp);
896
897	i = 0;
898	j = 1;
899	while (a[i] && a[j]) {
900		if (a[i] == a[j]) {
901			j++;
902			continue;
903		}
904		a[++i] = a[j++];
905	}
906	if (a[i])
907		i++;
908	a[i] = 0;
909}
910
911
912void int_array_add_unique(int **res, int a)
913{
914	int reslen;
915	int *n;
916
917	for (reslen = 0; *res && (*res)[reslen]; reslen++) {
918		if ((*res)[reslen] == a)
919			return; /* already in the list */
920	}
921
922	n = os_realloc_array(*res, reslen + 2, sizeof(int));
923	if (n == NULL) {
924		os_free(*res);
925		*res = NULL;
926		return;
927	}
928
929	n[reslen] = a;
930	n[reslen + 1] = 0;
931
932	*res = n;
933}
934
935
936void str_clear_free(char *str)
937{
938	if (str) {
939		size_t len = os_strlen(str);
940		os_memset(str, 0, len);
941		os_free(str);
942	}
943}
944
945
946void bin_clear_free(void *bin, size_t len)
947{
948	if (bin) {
949		os_memset(bin, 0, len);
950		os_free(bin);
951	}
952}
953
954
955int random_mac_addr(u8 *addr)
956{
957	if (os_get_random(addr, ETH_ALEN) < 0)
958		return -1;
959	addr[0] &= 0xfe; /* unicast */
960	addr[0] |= 0x02; /* locally administered */
961	return 0;
962}
963
964
965int random_mac_addr_keep_oui(u8 *addr)
966{
967	if (os_get_random(addr + 3, 3) < 0)
968		return -1;
969	addr[0] &= 0xfe; /* unicast */
970	addr[0] |= 0x02; /* locally administered */
971	return 0;
972}
973
974
975/**
976 * cstr_token - Get next token from const char string
977 * @str: a constant string to tokenize
978 * @delim: a string of delimiters
979 * @last: a pointer to a character following the returned token
980 *      It has to be set to NULL for the first call and passed for any
981 *      futher call.
982 * Returns: a pointer to token position in str or NULL
983 *
984 * This function is similar to str_token, but it can be used with both
985 * char and const char strings. Differences:
986 * - The str buffer remains unmodified
987 * - The returned token is not a NULL terminated string, but a token
988 *   position in str buffer. If a return value is not NULL a size
989 *   of the returned token could be calculated as (last - token).
990 */
991const char * cstr_token(const char *str, const char *delim, const char **last)
992{
993	const char *end, *token = str;
994
995	if (!str || !delim || !last)
996		return NULL;
997
998	if (*last)
999		token = *last;
1000
1001	while (*token && os_strchr(delim, *token))
1002		token++;
1003
1004	if (!*token)
1005		return NULL;
1006
1007	end = token + 1;
1008
1009	while (*end && !os_strchr(delim, *end))
1010		end++;
1011
1012	*last = end;
1013	return token;
1014}
1015
1016
1017/**
1018 * str_token - Get next token from a string
1019 * @buf: String to tokenize. Note that the string might be modified.
1020 * @delim: String of delimiters
1021 * @context: Pointer to save our context. Should be initialized with
1022 *	NULL on the first call, and passed for any further call.
1023 * Returns: The next token, NULL if there are no more valid tokens.
1024 */
1025char * str_token(char *str, const char *delim, char **context)
1026{
1027	char *token = (char *) cstr_token(str, delim, (const char **) context);
1028
1029	if (token && **context)
1030		*(*context)++ = '\0';
1031
1032	return token;
1033}
1034
1035
1036size_t utf8_unescape(const char *inp, size_t in_size,
1037		     char *outp, size_t out_size)
1038{
1039	size_t res_size = 0;
1040
1041	if (!inp || !outp)
1042		return 0;
1043
1044	if (!in_size)
1045		in_size = os_strlen(inp);
1046
1047	/* Advance past leading single quote */
1048	if (*inp == '\'' && in_size) {
1049		inp++;
1050		in_size--;
1051	}
1052
1053	while (in_size--) {
1054		if (res_size >= out_size)
1055			return 0;
1056
1057		switch (*inp) {
1058		case '\'':
1059			/* Terminate on bare single quote */
1060			*outp = '\0';
1061			return res_size;
1062
1063		case '\\':
1064			if (!in_size--)
1065				return 0;
1066			inp++;
1067			/* fall through */
1068
1069		default:
1070			*outp++ = *inp++;
1071			res_size++;
1072		}
1073	}
1074
1075	/* NUL terminate if space allows */
1076	if (res_size < out_size)
1077		*outp = '\0';
1078
1079	return res_size;
1080}
1081
1082
1083size_t utf8_escape(const char *inp, size_t in_size,
1084		   char *outp, size_t out_size)
1085{
1086	size_t res_size = 0;
1087
1088	if (!inp || !outp)
1089		return 0;
1090
1091	/* inp may or may not be NUL terminated, but must be if 0 size
1092	 * is specified */
1093	if (!in_size)
1094		in_size = os_strlen(inp);
1095
1096	while (in_size--) {
1097		if (res_size++ >= out_size)
1098			return 0;
1099
1100		switch (*inp) {
1101		case '\\':
1102		case '\'':
1103			if (res_size++ >= out_size)
1104				return 0;
1105			*outp++ = '\\';
1106			/* fall through */
1107
1108		default:
1109			*outp++ = *inp++;
1110			break;
1111		}
1112	}
1113
1114	/* NUL terminate if space allows */
1115	if (res_size < out_size)
1116		*outp = '\0';
1117
1118	return res_size;
1119}
1120
1121
1122int is_ctrl_char(char c)
1123{
1124	return c > 0 && c < 32;
1125}
1126