[thirdparty/hostap.git] / src / utils / common.c

/*
 * wpa_supplicant/hostapd / common helper functions, etc.
 * Copyright (c) 2002-2007, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"

#include "common.h"


static int hex2num(char c)
{
	if (c >= '0' && c <= '9')
		return c - '0';
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	return -1;
}


int hex2byte(const char *hex)
{
	int a, b;
	a = hex2num(*hex++);
	if (a < 0)
		return -1;
	b = hex2num(*hex++);
	if (b < 0)
		return -1;
	return (a << 4) | b;
}


/**
 * hwaddr_aton - Convert ASCII string to MAC address (colon-delimited format)
 * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
 */
int hwaddr_aton(const char *txt, u8 *addr)
{
	int i;

	for (i = 0; i < 6; i++) {
		int a, b;

		a = hex2num(*txt++);
		if (a < 0)
			return -1;
		b = hex2num(*txt++);
		if (b < 0)
			return -1;
		*addr++ = (a << 4) | b;
		if (i < 5 && *txt++ != ':')
			return -1;
	}

	return 0;
}

/**
 * hwaddr_compact_aton - Convert ASCII string to MAC address (no colon delimitors format)
 * @txt: MAC address as a string (e.g., "001122334455")
 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
 */
int hwaddr_compact_aton(const char *txt, u8 *addr)
{
	int i;

	for (i = 0; i < 6; i++) {
		int a, b;

		a = hex2num(*txt++);
		if (a < 0)
			return -1;
		b = hex2num(*txt++);
		if (b < 0)
			return -1;
		*addr++ = (a << 4) | b;
	}

	return 0;
}

/**
 * hwaddr_aton2 - Convert ASCII string to MAC address (in any known format)
 * @txt: MAC address as a string (e.g., 00:11:22:33:44:55 or 0011.2233.4455)
 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 * Returns: Characters used (> 0) on success, -1 on failure
 */
int hwaddr_aton2(const char *txt, u8 *addr)
{
	int i;
	const char *pos = txt;

	for (i = 0; i < 6; i++) {
		int a, b;

		while (*pos == ':' || *pos == '.' || *pos == '-')
			pos++;

		a = hex2num(*pos++);
		if (a < 0)
			return -1;
		b = hex2num(*pos++);
		if (b < 0)
			return -1;
		*addr++ = (a << 4) | b;
	}

	return pos - txt;
}


/**
 * hexstr2bin - Convert ASCII hex string into binary data
 * @hex: ASCII hex string (e.g., "01ab")
 * @buf: Buffer for the binary data
 * @len: Length of the text to convert in bytes (of buf); hex will be double
 * this size
 * Returns: 0 on success, -1 on failure (invalid hex string)
 */
int hexstr2bin(const char *hex, u8 *buf, size_t len)
{
	size_t i;
	int a;
	const char *ipos = hex;
	u8 *opos = buf;

	for (i = 0; i < len; i++) {
		a = hex2byte(ipos);
		if (a < 0)
			return -1;
		*opos++ = a;
		ipos += 2;
	}
	return 0;
}


/**
 * inc_byte_array - Increment arbitrary length byte array by one
 * @counter: Pointer to byte array
 * @len: Length of the counter in bytes
 *
 * This function increments the last byte of the counter by one and continues
 * rolling over to more significant bytes if the byte was incremented from
 * 0xff to 0x00.
 */
void inc_byte_array(u8 *counter, size_t len)
{
	int pos = len - 1;
	while (pos >= 0) {
		counter[pos]++;
		if (counter[pos] != 0)
			break;
		pos--;
	}
}


void wpa_get_ntp_timestamp(u8 *buf)
{
	struct os_time now;
	u32 sec, usec;
	be32 tmp;

	/* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
	os_get_time(&now);
	sec = now.sec + 2208988800U; /* Epoch to 1900 */
	/* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
	usec = now.usec;
	usec = 4295 * usec - (usec >> 5) - (usec >> 9);
	tmp = host_to_be32(sec);
	os_memcpy(buf, (u8 *) &tmp, 4);
	tmp = host_to_be32(usec);
	os_memcpy(buf + 4, (u8 *) &tmp, 4);
}


static inline int _wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data,
				    size_t len, int uppercase)
{
	size_t i;
	char *pos = buf, *end = buf + buf_size;
	int ret;
	if (buf_size == 0)
		return 0;
	for (i = 0; i < len; i++) {
		ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
				  data[i]);
		if (ret < 0 || ret >= end - pos) {
			end[-1] = '\0';
			return pos - buf;
		}
		pos += ret;
	}
	end[-1] = '\0';
	return pos - buf;
}

/**
 * wpa_snprintf_hex - Print data as a hex string into a buffer
 * @buf: Memory area to use as the output buffer
 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
 * @data: Data to be printed
 * @len: Length of data in bytes
 * Returns: Number of bytes written
 */
int wpa_snprintf_hex(char *buf, size_t buf_size, const u8 *data, size_t len)
{
	return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
}


/**
 * wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
 * @buf: Memory area to use as the output buffer
 * @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
 * @data: Data to be printed
 * @len: Length of data in bytes
 * Returns: Number of bytes written
 */
int wpa_snprintf_hex_uppercase(char *buf, size_t buf_size, const u8 *data,
			       size_t len)
{
	return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
}


#ifdef CONFIG_ANSI_C_EXTRA

#ifdef _WIN32_WCE
void perror(const char *s)
{
	wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
		   s, (int) GetLastError());
}
#endif /* _WIN32_WCE */


int optind = 1;
int optopt;
char *optarg;

int getopt(int argc, char *const argv[], const char *optstring)
{
	static int optchr = 1;
	char *cp;

	if (optchr == 1) {
		if (optind >= argc) {
			/* all arguments processed */
			return EOF;
		}

		if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
			/* no option characters */
			return EOF;
		}
	}

	if (os_strcmp(argv[optind], "--") == 0) {
		/* no more options */
		optind++;
		return EOF;
	}

	optopt = argv[optind][optchr];
	cp = os_strchr(optstring, optopt);
	if (cp == NULL || optopt == ':') {
		if (argv[optind][++optchr] == '\0') {
			optchr = 1;
			optind++;
		}
		return '?';
	}

	if (cp[1] == ':') {
		/* Argument required */
		optchr = 1;
		if (argv[optind][optchr + 1]) {
			/* No space between option and argument */
			optarg = &argv[optind++][optchr + 1];
		} else if (++optind >= argc) {
			/* option requires an argument */
			return '?';
		} else {
			/* Argument in the next argv */
			optarg = argv[optind++];
		}
	} else {
		/* No argument */
		if (argv[optind][++optchr] == '\0') {
			optchr = 1;
			optind++;
		}
		optarg = NULL;
	}
	return *cp;
}
#endif /* CONFIG_ANSI_C_EXTRA */


#ifdef CONFIG_NATIVE_WINDOWS
/**
 * wpa_unicode2ascii_inplace - Convert unicode string into ASCII
 * @str: Pointer to string to convert
 *
 * This function converts a unicode string to ASCII using the same
 * buffer for output. If UNICODE is not set, the buffer is not
 * modified.
 */
void wpa_unicode2ascii_inplace(TCHAR *str)
{
#ifdef UNICODE
	char *dst = (char *) str;
	while (*str)
		*dst++ = (char) *str++;
	*dst = '\0';
#endif /* UNICODE */
}


TCHAR * wpa_strdup_tchar(const char *str)
{
#ifdef UNICODE
	TCHAR *buf;
	buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
	if (buf == NULL)
		return NULL;
	wsprintf(buf, L"%S", str);
	return buf;
#else /* UNICODE */
	return os_strdup(str);
#endif /* UNICODE */
}
#endif /* CONFIG_NATIVE_WINDOWS */


/**
 * wpa_ssid_txt - Convert SSID to a printable string
 * @ssid: SSID (32-octet string)
 * @ssid_len: Length of ssid in octets
 * Returns: Pointer to a printable string
 *
 * This function can be used to convert SSIDs into printable form. In most
 * cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
 * does not limit the used character set, so anything could be used in an SSID.
 *
 * This function uses a static buffer, so only one call can be used at the
 * time, i.e., this is not re-entrant and the returned buffer must be used
 * before calling this again.
 */
const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
{
	static char ssid_txt[33];
	char *pos;

	if (ssid_len > 32)
		ssid_len = 32;
	os_memcpy(ssid_txt, ssid, ssid_len);
	ssid_txt[ssid_len] = '\0';
	for (pos = ssid_txt; *pos != '\0'; pos++) {
#ifndef WPA_UNICODE_SSID
		if ((u8) *pos < 32 || (u8) *pos >= 127)
			*pos = '_';
#endif
	}
	return ssid_txt;
}


void * __hide_aliasing_typecast(void *foo)
{
	return foo;
}
Commit	Line	Data
6fc6879b JM	1	/*
	2	* wpa_supplicant/hostapd / common helper functions, etc.
	3	* Copyright (c) 2002-2007, Jouni Malinen <j@w1.fi>
	4	*
0f3d578e JM	5	* This software may be distributed under the terms of the BSD license.
0f3d578e JM	6	* See README for more details.
6fc6879b JM	7	*/
	8
	9	#include "includes.h"
	10
	11	#include "common.h"
	12
	13
	14	static int hex2num(char c)
	15	{
	16	if (c >= '0' && c <= '9')
	17	return c - '0';
	18	if (c >= 'a' && c <= 'f')
	19	return c - 'a' + 10;
	20	if (c >= 'A' && c <= 'F')
	21	return c - 'A' + 10;
	22	return -1;
	23	}
	24
	25
b3a6d9d4	26	int hex2byte(const char *hex)
6fc6879b JM	27	{
	28	int a, b;
	29	a = hex2num(*hex++);
	30	if (a < 0)
	31	return -1;
	32	b = hex2num(*hex++);
	33	if (b < 0)
	34	return -1;
	35	return (a << 4) \| b;
	36	}
	37
	38
	39	/**
448a0a19	40	* hwaddr_aton - Convert ASCII string to MAC address (colon-delimited format)
6fc6879b JM	41	* @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
	42	* @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
	43	* Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
	44	*/
	45	int hwaddr_aton(const char txt, u8 addr)
	46	{
	47	int i;
	48
	49	for (i = 0; i < 6; i++) {
	50	int a, b;
	51
	52	a = hex2num(*txt++);
	53	if (a < 0)
	54	return -1;
	55	b = hex2num(*txt++);
	56	if (b < 0)
	57	return -1;
	58	*addr++ = (a << 4) \| b;
	59	if (i < 5 && *txt++ != ':')
	60	return -1;
	61	}
	62
	63	return 0;
	64	}
	65
0c11c633 JB	66	/**
	67	* hwaddr_compact_aton - Convert ASCII string to MAC address (no colon delimitors format)
	68	* @txt: MAC address as a string (e.g., "001122334455")
	69	* @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
	70	* Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
	71	*/
	72	int hwaddr_compact_aton(const char txt, u8 addr)
	73	{
	74	int i;
	75
	76	for (i = 0; i < 6; i++) {
	77	int a, b;
	78
	79	a = hex2num(*txt++);
	80	if (a < 0)
	81	return -1;
	82	b = hex2num(*txt++);
	83	if (b < 0)
	84	return -1;
	85	*addr++ = (a << 4) \| b;
	86	}
	87
	88	return 0;
	89	}
6fc6879b	90
448a0a19 JM	91	/**
	92	* hwaddr_aton2 - Convert ASCII string to MAC address (in any known format)
	93	* @txt: MAC address as a string (e.g., 00:11:22:33:44:55 or 0011.2233.4455)
	94	* @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
	95	* Returns: Characters used (> 0) on success, -1 on failure
	96	*/
	97	int hwaddr_aton2(const char txt, u8 addr)
	98	{
	99	int i;
	100	const char *pos = txt;
	101
	102	for (i = 0; i < 6; i++) {
	103	int a, b;
	104
	105	while (pos == ':' \|\| pos == '.' \|\| *pos == '-')
	106	pos++;
	107
	108	a = hex2num(*pos++);
	109	if (a < 0)
	110	return -1;
	111	b = hex2num(*pos++);
	112	if (b < 0)
	113	return -1;
	114	*addr++ = (a << 4) \| b;
	115	}
	116
	117	return pos - txt;
	118	}
	119
	120
6fc6879b JM	121	/**
	122	* hexstr2bin - Convert ASCII hex string into binary data
	123	* @hex: ASCII hex string (e.g., "01ab")
	124	* @buf: Buffer for the binary data
	125	* @len: Length of the text to convert in bytes (of buf); hex will be double
	126	* this size
	127	* Returns: 0 on success, -1 on failure (invalid hex string)
	128	*/
	129	int hexstr2bin(const char hex, u8 buf, size_t len)
	130	{
	131	size_t i;
	132	int a;
	133	const char *ipos = hex;
	134	u8 *opos = buf;
	135
	136	for (i = 0; i < len; i++) {
	137	a = hex2byte(ipos);
	138	if (a < 0)
	139	return -1;
	140	*opos++ = a;
	141	ipos += 2;
	142	}
	143	return 0;
	144	}
	145
	146
	147	/**
	148	* inc_byte_array - Increment arbitrary length byte array by one
	149	* @counter: Pointer to byte array
	150	* @len: Length of the counter in bytes
	151	*
	152	* This function increments the last byte of the counter by one and continues
	153	* rolling over to more significant bytes if the byte was incremented from
	154	* 0xff to 0x00.
	155	*/
	156	void inc_byte_array(u8 *counter, size_t len)
	157	{
	158	int pos = len - 1;
	159	while (pos >= 0) {
	160	counter[pos]++;
	161	if (counter[pos] != 0)
	162	break;
	163	pos--;
	164	}
	165	}
	166
	167
	168	void wpa_get_ntp_timestamp(u8 *buf)
	169	{
	170	struct os_time now;
	171	u32 sec, usec;
	172	be32 tmp;
	173
	174	/* 64-bit NTP timestamp (time from 1900-01-01 00:00:00) */
	175	os_get_time(&now);
	176	sec = now.sec + 2208988800U; /* Epoch to 1900 */
	177	/* Estimate 2^32/10^6 = 4295 - 1/32 - 1/512 */
	178	usec = now.usec;
	179	usec = 4295 * usec - (usec >> 5) - (usec >> 9);
	180	tmp = host_to_be32(sec);
	181	os_memcpy(buf, (u8 *) &tmp, 4);
	182	tmp = host_to_be32(usec);
	183	os_memcpy(buf + 4, (u8 *) &tmp, 4);
	184	}
185
186
187	static inline int _wpa_snprintf_hex(char buf, size_t buf_size, const u8 data,
188	size_t len, int uppercase)
189	{
190	size_t i;
191	char pos = buf, end = buf + buf_size;
192	int ret;
193	if (buf_size == 0)
194	return 0;
195	for (i = 0; i < len; i++) {
196	ret = os_snprintf(pos, end - pos, uppercase ? "%02X" : "%02x",
197	data[i]);
198	if (ret < 0 \|\| ret >= end - pos) {
199	end[-1] = '\0';
200	return pos - buf;
201	}
202	pos += ret;
203	}
204	end[-1] = '\0';
205	return pos - buf;
206	}
207
208	/**
209	* wpa_snprintf_hex - Print data as a hex string into a buffer
210	* @buf: Memory area to use as the output buffer
211	* @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
212	* @data: Data to be printed
213	* @len: Length of data in bytes
214	* Returns: Number of bytes written
215	*/
216	int wpa_snprintf_hex(char buf, size_t buf_size, const u8 data, size_t len)
217	{
218	return _wpa_snprintf_hex(buf, buf_size, data, len, 0);
219	}
220
221
222	/**
223	* wpa_snprintf_hex_uppercase - Print data as a upper case hex string into buf
224	* @buf: Memory area to use as the output buffer
225	* @buf_size: Maximum buffer size in bytes (should be at least 2 * len + 1)
226	* @data: Data to be printed
227	* @len: Length of data in bytes
228	* Returns: Number of bytes written
229	*/
230	int wpa_snprintf_hex_uppercase(char buf, size_t buf_size, const u8 data,
231	size_t len)
232	{
233	return _wpa_snprintf_hex(buf, buf_size, data, len, 1);
234	}
235
236
237	#ifdef CONFIG_ANSI_C_EXTRA
238
239	#ifdef _WIN32_WCE
240	void perror(const char *s)
241	{
242	wpa_printf(MSG_ERROR, "%s: GetLastError: %d",
243	s, (int) GetLastError());
244	}
245	#endif /* _WIN32_WCE */
246
247
248	int optind = 1;
249	int optopt;
250	char *optarg;
251
252	int getopt(int argc, char const argv[], const char optstring)
253	{
254	static int optchr = 1;
255	char *cp;
256
257	if (optchr == 1) {
258	if (optind >= argc) {
259	/* all arguments processed */
260	return EOF;
261	}
262
263	if (argv[optind][0] != '-' \|\| argv[optind][1] == '\0') {
264	/* no option characters */
265	return EOF;
266	}
267	}
268
269	if (os_strcmp(argv[optind], "--") == 0) {
270	/* no more options */
271	optind++;
272	return EOF;
273	}
274
275	optopt = argv[optind][optchr];
276	cp = os_strchr(optstring, optopt);
277	if (cp == NULL \|\| optopt == ':') {
278	if (argv[optind][++optchr] == '\0') {
279	optchr = 1;
280	optind++;
281	}
282	return '?';
283	}
284
285	if (cp[1] == ':') {
286	/* Argument required */
287	optchr = 1;
288	if (argv[optind][optchr + 1]) {
289	/* No space between option and argument */
290	optarg = &argv[optind++][optchr + 1];
291	} else if (++optind >= argc) {
292	/* option requires an argument */
293	return '?';
294	} else {
295	/* Argument in the next argv */
296	optarg = argv[optind++];
297	}
298	} else {
299	/* No argument */
300	if (argv[optind][++optchr] == '\0') {
301	optchr = 1;
302	optind++;
303	}
304	optarg = NULL;
305	}
306	return *cp;
307	}
308	#endif /* CONFIG_ANSI_C_EXTRA */
309
310
311	#ifdef CONFIG_NATIVE_WINDOWS
312	/**
313	* wpa_unicode2ascii_inplace - Convert unicode string into ASCII
314	* @str: Pointer to string to convert
315	*
316	* This function converts a unicode string to ASCII using the same
317	* buffer for output. If UNICODE is not set, the buffer is not
318	* modified.
319	*/
320	void wpa_unicode2ascii_inplace(TCHAR *str)
321	{
322	#ifdef UNICODE
323	char dst = (char ) str;
324	while (*str)
325	dst++ = (char) str++;
326	*dst = '\0';
327	#endif /* UNICODE */
328	}
329
330
331	TCHAR * wpa_strdup_tchar(const char *str)
332	{
333	#ifdef UNICODE
334	TCHAR *buf;
335	buf = os_malloc((strlen(str) + 1) * sizeof(TCHAR));
336	if (buf == NULL)
337	return NULL;
338	wsprintf(buf, L"%S", str);
339	return buf;
340	#else /* UNICODE */
341	return os_strdup(str);
342	#endif /* UNICODE */
343	}
344	#endif /* CONFIG_NATIVE_WINDOWS */
345
346
347	/**
348	* wpa_ssid_txt - Convert SSID to a printable string
349	* @ssid: SSID (32-octet string)
350	* @ssid_len: Length of ssid in octets
351	* Returns: Pointer to a printable string
352	*
353	* This function can be used to convert SSIDs into printable form. In most
354	* cases, SSIDs do not use unprintable characters, but IEEE 802.11 standard
355	* does not limit the used character set, so anything could be used in an SSID.
356	*
357	* This function uses a static buffer, so only one call can be used at the
358	* time, i.e., this is not re-entrant and the returned buffer must be used
359	* before calling this again.
360	*/
361	const char * wpa_ssid_txt(const u8 *ssid, size_t ssid_len)
362	{
363	static char ssid_txt[33];
364	char *pos;
365
366	if (ssid_len > 32)
367	ssid_len = 32;
368	os_memcpy(ssid_txt, ssid, ssid_len);
369	ssid_txt[ssid_len] = '\0';
370	for (pos = ssid_txt; *pos != '\0'; pos++) {
8451227f	371	#ifndef WPA_UNICODE_SSID
6fc6879b JM	372	if ((u8) pos < 32 \|\| (u8) pos >= 127)
6fc6879b JM	373	*pos = '_';
8451227f	374	#endif
6fc6879b JM	375	}
	376	return ssid_txt;
	377	}
0ae7b086 JM	378
	379
	380	void * __hide_aliasing_typecast(void *foo)
	381	{
	382	return foo;
	383	}