first commit

component/common/api/wifi/rtw_wpa_supplicant/src/utils/os.h

@@ -0,0 +1,578 @@
+/*
+ * OS specific functions
+ * Copyright (c) 2005-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef OS_H
+#define OS_H
+
+//#include "basic_types.h"
+#include <autoconf.h>
+#include "osdep_service.h"
+#include "utils/rom/rom_wps_os.h"
+
+typedef void* xqueue_handle_t;
+
+typedef long os_time_t;
+
+typedef _timer os_timer;
+
+/**
+ * os_sleep - Sleep (sec, usec)
+ * @sec: Number of seconds to sleep
+ * @usec: Number of microseconds to sleep
+ */
+void os_sleep(os_time_t sec, os_time_t usec);
+
+struct os_time {
+	os_time_t sec;
+	os_time_t usec;
+};
+
+struct os_reltime {
+	os_time_t sec;
+	os_time_t usec;
+};
+
+/**
+ * os_get_time - Get current time (sec, usec)
+ * @t: Pointer to buffer for the time
+ * Returns: 0 on success, -1 on failure
+ */
+int os_get_time(struct os_time *t);
+
+int os_get_reltime(struct os_reltime *t);
+/* Helper macros for handling struct os_time */
+/* (&timeout->time, &tmp->time) */
+#define os_time_before(a, b) \
+	((a)->sec < (b)->sec || \
+	 ((a)->sec == (b)->sec && (a)->usec < (b)->usec))
+
+#define os_time_sub(a, b, res) do { \
+	(res)->sec = (a)->sec - (b)->sec; \
+	(res)->usec = (a)->usec - (b)->usec; \
+	if ((res)->usec < 0) { \
+		(res)->sec--; \
+		(res)->usec += 1000000; \
+	} \
+} while (0)
+
+/**
+ * os_mktime - Convert broken-down time into seconds since 1970-01-01
+ * @year: Four digit year
+ * @month: Month (1 .. 12)
+ * @day: Day of month (1 .. 31)
+ * @hour: Hour (0 .. 23)
+ * @min: Minute (0 .. 59)
+ * @sec: Second (0 .. 60)
+ * @t: Buffer for returning calendar time representation (seconds since
+ * 1970-01-01 00:00:00)
+ * Returns: 0 on success, -1 on failure
+ *
+ * Note: The result is in seconds from Epoch, i.e., in UTC, not in local time
+ * which is used by POSIX mktime().
+ */
+int os_mktime(int year, int month, int day, int hour, int min, int sec,
+	      os_time_t *t);
+
+struct os_tm {
+	int sec; /* 0..59 or 60 for leap seconds */
+	int min; /* 0..59 */
+	int hour; /* 0..23 */
+	int day; /* 1..31 */
+	int month; /* 1..12 */
+	int year; /* Four digit year */
+};
+
+int os_gmtime(os_time_t t, struct os_tm *tm);
+
+/* Helpers for handling struct os_time */
+
+/* Helpers for handling struct os_reltime */
+
+static inline int os_reltime_before(struct os_reltime *a,
+				    struct os_reltime *b)
+{
+	return os_time_before(a,b);
+}
+
+
+static inline void os_reltime_sub(struct os_reltime *a, struct os_reltime *b,
+				  struct os_reltime *res)
+{
+	os_time_sub(a,b,res);
+}
+
+
+static inline void os_reltime_age(struct os_reltime *start,
+				  struct os_reltime *age)
+{
+	struct os_reltime now;
+
+	os_get_time((struct os_time *)&now);
+	os_reltime_sub(&now, start, age);
+}
+
+
+static inline int os_reltime_expired(struct os_reltime *now,
+				     struct os_reltime *ts,
+				     os_time_t timeout_secs)
+{
+	struct os_reltime age;
+
+	os_reltime_sub(now, ts, &age);
+	return (age.sec > timeout_secs) ||
+	       (age.sec == timeout_secs && age.usec > 0);
+}
+
+/**
+ * os_daemonize - Run in the background (detach from the controlling terminal)
+ * @pid_file: File name to write the process ID to or %NULL to skip this
+ * Returns: 0 on success, -1 on failure
+ */
+int os_daemonize(const char *pid_file);
+
+/**
+ * os_daemonize_terminate - Stop running in the background (remove pid file)
+ * @pid_file: File name to write the process ID to or %NULL to skip this
+ */
+void os_daemonize_terminate(const char *pid_file);
+
+/**
+ * os_get_random - Get cryptographically strong pseudo random data
+ * @buf: Buffer for pseudo random data
+ * @len: Length of the buffer
+ * Returns: 0 on success, -1 on failure
+ */
+int os_get_random(unsigned char *buf, size_t len);
+
+/**
+ * os_random - Get pseudo random value (not necessarily very strong)
+ * Returns: Pseudo random value
+ */
+unsigned long os_random(void);
+
+/**
+ * os_rel2abs_path - Get an absolute path for a file
+ * @rel_path: Relative path to a file
+ * Returns: Absolute path for the file or %NULL on failure
+ *
+ * This function tries to convert a relative path of a file to an absolute path
+ * in order for the file to be found even if current working directory has
+ * changed. The returned value is allocated and caller is responsible for
+ * freeing it. It is acceptable to just return the same path in an allocated
+ * buffer, e.g., return strdup(rel_path). This function is only used to find
+ * configuration files when os_daemonize() may have changed the current working
+ * directory and relative path would be pointing to a different location.
+ */
+char * os_rel2abs_path(const char *rel_path);
+
+/**
+ * os_program_init - Program initialization (called at start)
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is called when a programs starts. If there are any OS specific
+ * processing that is needed, it can be placed here. It is also acceptable to
+ * just return 0 if not special processing is needed.
+ */
+int os_program_init(void);
+
+/**
+ * os_program_deinit - Program deinitialization (called just before exit)
+ *
+ * This function is called just before a program exists. If there are any OS
+ * specific processing, e.g., freeing resourced allocated in os_program_init(),
+ * it should be done here. It is also acceptable for this function to do
+ * nothing.
+ */
+void os_program_deinit(void);
+
+/**
+ * os_setenv - Set environment variable
+ * @name: Name of the variable
+ * @value: Value to set to the variable
+ * @overwrite: Whether existing variable should be overwritten
+ * Returns: 0 on success, -1 on error
+ *
+ * This function is only used for wpa_cli action scripts. OS wrapper does not
+ * need to implement this if such functionality is not needed.
+ */
+int os_setenv(const char *name, const char *value, int overwrite);
+
+/**
+ * os_unsetenv - Delete environent variable
+ * @name: Name of the variable
+ * Returns: 0 on success, -1 on error
+ *
+ * This function is only used for wpa_cli action scripts. OS wrapper does not
+ * need to implement this if such functionality is not needed.
+ */
+int os_unsetenv(const char *name);
+
+/**
+ * os_readfile - Read a file to an allocated memory buffer
+ * @name: Name of the file to read
+ * @len: For returning the length of the allocated buffer
+ * Returns: Pointer to the allocated buffer or %NULL on failure
+ *
+ * This function allocates memory and reads the given file to this buffer. Both
+ * binary and text files can be read with this function. The caller is
+ * responsible for freeing the returned buffer with os_free().
+ */
+char * os_readfile(const char *name, size_t *len);
+
+#if 0
+/**
+ * os_zalloc - Allocate and zero memory
+ * @size: Number of bytes to allocate
+ * Returns: Pointer to allocated and zeroed memory or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer with os_free().
+ */
+void * os_zalloc(size_t size);
+
+/**
+ * os_calloc - Allocate and zero memory for an array
+ * @nmemb: Number of members in the array
+ * @size: Number of bytes in each member
+ * Returns: Pointer to allocated and zeroed memory or %NULL on failure
+ *
+ * This function can be used as a wrapper for os_zalloc(nmemb * size) when an
+ * allocation is used for an array. The main benefit over os_zalloc() is in
+ * having an extra check to catch integer overflows in multiplication.
+ *
+ * Caller is responsible for freeing the returned buffer with os_free().
+ */
+static inline void * os_calloc(size_t nmemb, size_t size)
+{
+	if (size && nmemb > (~(size_t) 0) / size)
+		return NULL;
+	return os_zalloc(nmemb * size);
+}
+#endif
+
+/*
+ * The following functions are wrapper for standard ANSI C or POSIX functions.
+ * By default, they are just defined to use the standard function name and no
+ * os_*.c implementation is needed for them. This avoids extra function calls
+ * by allowing the C pre-processor take care of the function name mapping.
+ *
+ * If the target system uses a C library that does not provide these functions,
+ * build_config.h can be used to define the wrappers to use a different
+ * function name. This can be done on function-by-function basis since the
+ * defines here are only used if build_config.h does not define the os_* name.
+ * If needed, os_*.c file can be used to implement the functions that are not
+ * included in the C library on the target system. Alternatively,
+ * OS_NO_C_LIB_DEFINES can be defined to skip all defines here in which case
+ * these functions need to be implemented in os_*.c file for the target system.
+ */
+
+#ifdef OS_NO_C_LIB_DEFINES
+
+/**
+ * os_malloc - Allocate dynamic memory
+ * @size: Size of the buffer to allocate
+ * Returns: Allocated buffer or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer with os_free().
+ */
+void * os_malloc(size_t size);
+
+/**
+ * os_realloc - Re-allocate dynamic memory
+ * @ptr: Old buffer from os_malloc() or os_realloc()
+ * @size: Size of the new buffer
+ * Returns: Allocated buffer or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer with os_free().
+ * If re-allocation fails, %NULL is returned and the original buffer (ptr) is
+ * not freed and caller is still responsible for freeing it.
+ */
+void * os_realloc(void *ptr, size_t size);
+
+/**
+ * os_free - Free dynamic memory
+ * @ptr: Old buffer from os_malloc() or os_realloc(); can be %NULL
+ */
+void os_free(void *ptr);
+
+/**
+ * os_memcpy - Copy memory area
+ * @dest: Destination
+ * @src: Source
+ * @n: Number of bytes to copy
+ * Returns: dest
+ *
+ * The memory areas src and dst must not overlap. os_memmove() can be used with
+ * overlapping memory.
+ */
+void * os_memcpy(void *dest, const void *src, size_t n);
+
+/**
+ * os_memmove - Copy memory area
+ * @dest: Destination
+ * @src: Source
+ * @n: Number of bytes to copy
+ * Returns: dest
+ *
+ * The memory areas src and dst may overlap.
+ */
+void *os_memmove(void *dest, const void *src, size_t n);
+
+/**
+ * os_memset - Fill memory with a constant byte
+ * @s: Memory area to be filled
+ * @c: Constant byte
+ * @n: Number of bytes started from s to fill with c
+ * Returns: s
+ */
+void *os_memset(void *s, int c, size_t n);
+
+/**
+ * os_memcmp - Compare memory areas
+ * @s1: First buffer
+ * @s2: Second buffer
+ * @n: Maximum numbers of octets to compare
+ * Returns: An integer less than, equal to, or greater than zero if s1 is
+ * found to be less than, to match, or be greater than s2. Only first n
+ * characters will be compared.
+ */
+int os_memcmp(const void *s1, const void *s2, size_t n);
+
+/**
+ * os_strdup - Duplicate a string
+ * @s: Source string
+ * Returns: Allocated buffer with the string copied into it or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer with os_free().
+ */
+char *os_strdup(const char *s);
+
+/**
+ * os_strlen - Calculate the length of a string
+ * @s: '\0' terminated string
+ * Returns: Number of characters in s (not counting the '\0' terminator)
+ */
+size_t os_strlen(const char *s);
+
+/**
+ * os_strcasecmp - Compare two strings ignoring case
+ * @s1: First string
+ * @s2: Second string
+ * Returns: An integer less than, equal to, or greater than zero if s1 is
+ * found to be less than, to match, or be greatred than s2
+ */
+int os_strcasecmp(const char *s1, const char *s2);
+
+/**
+ * os_strncasecmp - Compare two strings ignoring case
+ * @s1: First string
+ * @s2: Second string
+ * @n: Maximum numbers of characters to compare
+ * Returns: An integer less than, equal to, or greater than zero if s1 is
+ * found to be less than, to match, or be greater than s2. Only first n
+ * characters will be compared.
+ */
+int os_strncasecmp(const char *s1, const char *s2, size_t n);
+
+/**
+ * os_strchr - Locate the first occurrence of a character in string
+ * @s: String
+ * @c: Character to search for
+ * Returns: Pointer to the matched character or %NULL if not found
+ */
+char *os_strchr(const char *s, int c);
+
+/**
+ * os_strrchr - Locate the last occurrence of a character in string
+ * @s: String
+ * @c: Character to search for
+ * Returns: Pointer to the matched character or %NULL if not found
+ */
+char *os_strrchr(const char *s, int c);
+
+/**
+ * os_strcmp - Compare two strings
+ * @s1: First string
+ * @s2: Second string
+ * Returns: An integer less than, equal to, or greater than zero if s1 is
+ * found to be less than, to match, or be greatred than s2
+ */
+int os_strcmp(const char *s1, const char *s2);
+
+/**
+ * os_strncmp - Compare two strings
+ * @s1: First string
+ * @s2: Second string
+ * @n: Maximum numbers of characters to compare
+ * Returns: An integer less than, equal to, or greater than zero if s1 is
+ * found to be less than, to match, or be greater than s2. Only first n
+ * characters will be compared.
+ */
+int os_strncmp(const char *s1, const char *s2, size_t n);
+
+/**
+ * os_strncpy - Copy a string
+ * @dest: Destination
+ * @src: Source
+ * @n: Maximum number of characters to copy
+ * Returns: dest
+ */
+char *os_strncpy(char *dest, const char *src, size_t n);
+
+/**
+ * os_strstr - Locate a substring
+ * @haystack: String (haystack) to search from
+ * @needle: Needle to search from haystack
+ * Returns: Pointer to the beginning of the substring or %NULL if not found
+ */
+char *os_strstr(const char *haystack, const char *needle);
+
+/**
+ * os_snprintf - Print to a memory buffer
+ * @str: Memory buffer to print into
+ * @size: Maximum length of the str buffer
+ * @format: printf format
+ * Returns: Number of characters printed (not including trailing '\0').
+ *
+ * If the output buffer is truncated, number of characters which would have
+ * been written is returned. Since some C libraries return -1 in such a case,
+ * the caller must be prepared on that value, too, to indicate truncation.
+ *
+ * Note: Some C library implementations of snprintf() may not guarantee null
+ * termination in case the output is truncated. The OS wrapper function of
+ * os_snprintf() should provide this guarantee, i.e., to null terminate the
+ * output buffer if a C library version of the function is used and if that
+ * function does not guarantee null termination.
+ *
+ * If the target system does not include snprintf(), see, e.g.,
+ * http://www.ijs.si/software/snprintf/ for an example of a portable
+ * implementation of snprintf.
+ */
+int os_snprintf(char *str, size_t size, const char *format, ...);
+
+#else /* OS_NO_C_LIB_DEFINES */
+
+#if !defined(CONFIG_PLATFORM_8195A) && !defined(CONFIG_PLATFORM_8711B)
+#ifdef CONFIG_MEM_MONITOR
+	u8* os_malloc(u32 sz);
+	void os_mfree(u8 *pbuf, u32 sz);
+	#ifndef os_free
+			#define os_free(p, sz) os_mfree(((u8*)(p)), (sz))
+	#endif
+#else
+	#ifndef os_malloc
+			#define os_malloc(sz) _rtw_malloc(sz)
+	#endif
+	#ifndef os_free
+			#define os_free(p, sz) _rtw_mfree(((u8*)(p)), (sz))
+	#endif
+#endif
+#endif
+	extern void *os_zalloc(size_t size);
+	extern char *os_strdup(const char *string_copy_from); 
+
+	#ifndef os_sleep
+			#define os_sleep(s, us) rtw_mdelay_os((s)*1000 + (us)/1000)
+	#endif
+	#ifndef os_memcpy
+		#define os_memcpy(d, s, n) rtw_memcpy((void*)(d), ((void*)(s)), (n))
+	#endif
+	#ifndef os_memmove
+		#define os_memmove(d, s, n) memmove((d), (s), (n))
+	#endif
+	#ifndef os_memset
+		#define os_memset(pbuf, c, sz) rtw_memset(pbuf, c, sz)
+	#endif
+	#ifndef os_memcmp
+		#define os_memcmp(s1, s2, n) rtw_memcmp(((void*)(s1)), ((void*)(s2)), (n))
+	#endif
+	#ifndef os_memcmp_p2p
+		#define os_memcmp_p2p(s1, s2, n) memcmp((s1), (s2), (n))
+	#endif
+	#ifndef os_get_random_bytes
+		#define os_get_random_bytes(d,sz) rtw_get_random_bytes(((void*)(d)), (sz))
+	#endif	
+	#ifndef os_strlen
+		#define os_strlen(s) strlen(s)
+	#endif
+	#ifndef os_strcasecmp
+		#ifdef _MSC_VER
+			#define os_strcasecmp(s1, s2) _stricmp((s1), (s2))
+		#else
+			#define os_strcasecmp(s1, s2) strcasecmp((s1), (s2))
+		#endif
+	#endif
+	#ifndef os_strncasecmp
+	#ifdef _MSC_VER
+		#define os_strncasecmp(s1, s2, n) _strnicmp((s1), (s2), (n))
+	#else
+		#define os_strncasecmp(s1, s2, n) strncasecmp((s1), (s2), (n))
+	#endif
+	#endif
+	#ifndef os_init_timer
+		#define os_init_timer(t, p, f, x, n) rtw_init_timer((t), (p), (f), (x), (n))
+	#endif
+	#ifndef os_set_timer
+		#define os_set_timer(t, d) rtw_set_timer((t), (d))
+	#endif
+	#ifndef os_cancel_timer
+		#define os_cancel_timer(t) rtw_cancel_timer(t)
+	#endif
+	#ifndef os_del_timer
+		#define os_del_timer(t) rtw_del_timer(t)
+	#endif
+	#ifndef os_atoi
+		#define os_atoi(s) rtw_atoi(s)
+	#endif
+
+#ifndef os_strchr
+#define os_strchr(s, c) strchr((s), (c))
+#endif
+#ifndef os_strcmp
+#define os_strcmp(s1, s2) strcmp((s1), (s2))
+#endif
+#ifndef os_strncmp
+#define os_strncmp(s1, s2, n) strncmp((s1), (s2), (n))
+#endif
+#ifndef os_strncpy
+#define os_strncpy(d, s, n) strncpy((d), (s), (n))
+#endif
+#ifndef os_strrchr
+#define os_strrchr(s, c) strrchr((s), (c))
+#endif
+#ifndef os_strstr
+#define os_strstr(h, n) strstr((h), (n))
+#endif
+
+#ifndef os_snprintf
+	#ifdef _MSC_VER
+		#define os_snprintf _snprintf
+	#else
+		#define os_snprintf snprintf
+	#endif
+#endif
+
+#endif /* OS_NO_C_LIB_DEFINES */
+
+
+static inline void * os_realloc_array(void *ptr, size_t nmemb, size_t size)
+{
+	if (size && nmemb > (~(size_t) 0) / size)
+		return NULL;
+	return os_realloc(ptr, nmemb * size, nmemb * size);
+}
+
+void *os_xqueue_create(unsigned long uxQueueLength, unsigned long uxItemSize) ;
+
+int os_xqueue_receive(xqueue_handle_t xQueue, void * const pvBuffer, unsigned long xSecsToWait);
+
+void os_xqueue_delete(xqueue_handle_t xQueue );
+
+int os_xqueue_send(xqueue_handle_t xQueue, const void * const pvItemToQueue, unsigned long xSecsToWait);
+
+
+#endif /* OS_H */

component/common/api/wifi/rtw_wpa_supplicant/src/utils/os_freertos.c

@@ -0,0 +1,100 @@
+/*
+ * OS specific functions for UNIX/POSIX systems
+ * Copyright (c) 2005-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+#include <FreeRTOS.h>
+#include <task.h>
+#include <queue.h>
+#include <autoconf.h>
+
+#ifdef CONFIG_WPS
+#include "utils/os.h"
+
+#if !defined(CONFIG_PLATFORM_8195A) && !defined(CONFIG_PLATFORM_8711B)
+#ifdef CONFIG_MEM_MONITOR
+#if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
+_list wpa_mem_table;
+int wpa_mem_used_num;
+//int wpa_mem_used_size;
+#endif
+extern int min_free_heap_size;
+u8* os_malloc(u32 sz)
+{
+	int free_heap_size = rtw_getFreeHeapSize();
+	u8 *pbuf = _rtw_malloc(sz);
+#if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
+	add_mem_usage(&wpa_mem_table, pbuf, sz, &wpa_mem_used_num, MEM_MONITOR_FLAG_WPAS);
+#else
+	add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WPAS);
+#endif
+	if(min_free_heap_size > free_heap_size)
+		min_free_heap_size = free_heap_size;
+	return pbuf;
+}
+
+void os_mfree(u8 *pbuf, u32 sz)
+{
+	_rtw_mfree(pbuf, sz);
+#if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
+	del_mem_usage(&wpa_mem_table, pbuf, &wpa_mem_used_num, MEM_MONITOR_FLAG_WPAS);	
+#else
+	del_mem_usage(NULL, pbuf, NULL, MEM_MONITOR_FLAG_WPAS);
+#endif
+}
+#endif//CONFIG_MEM_MONITOR
+
+#endif// !defined(CONFIG_PLATFORM_8195A)
+
+#ifndef OS_NO_C_LIB_DEFINES
+char *os_strdup(const char *string_copy_from) 
+{
+	char *string_copy_to = NULL;
+	string_copy_to = os_zalloc(strlen(string_copy_from) + 1);
+	os_memcpy((void *)string_copy_to, string_copy_from, strlen(string_copy_from));
+	string_copy_to[strlen(string_copy_from)] = '\0';
+	return string_copy_to;
+}
+#endif
+
+int os_get_random(unsigned char *buf, size_t len)
+{
+	//TODO implement it
+	rtw_get_random_bytes(buf, len);
+	return 0;
+}
+
+int os_get_time(struct os_time *t){
+	unsigned int tt = rtw_get_current_time();
+	t->sec = (os_time_t) (tt / 1000);
+	t->usec = (os_time_t) (tt % 1000)*1000;
+	return 0;
+}
+
+int os_get_reltime(struct os_reltime *t){
+	os_get_time((struct os_time *)t);
+	return 0;
+}
+
+void *os_xqueue_create(unsigned long uxQueueLength, unsigned long uxItemSize) 
+{
+	return xQueueCreate( uxQueueLength, uxItemSize );
+}
+
+int os_xqueue_receive(xqueue_handle_t xQueue, void * const pvBuffer, unsigned long xSecsToWait)
+{
+	return xQueueReceive((xQueueHandle)xQueue, pvBuffer, (portTickType)(xSecsToWait*configTICK_RATE_HZ));
+}
+
+void os_xqueue_delete(xqueue_handle_t xQueue )
+{
+	vQueueDelete((xQueueHandle)xQueue);
+}
+
+int os_xqueue_send(xqueue_handle_t xQueue, const void * const pvItemToQueue, unsigned long xSecsToWait)
+{
+	return xQueueSendToBack((xQueueHandle)xQueue, pvItemToQueue, (portTickType)(xSecsToWait*configTICK_RATE_HZ));
+}
+#endif

component/common/api/wifi/rtw_wpa_supplicant/src/utils/rom/rom_wps_os.h

@@ -0,0 +1,24 @@
+/*
+ * OS specific functions
+ * Copyright (c) 2005-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef ROM_WPS_OS_H
+#define ROM_WPS_OS_H
+
+#if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B)
+
+#include <rom_wlan_ram_map.h>
+extern struct _rom_wlan_ram_map rom_wlan_ram_map;
+#define os_malloc(sz) rom_wlan_ram_map.rtw_malloc(sz)
+#define os_free(p, sz) rom_wlan_ram_map.rtw_mfree(((u8*)(p)), (sz))
+
+#endif
+
+extern u8 *WPS_realloc(u8 *old_buf, u32 old_sz, u32 new_sz);
+#define os_realloc(p, os, ns) WPS_realloc(((u8*)(p)),(os),(ns))
+
+#endif /* ROM_WPS_OS_H */

component/common/api/wifi/rtw_wpa_supplicant/src/wps/wps_defs.h

@@ -0,0 +1,319 @@
+
+/*
+ * Wi-Fi Protected Setup - message definitions
+ * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef WPS_DEFS_H
+#define WPS_DEFS_H
+
+
+/* Diffie-Hellman 1536-bit MODP Group; RFC 3526, Group 5 */
+#define WPS_DH_GROUP 			(5)
+
+#define WPS_UUID_LEN 			(16)
+#define WPS_NONCE_LEN 			(16)
+#define WPS_AUTHENTICATOR_LEN 		(8)
+#define WPS_AUTHKEY_LEN 		(32)
+#define WPS_KEYWRAPKEY_LEN 		(16)
+#define WPS_EMSK_LEN 			(32)
+#define WPS_PSK_LEN 			(16)
+#define WPS_SECRET_NONCE_LEN 		(16)
+#define WPS_HASH_LEN 			(32)
+#define WPS_KWA_LEN 			(8)
+#define WPS_MGMTAUTHKEY_LEN 		(32)
+#define WPS_MGMTENCKEY_LEN 		(16)
+#define WPS_MGMT_KEY_ID_LEN 		(16)
+#define WPS_OOB_DEVICE_PASSWORD_MIN_LEN (16)
+#define WPS_OOB_DEVICE_PASSWORD_LEN 	(32)
+#define WPS_OOB_PUBKEY_HASH_LEN 	(20)
+
+/* Attribute Types */
+enum wps_attribute {
+	ATTR_AP_CHANNEL 		= 0x1001,
+	ATTR_ASSOC_STATE 		= 0x1002,
+	ATTR_AUTH_TYPE 			= 0x1003,
+	ATTR_AUTH_TYPE_FLAGS 		= 0x1004,
+	ATTR_AUTHENTICATOR 		= 0x1005,
+	ATTR_CONFIG_METHODS 		= 0x1008,
+	ATTR_CONFIG_ERROR 		= 0x1009,
+	ATTR_CONFIRM_URL4 		= 0x100a,
+	ATTR_CONFIRM_URL6 		= 0x100b,
+	ATTR_CONN_TYPE 			= 0x100c,
+	ATTR_CONN_TYPE_FLAGS 		= 0x100d,
+	ATTR_CRED 			= 0x100e,
+	ATTR_ENCR_TYPE 			= 0x100f,
+	ATTR_ENCR_TYPE_FLAGS 		= 0x1010,
+	ATTR_DEV_NAME 			= 0x1011,
+	ATTR_DEV_PASSWORD_ID 		= 0x1012,
+	ATTR_E_HASH1 			= 0x1014,
+	ATTR_E_HASH2 			= 0x1015,
+	ATTR_E_SNONCE1 			= 0x1016,
+	ATTR_E_SNONCE2 			= 0x1017,
+	ATTR_ENCR_SETTINGS 		= 0x1018,
+	ATTR_ENROLLEE_NONCE 		= 0x101a,
+	ATTR_FEATURE_ID 		= 0x101b,
+	ATTR_IDENTITY 			= 0x101c,
+	ATTR_IDENTITY_PROOF 		= 0x101d,
+	ATTR_KEY_WRAP_AUTH 		= 0x101e,
+	ATTR_KEY_ID 			= 0x101f,
+	ATTR_MAC_ADDR 			= 0x1020,
+	ATTR_MANUFACTURER 		= 0x1021,
+	ATTR_MSG_TYPE 			= 0x1022,
+	ATTR_MODEL_NAME 		= 0x1023,
+	ATTR_MODEL_NUMBER 		= 0x1024,
+	ATTR_NETWORK_INDEX 		= 0x1026,
+	ATTR_NETWORK_KEY 		= 0x1027,
+	ATTR_NETWORK_KEY_INDEX 		= 0x1028,
+	ATTR_NEW_DEVICE_NAME 		= 0x1029,
+	ATTR_NEW_PASSWORD 		= 0x102a,
+	ATTR_OOB_DEVICE_PASSWORD 	= 0x102c,
+	ATTR_OS_VERSION 		= 0x102d,
+	ATTR_POWER_LEVEL 		= 0x102f,
+	ATTR_PSK_CURRENT 		= 0x1030,
+	ATTR_PSK_MAX 			= 0x1031,
+	ATTR_PUBLIC_KEY 		= 0x1032,
+	ATTR_RADIO_ENABLE 		= 0x1033,
+	ATTR_REBOOT 			= 0x1034,
+	ATTR_REGISTRAR_CURRENT 		= 0x1035,
+	ATTR_REGISTRAR_ESTABLISHED 	= 0x1036,
+	ATTR_REGISTRAR_LIST 		= 0x1037,
+	ATTR_REGISTRAR_MAX 		= 0x1038,
+	ATTR_REGISTRAR_NONCE 		= 0x1039,
+	ATTR_REQUEST_TYPE 		= 0x103a,
+	ATTR_RESPONSE_TYPE 		= 0x103b,
+	ATTR_RF_BANDS 			= 0x103c,
+	ATTR_R_HASH1 			= 0x103d,
+	ATTR_R_HASH2 			= 0x103e,
+	ATTR_R_SNONCE1 			= 0x103f,
+	ATTR_R_SNONCE2 			= 0x1040,
+	ATTR_SELECTED_REGISTRAR 	= 0x1041,
+	ATTR_SERIAL_NUMBER 		= 0x1042,
+	ATTR_WPS_STATE 			= 0x1044,
+	ATTR_SSID 			= 0x1045,
+	ATTR_TOTAL_NETWORKS 		= 0x1046,
+	ATTR_UUID_E 			= 0x1047,
+	ATTR_UUID_R 			= 0x1048,
+	ATTR_VENDOR_EXT 		= 0x1049,
+	ATTR_VERSION 			= 0x104a,
+	ATTR_X509_CERT_REQ 		= 0x104b,
+	ATTR_X509_CERT 			= 0x104c,
+	ATTR_EAP_IDENTITY 		= 0x104d,
+	ATTR_MSG_COUNTER 		= 0x104e,
+	ATTR_PUBKEY_HASH 		= 0x104f,
+	ATTR_REKEY_KEY 			= 0x1050,
+	ATTR_KEY_LIFETIME 		= 0x1051,
+	ATTR_PERMITTED_CFG_METHODS 	= 0x1052,
+	ATTR_SELECTED_REGISTRAR_CONFIG_METHODS = 0x1053,
+	ATTR_PRIMARY_DEV_TYPE 		= 0x1054,
+	ATTR_SECONDARY_DEV_TYPE_LIST 	= 0x1055,
+	ATTR_PORTABLE_DEV 		= 0x1056,
+	ATTR_AP_SETUP_LOCKED 		= 0x1057,
+	ATTR_APPLICATION_EXT 		= 0x1058,
+	ATTR_EAP_TYPE 			= 0x1059,
+	ATTR_IV 			= 0x1060,
+	ATTR_KEY_PROVIDED_AUTO 		= 0x1061,
+	ATTR_802_1X_ENABLED 		= 0x1062,
+	ATTR_APPSESSIONKEY 		= 0x1063,
+	ATTR_WEPTRANSMITKEY 		= 0x1064,
+	ATTR_REQUESTED_DEV_TYPE 	= 0x106a,
+	ATTR_EXTENSIBILITY_TEST 	= 0x10fa /* _NOT_ defined in the spec */
+};
+
+#define WPS_VENDOR_ID_WFA 14122
+
+/* WFA Vendor Extension subelements */
+enum {
+	WFA_ELEM_VERSION2 		= 0x00,
+	WFA_ELEM_AUTHORIZEDMACS 	= 0x01,
+	WFA_ELEM_NETWORK_KEY_SHAREABLE 	= 0x02,
+	WFA_ELEM_REQUEST_TO_ENROLL 	= 0x03,
+	WFA_ELEM_SETTINGS_DELAY_TIME 	= 0x04
+};
+
+/* Device Password ID */
+enum wps_dev_password_id {
+	DEV_PW_DEFAULT 			= 0x0000,
+	DEV_PW_USER_SPECIFIED 		= 0x0001,
+	DEV_PW_MACHINE_SPECIFIED	= 0x0002,
+	DEV_PW_REKEY 			= 0x0003,
+	DEV_PW_PUSHBUTTON 		= 0x0004,
+	DEV_PW_REGISTRAR_SPECIFIED 	= 0x0005
+};
+
+/* Message Type */
+enum wps_msg_type {
+	WPS_START		= 0x00,
+	WPS_Beacon 		= 0x01,
+	WPS_ProbeRequest 	= 0x02,
+	WPS_ProbeResponse 	= 0x03,
+	WPS_M1 			= 0x04,
+	WPS_M2 			= 0x05,
+	WPS_M2D 		= 0x06,
+	WPS_M3 			= 0x07,
+	WPS_M4 			= 0x08,
+	WPS_M5 			= 0x09,
+	WPS_M6 			= 0x0a,
+	WPS_M7 			= 0x0b,
+	WPS_M8 			= 0x0c,
+	WPS_WSC_ACK 		= 0x0d,
+	WPS_WSC_NACK 		= 0x0e,
+	WPS_WSC_DONE 		= 0x0f
+};
+
+/* Authentication Type Flags */
+#define WPS_AUTH_OPEN 		0x0001
+#define WPS_AUTH_WPAPSK 	0x0002
+#define WPS_AUTH_SHARED 	0x0004
+#define WPS_AUTH_WPA 		0x0008
+#define WPS_AUTH_WPA2 		0x0010
+#define WPS_AUTH_WPA2PSK 	0x0020
+#define WPS_AUTH_TYPES (WPS_AUTH_OPEN | WPS_AUTH_WPAPSK | WPS_AUTH_SHARED | \
+			WPS_AUTH_WPA | WPS_AUTH_WPA2 | WPS_AUTH_WPA2PSK)
+
+/* Encryption Type Flags */
+#define WPS_ENCR_NONE 	0x0001
+#define WPS_ENCR_WEP 	0x0002
+#define WPS_ENCR_TKIP 	0x0004
+#define WPS_ENCR_AES 	0x0008
+#define WPS_ENCR_TYPES (WPS_ENCR_NONE | WPS_ENCR_WEP | WPS_ENCR_TKIP | \
+			WPS_ENCR_AES)
+
+/* Configuration Error */
+enum wps_config_error {
+	WPS_CFG_NO_ERROR 		= 0,
+	WPS_CFG_OOB_IFACE_READ_ERROR 	= 1,
+	WPS_CFG_DECRYPTION_CRC_FAILURE 	= 2,
+	WPS_CFG_24_CHAN_NOT_SUPPORTED 	= 3,
+	WPS_CFG_50_CHAN_NOT_SUPPORTED 	= 4,
+	WPS_CFG_SIGNAL_TOO_WEAK 	= 5,
+	WPS_CFG_NETWORK_AUTH_FAILURE 	= 6,
+	WPS_CFG_NETWORK_ASSOC_FAILURE 	= 7,
+	WPS_CFG_NO_DHCP_RESPONSE 	= 8,
+	WPS_CFG_FAILED_DHCP_CONFIG 	= 9,
+	WPS_CFG_IP_ADDR_CONFLICT 	= 10,
+	WPS_CFG_NO_CONN_TO_REGISTRAR 	= 11,
+	WPS_CFG_MULTIPLE_PBC_DETECTED 	= 12,
+	WPS_CFG_ROGUE_SUSPECTED 	= 13,
+	WPS_CFG_DEVICE_BUSY 		= 14,
+	WPS_CFG_SETUP_LOCKED 		= 15,
+	WPS_CFG_MSG_TIMEOUT 		= 16,
+	WPS_CFG_REG_SESS_TIMEOUT 	= 17,
+	WPS_CFG_DEV_PASSWORD_AUTH_FAILURE = 18
+};
+
+/* RF Bands */
+#define WPS_RF_24GHZ (0x01)
+#define WPS_RF_50GHZ (0x02)
+
+/* Config Methods */
+#define WPS_CONFIG_USBA 		(0x0001)
+#define WPS_CONFIG_ETHERNET 		(0x0002)
+#define WPS_CONFIG_LABEL 		(0x0004)
+#define WPS_CONFIG_DISPLAY 		(0x0008)
+#define WPS_CONFIG_EXT_NFC_TOKEN 	(0x0010)
+#define WPS_CONFIG_INT_NFC_TOKEN 	(0x0020)
+#define WPS_CONFIG_NFC_INTERFACE 	(0x0040)
+#define WPS_CONFIG_PUSHBUTTON 		(0x0080)
+#define WPS_CONFIG_KEYPAD 		(0x0100)
+
+#ifdef CONFIG_WPS2
+#define WPS_CONFIG_VIRT_PUSHBUTTON 	(0x0280)
+#define WPS_CONFIG_PHY_PUSHBUTTON 	(0x0480)
+#define WPS_CONFIG_VIRT_DISPLAY 	(0x2008)
+#define WPS_CONFIG_PHY_DISPLAY 		(0x4008)
+#endif /* CONFIG_WPS2 */
+
+/* Connection Type Flags */
+#define WPS_CONN_ESS 			(0x01)
+#define WPS_CONN_IBSS 			(0x02)
+
+/* Wi-Fi Protected Setup State */
+enum wps_state {
+	WPS_STATE_NOT_CONFIGURED 	= 1,
+	WPS_STATE_CONFIGURED 		= 2
+};
+
+/* Association State */
+enum wps_assoc_state {
+	WPS_ASSOC_NOT_ASSOC 	= 0,
+	WPS_ASSOC_CONN_SUCCESS 	= 1,
+	WPS_ASSOC_CFG_FAILURE 	= 2,
+	WPS_ASSOC_FAILURE 	= 3,
+	WPS_ASSOC_IP_FAILURE 	= 4
+};
+
+
+#define WPS_DEV_OUI_WFA 	(0x0050f204)
+
+enum wps_dev_categ {
+	WPS_DEV_COMPUTER 	= 1,
+	WPS_DEV_INPUT 		= 2,
+	WPS_DEV_PRINTER 	= 3,
+	WPS_DEV_CAMERA 		= 4,
+	WPS_DEV_STORAGE 	= 5,
+	WPS_DEV_NETWORK_INFRA 	= 6,
+	WPS_DEV_DISPLAY 	= 7,
+	WPS_DEV_MULTIMEDIA 	= 8,
+	WPS_DEV_GAMING 		= 9,
+	WPS_DEV_PHONE 		= 10
+};
+
+enum wps_dev_subcateg {
+	WPS_DEV_COMPUTER_PC 			= 1,
+	WPS_DEV_COMPUTER_SERVER 		= 2,
+	WPS_DEV_COMPUTER_MEDIA_CENTER 		= 3,
+	
+	WPS_DEV_PRINTER_PRINTER 		= 1,
+	WPS_DEV_PRINTER_SCANNER 		= 2,
+	
+	WPS_DEV_CAMERA_DIGITAL_STILL_CAMERA 	= 1,
+	
+	WPS_DEV_STORAGE_NAS 			= 1,
+	
+	WPS_DEV_NETWORK_INFRA_AP 		= 1,
+	WPS_DEV_NETWORK_INFRA_ROUTER 		= 2,
+	WPS_DEV_NETWORK_INFRA_SWITCH 		= 3,
+	
+	WPS_DEV_DISPLAY_TV 			= 1,
+	WPS_DEV_DISPLAY_PICTURE_FRAME 		= 2,
+	WPS_DEV_DISPLAY_PROJECTOR 		= 3,
+	
+	WPS_DEV_MULTIMEDIA_DAR 			= 1,
+	WPS_DEV_MULTIMEDIA_PVR 			= 2,
+	WPS_DEV_MULTIMEDIA_MCX 			= 3,
+	
+	WPS_DEV_GAMING_XBOX 			= 1,
+	WPS_DEV_GAMING_XBOX360 			= 2,
+	WPS_DEV_GAMING_PLAYSTATION 		= 3,
+	
+	WPS_DEV_PHONE_WINDOWS_MOBILE 		= 1
+};
+
+
+/* Request Type */
+enum wps_request_type {
+	WPS_REQ_ENROLLEE_INFO 		= 0,
+	WPS_REQ_ENROLLEE 		= 1,
+	WPS_REQ_REGISTRAR 		= 2,
+	WPS_REQ_WLAN_MANAGER_REGISTRAR 	= 3
+};
+
+/* Response Type */
+enum wps_response_type {
+	WPS_RESP_ENROLLEE_INFO 		= 0,
+	WPS_RESP_ENROLLEE 		= 1,
+	WPS_RESP_REGISTRAR 		= 2,
+	WPS_RESP_AP 			= 3
+};
+
+/* Walk Time for push button configuration (in seconds) */
+#define WPS_PBC_WALK_TIME (120)
+
+#define WPS_MAX_AUTHORIZED_MACS (5)
+
+#endif /* WPS_DEFS_H */
+