j3d1/ameba-sdk-gcc-make
1
0
Fork 0
mirror of https://github.com/cwyark/ameba-sdk-gcc-make.git synced 2025-07-31 20:31:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

first commit and add gitignore, README.md

Browse source
This commit is contained in:
ChesterTseng 2016-06-04 19:09:35 +08:00
commit 760756ba2c
1861 changed files with 709236 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

578
component/common/api/wifi/rtw_wpa_supplicant/src/utils/os.h Executable file
View file

@ -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 */

120
component/common/api/wifi/rtw_wpa_supplicant/src/utils/os_freertos.c Executable file
View file

@ -0,0 +1,120 @@
/*
* 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 <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;
}
#if 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));
}
#else
void *os_xqueue_create(unsigned long uxQueueLength, unsigned long uxItemSize)
{
void* xQueue = NULL;
rtw_init_xqueue(&xQueue, "queue", uxItemSize, uxQueueLength);
return xQueue;
}
int os_xqueue_receive(xqueue_handle_t xQueue, void * const pvBuffer, unsigned long xSecsToWait)
{
return rtw_pop_from_xqueue(&xQueue, pvBuffer, xSecsToWait*1000);
}
void os_xqueue_delete(xqueue_handle_t xQueue )
{
rtw_deinit_xqueue(&xQueue);
}
int os_xqueue_send(xqueue_handle_t xQueue, const void * const pvItemToQueue, unsigned long xSecsToWait)
{
return rtw_push_to_xqueue(&xQueue, (void*)pvItemToQueue, xSecsToWait*1000);
}
#endif
#endif

24
component/common/api/wifi/rtw_wpa_supplicant/src/utils/rom/rom_wps_os.h Executable file
View file

@ -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 */

319
component/common/api/wifi/rtw_wpa_supplicant/src/wps/wps_defs.h Executable file
View file

@ -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 */

531
component/common/api/wifi/rtw_wpa_supplicant/wpa_supplicant/wifi_wps_config.c Executable file
View file

@ -0,0 +1,531 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "queue.h"
#include "utils/os.h"
#include <lwip_netconf.h>
#include <lwip/netif.h>
#include "wifi/wifi_conf.h"
#include "wps/wps_defs.h"
#include <platform/platform_stdlib.h>
/**
* struct wps_credential - WPS Credential
* @ssid: SSID
* @ssid_len: Length of SSID
* @auth_type: Authentication Type (WPS_AUTH_OPEN, .. flags)
* @encr_type: Encryption Type (WPS_ENCR_NONE, .. flags)
* @key_idx: Key index
* @key: Key
* @key_len: Key length in octets
* @mac_addr: MAC address of the Credential receiver
* @cred_attr: Unparsed Credential attribute data (used only in cred_cb());
* this may be %NULL, if not used
* @cred_attr_len: Length of cred_attr in octets
* @ap_channel: AP channel
*/
struct dev_credential {
u8 ssid[32];
size_t ssid_len;
u16 auth_type;
u16 encr_type;
u8 key_idx;
u8 key[65];
size_t key_len;
u8 mac_addr[6];
const u8 *cred_attr;
size_t cred_attr_len;
u16 ap_channel;
};
typedef struct {
char *target_ssid;
u16 config_method;
_sema scan_sema;
int isoverlap;
} internal_wps_scan_handler_arg_t;
#define WLAN0_NAME "wlan0"
#ifndef ENABLE
#define ENABLE (1)
#endif
#ifndef DISABLE
#define DISABLE (0)
#endif
#define STACKSIZE 512
//static xSemaphoreHandle wps_reconnect_semaphore;
//static struct _WIFI_NETWORK wifi_get_from_certificate = {0};
#define WPS_AUTH_TYPE_OPEN (0x0001)
#define WPS_AUTH_TYPE_WPA_PERSONAL (0x0002)
#define WPS_AUTH_TYPE_WPA_ENTERPRISE (0x0008)
#define WPS_AUTH_TYPE_WPA2_PERSONAL (0x0010)
#define WPS_AUTH_TYPE_WPA2_ENTERPRISE (0x0020)
#define SCAN_BUFFER_LENGTH (4096)
#ifdef CONFIG_WPS
#if CONFIG_ENABLE_WPS
xqueue_handle_t queue_for_credential;
char wps_pin_code[32];
u16 config_method;
u8 wps_password_id;
void wps_check_and_show_connection_info(void)
{
rtw_wifi_setting_t setting;
#if CONFIG_LWIP_LAYER
/* Start DHCP Client */
LwIP_DHCP(0, DHCP_START);
#endif
wifi_get_setting(WLAN0_NAME, &setting);
wifi_show_setting(WLAN0_NAME, &setting);
}
static void wps_config_wifi_setting(rtw_network_info_t *wifi, struct dev_credential *dev_cred)
{
printf("\r\nwps_config_wifi_setting\n");
//memcpy((void *)wifi->ssid, (void *)dev_cred->ssid, dev_cred->ssid_len);
strcpy((char*)wifi->ssid.val, (char*)&dev_cred->ssid[0]);
printf("\r\nwps_wifi.ssid = %s\n", wifi->ssid.val);
wifi->ssid.len = dev_cred->ssid_len;
printf("\r\nwps_wifi.ssid_len = %d\n", wifi->ssid.len);
switch(dev_cred->auth_type) {
case WPS_AUTH_TYPE_OPEN :
printf("\r\nsecurity_type = RTW_SECURITY_OPEN\n");
wifi->security_type = RTW_SECURITY_OPEN;
break;
case WPS_AUTH_TYPE_WPA_PERSONAL :
case WPS_AUTH_TYPE_WPA_ENTERPRISE :
printf("\r\nsecurity_type = RTW_SECURITY_WPA_AES_PSK\n");
wifi->security_type = RTW_SECURITY_WPA_AES_PSK;
break;
case WPS_AUTH_TYPE_WPA2_PERSONAL :
case WPS_AUTH_TYPE_WPA2_ENTERPRISE :
printf("\r\nsecurity_type = RTW_SECURITY_WPA2_AES_PSK\n");
wifi->security_type = RTW_SECURITY_WPA2_AES_PSK;
break;
}
printf("\r\nwps_wifi.security_type = %d\n", wifi->security_type);
//memcpy(wifi->password, dev_cred->key, dev_cred->key_len);
wifi->password = dev_cred->key;
printf("\r\nwps_wifi.password = %s\n", wifi->password);
wifi->password_len = dev_cred->key_len;
printf("\r\nwps_wifi.password_len = %d", wifi->password_len);
//xSemaphoreGive(wps_reconnect_semaphore);
//printf("\r\nrelease wps_reconnect_semaphore");
}
static void wps_connect_to_AP_by_certificate(rtw_network_info_t *wifi)
{
#define RETRY_COUNT 3
int retry_count = RETRY_COUNT, ret;
printf("\r\n=============== wifi_certificate_info ===============\n");
printf("\r\nwps_wifi.ssid = %s\n", wifi->ssid.val);
printf("\r\nsecurity_type = %d\n", wifi->security_type);
printf("\r\nwps_wifi.password = %s\n", wifi->password);
printf("\r\nssid_len = %d\n", wifi->ssid.len);
printf("\r\npassword_len = %d\n", wifi->password_len);
while (1) {
ret = wifi_connect((char*)wifi->ssid.val,
wifi->security_type,
(char*)wifi->password,
wifi->ssid.len,
wifi->password_len,
wifi->key_id,
NULL);
if (ret == RTW_SUCCESS) {
if(retry_count == RETRY_COUNT)
rtw_msleep_os(1000); //When start wps with OPEN AP, AP will send a disassociate frame after STA connected, need reconnect here.
if(RTW_SUCCESS == wifi_is_connected_to_ap( )){
//printf("\r\n[WPS]Ready to tranceive!!\n");
wps_check_and_show_connection_info();
break;
}
}
if (retry_count == 0) {
printf("\r\n[WPS]Join bss failed\n");
break;
}
retry_count --;
}
}
static int wps_connect_to_AP_by_open_system(char *target_ssid)
{
int retry_count = 3, ret;
if (target_ssid != NULL) {
rtw_msleep_os(500); //wait scan complete.
while (1) {
ret = wifi_connect(target_ssid,
RTW_SECURITY_OPEN,
NULL,
strlen(target_ssid),
0,
0,
NULL);
if (ret == RTW_SUCCESS) {
//wps_check_and_show_connection_info();
break;
}
if (retry_count == 0) {
printf("\r\n[WPS]Join bss failed\n");
return -1;
}
retry_count --;
}
//
} else {
printf("\r\n[WPS]Target SSID is NULL\n");
}
return 0;
}
static void process_wps_scan_result( rtw_scan_result_t* record, void * user_data )
{
internal_wps_scan_handler_arg_t *wps_arg = (internal_wps_scan_handler_arg_t *)user_data;
if (record->wps_type != 0xff) {
if (wps_arg->config_method == WPS_CONFIG_PUSHBUTTON) {
if (record->wps_type == 0x04) {
wps_password_id = record->wps_type;
if (++wps_arg->isoverlap == 0) {
memcpy(&wps_arg->target_ssid[0], record->SSID.val, record->SSID.len);
wps_arg->target_ssid[record->SSID.len] = '\0';
printf("\r\n[pbc]Record first triger wps AP = %s\n", wps_arg->target_ssid);
}
}
} else if (wps_arg->config_method == WPS_CONFIG_DISPLAY) {
if (record->wps_type == 0x00) {
wps_arg->isoverlap = 0;
wps_password_id = record->wps_type;
memcpy(&wps_arg->target_ssid[0], record->SSID.val, record->SSID.len);
wps_arg->target_ssid[record->SSID.len] = '\0';
printf("\r\n[pin]find out first triger wps AP = %s\n", wps_arg->target_ssid);
}
}
}
}
static rtw_result_t wps_scan_result_handler( rtw_scan_handler_result_t* malloced_scan_result )
{
internal_wps_scan_handler_arg_t *wps_arg = (internal_wps_scan_handler_arg_t *)malloced_scan_result->user_data;
if (malloced_scan_result->scan_complete != RTW_TRUE)
{
rtw_scan_result_t* record = &malloced_scan_result->ap_details;
record->SSID.val[record->SSID.len] = 0; /* Ensure the SSID is null terminated */
process_wps_scan_result(record, malloced_scan_result->user_data);
}
else
{
printf("\r\nWPS scan done!\r\n");
rtw_up_sema(&wps_arg->scan_sema);
}
return RTW_SUCCESS;
}
static int wps_find_out_triger_wps_AP(char *target_ssid, u16 config_method)
{
internal_wps_scan_handler_arg_t wps_arg = {0};
wps_password_id = 0xFF;
wps_arg.isoverlap = -1;
wps_arg.config_method = config_method;
wps_arg.target_ssid = target_ssid;
rtw_init_sema(&wps_arg.scan_sema, 0);
if(wps_arg.scan_sema == NULL) return RTW_ERROR;
if(wifi_scan_networks(wps_scan_result_handler, &wps_arg ) != RTW_SUCCESS){
printf("\n\rERROR: wifi scan failed");
goto exit;
}
if(rtw_down_timeout_sema(&wps_arg.scan_sema, SCAN_LONGEST_WAIT_TIME) == RTW_FALSE){
printf("\r\nWPS scan done early!\r\n");
}
exit:
rtw_free_sema(&wps_arg.scan_sema);
return wps_arg.isoverlap;
}
extern void wpas_wps_notify_wps_finish_hdl(char *buf, int buf_len, int flags, void *userdata);
extern void wpas_wsc_eapol_recvd_hdl(char *buf, int buf_len, int flags, void* handler_user_data);
int wps_start(u16 wps_config, char *pin, u8 channel, char *ssid)
{
struct dev_credential dev_cred;
rtw_network_info_t wifi = {0};
char target_ssid[64];
int is_overlap = -1;
u32 start_time = rtw_get_current_time();
int ret = 0;
memset(&dev_cred, 0, sizeof(struct dev_credential));
memset(target_ssid, 0, 64);
if((wps_config != WPS_CONFIG_PUSHBUTTON)
&& (wps_config != WPS_CONFIG_DISPLAY)
&& (wps_config != WPS_CONFIG_KEYPAD)){
printf("\n\rWPS: Wps method(%d) is wrong. Not triger WPS.\n", wps_config);
return -1;
}
config_method = wps_config;
if(wps_config == WPS_CONFIG_DISPLAY
|| wps_config == WPS_CONFIG_KEYPAD) {
if(pin)
strcpy(wps_pin_code, pin);
else{
printf("\n\rWPS: PIN is NULL. Not triger WPS.\n");
return -1;
}
}
if(!ssid) {
while (1) {
unsigned int current_time = rtw_get_current_time();
if (rtw_systime_to_sec(current_time - start_time) < 120) {
is_overlap = wps_find_out_triger_wps_AP(&target_ssid[0], wps_config);
if ((is_overlap == 0) || (is_overlap > 0))
break;
} else {
printf("\r\nWPS: WPS Walking Time Out\n");
return 0;
}
}
if (is_overlap > 0) {
printf("\r\nWPS: WPS session overlap. Not triger WPS.\n");
return 0;
}
}else{
rtw_memcpy(target_ssid, ssid, strlen(ssid));
}
if (queue_for_credential != NULL) {
os_xqueue_delete(queue_for_credential);
queue_for_credential = NULL;
}
queue_for_credential = os_xqueue_create(1, sizeof(struct dev_credential));
if(!queue_for_credential)
return -1;
wifi_reg_event_handler(WIFI_EVENT_WPS_FINISH, wpas_wps_notify_wps_finish_hdl, NULL);
wifi_reg_event_handler(WIFI_EVENT_EAPOL_RECVD, wpas_wsc_eapol_recvd_hdl, NULL);
wifi_set_wps_phase(ENABLE);
ret = wps_connect_to_AP_by_open_system(target_ssid);
if(ret < 0){
printf("\n\rWPS: WPS Fail!!\n");
goto exit;
}
os_xqueue_receive(queue_for_credential, &dev_cred, 120);
if (dev_cred.ssid[0] != 0 && dev_cred.ssid_len <= 32) {
wps_config_wifi_setting(&wifi, &dev_cred);
wifi_set_wps_phase(DISABLE);
wps_connect_to_AP_by_certificate(&wifi);
goto exit1;
} else {
printf("\n\rWPS: WPS FAIL!!!\n");
printf("\n\rWPS: WPS FAIL!!!\n");
printf("\n\rWPS: WPS FAIL!!!\n");
}
exit:
wifi_set_wps_phase(DISABLE);
exit1:
if (queue_for_credential != NULL) {
os_xqueue_delete(queue_for_credential);
queue_for_credential = NULL;
}
wifi_unreg_event_handler(WIFI_EVENT_WPS_FINISH, wpas_wps_notify_wps_finish_hdl);
wifi_unreg_event_handler(WIFI_EVENT_EAPOL_RECVD, wpas_wsc_eapol_recvd_hdl);
return 0;
}
#ifdef CONFIG_WPS_AP
int ap_wps_start(u16 wps_config, char *pin)
{
u8 authorized_mac[ETH_ALEN];
int ret = 0;
u32 pin_val = 0;
printf("\n\rWPS-AP: wps_config(%x).\n", wps_config);
if((wps_config != WPS_CONFIG_PUSHBUTTON)
&& (wps_config != WPS_CONFIG_DISPLAY)
&& (wps_config != WPS_CONFIG_KEYPAD)){
printf("\n\rWPS-AP: Wps method(%d) is wrong. Not triger WPS.\n", wps_config);
return -1;
}
config_method = wps_config;
if(wps_config == WPS_CONFIG_DISPLAY
|| wps_config == WPS_CONFIG_KEYPAD) {
if(pin)
strcpy(wps_pin_code, pin);
else{
printf("\n\rWPS-AP: PIN is NULL. Not triger WPS.\n");
return -1;
}
}
if (queue_for_credential != NULL) {
os_xqueue_delete(queue_for_credential);
queue_for_credential = NULL;
}
queue_for_credential = os_xqueue_create(1, sizeof(authorized_mac));
if(!queue_for_credential)
return -1;
wifi_set_wps_phase(1);
if(wps_config == WPS_CONFIG_KEYPAD)
{
pin_val = atoi(pin);
if (!wps_pin_valid(pin_val)) {
printf("\n\rWPS-AP: Enter pin code is unvalid.");
goto exit;
}
ret = wpas_wps_registrar_add_pin((unsigned char const*)pin, strlen(pin));
}
else if(wps_config == WPS_CONFIG_DISPLAY)
ret = wpas_wps_registrar_add_pin((unsigned char const*)pin, strlen(pin));
else
ret = wpas_wps_registrar_button_pushed();
if(ret<0)
goto exit;
printf("\n\rWPS-AP: wait for STA connect!\n");
os_xqueue_receive(queue_for_credential, authorized_mac, 120); //max wait 2min
if(!wpas_wps_registrar_check_done())
{
ret = -1;
wpas_wps_registrar_wps_cancel();
}
exit:
wifi_set_wps_phase(0);
os_xqueue_delete(queue_for_credential);
queue_for_credential = NULL;
return ret;
}
#endif //CONFIG_WPS_AP
void wps_judge_staion_disconnect(void)
{
int mode = 0;
unsigned char ssid[33];
wext_get_mode(WLAN0_NAME, &mode);
switch(mode) {
case IW_MODE_MASTER: //In AP mode
rltk_wlan_deinit();
rltk_wlan_init(0,RTW_MODE_STA);
rltk_wlan_start(0);
break;
case IW_MODE_INFRA: //In STA mode
if(wext_get_ssid(WLAN0_NAME, ssid) > 0)
wifi_disconnect();
}
}
void cmd_wps(int argc, char **argv)
{
wps_judge_staion_disconnect();
if((argc == 2 || argc == 3 ) && (argv[1] != NULL)){
if(strcmp(argv[1],"pin") == 0){
unsigned int pin_val = 0;
/* start pin */
if(argc == 2){
char device_pin[10];
pin_val = wps_generate_pin();
sprintf(device_pin, "%08d", pin_val);
/* Display PIN 3 times to prevent to be overwritten by logs from other tasks */
printf("\n\rWPS: Start WPS PIN Display. PIN: [%s]\n\r", device_pin);
printf("\n\rWPS: Start WPS PIN Display. PIN: [%s]\n\r", device_pin);
printf("\n\rWPS: Start WPS PIN Display. PIN: [%s]\n\r", device_pin);
wps_start(WPS_CONFIG_DISPLAY, (char*)device_pin, 0, NULL);
}else{
pin_val = atoi(argv[2]);
if (!wps_pin_valid(pin_val)) {
printf("\n\rWPS: Device pin code is invalid. Not triger WPS.\n");
return;
}
printf("\n\rWPS: Start WPS PIN Keypad.\n\r");
wps_start(WPS_CONFIG_KEYPAD, argv[2], 0, NULL);
}
}else if(strcmp(argv[1],"pbc") == 0){
/* start pbc */
printf("\n\rWPS: Start WPS PBC.\n\r");
wps_start(WPS_CONFIG_PUSHBUTTON, NULL, 0, NULL);
}else{
printf("\n\rWPS: Wps Method is wrong. Not triger WPS.\n");
return;
}
}
}
#ifdef CONFIG_WPS_AP
/*
cmd_ap_wps for AP WSC setting. command style:
cmd_ap_wps pbc or cmd_ap_wps pin 12345678
*/
void cmd_ap_wps(int argc, char **argv)
{
if(rltk_wlan_running(WLAN1_IDX)){
printf("\n\rNot support con-current softAP WSC!\n\r");
return;
}
if((argc == 2 || argc == 3) && (argv[1] != NULL)) {
if (strcmp(argv[1],"pin") == 0 ) {
unsigned int pin_val = 0;
if(argc == 3){
pin_val = atoi(argv[2]);
if (!wps_pin_valid(pin_val)) {
printf("\n\rWPS-AP: Device pin code is invalid. Not trigger WPS.\n\r");
return;
}
printf("\n\rWPS-AP: Start AP WPS PIN Keypad.\n");
ap_wps_start(WPS_CONFIG_KEYPAD, argv[2]);
}else{
char device_pin[10];
pin_val = wps_generate_pin();
sprintf(device_pin, "%08d", pin_val);
printf("\n\rWPS: Start WPS PIN Display. PIN: %s\n\r", device_pin);
ap_wps_start(WPS_CONFIG_DISPLAY, (char*)device_pin);
}
}else if (strcmp(argv[1],"pbc") == 0) {
printf("\n\rWPS-AP: Start AP WPS PBC\n");
ap_wps_start(WPS_CONFIG_PUSHBUTTON, NULL);
}else{
printf("\n\rWPS-AP Usage:\"wifi_ap_wps pin [pin_code]\" or \"wifi_ap_wps pbc\"\n");
return;
}
} else {
printf("\n\rWPS-AP Usage:\"wifi_ap_wps pin [pin_code]\" or \"wifi_ap_wps pbc\"\n");
}
return;
}
#endif //CONFIG_WPS_AP
#endif //CONFIG_ENABLE_WPS
#endif //#ifdef CONFIG_WPS

1686
component/common/api/wifi/wifi_conf.c Executable file
View file

File diff suppressed because it is too large Load diff

663
component/common/api/wifi/wifi_conf.h Executable file
View file

@ -0,0 +1,663 @@
//----------------------------------------------------------------------------//
#ifndef __WIFI_API_H
#define __WIFI_API_H
#include "FreeRTOS.h"
#include "wifi_constants.h"
#include "wifi_structures.h"
#include "wifi_util.h"
#include "wifi_ind.h"
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************
* Macros
******************************************************/
#define RTW_ENABLE_API_INFO
#ifdef RTW_ENABLE_API_INFO
#define RTW_API_INFO(args) do {printf args;} while(0)
#else
#define RTW_API_INFO(args)
#endif
#define MAC_ARG(x) ((u8*)(x))[0],((u8*)(x))[1],((u8*)(x))[2],((u8*)(x))[3],((u8*)(x))[4],((u8*)(x))[5]
#define CMP_MAC( a, b ) (((a[0])==(b[0]))&& \
((a[1])==(b[1]))&& \
((a[2])==(b[2]))&& \
((a[3])==(b[3]))&& \
((a[4])==(b[4]))&& \
((a[5])==(b[5])))
/******************************************************
* Constants
******************************************************/
#define SCAN_LONGEST_WAIT_TIME (4500)
#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
#define PSCAN_ENABLE 0x01 //enable for partial channel scan
#define PSCAN_FAST_SURVEY 0x02 //set to select scan time to FAST_SURVEY_TO, otherwise SURVEY_TO
#define PSCAN_SIMPLE_CONFIG 0x04 //set to select scan time to FAST_SURVEY_TO and resend probe request
/******************************************************
* Type Definitions
******************************************************/
/** Scan result callback function pointer type
*
* @param result_ptr : A pointer to the pointer that indicates where to put the next scan result
* @param user_data : User provided data
*/
typedef void (*rtw_scan_result_callback_t)( rtw_scan_result_t** result_ptr, void* user_data );
typedef rtw_result_t (*rtw_scan_result_handler_t)( rtw_scan_handler_result_t* malloced_scan_result );
/******************************************************
* Structures
******************************************************/
typedef struct {
char *buf;
int buf_len;
} scan_buf_arg;
/******************************************************
* Structures
******************************************************/
typedef struct internal_scan_handler{
rtw_scan_result_t** pap_details;
rtw_scan_result_t * ap_details;
int scan_cnt;
rtw_bool_t scan_complete;
unsigned char max_ap_size;
rtw_scan_result_handler_t gscan_result_handler;
#if SCAN_USE_SEMAPHORE
void *scan_semaphore;
#else
int scan_running;
#endif
void* user_data;
unsigned int scan_start_time;
} internal_scan_handler_t;
typedef struct {
rtw_network_info_t network_info;
void *join_sema;
} internal_join_result_t;
/******************************************************
* Function Declarations
******************************************************/
/**
* Initialises Realtek WiFi API System
*
* - Initialises the required parts of the software platform
* i.e. worker, event registering, semaphore, etc.
*
* - Initialises the RTW API thread which handles the asynchronous event
*
* @return RTW_SUCCESS if initialization is successful, RTW_ERROR otherwise
*/
int wifi_manager_init(void);
/** Joins a Wi-Fi network
*
* Scans for, associates and authenticates with a Wi-Fi network.
* On successful return, the system is ready to send data packets.
*
* @param[in] ssid : A null terminated string containing the SSID name of the network to join
* @param[in] security_type : Authentication type:
* - RTW_SECURITY_OPEN - Open Security
* - RTW_SECURITY_WEP_PSK - WEP Security with open authentication
* - RTW_SECURITY_WEP_SHARED - WEP Security with shared authentication
* - RTW_SECURITY_WPA_TKIP_PSK - WPA Security
* - RTW_SECURITY_WPA2_AES_PSK - WPA2 Security using AES cipher
* - RTW_SECURITY_WPA2_TKIP_PSK - WPA2 Security using TKIP cipher
* - RTW_SECURITY_WPA2_MIXED_PSK - WPA2 Security using AES and/or TKIP ciphers
* @param[in] password : A byte array containing either the
* cleartext security key for WPA/WPA2
* secured networks, or a pointer to
* an array of rtw_wep_key_t
* structures for WEP secured networks
* @param[in] ssid_len : The length of the SSID in
* bytes.
* @param[in] password_len : The length of the security_key in
* bytes.
* @param[in] key_id : The index of the wep key.
* @param[in] semaphore : A user provided semaphore that is flagged when the join is complete
*
* @return RTW_SUCCESS : when the system is joined and ready
* to send data packets
* RTW_ERROR : if an error occurred
*/
int wifi_connect(
char *ssid,
rtw_security_t security_type,
char *password,
int ssid_len,
int password_len,
int key_id,
void *semaphore);
int wifi_connect_bssid(
unsigned char bssid[ETH_ALEN],
char *ssid,
rtw_security_t security_type,
char *password,
int bssid_len,
int ssid_len,
int password_len,
int key_id,
void *semaphore);
/** Disassociates from a Wi-Fi network.
*
* @return RTW_SUCCESS : On successful disassociation from
* the AP
* RTW_ERROR : If an error occurred
*/
int wifi_disconnect(void);
/** Check if the interface specified is up.
*
* @return RTW_TRUE : If it's up
* RTW_FALSE : If it's not
*/
int wifi_is_connected_to_ap(void);
/*check if wifi has connected to AP before dhcp
*
* @return RTW_SUCCESS:if conneced
RTW_ERROR :if not connect
*/
int wifi_is_up(rtw_interface_t interface);
/** Determines if a particular interface is ready to transceive ethernet packets
*
* @param Radio interface to check, options are
* RTW_STA_INTERFACE, RTW_AP_INTERFACE
* @return RTW_SUCCESS : if the interface is ready to
* transceive ethernet packets
* @return RTW_NOTFOUND : no AP with a matching SSID was
* found
* @return RTW_NOT_AUTHENTICATED: a matching AP was found but
* it won't let you
* authenticate. This can
* occur if this device is
* in the block list on the
* AP.
* @return RTW_NOT_KEYED: the device has authenticated and
* associated but has not completed
* the key exchange. This can occur
* if the passphrase is incorrect.
* @return RTW_ERROR : if the interface is not ready to
* transceive ethernet packets
*/
int wifi_is_ready_to_transceive(rtw_interface_t interface);
/** ----------------------------------------------------------------------
* WARNING : This function is for internal use only!
* ----------------------------------------------------------------------
* This function sets the current Media Access Control (MAC) address of the
* 802.11 device.
*
* @param[in] mac Wi-Fi MAC address
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_set_mac_address(char * mac);
/** Retrieves the current Media Access Control (MAC) address
* (or Ethernet hardware address) of the 802.11 device
*
* @param mac Pointer to a variable that the current MAC address will be written to
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_get_mac_address(char * mac);
/** Enables powersave mode
*
* @return @ref rtw_result_t
*/
int wifi_enable_powersave(void);
/** Disables 802.11 power save mode
*
* @return RTW_SUCCESS : if power save mode was successfully
* disabled
* RTW_ERROR : if power save mode was not successfully
* disabled
*/
int wifi_disable_powersave(void);
/** Gets the tx power in index units
*
* @param dbm : The variable to receive the tx power in index.
*
* @return RTW_SUCCESS : if successful
* RTW_ERROR : if not successful
*/
int wifi_get_txpower(int *poweridx);
/** Sets the tx power in index units
*
* @param dbm : The desired tx power in index.
*
* @return RTW_SUCCESS : if tx power was successfully set
* RTW_ERROR : if tx power was not successfully set
*/
int wifi_set_txpower(int poweridx);
/** Get the associated clients with SoftAP
*
* @param client_list_buffer : the location where the client
* list will be stored
* @param buffer_length : the buffer length.
*
* @return RTW_SUCCESS : if result was successfully get
* RTW_ERROR : if result was not successfully get
*/
int wifi_get_associated_client_list(void * client_list_buffer, unsigned short buffer_length);
/** Get the SoftAP information
*
* @param ap_info : the location where the AP info will be
* stored
* @param security : the security type.
*
* @return RTW_SUCCESS : if result was successfully get
* RTW_ERROR : if result was not successfully get
*/
int wifi_get_ap_info(rtw_bss_info_t * ap_info, rtw_security_t* security);
/** Set the country code to driver to determine the channel set
*
* @param country_code : the country code.
*
* @return RTW_SUCCESS : if result was successfully set
* RTW_ERROR : if result was not successfully set
*/
int wifi_set_country(rtw_country_code_t country_code);
/** Retrieve the latest RSSI value
*
* @param rssi: The location where the RSSI value will be stored
*
* @return RTW_SUCCESS : if the RSSI was succesfully retrieved
* RTW_ERROR : if the RSSI was not retrieved
*/
int wifi_get_rssi(int *pRSSI);
/** Set the current channel on STA interface
*
* @param channel : The desired channel
*
* @return RTW_SUCCESS : if the channel was successfully set
* RTW_ERROR : if the channel was not successfully
* set
*/
int wifi_set_channel(int channel);
/** Get the current channel on STA interface
*
* @param channel : A pointer to the variable where the
* channel value will be written
*
* @return RTW_SUCCESS : if the channel was successfully read
* RTW_ERROR : if the channel was not successfully
* read
*/
int wifi_get_channel(int *channel);
/** Registers interest in a multicast address
* Once a multicast address has been registered, all packets detected on the
* medium destined for that address are forwarded to the host.
* Otherwise they are ignored.
*
* @param mac: Ethernet MAC address
*
* @return RTW_SUCCESS : if the address was registered
* successfully
* RTW_ERROR : if the address was not registered
*/
int wifi_register_multicast_address(rtw_mac_t *mac);
/** Unregisters interest in a multicast address
* Once a multicast address has been unregistered, all packets detected on the
* medium destined for that address are ignored.
*
* @param mac: Ethernet MAC address
*
* @return RTW_SUCCESS : if the address was unregistered
* successfully
* RTW_ERROR : if the address was not unregistered
*/
int wifi_unregister_multicast_address(rtw_mac_t *mac);
int wifi_rf_on(void);
int wifi_rf_off(void);
/** Turn on the Wi-Fi device
*
* - Bring the Wireless interface "Up"
* - Initialises the driver thread which arbitrates access
* to the SDIO/SPI bus
*
* @param mode: wifi work mode
*
* @return RTW_SUCCESS : if the WiFi chip was initialised
* successfully
* RTW_ERROR : if the WiFi chip was not initialised
* successfully
*/
int wifi_on(rtw_mode_t mode);
/**
* Turn off the Wi-Fi device
*
* - Bring the Wireless interface "Down"
* - De-Initialises the driver thread which arbitrates access
* to the SDIO/SPI bus
*
* @return RTW_SUCCESS if deinitialization is successful,
* RTW_ERROR otherwise
*/
int wifi_off(void);
/**
* Set IPS/LPS mode
*
* @param[in] ips_mode : The desired IPS mode. It become effective when wlan enter ips.
* @param[in] lps_mode : The desired LPS mode. It become effective when wlan enter lps.
*
* @return RTW_SUCCESS if setting LPS mode successful
* RTW_ERROR otherwise
*/
int wifi_set_power_mode(unsigned char ips_mode, unsigned char lps_mode);
/**
* Set TDMA parameters
*
* @param[in] slot_period : We separate TBTT into 2 or 3 slots.
* If we separate TBTT into 2 slots, then slot_period should be larger or equal to 50ms.
* It means 2 slot period is
* slot_period, 100-slot_period
* If we separate TBTT into 3 slots, then slot_period should be less or equal to 33ms.
* It means 3 slot period is
* 100 - 2 * slot_period, slot_period, slot_period
* @param[in] rfon_period_len_1: rf on period of slot 1
* @param[in] rfon_period_len_2: rf on period of slot 2
* @param[in] rfon_period_len_3: rf on period of slot 3
*
* @return RTW_SUCCESS if setting TDMA parameters successful
* RTW_ERROR otherwise
*/
int wifi_set_tdma_param(unsigned char slot_period, unsigned char rfon_period_len_1, unsigned char rfon_period_len_2, unsigned char rfon_period_len_3);
/**
* Set LPS DTIM
*
* @param[in] dtim : In LPS, the package can be buffered at AP side.
* STA leave LPS until dtim count of packages buffered at AP side.
*
* @return RTW_SUCCESS if setting LPS dtim successful
* RTW_ERROR otherwise
*/
int wifi_set_lps_dtim(unsigned char dtim);
/** Starts an infrastructure WiFi network
*
* @warning If a STA interface is active when this function is called, the softAP will\n
* start on the same channel as the STA. It will NOT use the channel provided!
*
* @param[in] ssid : A null terminated string containing
* the SSID name of the network to join
* @param[in] security_type : Authentication type: \n
* - RTW_SECURITY_OPEN - Open Security \n
* - RTW_SECURITY_WPA_TKIP_PSK - WPA Security \n
* - RTW_SECURITY_WPA2_AES_PSK - WPA2 Security using AES cipher \n
* - RTW_SECURITY_WPA2_MIXED_PSK - WPA2 Security using AES and/or TKIP ciphers \n
* - WEP security is NOT IMPLEMENTED. It is NOT SECURE! \n
* @param[in] password : A byte array containing the cleartext
* security key for the network
* @param[in] ssid_len : The length of the SSID in
* bytes.
* @param[in] password_len : The length of the security_key in
* bytes.
* @param[in] channel : 802.11 channel number
*
* @return RTW_SUCCESS : if successfully creates an AP
* RTW_ERROR : if an error occurred
*/
int wifi_start_ap(
char *ssid,
rtw_security_t security_type,
char *password,
int ssid_len,
int password_len,
int channel);
/** Initiates a scan to search for 802.11 networks.
*
* The scan progressively accumulates results over time, and
* may take between 1 and 3 seconds to complete. The results of
* the scan will be individually provided to the callback
* function. Note: The callback function will be executed in
* the context of the RTW thread.
*
* @param[in] scan_type : Specifies whether the scan should
* be Active, Passive or scan
* Prohibited channels
* @param[in] bss_type : Specifies whether the scan should
* search for Infrastructure
* networks (those using an Access
* Point), Ad-hoc networks, or both
* types.
* @param result_ptr[in] : Scan specific ssid. The first 4
* bytes is ssid lenth, and ssid name
* append after it.
* If no specific ssid need to scan,
* PLEASE CLEAN result_ptr before pass
* it into parameter.
* @param result_ptr[out] : a pointer to a pointer to a result
* storage structure.
*
* @note : When scanning specific channels, devices with a
* strong signal strength on nearby channels may be
* detected
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_scan(rtw_scan_type_t scan_type,
rtw_bss_type_t bss_type,
void* result_ptr);
/** Initiates a scan to search for 802.11 networks, a higher
* level API based on wifi_scan to simplify the scan
* operation.
*
* The scan results will be list by the order of RSSI.
* It may demand hundreds bytes memory during scan
* processing according to the quantity of AP nearby.
*
* @param results_handler[in] : the callback function which
* will receive and process the result data.
* @param user_data[in] : user specific data that will be
* passed directly to the callback function
*
* @note : Callback must not use blocking functions, since it is
* called from the context of the RTW thread.
* @note : The callback, user_data variables will
* be referenced after the function returns. Those
* variables must remain valid until the scan is
* complete.
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_scan_networks(rtw_scan_result_handler_t results_handler, void* user_data);
int wifi_scan_networks_with_ssid(rtw_scan_result_handler_t results_handler, void* user_data, char* ssid, int ssid_len);
/** Set the partical scan
*
* @param channel_list[in] : the channel set the scan will
* stay on
* @param pscan_config[in] : the pscan_config of the channel set
*
* @param length[in] : the channel list length
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_set_pscan_chan(__u8 * channel_list,__u8 * pscan_config, __u8 length);
/** Get the network information
*
* @param ifname[in] : the name of the interface we are care
* @param pSetting[in] : the location where the network
* information will be stored
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_get_setting(const char *ifname,rtw_wifi_setting_t *pSetting);
/** Show the network information
*
* @param ifname[in] : the name of the interface we are care
* @param pSetting[in] : the location where the network
* information was stored
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_show_setting(const char *ifname,rtw_wifi_setting_t *pSetting);
/** Set the network mode according to the data rate it's
* supported
*
* @param mode[in] : the network mode
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_set_network_mode(rtw_network_mode_t mode);
/** Set the chip to worke in the promisc mode
*
* @param enabled[in] : enabled can be set 0, 1 and 2. if enabled is zero, disable the promisc, else enable the promisc.
* 0 means disable the promisc
* 1 means enable the promisc
* 2 means enable the promisc special for length is used
* @param callback[in] : the callback function which will
* receive and process the netowork data.
* @param len_used[in] : specify if the the promisc length is
* used.
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_set_promisc(rtw_rcr_level_t enabled, void (*callback)(unsigned char*, unsigned int, void*), unsigned char len_used);
/** Set the wps phase
*
* @param is_trigger_wps[in] : to trigger wps function or not
*
* @return RTW_SUCCESS or RTW_ERROR
*/
int wifi_set_wps_phase(unsigned char is_trigger_wps);
/** Restarts an infrastructure WiFi network
*
* @warning If a STA interface is active when this function is called, the softAP will\n
* start on the same channel as the STA. It will NOT use the channel provided!
*
* @param[in] ssid : A null terminated string containing
* the SSID name of the network to join
* @param[in] security_type : Authentication type: \n
* - RTW_SECURITY_OPEN - Open Security \n
* - RTW_SECURITY_WPA_TKIP_PSK - WPA Security \n
* - RTW_SECURITY_WPA2_AES_PSK - WPA2 Security using AES cipher \n
* - RTW_SECURITY_WPA2_MIXED_PSK - WPA2 Security using AES and/or TKIP ciphers \n
* - WEP security is NOT IMPLEMENTED. It is NOT SECURE! \n
* @param[in] password : A byte array containing the cleartext
* security key for the network
* @param[in] ssid_len : The length of the SSID in
* bytes.
* @param[in] password_len : The length of the security_key in
* bytes.
* @param[in] channel : 802.11 channel number
*
* @return RTW_SUCCESS : if successfully creates an AP
* RTW_ERROR : if an error occurred
*/
int wifi_restart_ap(
unsigned char *ssid,
rtw_security_t security_type,
unsigned char *password,
int ssid_len,
int password_len,
int channel);
int wifi_config_autoreconnect(__u8 mode, __u8 retyr_times, __u16 timeout);
int wifi_set_autoreconnect(__u8 mode);
int wifi_get_autoreconnect(__u8 *mode);
int wifi_get_last_error( void );
/** Present device disconnect reason while connecting
*
*@return RTW_NO_ERROR = 0,
* RTW_NONE_NETWORK = 1,
* RTW_CONNECT_FAIL = 2,
* RTW_WRONG_PASSWORD = 3 ,
* RTW_DHCP_FAIL = 4,
* RTW_UNKNOWN, initial status
*/
#ifdef CONFIG_CUSTOM_IE
#ifndef BIT
#define BIT(x) ((__u32)1 << (x))
#endif
#ifndef _CUSTOM_IE_TYPE_
#define _CUSTOM_IE_TYPE_
enum CUSTOM_IE_TYPE{
PROBE_REQ = BIT(0),
PROBE_RSP = BIT(1),
BEACON = BIT(2),
};
#endif /* _CUSTOM_IE_TYPE_ */
/* ie format
* +-----------+--------+-----------------------+
* |element ID | length | content in length byte|
* +-----------+--------+-----------------------+
*
* type: refer to CUSTOM_IE_TYPE
*/
#ifndef _CUS_IE_
#define _CUS_IE_
typedef struct _cus_ie{
__u8 *ie;
__u8 type;
}cus_ie, *p_cus_ie;
#endif /* _CUS_IE_ */
int wifi_add_custom_ie(void *cus_ie, int ie_num);
int wifi_update_custom_ie(void *cus_ie, int ie_index);
int wifi_del_custom_ie(void);
#endif
#ifdef CONFIG_PROMISC
void wifi_init_packet_filter(void);
int wifi_add_packet_filter(unsigned char filter_id, rtw_packet_filter_pattern_t *patt, rtw_packet_filter_rule_e rule);
int wifi_enable_packet_filter(unsigned char filter_id);
int wifi_disable_packet_filter(unsigned char filter_id);
int wifi_remove_packet_filter(unsigned char filter_id);
#endif
#ifdef __cplusplus
}
#endif
#endif // __WIFI_API_H
//----------------------------------------------------------------------------//

239
component/common/api/wifi/wifi_ind.c Executable file
View file

@ -0,0 +1,239 @@
//----------------------------------------------------------------------------//
#include "wifi/wifi_ind.h"
#include "wifi/wifi_conf.h"
#include "osdep_service.h"
/******************************************************
* Constants
******************************************************/
#define WIFI_INDICATE_MSG 0
#define WIFI_MANAGER_STACKSIZE 128
#define WIFI_MANAGER_PRIORITY (5)
#define WIFI_MANAGER_PRIO 2
#define INDICATE_USE_THREAD 0
#define WIFI_EVENT_MAX_ROW 3
/******************************************************
* Globals
******************************************************/
static event_list_elem_t event_callback_list[WIFI_EVENT_MAX][WIFI_EVENT_MAX_ROW];
#if INDICATE_USE_THREAD
static rtw_worker_thread_t wifi_worker_thread;
#endif
//----------------------------------------------------------------------------//
#if INDICATE_USE_THREAD
static rtw_result_t rtw_send_event_to_worker(int event_cmd, char *buf, int buf_len, int flags)
{
rtw_event_message_t message;
int i;
rtw_result_t ret = RTW_SUCCESS;
if(event_cmd >= WIFI_EVENT_MAX)
return RTW_BADARG;
for(i = 0; i < WIFI_EVENT_MAX_ROW; i++){
if(event_callback_list[event_cmd][i].handler == NULL)
continue;
message.function = (event_handler_t)event_callback_list[event_cmd][i].handler;
message.buf = buf;
message.buf_len = buf_len;
message.flags = flags;
message.user_data = event_callback_list[event_cmd][i].handler_user_data;
ret = rtw_push_to_xqueue(&wifi_worker_thread->event_queue, &message, 0);
if(ret != RTW_SUCCESS)
break;
}
return ret;
}
#else
static rtw_result_t rtw_indicate_event_handle(int event_cmd, char *buf, int buf_len, int flags)
{
rtw_event_handler_t handle = NULL;
int i;
if(event_cmd >= WIFI_EVENT_MAX)
return RTW_BADARG;
for(i = 0; i < WIFI_EVENT_MAX_ROW; i++){
handle = event_callback_list[event_cmd][i].handler;
if(handle == NULL)
continue;
handle(buf, buf_len, flags, event_callback_list[event_cmd][i].handler_user_data);
}
return RTW_SUCCESS;
}
#endif
void wifi_indication( WIFI_EVENT_INDICATE event, char *buf, int buf_len, int flags)
{
//
// If upper layer application triggers additional operations on receiving of wext_wlan_indicate,
// please strictly check current stack size usage (by using uxTaskGetStackHighWaterMark() )
// , and tries not to share the same stack with wlan driver if remaining stack space is
// not available for the following operations.
// ex: using semaphore to notice another thread.
switch(event)
{
case WIFI_EVENT_DISCONNECT:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r %s():Disconnection indication received", __FUNCTION__);
#endif
break;
case WIFI_EVENT_CONNECT:
// For WPA/WPA2 mode, indication of connection does not mean data can be
// correctly transmitted or received. Data can be correctly transmitted or
// received only when 4-way handshake is done.
// Please check WIFI_EVENT_FOURWAY_HANDSHAKE_DONE event
#if(WIFI_INDICATE_MSG==1)
// Sample: return mac address
if(buf != NULL && buf_len == 6)
{
printf("\n\r%s():Connect indication received: %02x:%02x:%02x:%02x:%02x:%02x", __FUNCTION__,
buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]);
}
#endif
break;
case WIFI_EVENT_FOURWAY_HANDSHAKE_DONE:
#if(WIFI_INDICATE_MSG==1)
if(buf != NULL)
{
if(buf_len == strlen(IW_EXT_STR_FOURWAY_DONE))
printf("\n\r%s():%s", __FUNCTION__, buf);
}
#endif
break;
case WIFI_EVENT_SCAN_RESULT_REPORT:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_SCAN_RESULT_REPORT\n", __func__);
#endif
break;
case WIFI_EVENT_SCAN_DONE:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_SCAN_DONE\n", __func__);
#endif
break;
case WIFI_EVENT_RECONNECTION_FAIL:
#if(WIFI_INDICATE_MSG==1)
if(buf != NULL){
if(buf_len == strlen(IW_EXT_STR_RECONNECTION_FAIL))
printf("\n\r%s", buf);
}
#endif
break;
case WIFI_EVENT_NO_NETWORK:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_NO_NETWORK\n", __func__);
#endif
break;
#ifdef CONFIG_P2P_NEW
case WIFI_EVENT_SEND_ACTION_DONE:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_SEND_ACTION_DONE\n", __func__);
#endif
break;
case WIFI_EVENT_RX_MGNT:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_RX_MGNT\n", __func__);
#endif
break;
case WIFI_EVENT_STA_ASSOC:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_STA_ASSOC\n", __func__);
#endif
break;
case WIFI_EVENT_STA_DISASSOC:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_STA_DISASSOC\n", __func__);
#endif
break;
#endif //CONFIG_P2P_NEW
#ifdef CONFIG_WPS
case WIFI_EVENT_WPS_FINISH:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_WPS_FINISH\n", __func__);
#endif
break;
case WIFI_EVENT_EAPOL_RECVD:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_EAPOL_RECVD\n", __func__);
#endif
break;
#endif
case WIFI_EVENT_BEACON_AFTER_DHCP:
#if(WIFI_INDICATE_MSG==1)
printf("\n\r%s(): WIFI_EVENT_BEACON_AFTER_DHCP\n", __func__);
#endif
break;
}
#if CONFIG_INIC_EN
inic_indicate_event(event, buf, buf_len, flags);
#endif//CONFIG_INIC_EN
#if INDICATE_USE_THREAD
rtw_send_event_to_worker(event, buf, buf_len, flags);
#else
rtw_indicate_event_handle(event, buf, buf_len, flags);
#endif
}
void wifi_reg_event_handler(unsigned int event_cmds, rtw_event_handler_t handler_func, void *handler_user_data)
{
int i = 0, j = 0;
if(event_cmds < WIFI_EVENT_MAX){
for(i=0; i < WIFI_EVENT_MAX_ROW; i++){
if(event_callback_list[event_cmds][i].handler == NULL){
for(j=0; j<WIFI_EVENT_MAX_ROW; j++){
if(event_callback_list[event_cmds][j].handler == handler_func){
return;
}
}
event_callback_list[event_cmds][i].handler = handler_func;
event_callback_list[event_cmds][i].handler_user_data = handler_user_data;
return;
}
}
}
}
void wifi_unreg_event_handler(unsigned int event_cmds, rtw_event_handler_t handler_func)
{
int i;
if(event_cmds < WIFI_EVENT_MAX){
for(i = 0; i < WIFI_EVENT_MAX_ROW; i++){
if(event_callback_list[event_cmds][i].handler == handler_func){
event_callback_list[event_cmds][i].handler = NULL;
event_callback_list[event_cmds][i].handler_user_data = NULL;
return;
}
}
}
}
void init_event_callback_list(){
memset(event_callback_list, 0, sizeof(event_callback_list));
}
int wifi_manager_init()
{
#if INDICATE_USE_THREAD
rtw_create_worker_thread(&wifi_worker_thread,
WIFI_MANAGER_PRIORITY,
WIFI_MANAGER_STACKSIZE,
WIFI_MANAGER_PRIO);
#endif
return 0;
}
void rtw_wifi_manager_deinit()
{
#if INDICATE_USE_THREAD
rtw_delete_worker_thread(&wifi_worker_thread);
#endif
}

52
component/common/api/wifi/wifi_ind.h Executable file
View file

@ -0,0 +1,52 @@
#ifndef _WIFI_INDICATE_H
#define _WIFI_INDICATE_H
#include "wifi_conf.h"
#if 0 //move to wifi_constants.h
typedef enum _WIFI_EVENT_INDICATE{
WIFI_EVENT_CONNECT = 0,
WIFI_EVENT_DISCONNECT = 1,
WIFI_EVENT_FOURWAY_HANDSHAKE_DONE = 2,
WIFI_EVENT_SCAN_RESULT_REPORT = 3,
WIFI_EVENT_SCAN_DONE = 4,
WIFI_EVENT_RECONNECTION_FAIL = 5,
WIFI_EVENT_SEND_ACTION_DONE = 6,
WIFI_EVENT_RX_MGNT = 7,
WIFI_EVENT_STA_ASSOC = 8,
WIFI_EVENT_STA_DISASSOC = 9,
WIFI_EVENT_WPS_FINISH = 10,
WIFI_EVENT_EAPOL_RECVD = 11,
WIFI_EVENT_NO_NETWORK = 12,
WIFI_EVENT_BEACON_AFTER_DHCP = 13,
WIFI_EVENT_MAX,
}WIFI_EVENT_INDICATE;
#endif
typedef void (*rtw_event_handler_t)(char *buf, int buf_len, int flags, void* handler_user_data );
typedef struct
{
// WIFI_EVENT_INDICATE event_cmd;
rtw_event_handler_t handler;
void* handler_user_data;
} event_list_elem_t;
void init_event_callback_list(void);
extern void wifi_indication( WIFI_EVENT_INDICATE event, char *buf, int buf_len, int flags);
/** Register the event listener
*
* @param[in] event_cmds : The event command number indicated
* @param[in] handler_func : the callback function which will
* receive and process the event
* @param[in] handler_user_data : user specific data that will be
* passed directly to the callback function
*
* @note : Set the same event_cmds with empty handler_func will
* unregister the event_cmds
*
* @return RTW_SUCCESS : if successfully registers the event
* RTW_ERROR : if an error occurred
*/
extern void wifi_reg_event_handler(unsigned int event_cmds, rtw_event_handler_t handler_func, void *handler_user_data);
extern void wifi_unreg_event_handler(unsigned int event_cmds, rtw_event_handler_t handler_func);
#endif //_WIFI_INDICATE_H

409
component/common/api/wifi/wifi_promisc.c Executable file
View file

@ -0,0 +1,409 @@
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "tcpip.h"
#include "wifi/wifi_conf.h"
#ifndef CONFIG_WLAN
#define CONFIG_WLAN 1
#endif
#if CONFIG_WLAN
#include <platform/platform_stdlib.h>
struct eth_frame {
struct eth_frame *prev;
struct eth_frame *next;
unsigned char da[6];
unsigned char sa[6];
unsigned int len;
unsigned char type;
signed char rssi;
};
#if CONFIG_INIC_CMD_RSP
#if defined(__IAR_SYSTEMS_ICC__)
#pragma pack(1)
#endif
struct inic_eth_frame {
unsigned char da[6];
unsigned char sa[6];
unsigned int len;
unsigned char type;
};
#if defined(__IAR_SYSTEMS_ICC__)
#pragma pack()
#endif
static struct inic_eth_frame *inic_frame, *inic_frame_tail = NULL;
static int inic_frame_cnt = 0;
#define MAX_INIC_FRAME_NUM 50 //maximum packets for each channel
extern void inic_c2h_msg(const char *atcmd, char status, char *msg, u16 msg_len);
#endif
struct eth_buffer {
struct eth_frame *head;
struct eth_frame *tail;
};
static struct eth_buffer eth_buffer;
#ifdef CONFIG_PROMISC
#define MAX_PACKET_FILTER_INFO 5
#define FILTER_ID_INIT_VALUE 10
rtw_packet_filter_info_t paff_array[MAX_PACKET_FILTER_INFO]={0, 0, 0, 0, 0};
static u8 packet_filter_enable_num = 0;
void promisc_init_packet_filter()
{
int i = 0;
for(i=0; i<MAX_PACKET_FILTER_INFO; i++){
paff_array[i].filter_id = FILTER_ID_INIT_VALUE;
paff_array[i].enable = 0;
paff_array[i].patt.mask_size = 0;
paff_array[i].rule = RTW_POSITIVE_MATCHING;
paff_array[i].patt.mask = NULL;
paff_array[i].patt.pattern = NULL;
}
packet_filter_enable_num = 0;
}
int promisc_add_packet_filter(u8 filter_id, rtw_packet_filter_pattern_t *patt, rtw_packet_filter_rule_e rule)
{
int i = 0;
while(i < MAX_PACKET_FILTER_INFO){
if(paff_array[i].filter_id == FILTER_ID_INIT_VALUE){
break;
}
i++;
}
if(i == MAX_PACKET_FILTER_INFO)
return -1;
paff_array[i].filter_id = filter_id;
paff_array[i].patt.offset= patt->offset;
paff_array[i].patt.mask_size = patt->mask_size;
paff_array[i].patt.mask = pvPortMalloc(patt->mask_size);
memcpy(paff_array[i].patt.mask, patt->mask, patt->mask_size);
paff_array[i].patt.pattern= pvPortMalloc(patt->mask_size);
memcpy(paff_array[i].patt.pattern, patt->pattern, patt->mask_size);
paff_array[i].rule = rule;
paff_array[i].enable = 0;
return 0;
}
int promisc_enable_packet_filter(u8 filter_id)
{
int i = 0;
while(i < MAX_PACKET_FILTER_INFO){
if(paff_array[i].filter_id == filter_id)
break;
i++;
}
if(i == MAX_PACKET_FILTER_INFO)
return -1;
paff_array[i].enable = 1;
packet_filter_enable_num++;
return 0;
}
int promisc_disable_packet_filter(u8 filter_id)
{
int i = 0;
while(i < MAX_PACKET_FILTER_INFO){
if(paff_array[i].filter_id == filter_id)
break;
i++;
}
if(i == MAX_PACKET_FILTER_INFO)
return -1;
paff_array[i].enable = 0;
packet_filter_enable_num--;
return 0;
}
int promisc_remove_packet_filter(u8 filter_id)
{
int i = 0;
while(i < MAX_PACKET_FILTER_INFO){
if(paff_array[i].filter_id == filter_id)
break;
i++;
}
if(i == MAX_PACKET_FILTER_INFO)
return -1;
paff_array[i].filter_id = FILTER_ID_INIT_VALUE;
paff_array[i].enable = 0;
paff_array[i].patt.mask_size = 0;
paff_array[i].rule = 0;
if(paff_array[i].patt.mask){
vPortFree(paff_array[i].patt.mask);
paff_array[i].patt.mask = NULL;
}
if(paff_array[i].patt.pattern){
vPortFree(paff_array[i].patt.pattern);
paff_array[i].patt.pattern = NULL;
}
return 0;
}
#endif
/* Make callback simple to prevent latency to wlan rx when promiscuous mode */
static void promisc_callback(unsigned char *buf, unsigned int len, void* userdata)
{
struct eth_frame *frame = (struct eth_frame *) pvPortMalloc(sizeof(struct eth_frame));
if(frame) {
frame->prev = NULL;
frame->next = NULL;
memcpy(frame->da, buf, 6);
memcpy(frame->sa, buf+6, 6);
frame->len = len;
frame->rssi = ((ieee80211_frame_info_t *)userdata)->rssi;
taskENTER_CRITICAL();
if(eth_buffer.tail) {
eth_buffer.tail->next = frame;
frame->prev = eth_buffer.tail;
eth_buffer.tail = frame;
}
else {
eth_buffer.head = frame;
eth_buffer.tail = frame;
}
taskEXIT_CRITICAL();
}
}
struct eth_frame* retrieve_frame(void)
{
struct eth_frame *frame = NULL;
taskENTER_CRITICAL();
if(eth_buffer.head) {
frame = eth_buffer.head;
if(eth_buffer.head->next) {
eth_buffer.head = eth_buffer.head->next;
eth_buffer.head->prev = NULL;
}
else {
eth_buffer.head = NULL;
eth_buffer.tail = NULL;
}
}
taskEXIT_CRITICAL();
return frame;
}
static void promisc_test(int duration, unsigned char len_used)
{
int ch;
unsigned int start_time;
struct eth_frame *frame;
eth_buffer.head = NULL;
eth_buffer.tail = NULL;
wifi_enter_promisc_mode();
wifi_set_promisc(RTW_PROMISC_ENABLE, promisc_callback, len_used);
for(ch = 1; ch <= 13; ch ++) {
if(wifi_set_channel(ch) == 0)
printf("\n\n\rSwitch to channel(%d)", ch);
start_time = xTaskGetTickCount();
while(1) {
unsigned int current_time = xTaskGetTickCount();
if((current_time - start_time) < (duration * configTICK_RATE_HZ)) {
frame = retrieve_frame();
if(frame) {
int i;
printf("\n\rDA:");
for(i = 0; i < 6; i ++)
printf(" %02x", frame->da[i]);
printf(", SA:");
for(i = 0; i < 6; i ++)
printf(" %02x", frame->sa[i]);
printf(", len=%d", frame->len);
printf(", RSSI=%d", frame->rssi);
#if CONFIG_INIC_CMD_RSP
if(inic_frame_tail){
if(inic_frame_cnt < MAX_INIC_FRAME_NUM){
memcpy(inic_frame_tail->da, frame->da, 6);
memcpy(inic_frame_tail->sa, frame->sa, 6);
inic_frame_tail->len = frame->len;
inic_frame_tail++;
inic_frame_cnt++;
}
}
#endif
vPortFree((void *) frame);
}
else
vTaskDelay(1); //delay 1 tick
}
else
break;
}
#if CONFIG_INIC_CMD_RSP
if(inic_frame){
inic_c2h_msg("ATWM", RTW_SUCCESS, (char *)inic_frame, sizeof(struct inic_eth_frame)*inic_frame_cnt);
memset(inic_frame, '\0', sizeof(struct inic_eth_frame)*MAX_INIC_FRAME_NUM);
inic_frame_tail = inic_frame;
inic_frame_cnt = 0;
rtw_msleep_os(10);
}
#endif
}
wifi_set_promisc(RTW_PROMISC_DISABLE, NULL, 0);
while((frame = retrieve_frame()) != NULL)
vPortFree((void *) frame);
}
static void promisc_callback_all(unsigned char *buf, unsigned int len, void* userdata)
{
struct eth_frame *frame = (struct eth_frame *) pvPortMalloc(sizeof(struct eth_frame));
if(frame) {
frame->prev = NULL;
frame->next = NULL;
memcpy(frame->da, buf+4, 6);
memcpy(frame->sa, buf+10, 6);
frame->len = len;
frame->type = *buf;
frame->rssi = ((ieee80211_frame_info_t *)userdata)->rssi;
taskENTER_CRITICAL();
if(eth_buffer.tail) {
eth_buffer.tail->next = frame;
frame->prev = eth_buffer.tail;
eth_buffer.tail = frame;
}
else {
eth_buffer.head = frame;
eth_buffer.tail = frame;
}
taskEXIT_CRITICAL();
}
}
static void promisc_test_all(int duration, unsigned char len_used)
{
int ch;
unsigned int start_time;
struct eth_frame *frame;
eth_buffer.head = NULL;
eth_buffer.tail = NULL;
wifi_enter_promisc_mode();
wifi_set_promisc(RTW_PROMISC_ENABLE_2, promisc_callback_all, len_used);
for(ch = 1; ch <= 13; ch ++) {
if(wifi_set_channel(ch) == 0)
printf("\n\n\rSwitch to channel(%d)", ch);
start_time = xTaskGetTickCount();
while(1) {
unsigned int current_time = xTaskGetTickCount();
if((current_time - start_time) < (duration * configTICK_RATE_HZ)) {
frame = retrieve_frame();
if(frame) {
int i;
printf("\n\rTYPE: 0x%x, ", frame->type);
printf("DA:");
for(i = 0; i < 6; i ++)
printf(" %02x", frame->da[i]);
printf(", SA:");
for(i = 0; i < 6; i ++)
printf(" %02x", frame->sa[i]);
printf(", len=%d", frame->len);
printf(", RSSI=%d", frame->rssi);
#if CONFIG_INIC_CMD_RSP
if(inic_frame_tail){
if(inic_frame_cnt < MAX_INIC_FRAME_NUM){
memcpy(inic_frame_tail->da, frame->da, 6);
memcpy(inic_frame_tail->sa, frame->sa, 6);
inic_frame_tail->len = frame->len;
inic_frame_tail->type = frame->type;
inic_frame_tail++;
inic_frame_cnt++;
}
}
#endif
vPortFree((void *) frame);
}
else
vTaskDelay(1); //delay 1 tick
}
else
break;
}
#if CONFIG_INIC_CMD_RSP
if(inic_frame){
inic_c2h_msg("ATWM", RTW_SUCCESS, (char *)inic_frame, sizeof(struct inic_eth_frame)*inic_frame_cnt);
memset(inic_frame, '\0', sizeof(struct inic_eth_frame)*MAX_INIC_FRAME_NUM);
inic_frame_tail = inic_frame;
inic_frame_cnt = 0;
rtw_msleep_os(10);
}
#endif
}
wifi_set_promisc(RTW_PROMISC_DISABLE, NULL, 0);
while((frame = retrieve_frame()) != NULL)
vPortFree((void *) frame);
}
void cmd_promisc(int argc, char **argv)
{
int duration;
#if CONFIG_INIC_CMD_RSP
inic_frame_tail = inic_frame = pvPortMalloc(sizeof(struct inic_eth_frame)*MAX_INIC_FRAME_NUM);
if(inic_frame == NULL){
inic_c2h_msg("ATWM", RTW_BUFFER_UNAVAILABLE_TEMPORARY, NULL, 0);
return;
}
#endif
#ifdef CONFIG_PROMISC
wifi_init_packet_filter();
#endif
if((argc == 2) && ((duration = atoi(argv[1])) > 0))
//promisc_test(duration, 0);
promisc_test_all(duration, 0);
else if((argc == 3) && ((duration = atoi(argv[1])) > 0) && (strcmp(argv[2], "with_len") == 0))
promisc_test(duration, 1);
else
printf("\n\rUsage: %s DURATION_SECONDS [with_len]", argv[0]);
#if CONFIG_INIC_CMD_RSP
if(inic_frame)
vPortFree(inic_frame);
inic_frame_tail = NULL;
inic_frame_cnt = 0;
#endif
}
#endif //#if CONFIG_WLAN

606
component/common/api/wifi/wifi_simple_config.c Executable file
View file

@ -0,0 +1,606 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "udp.h"
#include <sockets.h>
#include <lwip_netconf.h>
#include <osdep_service.h>
#include "platform_stdlib.h"
#include "wifi_simple_config_parser.h"
#define STACKSIZE 512
#if CONFIG_WLAN
#if (CONFIG_INCLUDE_SIMPLE_CONFIG)
#include "wifi/wifi_conf.h"
int is_promisc_callback_unlock = 0;
static int is_fixed_channel;
int fixed_channel_num;
unsigned char g_ssid[32];
int g_ssid_len;
extern int promisc_get_fixed_channel( void *, u8 *, int* );
struct pattern_test_ops;
struct rtk_test_sc;
typedef int (*sc_test_check_pattern_call_back)(struct pattern_test_ops *pp, struct rtk_test_sc *pSc);
typedef int (*sc_test_get_cipher_info_call_back)(struct pattern_test_ops *pp, struct rtk_test_sc *pSc);
typedef int (*sc_test_generate_key_call_back)(struct pattern_test_ops *pp, struct rtk_test_sc *pSc);
typedef int (*sc_test_decode_profile_call_back)(struct pattern_test_ops *pp, struct rtk_test_sc *pSc);
typedef int (*sc_test_get_tlv_info_call_back)(struct pattern_test_ops *pp, struct rtk_test_sc *pSc);
struct pattern_test_ops {
unsigned int index;
unsigned flag;
unsigned char name[64];
sc_test_check_pattern_call_back check_pattern;
sc_test_get_cipher_info_call_back get_cipher_info;
sc_test_generate_key_call_back generate_key;
sc_test_decode_profile_call_back decode_profile;
sc_test_get_tlv_info_call_back get_tlv_info;
};
struct rtk_test_sc {
/* API exposed to user */
unsigned char ssid[32];
unsigned char password[65];
unsigned int ip_addr;
};
enum sc_result {
SC_ERROR = -1, /* default error code*/
SC_NO_CONTROLLER_FOUND = 1, /* cannot get sta(controller) in the air which starts a simple config session */
SC_CONTROLLER_INFO_PARSE_FAIL, /* cannot parse the sta's info */
SC_TARGET_CHANNEL_SCAN_FAIL, /* cannot scan the target channel */
SC_JOIN_BSS_FAIL, /* fail to connect to target ap */
SC_DHCP_FAIL, /* fail to get ip address from target ap */
/* fail to create udp socket to send info to controller. note that client isolation
must be turned off in ap. we cannot know if ap has configured this */
SC_UDP_SOCKET_CREATE_FAIL,
SC_SUCCESS, /* default success code */
};
#ifdef PACK_STRUCT_USE_INCLUDES
#include "arch/bpstruct.h"
#endif
PACK_STRUCT_BEGIN
struct ack_msg {
PACK_STRUCT_FIELD(u8_t flag);
PACK_STRUCT_FIELD(u16_t length);
PACK_STRUCT_FIELD(u8_t smac[6]);
PACK_STRUCT_FIELD(u8_t status);
PACK_STRUCT_FIELD(u16_t device_type);
PACK_STRUCT_FIELD(u32_t device_ip);
PACK_STRUCT_FIELD(u8_t device_name[64]);
};PACK_STRUCT_STRUCT;
PACK_STRUCT_END
#ifdef PACK_STRUCT_USE_INCLUDES
#include "arch/epstruct.h"
#endif
#define MULCAST_PORT (8864)
#define SCAN_BUFFER_LENGTH (1024)
#ifndef WLAN0_NAME
#define WLAN0_NAME "wlan0"
#endif
int simple_config_result;
static struct ack_msg *ack_content;
struct rtk_test_sc *backup_sc_ctx;
extern struct netif xnetif[NET_IF_NUM];
void SC_set_ack_content()
{
memset(ack_content, 0, sizeof(struct ack_msg));
ack_content->flag = 0x20;
ack_content->length = htons(sizeof(struct ack_msg)-3);
memcpy(ack_content->smac, xnetif[0].hwaddr, 6);
ack_content->status = 0;
ack_content->device_type = 0;
ack_content->device_ip = xnetif[0].ip_addr.addr;
memset(ack_content->device_name, 0, 64);
}
int SC_send_simple_config_ack()
{
#if CONFIG_LWIP_LAYER
int ack_transmit_round, ack_num_each_sec;
int ack_socket;
//int sended_data = 0;
struct sockaddr_in to_addr;
SC_set_ack_content();
ack_socket = socket(PF_INET, SOCK_DGRAM, IP_PROTO_UDP);
if (ack_socket == -1) {
return -1;
}
FD_ZERO(&to_addr);
to_addr.sin_family = AF_INET;
to_addr.sin_port = htons(8864);
to_addr.sin_addr.s_addr = (backup_sc_ctx->ip_addr);
for (ack_transmit_round = 0;ack_transmit_round < 10; ack_transmit_round++) {
for (ack_num_each_sec = 0;ack_num_each_sec < 10; ack_num_each_sec++) {
//sended_data =
sendto(ack_socket, (unsigned char *)ack_content, sizeof(struct ack_msg), 0, (struct sockaddr *) &to_addr, sizeof(struct sockaddr));
//printf("\r\nAlready send %d bytes data\n", sended_data);
vTaskDelay(100); /* delay 100 ms */
}
}
close(ack_socket);
#endif
#if CONFIG_INIC_CMD_RSP
extern unsigned int inic_sc_ip_addr;
inic_sc_ip_addr = backup_sc_ctx->ip_addr;
inic_c2h_wifi_info("ATWQ", RTW_SUCCESS);
#endif
return 0;
}
static enum sc_result SC_check_and_show_connection_info(void)
{
rtw_wifi_setting_t setting;
int ret = -1;
#if CONFIG_LWIP_LAYER
/* If not rise priority, LwIP DHCP may timeout */
vTaskPrioritySet(NULL, tskIDLE_PRIORITY + 3);
/* Start DHCP Client */
ret = LwIP_DHCP(0, DHCP_START);
vTaskPrioritySet(NULL, tskIDLE_PRIORITY + 1);
#endif
wifi_get_setting(WLAN0_NAME, &setting);
wifi_show_setting(WLAN0_NAME, &setting);
#if CONFIG_LWIP_LAYER
if (ret != DHCP_ADDRESS_ASSIGNED)
return SC_DHCP_FAIL;
else
#endif
return SC_SUCCESS;
}
static void check_and_set_security_in_connection(rtw_security_t security_mode, rtw_network_info_t *wifi)
{
if (security_mode == RTW_SECURITY_WPA2_AES_PSK) {
printf("\r\nwifi->security_type = RTW_SECURITY_WPA2_AES_PSK\n");
wifi->security_type = RTW_SECURITY_WPA2_AES_PSK;
} else if (security_mode == RTW_SECURITY_WEP_PSK) {
printf("\r\nwifi->security_type = RTW_SECURITY_WEP_PSK\n");
wifi->security_type = RTW_SECURITY_WEP_PSK;
wifi->key_id = 0;
} else if (security_mode == RTW_SECURITY_WPA_AES_PSK) {
printf("\r\nwifi->security_type = RTW_SECURITY_WPA_AES_PSK\n");
wifi->security_type = RTW_SECURITY_WPA_AES_PSK;
} else {
printf("\r\nwifi->security_type = RTW_SECURITY_OPEN\n");
wifi->security_type = RTW_SECURITY_OPEN;
}
}
static int get_connection_info_from_profile(rtw_security_t security_mode, rtw_network_info_t *wifi)
{
printf("\r\n======= Connection Information =======\n");
check_and_set_security_in_connection(security_mode, wifi);
wifi->password = backup_sc_ctx->password;
wifi->password_len = (int)strlen((char const *)backup_sc_ctx->password);
if ( g_ssid_len > 0 && g_ssid_len < 33){
wifi->ssid.len = g_ssid_len;
rtw_memcpy(wifi->ssid.val, g_ssid, wifi->ssid.len);
}else if(strlen(backup_sc_ctx->ssid) > 0 && strlen(backup_sc_ctx->ssid) < 33){
wifi->ssid.len = strlen(backup_sc_ctx->ssid);
rtw_memcpy(wifi->ssid.val, backup_sc_ctx->ssid, wifi->ssid.len);
}else{
printf("\r\n SSID is NULL or SSID length is over 32!!");
return -1;
}
if(wifi->security_type == RTW_SECURITY_WEP_PSK)
{
if(wifi->password_len == 10)
{
u32 p[5];
u8 pwd[6], i = 0;
sscanf((const char*)backup_sc_ctx->password, "%02x%02x%02x%02x%02x", &p[0], &p[1], &p[2], &p[3], &p[4]);
for(i=0; i< 5; i++)
pwd[i] = (u8)p[i];
pwd[5] = '\0';
memset(backup_sc_ctx->password, 0, 65);
strcpy((char*)backup_sc_ctx->password, (char*)pwd);
wifi->password_len = 5;
}else if(wifi->password_len == 26){
u32 p[13];
u8 pwd[14], i = 0;
sscanf((const char*)backup_sc_ctx->password, "%02x%02x%02x%02x%02x%02x%02x"\
"%02x%02x%02x%02x%02x%02x", &p[0], &p[1], &p[2], &p[3], &p[4],\
&p[5], &p[6], &p[7], &p[8], &p[9], &p[10], &p[11], &p[12]);
for(i=0; i< 13; i++)
pwd[i] = (u8)p[i];
pwd[13] = '\0';
memset(backup_sc_ctx->password, 0, 64);
strcpy((char*)backup_sc_ctx->password, (char*)pwd);
wifi->password_len = 13;
}
}
printf("\r\nwifi.password = %s\n", wifi->password);
printf("\r\nwifi.password_len = %d\n", wifi->password_len);
printf("\r\nwifi.ssid = %s\n", wifi->ssid.val);
printf("\r\nwifi.ssid_len = %d\n", wifi->ssid.len);
printf("\r\nwifi.channel = %d\n", fixed_channel_num);
printf("\r\n===== start to connect target AP =====\n");
return 0;
}
enum sc_result SC_connect_to_AP(void)
{
enum sc_result ret = SC_ERROR;
u8 scan_channel;
u8 pscan_config;
int max_retry = 10, retry = 0;
rtw_security_t security_mode;
rtw_network_info_t wifi = {0};
if(!(fixed_channel_num == 0)){
scan_channel = fixed_channel_num;
}
pscan_config = PSCAN_ENABLE | PSCAN_SIMPLE_CONFIG;
switch(g_security_mode){
case RTW_ENCRYPTION_OPEN:
security_mode = RTW_SECURITY_OPEN;
break;
case RTW_ENCRYPTION_WEP40:
case RTW_ENCRYPTION_WEP104:
security_mode = RTW_SECURITY_WEP_PSK;
break;
case RTW_ENCRYPTION_WPA_TKIP:
case RTW_ENCRYPTION_WPA_AES:
case RTW_ENCRYPTION_WPA2_TKIP:
case RTW_ENCRYPTION_WPA2_AES:
case RTW_ENCRYPTION_WPA2_MIXED:
security_mode = RTW_SECURITY_WPA2_AES_PSK;
break;
case RTW_ENCRYPTION_UNKNOWN:
case RTW_ENCRYPTION_UNDEF:
default:
printf("\r\n unknow security mode,connect fail!");
return ret;
}
g_security_mode = 0xff;//clear it
if (-1 == get_connection_info_from_profile(security_mode, &wifi)) {
ret = SC_CONTROLLER_INFO_PARSE_FAIL;
return ret;
}
while (1) {
if(wifi_set_pscan_chan(&scan_channel, &pscan_config, 1) < 0){
printf("\n\rERROR: wifi set partial scan channel fail");
ret = SC_TARGET_CHANNEL_SCAN_FAIL;
return ret;
}
#if 0
ret = wifi_connect((char*)wifi.ssid.val,
wifi.security_type,
(char*)wifi.password,
wifi.ssid.len,
wifi.password_len,
wifi.key_id,
NULL);
#else
ret = wifi_connect_bssid(g_bssid,
(char*)wifi.ssid.val,
wifi.security_type,
(char*)wifi.password,
6,
wifi.ssid.len,
wifi.password_len,
wifi.key_id,
NULL);
#endif
if (ret == RTW_SUCCESS) {
ret = SC_check_and_show_connection_info();
break;
}
if (retry == max_retry) {
ret = SC_JOIN_BSS_FAIL;
break;
}
retry ++;
if(retry > 3){
vTaskDelay(5000);
}
}
return ret;
}
/* Make callback one by one to wlan rx when promiscuous mode */
void simple_config_callback(unsigned char *buf, unsigned int len, void* userdata)
{
unsigned char * da = buf;
unsigned char * sa = buf + ETH_ALEN;
taskENTER_CRITICAL();
if (is_promisc_callback_unlock == 1) {
simple_config_result = rtk_start_parse_packet(da, sa, len, userdata, (void *)backup_sc_ctx);
//printf("\r\nresult in callback function = %d\n",simple_config_result);
}
taskEXIT_CRITICAL();
}
static unsigned int simple_config_cmd_start_time;
static unsigned int simple_config_cmd_current_time;
extern int simple_config_status;
extern void rtk_restart_simple_config(void);
extern void rtk_sc_deinit(void);
void init_simple_config_lib_config(struct simple_config_lib_config* config)
{
config->free = rtw_mfree;
config->malloc = rtw_malloc;
config->memcmp = (simple_config_memcmp_fn)_memcmp;
config->memcpy = _memcpy;
config->memset = _memset;
config->printf = printf;
config->strcpy = strcpy;
config->strlen = strlen;
config->zmalloc = rtw_zmalloc;
config->_ntohl = lwip_ntohl;
config->is_promisc_callback_unlock = &is_promisc_callback_unlock;
}
int init_test_data(char *custom_pin_code)
{
#if (CONFIG_INCLUDE_SIMPLE_CONFIG)
is_promisc_callback_unlock = 1;
is_fixed_channel = 0;
fixed_channel_num = 0;
simple_config_result = 0;
rtw_memset(g_ssid, 0, 32);
g_ssid_len = 0;
simple_config_cmd_start_time = xTaskGetTickCount();
if (ack_content != NULL) {
vPortFree(ack_content);
ack_content = NULL;
}
ack_content = pvPortMalloc(sizeof(struct ack_msg));
if (!ack_content) {
printf("\n\rrtk_sc_init fail by allocate ack\n");
}
memset(ack_content, 0, sizeof(struct ack_msg));
backup_sc_ctx = pvPortMalloc(sizeof(struct rtk_test_sc));
if (!backup_sc_ctx) {
printf("\n\r[Mem]malloc SC context fail\n");
} else {
memset(backup_sc_ctx, 0, sizeof(struct rtk_test_sc));
struct simple_config_lib_config lib_config;
init_simple_config_lib_config(&lib_config);
//custom_pin_code can be null
if (rtk_sc_init(custom_pin_code, &lib_config) < 0) {
printf("\n\rRtk_sc_init fail\n");
} else {
return 0;
}
}
#else
printf("\n\rPlatform no include simple config now\n");
#endif
return -1;
}
void deinit_test_data(){
#if (CONFIG_INCLUDE_SIMPLE_CONFIG)
rtk_sc_deinit();
if (backup_sc_ctx != NULL) {
vPortFree(backup_sc_ctx);
backup_sc_ctx = NULL;
}
if (ack_content != NULL) {
vPortFree(ack_content);
ack_content = NULL;
}
#endif
}
enum sc_result simple_config_test(void)
{
int channel = 1;
enum sc_result ret = SC_SUCCESS;
unsigned int start_time;
int is_need_connect_to_AP = 0;
int fix_channel = 0;
int delta_time = 0;
wifi_set_promisc(RTW_PROMISC_ENABLE, simple_config_callback, 1);
start_time = xTaskGetTickCount();
printf("\n\r");
wifi_set_channel(channel);
while (1) {
vTaskDelay(50); //delay 0.5s to release CPU usage
simple_config_cmd_current_time = xTaskGetTickCount();
if (simple_config_cmd_current_time - simple_config_cmd_start_time < ((120 + delta_time)*configTICK_RATE_HZ)) {
unsigned int current_time = xTaskGetTickCount();
if (((current_time - start_time)*1000 /configTICK_RATE_HZ < 100)
|| (is_fixed_channel == 1)) {
if((is_fixed_channel == 0)&&(!((fix_channel = promisc_get_fixed_channel(g_bssid,g_ssid,&g_ssid_len))== 0))){
//printf("\r\n in simple_config_test fix channel = %d ",fix_channel);
is_fixed_channel = 1;
fixed_channel_num = fix_channel;
wifi_set_channel(fix_channel);
}
if (simple_config_result == 1) {
is_need_connect_to_AP = 1;
is_fixed_channel = 0;
break;
}
if (simple_config_result == -1) {
printf("\r\nsimple_config_test restart for result = -1");
delta_time = 60;
wifi_set_channel(1);
is_need_connect_to_AP = 0;
is_fixed_channel = 0;
fixed_channel_num = 0;
memset(g_ssid, 0, 32);
g_ssid_len = 0;
simple_config_result = 0;
g_security_mode = 0xff;
rtk_restart_simple_config();
}
} else {
channel++;
if ((1 <= channel) && (channel <= 13)) {
if (wifi_set_channel(channel) == 0) {
start_time = xTaskGetTickCount();
printf("\n\rSwitch to channel(%d)\n", channel);
}
} else {
channel = 1;
if (wifi_set_channel(channel) == 0) {
start_time = xTaskGetTickCount();
printf("\n\rSwitch to channel(%d)\n", channel);
}
}
}
} else {
ret = SC_NO_CONTROLLER_FOUND;
break;
}
}
wifi_set_promisc(RTW_PROMISC_DISABLE, NULL, 0);
if (is_need_connect_to_AP == 1) {
enum sc_result tmp_res = SC_connect_to_AP();
if (SC_SUCCESS == tmp_res) {
if(-1 == SC_send_simple_config_ack())
ret = SC_UDP_SOCKET_CREATE_FAIL;
} else {
return tmp_res;
}
} else {
ret = SC_NO_CONTROLLER_FOUND;
}
deinit_test_data();
return ret;
}
//Filter packet da[] = {0x01, 0x00, 0x5e}
#define MASK_SIZE 3
void filter_add_enable(){
u8 mask[MASK_SIZE]={0xFF,0xFF,0xFF};
u8 pattern[MASK_SIZE]={0x01,0x00,0x5e};
rtw_packet_filter_pattern_t packet_filter;
rtw_packet_filter_rule_e rule;
packet_filter.offset = 0;
packet_filter.mask_size = 3;
packet_filter.mask = mask;
packet_filter.pattern = pattern;
rule = RTW_POSITIVE_MATCHING;
wifi_init_packet_filter();
wifi_add_packet_filter(1, &packet_filter,rule);
wifi_enable_packet_filter(1);
}
void remove_filter(){
wifi_disable_packet_filter(1);
wifi_remove_packet_filter(1);
}
static void print_simple_config_result(enum sc_result sc_code)
{
printf("\r\n");
switch (sc_code) {
case SC_NO_CONTROLLER_FOUND:
printf("Simple Config timeout!! Can't get Ap profile. Please try again\n");
break;
case SC_CONTROLLER_INFO_PARSE_FAIL:
printf("Simple Config fail, cannot parse target ap info from controller\n");
break;
case SC_TARGET_CHANNEL_SCAN_FAIL:
printf("Simple Config cannot scan the target channel\n");
break;
case SC_JOIN_BSS_FAIL:
printf("Simple Config Join bss failed\n");
break;
case SC_DHCP_FAIL:
printf("Simple Config fail, cannot get dhcp ip address\n");
break;
case SC_UDP_SOCKET_CREATE_FAIL:
printf("Simple Config Ack socket create fail!!!\n");
break;
case SC_SUCCESS:
printf("Simple Config success\n");
break;
case SC_ERROR:
default:
printf("unknown error when simple config!\n");
}
}
#endif //CONFIG_INCLUDE_SIMPLE_CONFIG
void cmd_simple_config(int argc, char **argv){
#if CONFIG_INCLUDE_SIMPLE_CONFIG
char *custom_pin_code = NULL;
enum sc_result ret = SC_ERROR;
if(argc > 2){
printf("\n\rInput Error!");
}
if(argc == 2)
custom_pin_code = (argv[1]);
wifi_enter_promisc_mode();
if(init_test_data(custom_pin_code) == 0){
filter_add_enable();
ret = simple_config_test();
print_simple_config_result(ret);
remove_filter();
}
#if CONFIG_INIC_CMD_RSP
if(ret != SC_SUCCESS)
inic_c2h_wifi_info("ATWQ", RTW_ERROR);
#endif
#endif
}
#endif //#if CONFIG_WLAN

85
component/common/api/wifi/wifi_simple_config_parser.h Executable file
View file

@ -0,0 +1,85 @@
#ifndef __SIMPLE_CONFIG_H__
#define __SIMPLE_CONFIG_H__
#ifdef __cplusplus
extern "C" {
#endif
/* This macro means user take simple config
* lib to another platform such as linux, and
* have no rom crypto libs of simple config,
* so we take simple_config_crypto as a sw lib
* This macro is used by Realtek internal to generate simple config lib
* Please delete this macro after generation.
*/
#define SIMPLE_CONFIG_PLATFORM_LIB 0
#include "platform_opts.h"
#include "autoconf.h"
/* platform related settings */
#undef u32
#undef s32
#undef u8
#undef s8
#undef u16
#undef s16
typedef unsigned int u32;
typedef signed int s32;
typedef unsigned char u8;
typedef char s8;
typedef unsigned short int u16;
typedef signed short int s16;
typedef s32 (*simple_config_printf_fn) (const s8 *fmt, ...);
typedef void* (*simple_config_memset_fn) (void *dst0, s32 Val, u32 length);
typedef void* (*simple_config_memcpy_fn) ( void *s1, const void *s2, u32 n );
typedef u32 (*simple_config_strlen_fn) (const char *s);
typedef char * (*simple_config_strcpy_fn) (s8 *dest, const s8 *src);
typedef void (*simple_config_free_fn) (u8 *pbuf, u32 sz);
typedef u8* (*simple_config_zmalloc_fn) (u32 sz);
typedef u8* (*simple_config_malloc_fn) (u32 sz);
typedef int (*simple_config_memcmp_fn) (const void *av, const void *bv, u32 len);
typedef u32 (*simple_config_ntohl_fn)(u32 x);
struct simple_config_lib_config {
simple_config_printf_fn printf;
simple_config_memset_fn memset;
simple_config_memcpy_fn memcpy;
simple_config_strlen_fn strlen;
simple_config_strcpy_fn strcpy;
simple_config_free_fn free;
simple_config_zmalloc_fn zmalloc;
simple_config_malloc_fn malloc;
simple_config_memcmp_fn memcmp;
simple_config_ntohl_fn _ntohl;
int *is_promisc_callback_unlock;
};
/* expose data */
extern s32 is_promisc_callback_unlock;
extern u8 g_bssid[6];
extern u8 g_security_mode;
/* expose API */
extern s32 rtk_sc_init(char *custom_pin_code, struct simple_config_lib_config* config);
extern s32 rtk_start_parse_packet(u8 *da, u8 *sa, s32 len, void * user_data, void *backup_sc);
extern void rtk_restart_simple_config(void);
extern void rtk_sc_deinit();
extern void wifi_enter_promisc_mode();
#ifdef __cplusplus
}
#endif
#endif /* __SIMPLE_CONFIG_H__*/

1086
component/common/api/wifi/wifi_util.c Executable file
View file

File diff suppressed because it is too large Load diff

65
component/common/api/wifi/wifi_util.h Executable file
View file

@ -0,0 +1,65 @@
#ifndef _UTIL_H
#define _UTIL_H
#include <wireless.h>
#include <wlan_intf.h>
#include <wifi_constants.h>
#include "wifi_structures.h"
#ifdef __cplusplus
extern "C" {
#endif
int wext_get_ssid(const char *ifname, __u8 *ssid);
int wext_set_ssid(const char *ifname, const __u8 *ssid, __u16 ssid_len);
int wext_set_auth_param(const char *ifname, __u16 idx, __u32 value);
int wext_set_key_ext(const char *ifname, __u16 alg, const __u8 *addr, int key_idx, int set_tx, const __u8 *seq, __u16 seq_len, __u8 *key, __u16 key_len);
int wext_get_enc_ext(const char *ifname, __u16 *alg, __u8 *key_idx, __u8 *passphrase);
int wext_set_passphrase(const char *ifname, const __u8 *passphrase, __u16 passphrase_len);
int wext_get_passphrase(const char *ifname, __u8 *passphrase);
int wext_set_mode(const char *ifname, int mode);
int wext_get_mode(const char *ifname, int *mode);
int wext_set_ap_ssid(const char *ifname, const __u8 *ssid, __u16 ssid_len);
int wext_set_country(const char *ifname, rtw_country_code_t country_code);
int wext_get_rssi(const char *ifname, int *rssi);
int wext_set_channel(const char *ifname, __u8 ch);
int wext_get_channel(const char *ifname, __u8 *ch);
int wext_register_multicast_address(const char *ifname, rtw_mac_t *mac);
int wext_unregister_multicast_address(const char *ifname, rtw_mac_t *mac);
int wext_set_scan(const char *ifname, char *buf, __u16 buf_len, __u16 flags);
int wext_get_scan(const char *ifname, char *buf, __u16 buf_len);
int wext_set_mac_address(const char *ifname, char * mac);
int wext_get_mac_address(const char *ifname, char * mac);
int wext_enable_powersave(const char *ifname, __u8 lps_mode, __u8 ips_mode);
int wext_disable_powersave(const char *ifname);
int wext_set_tdma_param(const char *ifname, __u8 slot_period, __u8 rfon_period_len_1, __u8 rfon_period_len_2, __u8 rfon_period_len_3);
int wext_set_lps_dtim(const char *ifname, __u8 lps_dtim);
int wext_get_tx_power(const char *ifname, __u8 *poweridx);
int wext_set_txpower(const char *ifname, int poweridx);
int wext_get_associated_client_list(const char *ifname, void * client_list_buffer, __u16 buffer_length);
int wext_get_ap_info(const char *ifname, rtw_bss_info_t * ap_info, rtw_security_t* security);
int wext_mp_command(const char *ifname, char *cmd, int show_msg);
int wext_private_command(const char *ifname, char *cmd, int show_msg);
int wext_private_command_with_retval(const char *ifname, char *cmd, char *ret_buf, int ret_len);
void wext_wlan_indicate(unsigned int cmd, union iwreq_data *wrqu, char *extra);
int wext_set_pscan_channel(const char *ifname, __u8 *ch, __u8 *pscan_config, __u8 length);
int wext_set_autoreconnect(const char *ifname, __u8 mode, __u8 retyr_times, __u16 timeout);
int wext_get_autoreconnect(const char *ifname, __u8 *mode);
#ifdef CONFIG_CUSTOM_IE
int wext_add_custom_ie(const char *ifname, void * cus_ie, int ie_num);
int wext_update_custom_ie(const char *ifname, void * cus_ie, int ie_index);
int wext_del_custom_ie(const char *ifname);
#endif
#define wext_handshake_done rltk_wlan_handshake_done
#ifdef CONFIG_P2P_NEW
int wext_send_mgnt(const char *ifname, char *buf, __u16 buf_len, __u16 flags);
#endif
int wext_set_gen_ie(const char *ifname, char *buf, __u16 buf_len, __u16 flags);
#ifdef __cplusplus
}
#endif
#endif /* _UTIL_H */