#include "crypto/aes_wrap.h"
#include "crypto/sha256.h"
#include "crypto/crypto.h"
+#include "crypto/md5.h"
+#include "crypto/sha1.h"
+#include "crypto/aes.h"
+#include "crypto/dh_group5.h"
+#include "wps/wps.h"
+#include "wps/wps_i.h"
+#include "wpa2/eap_peer/eap.h"
+#include "wpa2/tls/tls.h"
+#include "wpa2/eap_peer/eap_methods.h"
+#include "wpa2/eap_peer/eap_i.h"
+#include "wpa2/eap_peer/eap_common.h"
#include "esp_wifi_crypto_types.h"
-
/*
* The parameters is used to set the cyrpto callback function for station connect when in security mode,
* every callback function can register as fast_xxx or normal one, i.e, fast_aes_wrap or aes_wrap, the
.aes_wrap = (esp_aes_wrap_t)fast_aes_wrap,
.aes_unwrap = (esp_aes_unwrap_t)fast_aes_unwrap,
.hmac_sha256_vector = (esp_hmac_sha256_vector_t)fast_hmac_sha256_vector,
- .sha256_prf = (esp_sha256_prf_t)fast_sha256_prf
+ .sha256_prf = (esp_sha256_prf_t)fast_sha256_prf,
+ .hmac_md5 = (esp_hmac_md5_t)hmac_md5,
+ .hamc_md5_vector = (esp_hmac_md5_vector_t)hmac_md5_vector,
+ .hmac_sha1 = (esp_hmac_sha1_t)hmac_sha1,
+ .hmac_sha1_vector = (esp_hmac_sha1_vector_t)hmac_sha1_vector,
+ .sha1_prf = (esp_sha1_prf_t)sha1_prf,
+ .sha1_vector = (esp_sha1_vector_t)sha1_vector,
+ .pbkdf2_sha1 = (esp_pbkdf2_sha1_t)pbkdf2_sha1,
+ .rc4_skip = (esp_rc4_skip_t)rc4_skip,
+ .md5_vector = (esp_md5_vector_t)md5_vector,
+ .aes_encrypt = (esp_aes_encrypt_t)aes_encrypt,
+ .aes_encrypt_init = (esp_aes_encrypt_init_t)aes_encrypt_init,
+ .aes_encrypt_deinit = (esp_aes_encrypt_deinit_t)aes_encrypt_deinit,
+ .aes_decrypt = (esp_aes_decrypt_t)aes_decrypt,
+ .aes_decrypt_init = (esp_aes_decrypt_init_t)aes_decrypt_init,
+ .aes_decrypt_deinit = (esp_aes_decrypt_deinit_t)aes_decrypt_deinit
};
const wps_crypto_funcs_t g_wifi_default_wps_crypto_funcs = {
.crypto_mod_exp = (esp_crypto_mod_exp_t)fast_crypto_mod_exp,
.hmac_sha256 = (esp_hmac_sha256_t)fast_hmac_sha256,
.hmac_sha256_vector = (esp_hmac_sha256_vector_t)fast_hmac_sha256_vector,
- .sha256_vector = (esp_sha256_vector_t)fast_sha256_vector
+ .sha256_vector = (esp_sha256_vector_t)fast_sha256_vector,
+ .uuid_gen_mac_addr = (esp_uuid_gen_mac_addr_t)uuid_gen_mac_addr,
+ .dh5_free = (esp_dh5_free_t)dh5_free,
+ .wps_build_assoc_req_ie = (esp_wps_build_assoc_req_ie_t)wps_build_assoc_req_ie,
+ .wps_build_assoc_resp_ie = (esp_wps_build_assoc_resp_ie_t)wps_build_assoc_resp_ie,
+ .wps_build_probe_req_ie = (esp_wps_build_probe_req_ie_t)wps_build_probe_req_ie,
+ .wps_build_public_key = (esp_wps_build_public_key_t)wps_build_public_key,
+ .wps_enrollee_get_msg = (esp_wps_enrollee_get_msg_t)wps_enrollee_get_msg,
+ .wps_enrollee_process_msg = (esp_wps_enrollee_process_msg_t)wps_enrollee_process_msg,
+ .wps_generate_pin = (esp_wps_generate_pin_t)wps_generate_pin,
+ .wps_is_selected_pin_registrar = (esp_wps_is_selected_pin_registrar_t)wps_is_selected_pin_registrar,
+ .wps_is_selected_pbc_registrar = (esp_wps_is_selected_pbc_registrar_t)wps_is_selected_pbc_registrar,
+ .eap_msg_alloc = (esp_eap_msg_alloc_t)eap_msg_alloc
};
/*
.crypto_cipher_decrypt = (esp_crypto_cipher_decrypt_t)fast_crypto_cipher_decrypt,
.crypto_cipher_deinit = (esp_crypto_cipher_deinit_t)fast_crypto_cipher_deinit,
.crypto_mod_exp = (esp_crypto_mod_exp_t)crypto_mod_exp,
- .sha256_vector = (esp_sha256_vector_t)fast_sha256_vector
+ .sha256_vector = (esp_sha256_vector_t)fast_sha256_vector,
+ .tls_init = (esp_tls_init_t)tls_init,
+ .tls_deinit = (esp_tls_deinit_t)tls_deinit,
+ .eap_peer_blob_init = (esp_eap_peer_blob_init_t)eap_peer_blob_init,
+ .eap_peer_blob_deinit = (esp_eap_peer_blob_deinit_t)eap_peer_blob_deinit,
+ .eap_peer_config_init = (esp_eap_peer_config_init_t)eap_peer_config_init,
+ .eap_peer_config_deinit = (esp_eap_peer_config_deinit_t)eap_peer_config_deinit,
+ .eap_deinit_prev_method = (esp_eap_deinit_prev_method_t)eap_deinit_prev_method,
+ .eap_peer_get_eap_method = (esp_eap_peer_get_eap_method_t)eap_peer_get_eap_method,
+ .eap_sm_abort = (esp_eap_sm_abort_t)eap_sm_abort,
+ .eap_sm_build_nak = (esp_eap_sm_build_nak_t)eap_sm_build_nak,
+ .eap_sm_build_identity_resp = (esp_eap_sm_build_identity_resp_t)eap_sm_build_identity_resp,
+ .eap_msg_alloc = (esp_eap_msg_alloc_t)eap_msg_alloc
};
const mesh_crypto_funcs_t g_wifi_default_mesh_crypto_funcs = {
#include "esp_wifi_types.h"
#include "esp_wifi_crypto_types.h"
#include "esp_event.h"
+#include "esp_wifi_os_adapter.h"
#ifdef __cplusplus
extern "C" {
*/
typedef struct {
system_event_handler_t event_handler; /**< WiFi event handler */
+ wifi_osi_funcs_t* osi_funcs; /**< WiFi OS functions */
wpa_crypto_funcs_t wpa_crypto_funcs; /**< WiFi station crypto functions when connect */
int static_rx_buf_num; /**< WiFi static RX buffer number */
int dynamic_rx_buf_num; /**< WiFi dynamic RX buffer number */
#define WIFI_INIT_CONFIG_DEFAULT() { \
.event_handler = &esp_event_send, \
+ .osi_funcs = &g_wifi_osi_funcs, \
.wpa_crypto_funcs = g_wifi_default_wpa_crypto_funcs, \
.static_rx_buf_num = CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM,\
.dynamic_rx_buf_num = CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM,\
* @param len Length of the buffer.
*
*/
-typedef void * (*esp_crypto_hash_update_t)(esp_crypto_hash_t *ctx, const unsigned char *data, int len);
+typedef void (*esp_crypto_hash_update_t)(esp_crypto_hash_t *ctx, const unsigned char *data, int len);
/**
* @brief The crypto callback function used in wpa enterprise hash operation when connect.
* or -2 on other failures (including failed crypto_hash_update() operations)
*
*/
-typedef int * (*esp_crypto_hash_finish_t)(esp_crypto_hash_t *ctx, unsigned char *hash, int *len);
+typedef int (*esp_crypto_hash_finish_t)(esp_crypto_hash_t *ctx, unsigned char *hash, int *len);
/**
* @brief The AES callback function when do WPS connect.
* @param data Data to encrypt in-place.
* @param data_len Length of data in bytes (must be divisible by 16)
*/
-typedef int * (*esp_aes_128_encrypt_t)(const unsigned char *key, const unsigned char *iv, unsigned char *data, int data_len);
+typedef int (*esp_aes_128_encrypt_t)(const unsigned char *key, const unsigned char *iv, unsigned char *data, int data_len);
/**
* @brief The AES callback function when do WPS connect.
* @param data_len Length of data in bytes (must be divisible by 16)
*
*/
-typedef int * (*esp_aes_128_decrypt_t)(const unsigned char *key, const unsigned char *iv, unsigned char *data, int data_len);
+typedef int (*esp_aes_128_decrypt_t)(const unsigned char *key, const unsigned char *iv, unsigned char *data, int data_len);
/**
* @brief The AES callback function when do STA connect.
* @param cipher Wrapped key, (n + 1) * 64 bits
*
*/
-typedef int * (*esp_aes_wrap_t)(const unsigned char *kek, int n, const unsigned char *plain, unsigned char *cipher);
+typedef int (*esp_aes_wrap_t)(const unsigned char *kek, int n, const unsigned char *plain, unsigned char *cipher);
/**
* @brief The AES callback function when do STA connect.
* @param plain Plaintext key, n * 64 bits
*
*/
-typedef int * (*esp_aes_unwrap_t)(const unsigned char *kek, int n, const unsigned char *cipher, unsigned char *plain);
+typedef int (*esp_aes_unwrap_t)(const unsigned char *kek, int n, const unsigned char *cipher, unsigned char *plain);
/**
* @brief The crypto callback function used in wpa enterprise cipher operation when connect.
* @param len Length of the plaintext.
*
*/
-typedef int * (*esp_crypto_cipher_encrypt_t)(esp_crypto_cipher_t *ctx,
+typedef int (*esp_crypto_cipher_encrypt_t)(esp_crypto_cipher_t *ctx,
const unsigned char *plain, unsigned char *crypt, int len);
/**
* @brief The crypto callback function used in wpa enterprise cipher operation when connect.
* @param len Length of the cipher text.
*
*/
-typedef int * (*esp_crypto_cipher_decrypt_t)(esp_crypto_cipher_t *ctx,
+typedef int (*esp_crypto_cipher_decrypt_t)(esp_crypto_cipher_t *ctx,
const unsigned char *crypt, unsigned char *plain, int len);
/**
* @brief The crypto callback function used in wpa enterprise cipher operation when connect.
* @param ctx Context pointer from esp_crypto_cipher_init_t callback function.
*
*/
-typedef void * (*esp_crypto_cipher_deinit_t)(esp_crypto_cipher_t *ctx);
+typedef void (*esp_crypto_cipher_deinit_t)(esp_crypto_cipher_t *ctx);
/**
* @brief The SHA256 callback function when do WPS connect.
* @param mac Buffer for the hash (20 bytes).
*
*/
-typedef void * (*esp_hmac_sha256_t)(const unsigned char *key, int key_len, const unsigned char *data,
+typedef void (*esp_hmac_sha256_t)(const unsigned char *key, int key_len, const unsigned char *data,
int data_len, unsigned char *mac);
/**
* @param mac Buffer for the hash (32 bytes).
*
*/
-typedef void * (*esp_hmac_sha256_vector_t)(const unsigned char *key, int key_len, int num_elem,
+typedef void (*esp_hmac_sha256_vector_t)(const unsigned char *key, int key_len, int num_elem,
const unsigned char *addr[], const int *len, unsigned char *mac);
/**
* @param buf_len Number of bytes of key to generate.
*
*/
-typedef void * (*esp_sha256_prf_t)(const unsigned char *key, int key_len, const char *label,
+typedef void (*esp_sha256_prf_t)(const unsigned char *key, int key_len, const char *label,
const unsigned char *data, int data_len, unsigned char *buf, int buf_len);
/**
* @param num_elem Number of elements in the data vector.
* @param addr Pointers to the data areas.
* @param len Lengths of the data blocks.
- * @param mac Buffer for the hash.
+ * @paramac Buffer for the hash.
*
*/
-typedef int * (*esp_sha256_vector_t)(int num_elem, const unsigned char *addr[], const int *len,
+typedef int (*esp_sha256_vector_t)(int num_elem, const unsigned char *addr[], const int *len,
unsigned char *mac);
/**
* @param result_len Result length (max buffer size on input, real len on output).
*
*/
-typedef int * (*esp_crypto_mod_exp_t)(const unsigned char *base, int base_len,
+typedef int (*esp_crypto_mod_exp_t)(const unsigned char *base, int base_len,
const unsigned char *power, int power_len,
const unsigned char *modulus, int modulus_len,
unsigned char *result, unsigned int *result_len);
+
+/**
+ * @brief HMAC-MD5 over data buffer (RFC 2104)'
+ *
+ * @key: Key for HMAC operations
+ * @key_len: Length of the key in bytes
+ * @data: Pointers to the data area
+ * @data_len: Length of the data area
+ * @mac: Buffer for the hash (16 bytes)
+ * Returns: 0 on success, -1 on failure
+ */
+typedef int (*esp_hmac_md5_t)(const unsigned char *key, unsigned int key_len, const unsigned char *data,
+ unsigned int data_len, unsigned char *mac);
+
+/**
+ * @brief HMAC-MD5 over data vector (RFC 2104)
+ *
+ * @key: Key for HMAC operations
+ * @key_len: Length of the key in bytes
+ * @num_elem: Number of elements in the data vector
+ * @addr: Pointers to the data areas
+ * @len: Lengths of the data blocks
+ * @mac: Buffer for the hash (16 bytes)
+ * Returns: 0 on success, -1 on failure
+ */
+typedef int (*esp_hmac_md5_vector_t)(const unsigned char *key, unsigned int key_len, unsigned int num_elem,
+ const unsigned char *addr[], const unsigned int *len, unsigned char *mac);
+
+/**
+ * @brief HMAC-SHA1 over data buffer (RFC 2104)
+ *
+ * @key: Key for HMAC operations
+ * @key_len: Length of the key in bytes
+ * @data: Pointers to the data area
+ * @data_len: Length of the data area
+ * @mac: Buffer for the hash (20 bytes)
+ * Returns: 0 on success, -1 of failure
+ */
+typedef int (*esp_hmac_sha1_t)(const unsigned char *key, unsigned int key_len, const unsigned char *data,
+ unsigned int data_len, unsigned char *mac);
+
+/**
+ * @brief HMAC-SHA1 over data vector (RFC 2104)
+ *
+ * @key: Key for HMAC operations
+ * @key_len: Length of the key in bytes
+ * @num_elem: Number of elements in the data vector
+ * @addr: Pointers to the data areas
+ * @len: Lengths of the data blocks
+ * @mac: Buffer for the hash (20 bytes)
+ * Returns: 0 on success, -1 on failure
+ */
+typedef int (*esp_hmac_sha1_vector_t)(const unsigned char *key, unsigned int key_len, unsigned int num_elem,
+ const unsigned char *addr[], const unsigned int *len, unsigned char *mac);
+
+/**
+ * @brief SHA1-based Pseudo-Random Function (PRF) (IEEE 802.11i, 8.5.1.1)
+ *
+ * @key: Key for PRF
+ * @key_len: Length of the key in bytes
+ * @label: A unique label for each purpose of the PRF
+ * @data: Extra data to bind into the key
+ * @data_len: Length of the data
+ * @buf: Buffer for the generated pseudo-random key
+ * @buf_len: Number of bytes of key to generate
+ * Returns: 0 on success, -1 of failure
+ *
+ * This function is used to derive new, cryptographically separate keys from a
+ * given key (e.g., PMK in IEEE 802.11i).
+ */
+typedef int (*esp_sha1_prf_t)(const unsigned char *key, unsigned int key_len, const char *label,
+ const unsigned char *data, unsigned int data_len, unsigned char *buf, unsigned int buf_len);
+
+/**
+ * @brief SHA-1 hash for data vector
+ *
+ * @num_elem: Number of elements in the data vector
+ * @addr: Pointers to the data areas
+ * @len: Lengths of the data blocks
+ * @mac: Buffer for the hash
+ * Returns: 0 on success, -1 on failure
+ */
+typedef int (*esp_sha1_vector_t)(unsigned int num_elem, const unsigned char *addr[], const unsigned int *len,
+ unsigned char *mac);
+
+/**
+ * @brief SHA1-based key derivation function (PBKDF2) for IEEE 802.11i
+ *
+ * @passphrase: ASCII passphrase
+ * @ssid: SSID
+ * @ssid_len: SSID length in bytes
+ * @iterations: Number of iterations to run
+ * @buf: Buffer for the generated key
+ * @buflen: Length of the buffer in bytes
+ * Returns: 0 on success, -1 of failure
+ *
+ * This function is used to derive PSK for WPA-PSK. For this protocol,
+ * iterations is set to 4096 and buflen to 32. This function is described in
+ * IEEE Std 802.11-2004, Clause H.4. The main construction is from PKCS#5 v2.0.
+ */
+typedef int (*esp_pbkdf2_sha1_t)(const char *passphrase, const char *ssid, unsigned int ssid_len,
+ int iterations, unsigned char *buf, unsigned int buflen);
+
+/**
+ * @brief XOR RC4 stream to given data with skip-stream-start
+ *
+ * @key: RC4 key
+ * @keylen: RC4 key length
+ * @skip: number of bytes to skip from the beginning of the RC4 stream
+ * @data: data to be XOR'ed with RC4 stream
+ * @data_len: buf length
+ * Returns: 0 on success, -1 on failure
+ *
+ * Generate RC4 pseudo random stream for the given key, skip beginning of the
+ * stream, and XOR the end result with the data buffer to perform RC4
+ * encryption/decryption.
+ */
+typedef int (*esp_rc4_skip_t)(const unsigned char *key, unsigned int keylen, unsigned int skip,
+ unsigned char *data, unsigned int data_len);
+
+/**
+ * @brief MD5 hash for data vector
+ *
+ * @num_elem: Number of elements in the data vector
+ * @addr: Pointers to the data areas
+ * @len: Lengths of the data blocks
+ * @mac: Buffer for the hash
+ * Returns: 0 on success, -1 on failure
+ */
+typedef int (*esp_md5_vector_t)(unsigned int num_elem, const unsigned char *addr[], const unsigned int *len,
+ unsigned char *mac);
+
+/**
+ * @brief Encrypt one AES block
+ *
+ * @ctx: Context pointer from aes_encrypt_init()
+ * @plain: Plaintext data to be encrypted (16 bytes)
+ * @crypt: Buffer for the encrypted data (16 bytes)
+ */
+typedef void (*esp_aes_encrypt_t)(void *ctx, const unsigned char *plain, unsigned char *crypt);
+
+/**
+ * @brief Initialize AES for encryption
+ *
+ * @key: Encryption key
+ * @len: Key length in bytes (usually 16, i.e., 128 bits)
+ * Returns: Pointer to context data or %NULL on failure
+ */
+typedef void * (*esp_aes_encrypt_init_t)(const unsigned char *key, unsigned int len);
+
+/**
+ * @brief Deinitialize AES encryption
+ *
+ * @ctx: Context pointer from aes_encrypt_init()
+ */
+typedef void (*esp_aes_encrypt_deinit_t)(void *ctx);
+
+/**
+ * @brief Decrypt one AES block
+ *
+ * @ctx: Context pointer from aes_encrypt_init()
+ * @crypt: Encrypted data (16 bytes)
+ * @plain: Buffer for the decrypted data (16 bytes)
+ */
+typedef void (*esp_aes_decrypt_t)(void *ctx, const unsigned char *crypt, unsigned char *plain);
+
+/**
+ * @brief Initialize AES for decryption
+ *
+ * @key: Decryption key
+ * @len: Key length in bytes (usually 16, i.e., 128 bits)
+ * Returns: Pointer to context data or %NULL on failure
+ */
+typedef void * (*esp_aes_decrypt_init_t)(const unsigned char *key, unsigned int len);
+
+/**
+ * @brief Deinitialize AES decryption
+ *
+ * @ctx: Context pointer from aes_encrypt_init()
+ */
+typedef void (*esp_aes_decrypt_deinit_t)(void *ctx);
+
+/**
+ * @brief Initialize TLS library
+ *
+ * @conf: Configuration data for TLS library
+ * Returns: Context data to be used as tls_ctx in calls to other functions,
+ * or %NULL on failure.
+ *
+ * Called once during program startup and once for each RSN pre-authentication
+ * session. In other words, there can be two concurrent TLS contexts. If global
+ * library initialization is needed (i.e., one that is shared between both
+ * authentication types), the TLS library wrapper should maintain a reference
+ * counter and do global initialization only when moving from 0 to 1 reference.
+ */
+typedef void * (*esp_tls_init_t)(void);
+
+/**
+ * @brief Deinitialize TLS library
+ *
+ * @tls_ctx: TLS context data from tls_init()
+ *
+ * Called once during program shutdown and once for each RSN pre-authentication
+ * session. If global library deinitialization is needed (i.e., one that is
+ * shared between both authentication types), the TLS library wrapper should
+ * maintain a reference counter and do global deinitialization only when moving
+ * from 1 to 0 references.
+ */
+typedef void (*esp_tls_deinit_t)(void *tls_ctx);
+
+/**
+ * @brief Add certificate and private key for connect
+
+ * @sm: eap state machine
+ *
+ * Returns: 0 for success, -1 state machine didn't exist, -2 short of certificate or key
+ */
+typedef int (*esp_eap_peer_blob_init_t)(void *sm);
+
+/**
+ * @brief delete the certificate and private
+ *
+ * @sm: eap state machine
+ *
+ */
+typedef void (*esp_eap_peer_blob_deinit_t)(void *sm);
+
+/**
+ * @brief Initialize the eap state machine
+ *
+ * @sm: eap state machine
+ * @private_key_passwd: the start address of private_key_passwd
+ * @private_key_passwd_len: length of private_key_password
+ *
+ * Returns: 0 is success, -1 state machine didn't exist, -2 short of parameters
+ *
+ */
+typedef int (*esp_eap_peer_config_init_t)(void *sm, unsigned char *private_key_passwd,int private_key_passwd_len);
+
+/**
+ * @brief Deinit the eap state machine
+ *
+ * @sm: eap state machine
+ *
+ */
+typedef void (*esp_eap_peer_config_deinit_t)(void *sm);
+
+/**
+ * @brief Register the eap method
+ *
+ * Note: ESP32 only support PEAP/TTLS/TLS three eap methods now.
+ *
+ */
+typedef int (*esp_eap_peer_register_methods_t)(void);
+
+/**
+ * @brief remove the eap method
+ *
+ * Note: ESP32 only support PEAP/TTLS/TLS three eap methods now.
+ *
+ */
+typedef void (*esp_eap_peer_unregister_methods_t)(void);
+
+/**
+ * @brief remove the eap method before build new connect
+ *
+ * @sm: eap state machine
+ * @txt: not used now
+ */
+typedef void (*esp_eap_deinit_prev_method_t)(void *sm, const char *txt);
+
+/**
+ * @brief Get EAP method based on type number
+ *
+ * @vendor: EAP Vendor-Id (0 = IETF)
+ * @method: EAP type number
+ * Returns: Pointer to EAP method or %NULL if not found
+ */
+typedef const void * (*esp_eap_peer_get_eap_method_t)(int vendor, int method);
+
+/**
+ * @brief Abort EAP authentication
+ *
+ * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
+ *
+ * Release system resources that have been allocated for the authentication
+ * session without fully deinitializing the EAP state machine.
+ */
+typedef void (*esp_eap_sm_abort_t)(void *sm);
+
+/**
+ * @brief Build EAP-NAK for the current network
+ *
+ * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
+ * @type: EAP type of the fail reason
+ * @id: EAP identifier for the packet
+ *
+ * This function allocates and builds a nak packet for the
+ * current network. The caller is responsible for freeing the returned data.
+ */
+typedef void * (*esp_eap_sm_build_nak_t)(void *sm, int type, unsigned char id);
+
+/**
+ * @brief Build EAP-Identity/Response for the current network
+ *
+ * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
+ * @id: EAP identifier for the packet
+ * @encrypted: Whether the packet is for encrypted tunnel (EAP phase 2)
+ * Returns: Pointer to the allocated EAP-Identity/Response packet or %NULL on
+ * failure
+ *
+ * This function allocates and builds an EAP-Identity/Response packet for the
+ * current network. The caller is responsible for freeing the returned data.
+ */
+typedef void * (*esp_eap_sm_build_identity_resp_t)(void *sm, unsigned char id, int encrypted);
+
+/**
+ * @brief Allocate a buffer for an EAP message
+ *
+ * @vendor: Vendor-Id (0 = IETF)
+ * @type: EAP type
+ * @payload_len: Payload length in bytes (data after Type)
+ * @code: Message Code (EAP_CODE_*)
+ * @identifier: Identifier
+ * Returns: Pointer to the allocated message buffer or %NULL on error
+ *
+ * This function can be used to allocate a buffer for an EAP message and fill
+ * in the EAP header. This function is automatically using expanded EAP header
+ * if the selected Vendor-Id is not IETF. In other words, most EAP methods do
+ * not need to separately select which header type to use when using this
+ * function to allocate the message buffers. The returned buffer has room for
+ * payload_len bytes and has the EAP header and Type field already filled in.
+ */
+typedef void * (*esp_eap_msg_alloc_t)(int vendor, int type, unsigned int payload_len,
+ unsigned char code, unsigned char identifier);
+
+/**
+ * @brief get the enrollee mac address
+ * @mac_addr: instore the mac address of enrollee
+ * @uuid: Universally Unique Identifer of the enrollee
+ *
+ */
+typedef void (*esp_uuid_gen_mac_addr_t)(const unsigned char *mac_addr, unsigned char *uuid);
+
+/**
+ * @brief free the message after finish DH
+ *
+ */
+typedef void * (*esp_dh5_free_t)(void *ctx);
+
+/**
+ * @brief Build WPS IE for (Re)Association Request
+ *
+ * @req_type: Value for Request Type attribute
+ * Returns: WPS IE or %NULL on failure
+ *
+ * The caller is responsible for freeing the buffer.
+ */
+typedef void * (*esp_wps_build_assoc_req_ie_t)(int req_type);
+
+/**
+ * @brief Build WPS IE for (Re)Association Response
+ *
+ * Returns: WPS IE or %NULL on failure
+ *
+ * The caller is responsible for freeing the buffer.
+ */
+typedef void * (*esp_wps_build_assoc_resp_ie_t)(void);
+
+/**
+ * @brief Build WPS IE for Probe Request
+ *
+ * @pw_id: Password ID (DEV_PW_PUSHBUTTON for active PBC and DEV_PW_DEFAULT for
+ * most other use cases)
+ * @dev: Device attributes
+ * @uuid: Own UUID
+ * @req_type: Value for Request Type attribute
+ * @num_req_dev_types: Number of requested device types
+ * @req_dev_types: Requested device types (8 * num_req_dev_types octets) or
+ * %NULL if none
+ * Returns: WPS IE or %NULL on failure
+ *
+ * The caller is responsible for freeing the buffer.
+ */
+typedef void * (*esp_wps_build_probe_req_ie_t)(uint16_t pw_id, void *dev, const unsigned char *uuid,
+ int req_type, unsigned int num_req_dev_types, const unsigned char *req_dev_types);
+
+/**
+ * @brief build public key for exchange in M1
+ *
+ *
+ */
+typedef int (*esp_wps_build_public_key_t)(void *wps, void *msg, int mode);
+
+
+/**
+ * @brief get the wps information in exchange password
+ *
+ *
+ */
+typedef void * (*esp_wps_enrollee_get_msg_t)(void *wps, void *op_code);
+
+/**
+ * @brief deal with the wps information in exchange password
+ *
+ *
+ */
+typedef int (*esp_wps_enrollee_process_msg_t)(void *wps, int op_code, const void *msg);
+
+/**
+ * @brief Generate a random PIN
+ *
+ * Returns: Eight digit PIN (i.e., including the checksum digit)
+ */
+typedef unsigned int (*esp_wps_generate_pin_t)(void);
+
+/**
+ * @brief Check whether WPS IE indicates active PIN
+ *
+ * @msg: WPS IE contents from Beacon or Probe Response frame
+ * Returns: 1 if PIN Registrar is active, 0 if not
+ */
+typedef int (*esp_wps_is_selected_pin_registrar_t)(const void *msg, unsigned char *bssid);
+
+/**
+ * @brief Check whether WPS IE indicates active PBC
+ *
+ * @msg: WPS IE contents from Beacon or Probe Response frame
+ * Returns: 1 if PBC Registrar is active, 0 if not
+ */
+typedef int (*esp_wps_is_selected_pbc_registrar_t)(const void *msg, unsigned char *bssid);
+
+
+
/**
* @brief The crypto callback function structure used when do station security connect.
* The structure can be set as software crypto or the crypto optimized by ESP32
esp_aes_unwrap_t aes_unwrap; /**< station connect function used when decrypt key data */
esp_hmac_sha256_vector_t hmac_sha256_vector; /**< station connect function used when check MIC */
esp_sha256_prf_t sha256_prf; /**< station connect function used when check MIC */
+ esp_hmac_md5_t hmac_md5;
+ esp_hmac_md5_vector_t hamc_md5_vector;
+ esp_hmac_sha1_t hmac_sha1;
+ esp_hmac_sha1_vector_t hmac_sha1_vector;
+ esp_sha1_prf_t sha1_prf;
+ esp_sha1_vector_t sha1_vector;
+ esp_pbkdf2_sha1_t pbkdf2_sha1;
+ esp_rc4_skip_t rc4_skip;
+ esp_md5_vector_t md5_vector;
+ esp_aes_encrypt_t aes_encrypt;
+ esp_aes_encrypt_init_t aes_encrypt_init;
+ esp_aes_encrypt_deinit_t aes_encrypt_deinit;
+ esp_aes_decrypt_t aes_decrypt;
+ esp_aes_decrypt_init_t aes_decrypt_init;
+ esp_aes_decrypt_deinit_t aes_decrypt_deinit;
}wpa_crypto_funcs_t;
/**
esp_hmac_sha256_t hmac_sha256; /**< function used to get attribute */
esp_hmac_sha256_vector_t hmac_sha256_vector; /**< function used to process message when do WPS */
esp_sha256_vector_t sha256_vector; /**< function used to process message when do WPS */
+ esp_uuid_gen_mac_addr_t uuid_gen_mac_addr;
+ esp_dh5_free_t dh5_free;
+ esp_wps_build_assoc_req_ie_t wps_build_assoc_req_ie;
+ esp_wps_build_assoc_resp_ie_t wps_build_assoc_resp_ie;
+ esp_wps_build_probe_req_ie_t wps_build_probe_req_ie;
+ esp_wps_build_public_key_t wps_build_public_key;
+ esp_wps_enrollee_get_msg_t wps_enrollee_get_msg;
+ esp_wps_enrollee_process_msg_t wps_enrollee_process_msg;
+ esp_wps_generate_pin_t wps_generate_pin;
+ esp_wps_is_selected_pin_registrar_t wps_is_selected_pin_registrar;
+ esp_wps_is_selected_pbc_registrar_t wps_is_selected_pbc_registrar;
+ esp_eap_msg_alloc_t eap_msg_alloc;
}wps_crypto_funcs_t;
/**
esp_crypto_cipher_deinit_t crypto_cipher_deinit; /**< function used to free context when use TLSV1 */
esp_crypto_mod_exp_t crypto_mod_exp; /**< function used to do key exchange when use TLSV1 */
esp_sha256_vector_t sha256_vector; /**< function used to do X.509v3 certificate parsing and processing */
+ esp_tls_init_t tls_init;
+ esp_tls_deinit_t tls_deinit;
+ esp_eap_peer_blob_init_t eap_peer_blob_init;
+ esp_eap_peer_blob_deinit_t eap_peer_blob_deinit;
+ esp_eap_peer_config_init_t eap_peer_config_init;
+ esp_eap_peer_config_deinit_t eap_peer_config_deinit;
+ esp_eap_deinit_prev_method_t eap_deinit_prev_method;
+ esp_eap_peer_get_eap_method_t eap_peer_get_eap_method;
+ esp_eap_sm_abort_t eap_sm_abort;
+ esp_eap_sm_build_nak_t eap_sm_build_nak;
+ esp_eap_sm_build_identity_resp_t eap_sm_build_identity_resp;
+ esp_eap_msg_alloc_t eap_msg_alloc;
} wpa2_crypto_funcs_t;
/**
#include "esp_err.h"
#include "esp_wifi_types.h"
#include "esp_event.h"
+#include "esp_wifi.h"
#ifdef __cplusplus
extern "C" {
*/
esp_err_t esp_wifi_internal_set_sta_ip(void);
+/**
+ * @brief Check the MD5 values of the OS adapter header files in IDF and WiFi library
+ *
+ * @attention 1. It is used for internal CI version check
+ *
+ * @return
+ * - ESP_OK : succeed
+ * - ESP_WIFI_INVALID_ARG : MD5 check fail
+ */
+esp_err_t esp_wifi_internal_osi_funcs_md5_check(const char *md5);
+
/**
* @brief Allocate a chunk of memory for WiFi driver
*
--- /dev/null
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ESP_WIFI_OS_ADAPTER_H_
+#define ESP_WIFI_OS_ADAPTER_H_
+
+#include <stdarg.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ESP_WIFI_OS_ADAPTER_VERSION 0x00000001
+#define ESP_WIFI_OS_ADAPTER_MAGIC 0xDEADBEAF
+
+#define OSI_FUNCS_TIME_BLOCKING 0xffffffff
+
+#define OSI_QUEUE_SEND_FRONT 0
+#define OSI_QUEUE_SEND_BACK 1
+#define OSI_QUEUE_SEND_OVERWRITE 2
+
+typedef struct {
+ int32_t _version;
+ void (*_set_isr)(int32_t n, void *f, void *arg);
+ void (*_ints_on)(uint32_t mask);
+ void (*_ints_off)(uint32_t mask);
+ void *(* _spin_lock_create)(void);
+ void (* _spin_lock_delete)(void *lock);
+ uint32_t (*_wifi_int_disable)(void *wifi_int_mux);
+ void (*_wifi_int_restore)(void *wifi_int_mux, uint32_t tmp);
+ void (*_task_yield)(void);
+ void (*_task_yield_from_isr)(void);
+ void *(*_semphr_create)(uint32_t max, uint32_t init);
+ void (*_semphr_delete)(void *semphr);
+ int32_t (*_semphr_take_from_isr)(void *semphr, void *hptw);
+ int32_t (*_semphr_give_from_isr)(void *semphr, void *hptw);
+ int32_t (*_semphr_take)(void *semphr, uint32_t block_time_tick);
+ int32_t (*_semphr_give)(void *semphr);
+ void *(*_mutex_create)(void);
+ void *(*_recursive_mutex_create)(void);
+ void (*_mutex_delete)(void *mutex);
+ int32_t (*_mutex_lock)(void *mutex);
+ int32_t (*_mutex_unlock)(void *mutex);
+ void *(* _queue_create)(uint32_t queue_len, uint32_t item_size);
+ void (* _queue_delete)(void *queue);
+ int32_t (* _queue_send)(void *queue, void *item, uint32_t block_time_tick);
+ int32_t (* _queue_send_from_isr)(void *queue, void *item, void *hptw);
+ int32_t (* _queue_send_to_back)(void *queue, void *item, uint32_t block_time_tick);
+ int32_t (* _queue_send_to_front)(void *queue, void *item, uint32_t block_time_tick);
+ int32_t (* _queue_recv)(void *queue, void *item, uint32_t block_time_tick);
+ int32_t (* _queue_recv_from_isr)(void *queue, void * const item, int32_t * const hptw);
+ uint32_t (* _queue_msg_waiting)(void *queue);
+ void *(* _event_group_create)(void);
+ void (* _event_group_delete)(void *event);
+ uint32_t (* _event_group_set_bits)(void *event, uint32_t bits);
+ uint32_t (* _event_group_clear_bits)(void *event, uint32_t bits);
+ uint32_t (* _event_group_wait_bits)(void *event, uint32_t bits_to_wait_for, int32_t clear_on_exit, int32_t wait_for_all_bits, uint32_t block_time_tick);
+ int32_t (* _task_create_pinned_to_core)(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id);
+ int32_t (* _task_create)(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle);
+ void (* _task_delete)(void *task_handle);
+ void (* _task_delay)(uint32_t tick);
+ int32_t (* _task_ms_to_tick)(uint32_t ms);
+ void *(* _task_get_current_task)(void);
+ int32_t (* _task_get_max_priority)(void);
+ int32_t (* _is_in_isr)(void);
+ void *(* _malloc)(uint32_t size);
+ void (* _free)(void *p);
+ uint32_t (* _get_free_heap_size)(void);
+ uint32_t (* _rand)(void);
+ void (* _dport_access_stall_other_cpu_start_wrap)(void);
+ void (* _dport_access_stall_other_cpu_end_wrap)(void);
+ int32_t (* _phy_rf_init)(const void * init_data, uint32_t mode, void * calibration_data, uint32_t module);
+ int32_t (* _phy_rf_deinit)(uint32_t module);
+ void (* _phy_load_cal_and_init)(uint32_t module);
+ int32_t (* _read_mac)(uint8_t* mac, uint32_t type);
+ void (* _timer_init)(void);
+ void (* _timer_deinit)(void);
+ void (* _timer_arm)(void *timer, uint32_t tmout, bool repeat);
+ void (* _timer_disarm)(void *timer);
+ void (* _timer_done)(void *ptimer);
+ void (* _timer_setfn)(void *ptimer, void *pfunction, void *parg);
+ void (* _timer_arm_us)(void *ptimer, uint32_t us, bool repeat);
+ void (* _periph_module_enable)(uint32_t periph);
+ void (* _periph_module_disable)(uint32_t periph);
+ int64_t (* _esp_timer_get_time)(void);
+ int32_t (* _nvs_set_i8)(uint32_t handle, const char* key, int8_t value);
+ int32_t (* _nvs_get_i8)(uint32_t handle, const char* key, int8_t* out_value);
+ int32_t (* _nvs_set_u8)(uint32_t handle, const char* key, uint8_t value);
+ int32_t (* _nvs_get_u8)(uint32_t handle, const char* key, uint8_t* out_value);
+ int32_t (* _nvs_set_u16)(uint32_t handle, const char* key, uint16_t value);
+ int32_t (* _nvs_get_u16)(uint32_t handle, const char* key, uint16_t* out_value);
+ int32_t (* _nvs_open)(const char* name, uint32_t open_mode, uint32_t *out_handle);
+ void (* _nvs_close)(uint32_t handle);
+ int32_t (* _nvs_commit)(uint32_t handle);
+ int32_t (* _nvs_set_blob)(uint32_t handle, const char* key, const void* value, size_t length);
+ int32_t (* _nvs_get_blob)(uint32_t handle, const char* key, void* out_value, size_t* length);
+ int32_t (* _nvs_erase_key)(uint32_t handle, const char* key);
+ int32_t (* _get_random)(uint8_t *buf, size_t len);
+ int32_t (* _get_time)(void *t);
+ unsigned long (* _random)(void);
+ void (* _log_write)(uint32_t level, const char* tag, const char* format, ...);
+ uint32_t (* _log_timestamp)(void);
+ void * (* _malloc_internal)(size_t size);
+ void * (* _realloc_internal)(void *ptr, size_t size);
+ void * (* _calloc_internal)(size_t n, size_t size);
+ void * (* _zalloc_internal)(size_t size);
+ void * (* _wifi_malloc)(size_t size);
+ void * (* _wifi_realloc)(void *ptr, size_t size);
+ void * (* _wifi_calloc)(size_t n, size_t size);
+ void * (* _wifi_zalloc)(size_t size);
+ void * (* _wifi_create_queue)(int32_t queue_len, int32_t item_size);
+ void (* _wifi_delete_queue)(void * queue);
+ int32_t (* _modem_sleep_enter)(uint32_t module);
+ int32_t (* _modem_sleep_exit)(uint32_t module);
+ int32_t (* _modem_sleep_register)(uint32_t module);
+ int32_t (* _modem_sleep_deregister)(uint32_t module);
+ void (* _sc_ack_send)(void *param);
+ void (* _sc_ack_send_stop)(void);
+ int32_t _magic;
+} wifi_osi_funcs_t;
+
+extern wifi_osi_funcs_t g_wifi_osi_funcs;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ESP_WIFI_OS_ADAPTER_H_ */
*/
void ets_timer_init(void);
+/**
+ * @brief In FreeRTOS, please call FreeRTOS apis, never call this api.
+ *
+ * @param None
+ *
+ * @return None
+ */
+void ets_timer_deinit(void);
+
/**
* @brief Arm an ets timer, this timer range is 640 us to 429496 ms.
* In FreeRTOS, please call FreeRTOS apis, never call this api.
-Subproject commit 8b6d5837a4215b83ff8a3ff088ccbb716adf05fb
+Subproject commit f56b7bd4127aa01dbd50eb8ac3c637690bd98f84
#include "phy_init_data.h"
#include "coexist_internal.h"
#include "driver/periph_ctrl.h"
+#include "esp_wifi_internal.h"
static const char* TAG = "phy_init";
#endif
}
+extern esp_err_t wifi_osi_funcs_register(wifi_osi_funcs_t *osi_funcs);
+ status = wifi_osi_funcs_register(&g_wifi_osi_funcs);
+ if(status != ESP_OK) {
+ return ESP_FAIL;
+ }
coex_bt_high_prio();
}
}
COMPONENT_SRCDIRS := . test_vectors
+# Calculate MD5 value of header file esp_wifi_os_adapter.h
+WIFI_OS_ADAPTER_MD5_VAL=\"$(shell md5sum $(IDF_PATH)/components/esp32/include/esp_wifi_os_adapter.h | cut -c 1-7)\"
+CFLAGS+=-DWIFI_OS_ADAPTER_MD5=$(WIFI_OS_ADAPTER_MD5_VAL)
+
test_tjpgd.o: test_tjpgd_logo.h
test_tjpgd_logo.h: $(COMPONENT_PATH)/logo.jpg
--- /dev/null
+/*
+ Tests for the Wi-Fi
+*/
+#include "unity.h"
+#include "esp_log.h"
+#include "esp_wifi_internal.h"
+
+static const char* TAG = "test_os_adapter_md5";
+
+TEST_CASE("wifi os adapter MD5","[wifi]")
+{
+ const char *test_wifi_os_funcs_md5 = WIFI_OS_ADAPTER_MD5;
+
+ ESP_LOGI(TAG, "test wifi os adapter MD5...");
+ TEST_ESP_OK(esp_wifi_internal_osi_funcs_md5_check(test_wifi_os_funcs_md5));
+
+ ESP_LOGI(TAG, "test passed...");
+}
+++ /dev/null
-// Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string.h>
-#include "esp_attr.h"
-#include "esp_heap_caps.h"
-#include "sdkconfig.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
-#include "esp_wifi.h"
-#include "esp_wifi_internal.h"
-
-/*
- If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
- If failed, try to allocate it in internal memory then.
- */
-IRAM_ATTR void *wifi_malloc( size_t size )
-{
-#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
- return heap_caps_malloc_prefer(size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
-#else
- return malloc(size);
-#endif
-}
-
-/*
- If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
- If failed, try to allocate it in internal memory then.
- */
-IRAM_ATTR void *wifi_realloc( void *ptr, size_t size )
-{
-#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
- return heap_caps_realloc_prefer(ptr, size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
-#else
- return realloc(ptr, size);
-#endif
-}
-
-/*
- If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
- If failed, try to allocate it in internal memory then.
- */
-IRAM_ATTR void *wifi_calloc( size_t n, size_t size )
-{
-#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
- return heap_caps_calloc_prefer(n, size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
-#else
- return calloc(n, size);
-#endif
-}
-
-wifi_static_queue_t* wifi_create_queue( int queue_len, int item_size)
-{
- wifi_static_queue_t *queue = NULL;
-
- queue = (wifi_static_queue_t*)heap_caps_malloc(sizeof(wifi_static_queue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
- if (!queue) {
- return NULL;
- }
-
-#if CONFIG_SPIRAM_USE_MALLOC
-
- queue->storage = heap_caps_calloc(1, sizeof(StaticQueue_t) + (queue_len*item_size), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
- if (!queue->storage) {
- goto _error;
- }
-
- queue->handle = xQueueCreateStatic( queue_len, item_size, ((uint8_t*)(queue->storage)) + sizeof(StaticQueue_t), (StaticQueue_t*)(queue->storage));
-
- if (!queue->handle) {
- goto _error;
- }
-
- return queue;
-
-_error:
- if (queue) {
- if (queue->storage) {
- free(queue->storage);
- }
-
- free(queue);
- }
-
- return NULL;
-#else
- queue->handle = xQueueCreate( queue_len, item_size);
- return queue;
-#endif
-}
-
-void wifi_delete_queue(wifi_static_queue_t *queue)
-{
- if (queue) {
- vQueueDelete(queue->handle);
-
-#if CONFIG_SPIRAM_USE_MALLOC
- if (queue->storage) {
- free(queue->storage);
- }
-#endif
-
- free(queue);
- }
-}
--- /dev/null
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/event_groups.h"
+#include "freertos/xtensa_api.h"
+#include "freertos/portmacro.h"
+#include "freertos/xtensa_api.h"
+#include "esp_types.h"
+#include "esp_system.h"
+#include "esp_task.h"
+#include "esp_intr.h"
+#include "esp_attr.h"
+#include "esp_log.h"
+#include "esp_heap_caps.h"
+#include "esp_wifi_os_adapter.h"
+#include "esp_wifi_internal.h"
+#include "esp_phy_init.h"
+#include "crypto/md5.h"
+#include "crypto/sha1.h"
+#include "crypto/crypto.h"
+#include "crypto/aes.h"
+#include "crypto/dh_group5.h"
+#include "driver/periph_ctrl.h"
+#include "nvs.h"
+#include "os.h"
+#include "esp_smartconfig.h"
+#include "smartconfig_ack.h"
+
+
+extern void esp_dport_access_stall_other_cpu_start_wrap(void);
+extern void esp_dport_access_stall_other_cpu_end_wrap(void);
+
+/*
+ If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
+ If failed, try to allocate it in internal memory then.
+ */
+IRAM_ATTR void *wifi_malloc( size_t size )
+{
+#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
+ return heap_caps_malloc_prefer(size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+#else
+ return malloc(size);
+#endif
+}
+
+/*
+ If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
+ If failed, try to allocate it in internal memory then.
+ */
+IRAM_ATTR void *wifi_realloc( void *ptr, size_t size )
+{
+#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
+ return heap_caps_realloc_prefer(ptr, size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+#else
+ return realloc(ptr, size);
+#endif
+}
+
+/*
+ If CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST is enabled. Prefer to allocate a chunk of memory in SPIRAM firstly.
+ If failed, try to allocate it in internal memory then.
+ */
+IRAM_ATTR void *wifi_calloc( size_t n, size_t size )
+{
+#if CONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST
+ return heap_caps_calloc_prefer(n, size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+#else
+ return calloc(n, size);
+#endif
+}
+
+static void * IRAM_ATTR wifi_zalloc_wrapper(size_t size)
+{
+ void *ptr = wifi_calloc(1, size);
+ if (ptr) {
+ memset(ptr, 0, size);
+ }
+ return ptr;
+}
+
+wifi_static_queue_t* wifi_create_queue( int queue_len, int item_size)
+{
+ wifi_static_queue_t *queue = NULL;
+
+ queue = (wifi_static_queue_t*)heap_caps_malloc(sizeof(wifi_static_queue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+ if (!queue) {
+ return NULL;
+ }
+
+#if CONFIG_SPIRAM_USE_MALLOC
+
+ queue->storage = heap_caps_calloc(1, sizeof(StaticQueue_t) + (queue_len*item_size), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+ if (!queue->storage) {
+ goto _error;
+ }
+
+ queue->handle = xQueueCreateStatic( queue_len, item_size, ((uint8_t*)(queue->storage)) + sizeof(StaticQueue_t), (StaticQueue_t*)(queue->storage));
+
+ if (!queue->handle) {
+ goto _error;
+ }
+
+ return queue;
+
+_error:
+ if (queue) {
+ if (queue->storage) {
+ free(queue->storage);
+ }
+
+ free(queue);
+ }
+
+ return NULL;
+#else
+ queue->handle = xQueueCreate( queue_len, item_size);
+ return queue;
+#endif
+}
+
+void wifi_delete_queue(wifi_static_queue_t *queue)
+{
+ if (queue) {
+ vQueueDelete(queue->handle);
+
+#if CONFIG_SPIRAM_USE_MALLOC
+ if (queue->storage) {
+ free(queue->storage);
+ }
+#endif
+
+ free(queue);
+ }
+}
+
+static void * IRAM_ATTR wifi_create_queue_wrapper(int queue_len, int item_size)
+{
+ return wifi_create_queue(queue_len, item_size);
+}
+
+static void IRAM_ATTR wifi_delete_queue_wrapper(void *queue)
+{
+ wifi_delete_queue(queue);
+}
+
+static void IRAM_ATTR set_isr_wrapper(int32_t n, void *f, void *arg)
+{
+ xt_set_interrupt_handler(n, (xt_handler)f, arg);
+}
+
+static void * IRAM_ATTR spin_lock_create_wrapper(void)
+{
+ portMUX_TYPE tmp = portMUX_INITIALIZER_UNLOCKED;
+ void *mux = malloc(sizeof(portMUX_TYPE));
+
+ if (mux) {
+ memcpy(mux,&tmp,sizeof(portMUX_TYPE));
+ return mux;
+ }
+ return NULL;
+}
+
+static uint32_t IRAM_ATTR wifi_int_disable_wrapper(void *wifi_int_mux)
+{
+ if (xPortInIsrContext()) {
+ portENTER_CRITICAL_ISR(wifi_int_mux);
+ } else {
+ portENTER_CRITICAL(wifi_int_mux);
+ }
+
+ return 0;
+}
+
+static void IRAM_ATTR wifi_int_restore_wrapper(void *wifi_int_mux, uint32_t tmp)
+{
+ if (xPortInIsrContext()) {
+ portEXIT_CRITICAL_ISR(wifi_int_mux);
+ } else {
+ portEXIT_CRITICAL(wifi_int_mux);
+ }
+}
+
+static void IRAM_ATTR task_yield_from_isr_wrapper(void)
+{
+ portYIELD_FROM_ISR();
+}
+
+static void *IRAM_ATTR semphr_create_wrapper(uint32_t max, uint32_t init)
+{
+ return (void *)xSemaphoreCreateCounting(max, init);
+}
+
+static void IRAM_ATTR semphr_delete_wrapper(void *semphr)
+{
+ vSemaphoreDelete(semphr);
+}
+
+static int32_t IRAM_ATTR semphr_take_from_isr_wrapper(void *semphr, void *hptw)
+{
+ return (int32_t)xSemaphoreTakeFromISR(semphr, hptw);
+}
+
+static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw)
+{
+ return (int32_t)xSemaphoreGiveFromISR(semphr, hptw);
+}
+
+static int32_t IRAM_ATTR semphr_take_wrapper(void *semphr, uint32_t block_time_tick)
+{
+ if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
+ return (int32_t)xSemaphoreTake(semphr, portMAX_DELAY);
+ } else {
+ return (int32_t)xSemaphoreTake(semphr, block_time_tick);
+ }
+}
+
+static int32_t IRAM_ATTR semphr_give_wrapper(void *semphr)
+{
+ return (int32_t)xSemaphoreGive(semphr);
+}
+
+static void *IRAM_ATTR recursive_mutex_create_wrapper(void)
+{
+ return (void *)xSemaphoreCreateRecursiveMutex();
+}
+
+static void *IRAM_ATTR mutex_create_wrapper(void)
+{
+ return (void *)xSemaphoreCreateMutex();
+}
+
+static void IRAM_ATTR mutex_delete_wrapper(void *mutex)
+{
+ vSemaphoreDelete(mutex);
+}
+
+static int32_t IRAM_ATTR mutex_lock_wrapper(void *mutex)
+{
+ return (int32_t)xSemaphoreTakeRecursive(mutex, portMAX_DELAY);
+}
+
+static int32_t IRAM_ATTR mutex_unlock_wrapper(void *mutex)
+{
+ return (int32_t)xSemaphoreGiveRecursive(mutex);
+}
+
+static void *IRAM_ATTR queue_create_wrapper(uint32_t queue_len, uint32_t item_size)
+{
+ return (void *)xQueueCreate(queue_len, item_size);
+}
+
+static int32_t IRAM_ATTR queue_send_wrapper(void *queue, void *item, uint32_t block_time_tick)
+{
+ if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
+ return (int32_t)xQueueSend(queue, item, portMAX_DELAY);
+ } else {
+ return (int32_t)xQueueSend(queue, item, block_time_tick);
+ }
+}
+
+static int32_t IRAM_ATTR queue_send_from_isr_wrapper(void *queue, void *item, void *hptw)
+{
+ return (int32_t)xQueueSendFromISR(queue, item, hptw);
+}
+
+static int32_t IRAM_ATTR queue_send_to_back_wrapper(void *queue, void *item, uint32_t block_time_tick)
+{
+ return (int32_t)xQueueGenericSend(queue, item, block_time_tick, queueSEND_TO_BACK);
+}
+
+static int32_t IRAM_ATTR queue_send_to_front_wrapper(void *queue, void *item, uint32_t block_time_tick)
+{
+ return (int32_t)xQueueGenericSend(queue, item, block_time_tick, queueSEND_TO_FRONT);
+}
+
+static int32_t IRAM_ATTR queue_recv_wrapper(void *queue, void *item, uint32_t block_time_tick)
+{
+ if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
+ return (int32_t)xQueueReceive(queue, item, portMAX_DELAY);
+ } else {
+ return (int32_t)xQueueReceive(queue, item, block_time_tick);
+ }
+}
+
+static uint32_t IRAM_ATTR event_group_wait_bits_wrapper(void *event, uint32_t bits_to_wait_for, int clear_on_exit, int wait_for_all_bits, uint32_t block_time_tick)
+{
+ if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
+ return (uint32_t)xEventGroupWaitBits(event, bits_to_wait_for, clear_on_exit, wait_for_all_bits, portMAX_DELAY);
+ } else {
+ return (uint32_t)xEventGroupWaitBits(event, bits_to_wait_for, clear_on_exit, wait_for_all_bits, block_time_tick);
+ }
+}
+
+static int32_t IRAM_ATTR task_create_pinned_to_core_wrapper(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id)
+{
+ return (uint32_t)xTaskCreatePinnedToCore(task_func, name, stack_depth, param, prio, task_handle, (core_id < portNUM_PROCESSORS ? core_id : tskNO_AFFINITY));
+}
+
+static int32_t IRAM_ATTR task_create_wrapper(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle)
+{
+ return (uint32_t)xTaskCreate(task_func, name, stack_depth, param, prio, task_handle);
+}
+
+static int32_t IRAM_ATTR task_ms_to_tick_wrapper(uint32_t ms)
+{
+ return (int32_t)(ms / portTICK_PERIOD_MS);
+}
+
+
+static int32_t IRAM_ATTR task_get_max_priority_wrapper(void)
+{
+ return (int32_t)(configMAX_PRIORITIES);
+}
+
+static int32_t IRAM_ATTR phy_rf_init_wrapper(const void* init_data, uint32_t mode, void* calibration_data, uint32_t module)
+{
+ return esp_phy_rf_init( init_data, mode, calibration_data, module);
+}
+
+static void IRAM_ATTR timer_arm_wrapper(void *timer, uint32_t tmout, bool repeat)
+{
+ ets_timer_arm(timer, tmout, repeat);
+}
+
+static void IRAM_ATTR timer_disarm_wrapper(void *timer)
+{
+ ets_timer_disarm(timer);
+}
+
+static void IRAM_ATTR timer_done_wrapper(void *ptimer)
+{
+ ets_timer_done(ptimer);
+}
+
+static void IRAM_ATTR timer_setfn_wrapper(void *ptimer, void *pfunction, void *parg)
+{
+ ets_timer_setfn(ptimer, pfunction, parg);
+}
+
+static void IRAM_ATTR timer_arm_us_wrapper(void *ptimer, uint32_t us, bool repeat)
+{
+ ets_timer_arm_us(ptimer, us, repeat);
+}
+
+static int IRAM_ATTR get_time_wrapper(void *t)
+{
+ return os_get_time(t);
+}
+
+static void * IRAM_ATTR malloc_internal_wrapper(size_t size)
+{
+ return heap_caps_malloc(size, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+}
+
+static void * IRAM_ATTR realloc_internal_wrapper(void *ptr, size_t size)
+{
+ return heap_caps_realloc(ptr, size, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+}
+
+static void * IRAM_ATTR calloc_internal_wrapper(size_t n, size_t size)
+{
+ return heap_caps_calloc(n, size, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+}
+
+static void * IRAM_ATTR zalloc_internal_wrapper(size_t size)
+{
+ void *ptr = heap_caps_calloc(1, size, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL);
+ if (ptr) {
+ memset(ptr, 0, size);
+ }
+ return ptr;
+}
+
+static void IRAM_ATTR sc_ack_send_wrapper(void *param)
+{
+ return sc_ack_send((sc_ack_t *)param);
+}
+
+wifi_osi_funcs_t g_wifi_osi_funcs = {
+ ._version = ESP_WIFI_OS_ADAPTER_VERSION,
+ ._set_isr = set_isr_wrapper,
+ ._ints_on = xt_ints_on,
+ ._ints_off = xt_ints_off,
+ ._spin_lock_create = spin_lock_create_wrapper,
+ ._spin_lock_delete = free,
+ ._wifi_int_disable = wifi_int_disable_wrapper,
+ ._wifi_int_restore = wifi_int_restore_wrapper,
+ ._task_yield = vPortYield,
+ ._task_yield_from_isr = task_yield_from_isr_wrapper,
+ ._semphr_create = semphr_create_wrapper,
+ ._semphr_delete = semphr_delete_wrapper,
+ ._semphr_take_from_isr = semphr_take_from_isr_wrapper,
+ ._semphr_give_from_isr = semphr_give_from_isr_wrapper,
+ ._semphr_take = semphr_take_wrapper,
+ ._semphr_give = semphr_give_wrapper,
+ ._mutex_create = mutex_create_wrapper,
+ ._recursive_mutex_create = recursive_mutex_create_wrapper,
+ ._mutex_delete = mutex_delete_wrapper,
+ ._mutex_lock = mutex_lock_wrapper,
+ ._mutex_unlock = mutex_unlock_wrapper,
+ ._queue_create = queue_create_wrapper,
+ ._queue_delete = vQueueDelete,
+ ._queue_send = queue_send_wrapper,
+ ._queue_send_from_isr = queue_send_from_isr_wrapper,
+ ._queue_send_to_back = queue_send_to_back_wrapper,
+ ._queue_send_to_front = queue_send_to_front_wrapper,
+ ._queue_recv = queue_recv_wrapper,
+ ._queue_recv_from_isr = xQueueReceiveFromISR,
+ ._queue_msg_waiting = uxQueueMessagesWaiting,
+ ._event_group_create = xEventGroupCreate,
+ ._event_group_delete = vEventGroupDelete,
+ ._event_group_set_bits = xEventGroupSetBits,
+ ._event_group_clear_bits = xEventGroupClearBits,
+ ._event_group_wait_bits = event_group_wait_bits_wrapper,
+ ._task_create_pinned_to_core = task_create_pinned_to_core_wrapper,
+ ._task_create = task_create_wrapper,
+ ._task_delete = vTaskDelete,
+ ._task_delay = vTaskDelay,
+ ._task_ms_to_tick = task_ms_to_tick_wrapper,
+ ._task_get_current_task = xTaskGetCurrentTaskHandle,
+ ._task_get_max_priority = task_get_max_priority_wrapper,
+ ._is_in_isr = xPortInIsrContext,
+ ._malloc = malloc,
+ ._free = free,
+ ._get_free_heap_size = esp_get_free_heap_size,
+ ._rand = esp_random,
+ ._dport_access_stall_other_cpu_start_wrap = esp_dport_access_stall_other_cpu_start_wrap,
+ ._dport_access_stall_other_cpu_end_wrap = esp_dport_access_stall_other_cpu_end_wrap,
+ ._phy_rf_init = phy_rf_init_wrapper,
+ ._phy_rf_deinit = esp_phy_rf_deinit,
+ ._phy_load_cal_and_init = esp_phy_load_cal_and_init,
+ ._read_mac = esp_read_mac,
+ ._timer_init = ets_timer_init,
+ ._timer_deinit = ets_timer_deinit,
+ ._timer_arm = timer_arm_wrapper,
+ ._timer_disarm = timer_disarm_wrapper,
+ ._timer_done = timer_done_wrapper,
+ ._timer_setfn = timer_setfn_wrapper,
+ ._timer_arm_us = timer_arm_us_wrapper,
+ ._periph_module_enable = periph_module_enable,
+ ._periph_module_disable = periph_module_disable,
+ ._esp_timer_get_time = esp_timer_get_time,
+ ._nvs_set_i8 = nvs_set_i8,
+ ._nvs_get_i8 = nvs_get_i8,
+ ._nvs_set_u8 = nvs_set_u8,
+ ._nvs_get_u8 = nvs_get_u8,
+ ._nvs_set_u16 = nvs_set_u16,
+ ._nvs_get_u16 = nvs_get_u16,
+ ._nvs_open = nvs_open,
+ ._nvs_close = nvs_close,
+ ._nvs_commit = nvs_commit,
+ ._nvs_set_blob = nvs_set_blob,
+ ._nvs_get_blob = nvs_get_blob,
+ ._nvs_erase_key = nvs_erase_key,
+ ._get_random = os_get_random,
+ ._get_time = get_time_wrapper,
+ ._random = os_random,
+ ._log_write = esp_log_write,
+ ._log_timestamp = esp_log_timestamp,
+ ._malloc_internal = malloc_internal_wrapper,
+ ._realloc_internal = realloc_internal_wrapper,
+ ._calloc_internal = calloc_internal_wrapper,
+ ._zalloc_internal = zalloc_internal_wrapper,
+ ._wifi_malloc = wifi_malloc,
+ ._wifi_realloc = wifi_realloc,
+ ._wifi_calloc = wifi_calloc,
+ ._wifi_zalloc = wifi_zalloc_wrapper,
+ ._wifi_create_queue = wifi_create_queue_wrapper,
+ ._wifi_delete_queue = wifi_delete_queue_wrapper,
+ ._modem_sleep_enter = esp_modem_sleep_enter,
+ ._modem_sleep_exit = esp_modem_sleep_exit,
+ ._modem_sleep_register = esp_modem_sleep_register,
+ ._modem_sleep_deregister = esp_modem_sleep_deregister,
+ ._sc_ack_send = sc_ack_send_wrapper,
+ ._sc_ack_send_stop = sc_ack_send_stop,
+ ._magic = ESP_WIFI_OS_ADAPTER_MAGIC,
+};
#ifndef CRYPTO_H
#define CRYPTO_H
+#include "common.h"
+
/**
* md4_vector - MD4 hash for data vector
* @num_elem: Number of elements in the data vector
#ifndef DH_GROUP5_H
#define DH_GROUP5_H
+#include "wpa/wpabuf.h"
+
void * dh5_init(struct wpabuf **priv, struct wpabuf **publ);
struct wpabuf * dh5_derive_shared(void *ctx, const struct wpabuf *peer_public,
const struct wpabuf *own_private);
#define MD5_MAC_LEN 16
-int hmac_md5_vector(const u8 *key, size_t key_len, size_t num_elem,
- const u8 *addr[], const size_t *len, u8 *mac);
-int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
- u8 *mac);
+int hmac_md5_vector(const uint8_t *key, size_t key_len, size_t num_elem,
+ const uint8_t *addr[], const size_t *len, uint8_t *mac);
+int hmac_md5(const uint8_t *key, size_t key_len, const uint8_t *data, size_t data_len,
+ uint8_t *mac);
#ifdef CONFIG_FIPS
-int hmac_md5_vector_non_fips_allow(const u8 *key, size_t key_len,
- size_t num_elem, const u8 *addr[],
- const size_t *len, u8 *mac);
-int hmac_md5_non_fips_allow(const u8 *key, size_t key_len, const u8 *data,
- size_t data_len, u8 *mac);
+int hmac_md5_vector_non_fips_allow(const uint8_t *key, size_t key_len,
+ size_t num_elem, const uint8_t *addr[],
+ const size_t *len, uint8_t *mac);
+int hmac_md5_non_fips_allow(const uint8_t *key, size_t key_len, const uint8_t *data,
+ size_t data_len, uint8_t *mac);
#else /* CONFIG_FIPS */
#define hmac_md5_vector_non_fips_allow hmac_md5_vector
#define hmac_md5_non_fips_allow hmac_md5
#define SHA1_MAC_LEN 20
-int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
- const u8 *addr[], const size_t *len, u8 *mac);
-int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
- u8 *mac);
-int sha1_prf(const u8 *key, size_t key_len, const char *label,
- const u8 *data, size_t data_len, u8 *buf, size_t buf_len);
-int sha1_t_prf(const u8 *key, size_t key_len, const char *label,
- const u8 *seed, size_t seed_len, u8 *buf, size_t buf_len);
-//int __must_check tls_prf(const u8 *secret, size_t secret_len,
-// const char *label, const u8 *seed, size_t seed_len,
-// u8 *out, size_t outlen);
+int hmac_sha1_vector(const uint8_t *key, size_t key_len, size_t num_elem,
+ const uint8_t *addr[], const size_t *len, uint8_t *mac);
+int hmac_sha1(const uint8_t *key, size_t key_len, const uint8_t *data, size_t data_len,
+ uint8_t *mac);
+int sha1_prf(const uint8_t *key, size_t key_len, const char *label,
+ const uint8_t *data, size_t data_len, uint8_t *buf, size_t buf_len);
+int sha1_t_prf(const uint8_t *key, size_t key_len, const char *label,
+ const uint8_t *seed, size_t seed_len, uint8_t *buf, size_t buf_len);
+//int __must_check tls_prf(const uint8_t *secret, size_t secret_len,
+// const char *label, const uint8_t *seed, size_t seed_len,
+// uint8_t *out, size_t outlen);
int pbkdf2_sha1(const char *passphrase, const char *ssid, size_t ssid_len,
- int iterations, u8 *buf, size_t buflen);
+ int iterations, uint8_t *buf, size_t buflen);
#endif /* SHA1_H */
#define EAP_METHODS_H
#include "eap_defs.h"
+#include "eap_config.h"
const struct eap_method * eap_peer_get_eap_method(int vendor, EapType method);
const struct eap_method * eap_peer_get_methods(size_t *count);
struct wpabuf * wps_get_msg(struct wps_data *wps, enum wsc_op_code *op_code);
int wps_is_selected_pbc_registrar(const struct wpabuf *msg, u8 *bssid);
-#ifdef CONFIG_WPS_PIN
int wps_is_selected_pin_registrar(const struct wpabuf *msg, u8 *bssid);
-#endif
int wps_ap_priority_compar(const struct wpabuf *wps_a,
const struct wpabuf *wps_b);
int wps_is_addr_authorized(const struct wpabuf *msg, const u8 *addr,
unsigned int wps_pin_checksum(unsigned int pin);
unsigned int wps_pin_valid(unsigned int pin);
-unsigned int wps_generate_pin(void);
int wps_pin_str_valid(const char *pin);
#endif
+unsigned int wps_generate_pin(void);
#ifdef CONFIG_WPS_OOB
projects / esp-idf / commitdiff