Merge branch 'feature/wifi_add_os_adapter_func' into 'master'

Feature/wifi add os adapter func

See merge request idf/esp-idf!2417

components/esp32/fast_crypto_ops.c

@@ -16,8 +16,18 @@
 #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 
@@ -29,7 +39,22 @@ const wpa_crypto_funcs_t g_wifi_default_wpa_crypto_funcs = {
     .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 = {
@@ -38,7 +63,19 @@ 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
 };
 
 /*
@@ -56,7 +93,19 @@ const wpa2_crypto_funcs_t g_wifi_default_wpa2_crypto_funcs = {
     .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 = {

components/esp32/include/esp_wifi.h

@@ -67,6 +67,7 @@
 #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" {
@@ -93,6 +94,7 @@ 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 */
@@ -176,6 +178,7 @@ extern const wpa_crypto_funcs_t g_wifi_default_wpa_crypto_funcs;
 
 #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,\

components/esp32/include/esp_wifi_crypto_types.h

@@ -80,7 +80,7 @@ typedef esp_crypto_hash_t * (*esp_crypto_hash_init_t)(esp_crypto_hash_alg_t alg,
   * @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. 
@@ -95,7 +95,7 @@ typedef void * (*esp_crypto_hash_update_t)(esp_crypto_hash_t *ctx, const unsigne
   *             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. 
@@ -105,7 +105,7 @@ typedef int * (*esp_crypto_hash_finish_t)(esp_crypto_hash_t *ctx, unsigned char
   * @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. 
@@ -116,7 +116,7 @@ typedef int * (*esp_aes_128_encrypt_t)(const unsigned char *key, const unsigned
   * @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.
@@ -127,7 +127,7 @@ typedef int * (*esp_aes_128_decrypt_t)(const unsigned char *key, const unsigned
   * @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.
@@ -138,7 +138,7 @@ typedef int * (*esp_aes_wrap_t)(const unsigned char *kek, int n, const unsigned
   * @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.
@@ -162,7 +162,7 @@ typedef esp_crypto_cipher_t * (*esp_crypto_cipher_init_t)(esp_crypto_cipher_alg_
   * @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.
@@ -174,7 +174,7 @@ typedef int * (*esp_crypto_cipher_encrypt_t)(esp_crypto_cipher_t *ctx,
   * @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.
@@ -183,7 +183,7 @@ typedef int * (*esp_crypto_cipher_decrypt_t)(esp_crypto_cipher_t *ctx,
   * @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. 
@@ -195,7 +195,7 @@ typedef void * (*esp_crypto_cipher_deinit_t)(esp_crypto_cipher_t *ctx);
   * @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);
 
 /**
@@ -209,7 +209,7 @@ typedef void * (*esp_hmac_sha256_t)(const unsigned char *key, int key_len, const
   * @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);
 
 /**
@@ -224,7 +224,7 @@ typedef void * (*esp_hmac_sha256_vector_t)(const unsigned char *key, int key_len
   * @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);
 
 /**
@@ -233,10 +233,10 @@ typedef void * (*esp_sha256_prf_t)(const unsigned char *key, int key_len, const
   * @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);
 
 /**
@@ -253,10 +253,444 @@ typedef int * (*esp_sha256_vector_t)(int num_elem, const unsigned char *addr[],
   * @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
@@ -267,6 +701,21 @@ typedef struct {
     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;
 
 /**
@@ -281,6 +730,18 @@ typedef struct{
     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;
 
 /**
@@ -298,6 +759,18 @@ typedef struct {
     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;
 
 /**

components/esp32/include/esp_wifi_internal.h

@@ -35,6 +35,7 @@
 #include "esp_err.h"
 #include "esp_wifi_types.h"
 #include "esp_event.h"
+#include "esp_wifi.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -126,6 +127,17 @@ esp_err_t esp_wifi_internal_reg_rxcb(wifi_interface_t ifx, wifi_rxcb_t fn);
   */
 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
   *

components/esp32/include/esp_wifi_os_adapter.h

@@ -0,0 +1,139 @@
+// 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_ */

components/esp32/include/rom/ets_sys.h

@@ -301,6 +301,15 @@ typedef struct _ETSTIMER_ {
   */
 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.

components/esp32/lib

@@ -1 +1 @@
-Subproject commit 8b6d5837a4215b83ff8a3ff088ccbb716adf05fb
+Subproject commit f56b7bd4127aa01dbd50eb8ac3c637690bd98f84

components/esp32/phy_init.c

@@ -38,6 +38,7 @@
 #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";
@@ -129,6 +130,11 @@ esp_err_t esp_phy_rf_init(const esp_phy_init_data_t* init_data, esp_phy_calibrat
 #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();
         }
     }

components/esp32/test/component.mk

@@ -8,6 +8,10 @@ COMPONENT_ADD_LDFLAGS = -Wl,--whole-archive -l$(COMPONENT_NAME) -Wl,--no-whole-a
 
 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

components/esp32/test/test_os_adapter_md5.c

@@ -0,0 +1,18 @@
+/*
+ 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...");
+}

components/esp32/wifi_internal.c

@@ -1,116 +0,0 @@
-// 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);
-    }
-}

components/esp32/wifi_os_adapter.c

@@ -0,0 +1,498 @@
+// 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,
+};

components/wpa_supplicant/include/crypto/crypto.h

@@ -27,6 +27,8 @@
 #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

components/wpa_supplicant/include/crypto/dh_group5.h

@@ -15,6 +15,8 @@
 #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);

components/wpa_supplicant/include/crypto/md5.h

@@ -17,16 +17,16 @@
 
 #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

components/wpa_supplicant/include/crypto/sha1.h

@@ -17,17 +17,17 @@
 
 #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 */

components/wpa_supplicant/include/wpa2/eap_peer/eap_methods.h

@@ -10,6 +10,7 @@
 #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);

components/wpa_supplicant/include/wps/wps.h

@@ -233,9 +233,7 @@ enum wps_process_res wps_process_msg(struct wps_data *wps,
 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,
@@ -803,9 +801,9 @@ int wps_build_credential_wrap(struct wpabuf *msg,
 
 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