Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-06 11:36:59 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
f74ecf5e60867ea9141c2824c0c571c0ed07d702
squeezelite-esp32/components/wifi-manager/network_wifi.c
Sebastien L f74ecf5e60 improv-wifi initial commit
2022-11-29 11:53:20 -05:00

1252 lines
48 KiB
C
Raw Blame History

#ifdef NETWORK_WIFI_LOG_LEVEL
#define LOG_LOCAL_LEVEL NETWORK_WIFI_LOG_LEVEL
#endif
#include "network_wifi.h"
#include <string.h>
#include "cJSON.h"
#include "dns_server.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_wifi_types.h"
#include "lwip/sockets.h"
#include "messaging.h"
#include "network_status.h"
#include "nvs.h"
#include "nvs_flash.h"
#include "nvs_utilities.h"
#include "platform_config.h"
#include "platform_esp32.h"
#include "tools.h"
#include "trace.h"
static void network_wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data);
static char* get_disconnect_code_desc(uint8_t reason);
esp_err_t network_wifi_get_blob(void* target, size_t size, const char* key);
static inline const char* ssid_string(const wifi_sta_config_t* sta);
static inline const char* password_string(const wifi_sta_config_t* sta);
cJSON* accessp_cjson = NULL;
static const char TAG[] = "network_wifi";
const char network_wifi_nvs_namespace[] = "config";
const char ap_list_nsv_namespace[] = "aplist";
/* rrm ctx */
//Roaming support - int rrm_ctx = 0;
uint16_t ap_num = 0;
esp_netif_t* wifi_netif;
esp_netif_t* wifi_ap_netif;
wifi_ap_record_t* accessp_records = NULL;
#define UINT_TO_STRING(val) \
static char loc[sizeof(val) + 1]; \
memset(loc, 0x00, sizeof(loc)); \
strlcpy(loc, (char*)val, sizeof(loc)); \
return loc;
static inline const char* ssid_string(const wifi_sta_config_t* sta) {
UINT_TO_STRING(sta->ssid);
}
static inline const char* password_string(const wifi_sta_config_t* sta) {
UINT_TO_STRING(sta->password);
}
static inline const char* ap_ssid_string(const wifi_ap_record_t* ap) {
UINT_TO_STRING(ap->ssid);
}
typedef struct known_access_point {
char* ssid;
char* password;
bool found;
uint8_t bssid[6]; /**< MAC address of AP */
uint8_t primary; /**< channel of AP */
wifi_auth_mode_t authmode; /**< authmode of AP */
uint32_t phy_11b : 1; /**< bit: 0 flag to identify if 11b mode is enabled or not */
uint32_t phy_11g : 1; /**< bit: 1 flag to identify if 11g mode is enabled or not */
uint32_t phy_11n : 1; /**< bit: 2 flag to identify if 11n mode is enabled or not */
uint32_t phy_lr : 1; /**< bit: 3 flag to identify if low rate is enabled or not */
time_t last_try;
SLIST_ENTRY(known_access_point)
next; //!< next callback
} known_access_point_t;
/** linked list of command structures */
static EXT_RAM_ATTR SLIST_HEAD(ap_list, known_access_point) s_ap_list;
known_access_point_t* network_wifi_get_ap_entry(const char* ssid) {
known_access_point_t* it;
if (!ssid || strlen(ssid) == 0) {
ESP_LOGW(TAG, "network_wifi_get_ap_entry Invalid SSID %s", !ssid ? "IS NULL" : "IS BLANK");
return NULL;
}
SLIST_FOREACH(it, &s_ap_list, next) {
ESP_LOGD(TAG, "Looking for SSID %s = %s ?", ssid, it->ssid);
if (strcmp(it->ssid, ssid) == 0) {
ESP_LOGD(TAG, "network_wifi_get_ap_entry SSID %s found! ", ssid);
return it;
}
}
return NULL;
}
void network_wifi_remove_ap_entry(const char* ssid) {
if (!ssid || strlen(ssid) == 0) {
ESP_LOGE(TAG, "network_wifi_remove_ap_entry error empty SSID");
}
known_access_point_t* it = network_wifi_get_ap_entry(ssid);
if (it) {
ESP_LOGW(TAG, "Removing %s from known list of access points", ssid);
FREE_AND_NULL(it->ssid);
FREE_AND_NULL(it->password);
SLIST_REMOVE(&s_ap_list, it, known_access_point, next);
FREE_AND_NULL(it);
}
}
void network_wifi_empty_known_list() {
known_access_point_t* it;
while ((it = SLIST_FIRST(&s_ap_list)) != NULL) {
network_wifi_remove_ap_entry(it->ssid);
}
}
const wifi_sta_config_t* network_wifi_get_active_config() {
static wifi_config_t config;
esp_err_t err = ESP_OK;
memset(&config, 0x00, sizeof(config));
if ((err = esp_wifi_get_config(WIFI_IF_STA, &config)) == ESP_OK) {
return &config.sta;
} else {
ESP_LOGD(TAG, "Could not get wifi STA config: %s", esp_err_to_name(err));
}
return NULL;
}
size_t network_wifi_get_known_count() {
size_t count = 0;
known_access_point_t* it;
SLIST_FOREACH(it, &s_ap_list, next) {
count++;
}
return count;
}
size_t network_wifi_get_known_count_in_range() {
size_t count = 0;
known_access_point_t* it;
SLIST_FOREACH(it, &s_ap_list, next) {
if(it->found) count++;
}
return count;
}
esp_err_t network_wifi_add_ap(known_access_point_t* item) {
known_access_point_t* last = SLIST_FIRST(&s_ap_list);
if (last == NULL) {
SLIST_INSERT_HEAD(&s_ap_list, item, next);
} else {
known_access_point_t* it;
while ((it = SLIST_NEXT(last, next)) != NULL) {
last = it;
}
SLIST_INSERT_AFTER(last, item, next);
}
return ESP_OK;
}
esp_err_t network_wifi_add_ap_copy(const known_access_point_t* known_ap) {
known_access_point_t* item = NULL;
esp_err_t err = ESP_OK;
if (!known_ap) {
ESP_LOGE(TAG, "Invalid access point entry");
return ESP_ERR_INVALID_ARG;
}
if (!known_ap->ssid || strlen(known_ap->ssid) == 0) {
ESP_LOGE(TAG, "Invalid access point ssid");
return ESP_ERR_INVALID_ARG;
}
item = malloc_init_external(sizeof(known_access_point_t));
if (item == NULL) {
ESP_LOGE(TAG, "Memory allocation failed");
return ESP_ERR_NO_MEM;
}
item->ssid = strdup_psram(known_ap->ssid);
item->password = strdup_psram(known_ap->password);
memcpy(&item->bssid, known_ap->bssid, sizeof(item->bssid));
item->primary = known_ap->primary;
item->authmode = known_ap->authmode;
item->phy_11b = known_ap->phy_11b;
item->phy_11g = known_ap->phy_11g;
item->phy_11n = known_ap->phy_11n;
item->phy_lr = known_ap->phy_lr;
err = network_wifi_add_ap(item);
return err;
}
const wifi_ap_record_t* network_wifi_get_ssid_info(const char* ssid) {
if (!accessp_records)
return NULL;
for (int i = 0; i < ap_num; i++) {
if (strcmp(ap_ssid_string(&accessp_records[i]), ssid) == 0) {
return &accessp_records[i];
}
}
return NULL;
}
esp_err_t network_wifi_add_ap_from_sta_copy(const wifi_sta_config_t* sta) {
known_access_point_t* item = NULL;
esp_err_t err = ESP_OK;
if (!sta) {
ESP_LOGE(TAG, "Invalid access point entry");
return ESP_ERR_INVALID_ARG;
}
if (!sta->ssid || strlen((char*)sta->ssid) == 0) {
ESP_LOGE(TAG, "Invalid access point ssid");
return ESP_ERR_INVALID_ARG;
}
item = malloc_init_external(sizeof(known_access_point_t));
if (item == NULL) {
ESP_LOGE(TAG, "Memory allocation failed");
return ESP_ERR_NO_MEM;
}
item->ssid = strdup_psram(ssid_string(sta));
item->password = strdup_psram(password_string(sta));
memcpy(&item->bssid, sta->bssid, sizeof(item->bssid));
item->primary = sta->channel;
const wifi_ap_record_t* seen = network_wifi_get_ssid_info(item->ssid);
if (seen) {
item->authmode = seen->authmode;
item->phy_11b = seen->phy_11b;
item->phy_11g = seen->phy_11g;
item->phy_11n = seen->phy_11n;
item->phy_lr = seen->phy_lr;
}
err = network_wifi_add_ap(item);
return err;
}
bool network_wifi_is_known_ap(const char* ssid) {
return network_wifi_get_ap_entry(ssid) != NULL;
}
static bool network_wifi_was_ssid_seen(const char* ssid) {
if (!accessp_records || ap_num == 0 || ap_num == MAX_AP_NUM) {
return false;
}
for (int i = 0; i < ap_num; i++) {
if (strcmp(ap_ssid_string(&accessp_records[i]), ssid) == 0) {
return true;
}
}
return false;
}
void network_wifi_set_found_ap() {
known_access_point_t* it;
SLIST_FOREACH(it, &s_ap_list, next) {
if (network_wifi_was_ssid_seen(it->ssid)) {
it->found = true;
} else {
it->found = false;
}
}
}
bool network_wifi_known_ap_in_range(){
known_access_point_t* it;
SLIST_FOREACH(it, &s_ap_list, next) {
if (it->found) {
return true;
}
}
return false;
}
const char * network_wifi_get_next_ap_in_range(){
known_access_point_t* it;
time_t last_try_min=(esp_timer_get_time() / 1000);
SLIST_FOREACH(it, &s_ap_list, next) {
if (it->found && it->last_try < last_try_min) {
last_try_min = it->last_try;
}
}
SLIST_FOREACH(it, &s_ap_list, next) {
if (it->found && it->last_try == last_try_min) {
return it->ssid;
}
}
return NULL;
}
esp_err_t network_wifi_alloc_ap_json(known_access_point_t* item, char** json_string) {
esp_err_t err = ESP_OK;
if (!item || !json_string) {
return ESP_ERR_INVALID_ARG;
}
cJSON* cjson_item = cJSON_CreateObject();
if (!cjson_item) {
ESP_LOGE(TAG, "Memory allocation failure. Cannot save ap json");
return ESP_ERR_NO_MEM;
}
cJSON_AddStringToObject(cjson_item, "ssid", item->ssid);
cJSON_AddStringToObject(cjson_item, "pass", item->password);
cJSON_AddNumberToObject(cjson_item, "chan", item->primary);
cJSON_AddNumberToObject(cjson_item, "auth", item->authmode);
char* bssid = network_manager_alloc_get_mac_string(item->bssid);
if (bssid) {
cJSON_AddItemToObject(cjson_item, "bssid", cJSON_CreateString(STR_OR_BLANK(bssid)));
}
FREE_AND_NULL(bssid);
cJSON_AddNumberToObject(cjson_item, "b", item->phy_11b ? 1 : 0);
cJSON_AddNumberToObject(cjson_item, "g", item->phy_11g ? 1 : 0);
cJSON_AddNumberToObject(cjson_item, "n", item->phy_11n ? 1 : 0);
cJSON_AddNumberToObject(cjson_item, "low_rate", item->phy_lr ? 1 : 0);
*json_string = cJSON_PrintUnformatted(cjson_item);
if (!*json_string) {
ESP_LOGE(TAG, "Memory allocaiton failed. Cannot save ap entry.");
err = ESP_ERR_NO_MEM;
}
cJSON_Delete(cjson_item);
return err;
}
bool network_wifi_str2mac(const char* mac, uint8_t* values) {
if (6 == sscanf(mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &values[0], &values[1], &values[2], &values[3], &values[4], &values[5])) {
return true;
} else {
return false;
}
}
esp_err_t network_wifi_add_json_entry(const char* json_text) {
esp_err_t err = ESP_OK;
known_access_point_t known_ap;
if (!json_text || strlen(json_text) == 0) {
ESP_LOGE(TAG, "Invalid access point json");
return ESP_ERR_INVALID_ARG;
}
cJSON* cjson_item = cJSON_Parse(json_text);
if (!cjson_item) {
ESP_LOGE(TAG, "Invalid JSON %s", json_text);
return ESP_ERR_INVALID_ARG;
}
cJSON* value = cJSON_GetObjectItemCaseSensitive(cjson_item, "ssid");
if (!value || !cJSON_IsString(value) || strlen(cJSON_GetStringValue(value)) == 0) {
ESP_LOGE(TAG, "Missing ssid in : %s", json_text);
err = ESP_ERR_INVALID_ARG;
} else {
if (!network_wifi_get_ap_entry(cJSON_GetStringValue(value))) {
known_ap.ssid = strdup_psram(cJSON_GetStringValue(value));
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "pass");
if (value && cJSON_IsString(value) && strlen(cJSON_GetStringValue(value)) > 0) {
known_ap.password = strdup_psram(cJSON_GetStringValue(value));
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "chan");
if (value) {
known_ap.primary = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "auth");
if (value) {
known_ap.authmode = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "b");
if (value) {
known_ap.phy_11b = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "g");
if (value) {
known_ap.phy_11g = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "n");
if (value) {
known_ap.phy_11n = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "low_rate");
if (value) {
known_ap.phy_lr = value->valueint;
}
value = cJSON_GetObjectItemCaseSensitive(cjson_item, "bssid");
if (value && cJSON_IsString(value) && strlen(cJSON_GetStringValue(value)) > 0) {
network_wifi_str2mac(cJSON_GetStringValue(value), known_ap.bssid);
}
err = network_wifi_add_ap_copy(&known_ap);
} else {
ESP_LOGE(TAG, "Duplicate ssid %s found in storage", cJSON_GetStringValue(value));
}
}
cJSON_Delete(cjson_item);
return err;
}
esp_err_t network_wifi_delete_ap(const char* key) {
esp_err_t esp_err = ESP_OK;
if (!key || strlen(key) == 0) {
ESP_LOGE(TAG, "SSID Empty. Cannot remove ");
return ESP_ERR_INVALID_ARG;
}
known_access_point_t* it = network_wifi_get_ap_entry(key);
if (!it) {
ESP_LOGE(TAG, "Unknown AP entry");
return ESP_ERR_INVALID_ARG;
}
/*
* Check if we're deleting the active network
*/
ESP_LOGD(TAG, "Deleting AP %s. Checking if this is the active AP", key);
const wifi_sta_config_t* config = network_wifi_load_active_config();
if (config && strlen(ssid_string(config)) > 0 && strcmp(ssid_string(config), it->ssid) == 0) {
ESP_LOGD(TAG, "Confirmed %s to be the active network. Removing it from flash.", key);
esp_err = network_wifi_erase_legacy();
if (esp_err != ESP_OK) {
ESP_LOGW(TAG, "Legacy network details could not be removed from flash : %s", esp_err_to_name(esp_err));
}
}
ESP_LOGD(TAG, "Removing network %s from the flash AP list", key);
esp_err = erase_nvs_for_partition(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace, it->ssid);
if (esp_err != ESP_OK) {
messaging_post_message(MESSAGING_ERROR, MESSAGING_CLASS_SYSTEM, "Deleting network entry %s error (%s). Error %s", key, ap_list_nsv_namespace, esp_err_to_name(esp_err));
}
ESP_LOGD(TAG, "Removing network %s from the known AP list", key);
network_wifi_remove_ap_entry(it->ssid);
return esp_err;
}
esp_err_t network_wifi_erase_legacy() {
esp_err_t err = erase_nvs_partition(NVS_DEFAULT_PART_NAME, network_wifi_nvs_namespace);
if (err == ESP_OK) {
ESP_LOGW(TAG, "Erased wifi configuration. Disconnecting from network");
if ((err = esp_wifi_disconnect()) != ESP_OK) {
ESP_LOGW(TAG, "Could not disconnect from deleted network : %s", esp_err_to_name(err));
}
}
return err;
}
esp_err_t network_wifi_erase_known_ap() {
network_wifi_empty_known_list();
esp_err_t err = erase_nvs_partition(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace);
return err;
}
esp_err_t network_wifi_write_ap(const char* key, const char* value, size_t size) {
size_t size_override = size > 0 ? size : strlen(value) + 1;
esp_err_t esp_err = store_nvs_value_len_for_partition(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace, NVS_TYPE_BLOB, key, value, size_override);
if (esp_err != ESP_OK) {
messaging_post_message(MESSAGING_ERROR, MESSAGING_CLASS_SYSTEM, "%s (%s). Error %s", key, network_wifi_nvs_namespace, esp_err_to_name(esp_err));
}
return esp_err;
}
esp_err_t network_wifi_write_nvs(const char* key, const char* value, size_t size) {
size_t size_override = size > 0 ? size : strlen(value) + 1;
esp_err_t esp_err = store_nvs_value_len_for_partition(NVS_DEFAULT_PART_NAME, network_wifi_nvs_namespace, NVS_TYPE_BLOB, key, value, size_override);
if (esp_err != ESP_OK) {
messaging_post_message(MESSAGING_ERROR, MESSAGING_CLASS_SYSTEM, "%s (%s). Error %s", key, network_wifi_nvs_namespace, esp_err_to_name(esp_err));
}
return esp_err;
}
esp_err_t network_wifi_store_ap_json(known_access_point_t* item) {
esp_err_t err = ESP_OK;
size_t size = 0;
char* json_string = NULL;
const wifi_sta_config_t* sta = network_wifi_get_active_config();
if ((err = network_wifi_alloc_ap_json(item, &json_string)) == ESP_OK) {
// get any existing entry from the nvs and compare
char* existing = get_nvs_value_alloc_for_partition(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace, NVS_TYPE_BLOB, item->ssid, &size);
if (!existing || strncmp(existing, json_string, strlen(json_string)) != 0) {
ESP_LOGI(TAG, "SSID %s was changed or is new. Committing to flash", item->ssid);
err = network_wifi_write_ap(item->ssid, json_string, 0);
if (sta && strlen(ssid_string(sta)) > 0 && strcmp(ssid_string(sta), item->ssid) == 0) {
ESP_LOGI(TAG, "Committing active access point");
err = network_wifi_write_nvs("ssid", ssid_string(sta), 0);
if (err == ESP_OK) {
err = network_wifi_write_nvs("password", STR_OR_BLANK(password_string(sta)), 0);
}
if (err != ESP_OK) {
ESP_LOGE(TAG, "Error committing active access point : %s", esp_err_to_name(err));
}
}
}
FREE_AND_NULL(existing);
FREE_AND_NULL(json_string);
}
return err;
}
esp_netif_t* network_wifi_get_interface() {
return wifi_netif;
}
esp_netif_t* network_wifi_get_ap_interface() {
return wifi_ap_netif;
}
esp_err_t network_wifi_set_sta_mode() {
if (!wifi_netif) {
ESP_LOGE(TAG, "Wifi not initialized. Cannot set sta mode");
return ESP_ERR_INVALID_STATE;
}
ESP_LOGD(TAG, "Set Mode to STA");
esp_err_t err = esp_wifi_set_mode(WIFI_MODE_STA);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Error setting mode to STA: %s", esp_err_to_name(err));
} else {
ESP_LOGI(TAG, "Starting wifi");
err = esp_wifi_start();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Error starting wifi: %s", esp_err_to_name(err));
}
}
return err;
}
esp_netif_t* network_wifi_start() {
MEMTRACE_PRINT_DELTA_MESSAGE( "Starting wifi interface as STA mode");
accessp_cjson = network_manager_clear_ap_list_json(&accessp_cjson);
if (!wifi_netif) {
MEMTRACE_PRINT_DELTA_MESSAGE("Init STA mode - creating default interface. ");
wifi_netif = esp_netif_create_default_wifi_sta();
MEMTRACE_PRINT_DELTA_MESSAGE("Initializing Wifi. ");
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK_WITHOUT_ABORT(esp_wifi_init(&cfg));
MEMTRACE_PRINT_DELTA_MESSAGE("Registering wifi Handlers");
//network_wifi_register_handlers();
ESP_ERROR_CHECK_WITHOUT_ABORT(esp_event_handler_instance_register(WIFI_EVENT,
ESP_EVENT_ANY_ID,
&network_wifi_event_handler,
NULL,
NULL));
MEMTRACE_PRINT_DELTA_MESSAGE("Setting up wifi Storage");
ESP_ERROR_CHECK_WITHOUT_ABORT(esp_wifi_set_storage(WIFI_STORAGE_RAM));
}
MEMTRACE_PRINT_DELTA_MESSAGE("Setting up wifi mode as STA");
network_wifi_set_sta_mode();
MEMTRACE_PRINT_DELTA_MESSAGE("Setting hostname");
network_set_hostname(wifi_netif);
MEMTRACE_PRINT_DELTA_MESSAGE("Done starting wifi interface");
return wifi_netif;
}
void destroy_network_wifi() {
cJSON_Delete(accessp_cjson);
accessp_cjson = NULL;
}
bool network_wifi_sta_config_changed() {
bool changed = true;
const wifi_sta_config_t* sta = network_wifi_get_active_config();
if (!sta || strlen(ssid_string(sta)) == 0)
return false;
known_access_point_t* known = network_wifi_get_ap_entry(ssid_string(sta));
if (known && strcmp(known->ssid, ssid_string(sta)) == 0 &&
strcmp((char*)known->password, password_string(sta)) == 0) {
changed = false;
} else {
ESP_LOGI(TAG, "New network configuration found");
}
return changed;
}
esp_err_t network_wifi_save_sta_config() {
esp_err_t esp_err = ESP_OK;
known_access_point_t* item = NULL;
MEMTRACE_PRINT_DELTA_MESSAGE("Config Save");
const wifi_sta_config_t* sta = network_wifi_get_active_config();
if (sta && strlen(ssid_string(sta)) > 0) {
MEMTRACE_PRINT_DELTA_MESSAGE("Checking if current SSID is known");
item = network_wifi_get_ap_entry(ssid_string(sta));
if (!item) {
ESP_LOGD(TAG,"New SSID %s found", ssid_string(sta));
// this is a new access point. First add it to the end of the AP list
esp_err = network_wifi_add_ap_from_sta_copy(sta);
}
}
// now traverse the list and commit
MEMTRACE_PRINT_DELTA_MESSAGE("Saving all known ap as json strings");
known_access_point_t* it;
SLIST_FOREACH(it, &s_ap_list, next) {
if ((esp_err = network_wifi_store_ap_json(it)) != ESP_OK) {
ESP_LOGW(TAG, "Error saving wifi ap entry %s : %s", it->ssid, esp_err_to_name(esp_err));
break;
}
}
return esp_err;
}
void network_wifi_load_known_access_points() {
esp_err_t esp_err;
size_t size = 0;
if (network_wifi_get_known_count() > 0) {
ESP_LOGW(TAG, "Access points already loaded");
return;
}
nvs_iterator_t it = nvs_entry_find(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace, NVS_TYPE_ANY);
if (it == NULL) {
ESP_LOGW(TAG, "No known access point found");
return;
}
do {
nvs_entry_info_t info;
nvs_entry_info(it, &info);
if (strstr(info.namespace_name, ap_list_nsv_namespace)) {
void* value = get_nvs_value_alloc_for_partition(NVS_DEFAULT_PART_NAME, ap_list_nsv_namespace, info.type, info.key, &size);
if (value == NULL) {
ESP_LOGE(TAG, "nvs read failed for %s.", info.key);
} else if ((esp_err = network_wifi_add_json_entry(value)) != ESP_OK) {
ESP_LOGE(TAG, "Invalid entry or error for %s.", (char*)value);
}
FREE_AND_NULL(value);
}
it = nvs_entry_next(it);
} while (it != NULL);
return;
}
esp_err_t network_wifi_get_blob(void* target, size_t size, const char* key) {
esp_err_t esp_err = ESP_OK;
size_t found_size = 0;
if (!target) {
ESP_LOGE(TAG, "%s invalid target pointer", __FUNCTION__);
return ESP_ERR_INVALID_ARG;
}
memset(target, 0x00, size);
char* value = (char*)get_nvs_value_alloc_for_partition(NVS_DEFAULT_PART_NAME, network_wifi_nvs_namespace, NVS_TYPE_BLOB, key, &found_size);
if (!value) {
ESP_LOGD(TAG,"nvs key %s not found.", key);
esp_err = ESP_FAIL;
} else {
memcpy((char*)target, value, size > found_size ? found_size : size);
FREE_AND_NULL(value);
ESP_LOGD(TAG,"Successfully loaded key %s", key);
}
return esp_err;
}
const wifi_sta_config_t* network_wifi_load_active_config() {
static wifi_sta_config_t config;
esp_err_t esp_err = ESP_OK;
memset(&config, 0x00, sizeof(config));
config.scan_method = WIFI_ALL_CHANNEL_SCAN;
MEMTRACE_PRINT_DELTA_MESSAGE("Fetching wifi sta config - ssid.");
esp_err = network_wifi_get_blob(&config.ssid, sizeof(config.ssid), "ssid");
if (esp_err == ESP_OK && strlen((char*)config.ssid) > 0) {
ESP_LOGD(TAG,"network_wifi_load_active_config: ssid:%s. Fetching password (if any) ", ssid_string(&config));
if (network_wifi_get_blob(&config.password, sizeof(config.password), "password") != ESP_OK) {
ESP_LOGW(TAG, "No wifi password found in nvs");
}
} else {
if(network_wifi_get_known_count() > 0) {
ESP_LOGW(TAG, "No wifi ssid found in nvs, but known access points found. Using first known access point.");
known_access_point_t* ap = SLIST_FIRST(&s_ap_list);
if (ap) {
strncpy((char*)&config.ssid, ap->ssid, sizeof(config.ssid));
strncpy((char*)&config.password, ap->password, sizeof(config.password));
}
esp_err = ESP_OK;
} else {
ESP_LOGW(TAG, "network manager has no previous configuration. %s", esp_err_to_name(esp_err));
return NULL;
}
}
return &config;
}
bool network_wifi_load_wifi_sta_config() {
network_wifi_load_known_access_points();
const wifi_sta_config_t* config = network_wifi_load_active_config();
if (config) {
known_access_point_t* item = network_wifi_get_ap_entry(ssid_string(config));
if (!item) {
ESP_LOGI(TAG, "Adding legacy/active wifi connection to the known list");
network_wifi_add_ap_from_sta_copy(config);
}
}
return config && config->ssid[0] != '\0';
}
bool network_wifi_get_config_for_ssid(wifi_config_t* config, const char* ssid) {
known_access_point_t* item = network_wifi_get_ap_entry(ssid);
if (!item) {
ESP_LOGE(TAG, "Unknown ssid %s", ssid);
return false;
}
memset(&config->ap, 0x00, sizeof(config->ap));
strncpy((char*)config->ap.ssid, item->ssid, sizeof(config->ap.ssid));
strncpy((char*)config->ap.password, item->password, sizeof(config->ap.ssid));
config->sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
return true;
}
static void network_wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
if (event_base != WIFI_EVENT)
return;
switch (event_id) {
case WIFI_EVENT_WIFI_READY:
ESP_LOGD(TAG, "WIFI_EVENT_WIFI_READY");
break;
case WIFI_EVENT_SCAN_DONE:
ESP_LOGD(TAG, "WIFI_EVENT_SCAN_DONE");
network_async_scan_done();
break;
case WIFI_EVENT_STA_AUTHMODE_CHANGE:
ESP_LOGD(TAG, "WIFI_EVENT_STA_AUTHMODE_CHANGE");
break;
case WIFI_EVENT_AP_START:
ESP_LOGD(TAG, "WIFI_EVENT_AP_START");
break;
case WIFI_EVENT_AP_STOP:
ESP_LOGD(TAG, "WIFI_EVENT_AP_STOP");
break;
case WIFI_EVENT_AP_PROBEREQRECVED: {
wifi_event_ap_probe_req_rx_t* s = (wifi_event_ap_probe_req_rx_t*)event_data;
char* mac = network_manager_alloc_get_mac_string(s->mac);
if (mac) {
ESP_LOGD(TAG, "WIFI_EVENT_AP_PROBEREQRECVED. RSSI: %d, MAC: %s", s->rssi, STR_OR_BLANK(mac));
}
FREE_AND_NULL(mac);
} break;
case WIFI_EVENT_STA_WPS_ER_SUCCESS:
ESP_LOGD(TAG, "WIFI_EVENT_STA_WPS_ER_SUCCESS");
break;
case WIFI_EVENT_STA_WPS_ER_FAILED:
ESP_LOGD(TAG, "WIFI_EVENT_STA_WPS_ER_FAILED");
break;
case WIFI_EVENT_STA_WPS_ER_TIMEOUT:
ESP_LOGD(TAG, "WIFI_EVENT_STA_WPS_ER_TIMEOUT");
break;
case WIFI_EVENT_STA_WPS_ER_PIN:
ESP_LOGD(TAG, "WIFI_EVENT_STA_WPS_ER_PIN");
break;
case WIFI_EVENT_AP_STACONNECTED: {
wifi_event_ap_staconnected_t* stac = (wifi_event_ap_staconnected_t*)event_data;
char* mac = network_manager_alloc_get_mac_string(stac->mac);
if (mac) {
ESP_LOGD(TAG, "WIFI_EVENT_AP_STACONNECTED. aid: %d, mac: %s", stac->aid, STR_OR_BLANK(mac));
}
FREE_AND_NULL(mac);
} break;
case WIFI_EVENT_AP_STADISCONNECTED:
ESP_LOGD(TAG, "WIFI_EVENT_AP_STADISCONNECTED");
break;
case WIFI_EVENT_STA_START:
ESP_LOGD(TAG, "WIFI_EVENT_STA_START");
break;
case WIFI_EVENT_STA_STOP:
ESP_LOGD(TAG, "WIFI_EVENT_STA_STOP");
break;
case WIFI_EVENT_STA_CONNECTED: {
ESP_LOGD(TAG, "WIFI_EVENT_STA_CONNECTED. ");
wifi_event_sta_connected_t* s = (wifi_event_sta_connected_t*)event_data;
char* bssid = network_manager_alloc_get_mac_string(s->bssid);
char* ssid = strdup_psram((char*)s->ssid);
network_wifi_set_connect_state(NETWORK_WIFI_STATE_CONNECTED);
if (bssid && ssid) {
ESP_LOGD(TAG, "WIFI_EVENT_STA_CONNECTED. Channel: %d, Access point: %s, BSSID: %s ", s->channel, STR_OR_BLANK(ssid), (bssid));
}
FREE_AND_NULL(bssid);
FREE_AND_NULL(ssid);
network_async(EN_CONNECTED);
} break;
case WIFI_EVENT_STA_DISCONNECTED: {
// structwifi_event_sta_disconnected_t
// Argument structure for WIFI_EVENT_STA_DISCONNECTED event
//
// Public Members
//
// uint8_t ssid[32]
// SSID of disconnected AP
//
// uint8_t ssid_len
// SSID length of disconnected AP
//
// uint8_t bssid[6]
// BSSID of disconnected AP
//
// uint8_t reason
// reason of disconnection
wifi_event_sta_disconnected_t* s = (wifi_event_sta_disconnected_t*)event_data;
char* bssid = network_manager_alloc_get_mac_string(s->bssid);
ESP_LOGW(TAG, "WIFI_EVENT_STA_DISCONNECTED. From BSSID: %s, reason code: %d (%s)", STR_OR_BLANK(bssid), s->reason, get_disconnect_code_desc(s->reason));
FREE_AND_NULL(bssid);
if (s->reason == WIFI_REASON_ROAMING) {
ESP_LOGI(TAG, "WiFi Roaming to new access point");
} else {
network_async_lost_connection((wifi_event_sta_disconnected_t*)event_data);
network_wifi_set_connect_state(NETWORK_WIFI_STATE_FAILED);
}
} break;
default:
break;
}
}
cJSON* network_wifi_get_new_array_json(cJSON** old) {
ESP_LOGV(TAG, "network_wifi_get_new_array_json called");
cJSON* root = *old;
if (root != NULL) {
cJSON_Delete(root);
*old = NULL;
}
ESP_LOGV(TAG, "network_wifi_get_new_array_json done");
return cJSON_CreateArray();
}
void network_wifi_global_init() {
network_wifi_get_new_array_json(&accessp_cjson);
ESP_LOGD(TAG, "Loading existing wifi configuration (if any)");
network_wifi_load_wifi_sta_config();
}
void network_wifi_add_access_point_json(cJSON* ap_list, wifi_ap_record_t* ap_rec) {
cJSON* ap = cJSON_CreateObject();
if (ap == NULL) {
ESP_LOGE(TAG, "Unable to allocate memory for access point %s", ap_rec->ssid);
return;
}
cJSON* radio = cJSON_CreateObject();
if (radio == NULL) {
ESP_LOGE(TAG, "Unable to allocate memory for access point %s", ap_rec->ssid);
cJSON_Delete(ap);
return;
}
cJSON_AddItemToObject(ap, "ssid", cJSON_CreateString(ap_ssid_string(ap_rec)));
cJSON_AddBoolToObject(ap, "known", network_wifi_is_known_ap(ap_ssid_string(ap_rec)));
if (ap_rec->rssi != 0) {
// only add the rest of the details when record doesn't come from
// "known" access points that aren't in range
cJSON_AddNumberToObject(ap, "chan", ap_rec->primary);
cJSON_AddNumberToObject(ap, "rssi", ap_rec->rssi);
cJSON_AddNumberToObject(ap, "auth", ap_rec->authmode);
char* bssid = network_manager_alloc_get_mac_string(ap_rec->bssid);
if (bssid) {
cJSON_AddItemToObject(ap, "bssid", cJSON_CreateString(STR_OR_BLANK(bssid)));
}
FREE_AND_NULL(bssid);
cJSON_AddNumberToObject(radio, "b", ap_rec->phy_11b ? 1 : 0);
cJSON_AddNumberToObject(radio, "g", ap_rec->phy_11g ? 1 : 0);
cJSON_AddNumberToObject(radio, "n", ap_rec->phy_11n ? 1 : 0);
cJSON_AddNumberToObject(radio, "low_rate", ap_rec->phy_lr ? 1 : 0);
cJSON_AddItemToObject(ap, "radio", radio);
}
cJSON_AddItemToArray(ap_list, ap);
char* ap_json = cJSON_PrintUnformatted(ap);
if (ap_json != NULL) {
ESP_LOGD(TAG, "New access point found: %s", ap_json);
free(ap_json);
}
}
void network_wifi_generate_access_points_json(cJSON** ap_list) {
*ap_list = network_wifi_get_new_array_json(ap_list);
wifi_ap_record_t known_ap;
known_access_point_t* it;
if (*ap_list == NULL)
return;
improv_wifi_list_allocate(ap_num);
for (int i = 0; i < ap_num; i++) {
network_wifi_add_access_point_json(*ap_list, &accessp_records[i]);
improv_wifi_list_add(ap_ssid_string(&accessp_records[i]),accessp_records[i].rssi, accessp_records[i].authmode!=WIFI_AUTH_OPEN);
}
SLIST_FOREACH(it, &s_ap_list, next) {
if (!network_wifi_was_ssid_seen(it->ssid)) {
memset(&known_ap, 0x00, sizeof(known_ap));
strlcpy((char*)known_ap.ssid, it->ssid, sizeof(known_ap.ssid));
ESP_LOGD(TAG, "Adding known access point that is not in range: %s", it->ssid);
network_wifi_add_access_point_json(*ap_list, &known_ap);
}
}
char* ap_list_json = cJSON_PrintUnformatted(*ap_list);
if (ap_list_json != NULL) {
ESP_LOGV(TAG, "Full access point list: %s", ap_list_json);
free(ap_list_json);
}
}
void network_wifi_set_ipv4val(const char* key, char* default_value, ip4_addr_t* target) {
char* value = config_alloc_get_default(NVS_TYPE_STR, key, default_value, 0);
if (value != NULL) {
ESP_LOGD(TAG, "%s: %s", key, value);
inet_pton(AF_INET, value, target); /* access point is on a static IP */
}
FREE_AND_NULL(value);
}
esp_netif_t* network_wifi_config_ap() {
esp_netif_ip_info_t info;
esp_err_t err = ESP_OK;
char* value = NULL;
wifi_config_t ap_config = {
.ap = {
.ssid_len = 0,
},
};
ESP_LOGI(TAG, "Configuring Access Point.");
if (!wifi_ap_netif) {
wifi_ap_netif = esp_netif_create_default_wifi_ap();
}
network_wifi_set_ipv4val("ap_ip_address", DEFAULT_AP_IP, (ip4_addr_t*)&info.ip);
network_wifi_set_ipv4val("ap_ip_gateway", CONFIG_DEFAULT_AP_GATEWAY, (ip4_addr_t*)&info.gw);
network_wifi_set_ipv4val("ap_ip_netmask", CONFIG_DEFAULT_AP_NETMASK, (ip4_addr_t*)&info.netmask);
/* In order to change the IP info structure, we have to first stop
* the DHCP server on the new interface
*/
network_start_stop_dhcps(wifi_ap_netif, false);
ESP_LOGD(TAG, "Setting tcp_ip info for access point");
if ((err = esp_netif_set_ip_info(wifi_ap_netif, &info)) != ESP_OK) {
ESP_LOGE(TAG, "Setting tcp_ip info for interface TCPIP_ADAPTER_IF_AP. Error %s", esp_err_to_name(err));
return wifi_ap_netif;
}
network_start_stop_dhcps(wifi_ap_netif, true);
/*
* Set Access Point configuration
*/
value = config_alloc_get_default(NVS_TYPE_STR, "ap_ssid", CONFIG_DEFAULT_AP_SSID, 0);
if (value != NULL) {
strlcpy((char*)ap_config.ap.ssid, value, sizeof(ap_config.ap.ssid));
ESP_LOGI(TAG, "AP SSID: %s", (char*)ap_config.ap.ssid);
}
FREE_AND_NULL(value);
value = config_alloc_get_default(NVS_TYPE_STR, "ap_pwd", DEFAULT_AP_PASSWORD, 0);
if (value != NULL) {
strlcpy((char*)ap_config.ap.password, value, sizeof(ap_config.ap.password));
ESP_LOGI(TAG, "AP Password: %s", (char*)ap_config.ap.password);
}
FREE_AND_NULL(value);
value = config_alloc_get_default(NVS_TYPE_STR, "ap_channel", STR(CONFIG_DEFAULT_AP_CHANNEL), 0);
if (value != NULL) {
ESP_LOGD(TAG, "Channel: %s", value);
ap_config.ap.channel = atoi(value);
}
FREE_AND_NULL(value);
ap_config.ap.authmode = AP_AUTHMODE;
ap_config.ap.ssid_hidden = DEFAULT_AP_SSID_HIDDEN;
ap_config.ap.max_connection = DEFAULT_AP_MAX_CONNECTIONS;
ap_config.ap.beacon_interval = DEFAULT_AP_BEACON_INTERVAL;
ESP_LOGD(TAG, "Auth Mode: %d", ap_config.ap.authmode);
ESP_LOGD(TAG, "SSID Hidden: %d", ap_config.ap.ssid_hidden);
ESP_LOGD(TAG, "Max Connections: %d", ap_config.ap.max_connection);
ESP_LOGD(TAG, "Beacon interval: %d", ap_config.ap.beacon_interval);
const char* msg = "Setting wifi mode as WIFI_MODE_APSTA";
ESP_LOGD(TAG, "%s", msg);
if ((err = esp_wifi_set_mode(WIFI_MODE_APSTA)) != ESP_OK) {
ESP_LOGE(TAG, "%s. Error %s", msg, esp_err_to_name(err));
return wifi_ap_netif;
}
msg = "Setting wifi AP configuration for WIFI_IF_AP";
ESP_LOGD(TAG, "%s", msg);
if ((err = esp_wifi_set_config(WIFI_IF_AP, &ap_config)) != ESP_OK) /* stop AP DHCP server */
{
ESP_LOGE(TAG, "%s . Error %s", msg, esp_err_to_name(err));
return wifi_ap_netif;
}
msg = "Setting wifi bandwidth";
ESP_LOGD(TAG, "%s (%d)", msg, DEFAULT_AP_BANDWIDTH);
if ((err = esp_wifi_set_bandwidth(WIFI_IF_AP, DEFAULT_AP_BANDWIDTH)) != ESP_OK) /* stop AP DHCP server */
{
ESP_LOGE(TAG, "%s failed. Error %s", msg, esp_err_to_name(err));
return wifi_ap_netif;
}
msg = "Setting wifi power save";
ESP_LOGD(TAG, "%s (%d)", msg, DEFAULT_STA_POWER_SAVE);
if ((err = esp_wifi_set_ps(DEFAULT_STA_POWER_SAVE)) != ESP_OK) /* stop AP DHCP server */
{
ESP_LOGE(TAG, "%s failed. Error %s", msg, esp_err_to_name(err));
return wifi_ap_netif;
}
ESP_LOGD(TAG, "Done configuring Soft Access Point");
return wifi_ap_netif;
}
void network_wifi_filter_unique(wifi_ap_record_t* aplist, uint16_t* aps) {
int total_unique;
wifi_ap_record_t* first_free;
total_unique = *aps;
first_free = NULL;
for (int i = 0; i < *aps - 1; i++) {
wifi_ap_record_t* ap = &aplist[i];
/* skip the previously removed APs */
if (ap->ssid[0] == 0)
continue;
/* remove the identical SSID+authmodes */
for (int j = i + 1; j < *aps; j++) {
wifi_ap_record_t* ap1 = &aplist[j];
if ((strcmp((const char*)ap->ssid, (const char*)ap1->ssid) == 0) &&
(ap->authmode == ap1->authmode)) { /* same SSID, different auth mode is skipped */
/* save the rssi for the display */
if ((ap1->rssi) > (ap->rssi))
ap->rssi = ap1->rssi;
/* clearing the record */
memset(ap1, 0, sizeof(wifi_ap_record_t));
}
}
}
/* reorder the list so APs follow each other in the list */
for (int i = 0; i < *aps; i++) {
wifi_ap_record_t* ap = &aplist[i];
/* skipping all that has no name */
if (ap->ssid[0] == 0) {
/* mark the first free slot */
if (first_free == NULL)
first_free = ap;
total_unique--;
continue;
}
if (first_free != NULL) {
memcpy(first_free, ap, sizeof(wifi_ap_record_t));
memset(ap, 0, sizeof(wifi_ap_record_t));
/* find the next free slot */
for (int j = 0; j < *aps; j++) {
if (aplist[j].ssid[0] == 0) {
first_free = &aplist[j];
break;
}
}
}
}
/* update the length of the list */
*aps = total_unique;
}
char* network_status_alloc_get_ap_list_json() {
return cJSON_PrintUnformatted(accessp_cjson);
}
cJSON* network_manager_clear_ap_list_json(cJSON** old) {
ESP_LOGV(TAG, "network_manager_clear_ap_list_json called");
cJSON* root = network_wifi_get_new_array_json(old);
ESP_LOGV(TAG, "network_manager_clear_ap_list_json done");
return root;
}
esp_err_t network_wifi_built_known_ap_list() {
if (network_status_lock_json_buffer(pdMS_TO_TICKS(1000))) {
ESP_LOGD(TAG,"Building known AP list");
accessp_cjson = network_manager_clear_ap_list_json(&accessp_cjson);
network_wifi_generate_access_points_json(&accessp_cjson);
network_status_unlock_json_buffer();
ESP_LOGD(TAG, "Done building ap JSON list");
} else {
ESP_LOGE(TAG, "Failed to lock json buffer");
return ESP_FAIL;
}
return ESP_OK;
}
esp_err_t wifi_scan_done() {
esp_err_t err = ESP_OK;
/* As input param, it stores max AP number ap_records can hold. As output param, it receives the actual AP number this API returns.
* As a consequence, ap_num MUST be reset to MAX_AP_NUM at every scan */
ESP_LOGD(TAG, "Getting AP list records");
ap_num = MAX_AP_NUM;
if ((err = esp_wifi_scan_get_ap_num(&ap_num)) != ESP_OK) {
ESP_LOGE(TAG, "Failed to retrieve scan results count. Error %s", esp_err_to_name(err));
return err;
}
FREE_AND_NULL(accessp_records);
if (ap_num > 0) {
accessp_records = (wifi_ap_record_t*)malloc_init_external(sizeof(wifi_ap_record_t) * ap_num);
if ((err = esp_wifi_scan_get_ap_records(&ap_num, accessp_records)) != ESP_OK) {
ESP_LOGE(TAG, "Failed to retrieve scan results list. Error %s", esp_err_to_name(err));
return err;
}
/* make sure the http server isn't trying to access the list while it gets refreshed */
ESP_LOGD(TAG, "Preparing to build ap JSON list");
if (network_status_lock_json_buffer(pdMS_TO_TICKS(1000))) {
/* Will remove the duplicate SSIDs from the list and update ap_num */
network_wifi_filter_unique(accessp_records, &ap_num);
network_wifi_set_found_ap();
network_wifi_generate_access_points_json(&accessp_cjson);
network_status_unlock_json_buffer();
ESP_LOGD(TAG, "Done building ap JSON list");
} else {
ESP_LOGE(TAG, "could not get access to json mutex in wifi_scan");
err = ESP_FAIL;
}
} else {
//
ESP_LOGD(TAG, "No AP Found. Emptying the list.");
accessp_cjson = network_wifi_get_new_array_json(&accessp_cjson);
}
return err;
}
bool is_wifi_up() {
return wifi_netif != NULL;
}
esp_err_t network_wifi_start_scan() {
wifi_scan_config_t scan_config = {
.ssid = 0,
.bssid = 0,
.channel = 0,
.scan_type = WIFI_SCAN_TYPE_ACTIVE,
.show_hidden = true};
esp_err_t err = ESP_OK;
ESP_LOGI(TAG, "Initiating wifi network scan");
if (!is_wifi_up()) {
messaging_post_message(MESSAGING_WARNING, MESSAGING_CLASS_SYSTEM, "Wifi not started. Cannot scan");
return ESP_FAIL;
}
/* if a scan is already in progress this message is simply ignored thanks to the WIFI_MANAGER_SCAN_BIT uxBit */
if ((err = esp_wifi_scan_start(&scan_config, false)) != ESP_OK) {
ESP_LOGW(TAG, "Unable to start scan; %s ", esp_err_to_name(err));
// set_status_message(WARNING, "Wifi Connecting. Cannot start scan.");
messaging_post_message(MESSAGING_WARNING, MESSAGING_CLASS_SYSTEM, "Scanning failed: %s", esp_err_to_name(err));
}
return err;
}
bool network_wifi_is_ap_mode() {
wifi_mode_t mode;
/* update config to latest and attempt connection */
return esp_wifi_get_mode(&mode) == ESP_OK && mode == WIFI_MODE_AP;
}
bool network_wifi_is_sta_mode() {
wifi_mode_t mode;
/* update config to latest and attempt connection */
return esp_wifi_get_mode(&mode) == ESP_OK && mode == WIFI_MODE_STA;
}
bool network_wifi_is_ap_sta_mode() {
wifi_mode_t mode;
/* update config to latest and attempt connection */
return esp_wifi_get_mode(&mode) == ESP_OK && mode == WIFI_MODE_APSTA;
}
esp_err_t network_wifi_connect(const char* ssid, const char* password) {
esp_err_t err = ESP_OK;
wifi_config_t config;
memset(&config, 0x00, sizeof(config));
ESP_LOGD(TAG, "network_wifi_connect");
if (!is_wifi_up()) {
messaging_post_message(MESSAGING_WARNING, MESSAGING_CLASS_SYSTEM, "Wifi not started. Cannot connect");
network_wifi_set_connect_state(NETWORK_WIFI_STATE_DOWN);
return ESP_FAIL;
}
if (!ssid || !password || strlen(ssid) == 0) {
ESP_LOGE(TAG, "Cannot connect wifi. wifi config is null!");
network_wifi_set_connect_state(NETWORK_WIFI_STATE_INVALID_CONFIG);
return ESP_ERR_INVALID_ARG;
}
wifi_mode_t wifi_mode;
err = esp_wifi_get_mode(&wifi_mode);
if (err == ESP_ERR_WIFI_NOT_INIT) {
ESP_LOGW(TAG, "Wifi not initialized. Attempting to start sta mode");
network_wifi_start();
} else if (err != ESP_OK) {
ESP_LOGE(TAG, "Could not retrieve wifi mode : %s", esp_err_to_name(err));
} else if (wifi_mode != WIFI_MODE_STA && wifi_mode != WIFI_MODE_APSTA) {
ESP_LOGD(TAG, "Changing wifi mode to STA");
err = network_wifi_set_sta_mode();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Could not set mode to STA. Cannot connect to SSID %s", ssid);
return err;
}
}
// copy configuration and connect
strlcpy((char*)config.sta.ssid, ssid, sizeof(config.sta.ssid));
if (password) {
strlcpy((char*)config.sta.password, password, sizeof(config.sta.password));
}
// First Disconnect
esp_wifi_disconnect();
config.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
if ((err = esp_wifi_set_config(WIFI_IF_STA, &config)) != ESP_OK) {
network_wifi_set_connect_state(NETWORK_WIFI_STATE_FAILED);
ESP_LOGE(TAG, "Failed to set STA configuration. Error %s", esp_err_to_name(err));
}
if (err == ESP_OK) {
ESP_LOGI(TAG, "Wifi Connecting to %s...", ssid);
if ((err = esp_wifi_connect()) != ESP_OK) {
ESP_LOGE(TAG, "Failed to initiate wifi connection. Error %s", esp_err_to_name(err));
network_wifi_set_connect_state(NETWORK_WIFI_STATE_FAILED);
}
else{
network_wifi_set_connect_state(NETWORK_WIFI_STATE_CONNECTING);
}
}
return err;
}
esp_err_t network_wifi_connect_next_in_range(){
const char * ssid = network_wifi_get_next_ap_in_range();
if(ssid){
return network_wifi_connect_ssid(ssid);
}
return ESP_FAIL;
}
esp_err_t network_wifi_connect_ssid(const char* ssid) {
known_access_point_t* item = network_wifi_get_ap_entry(ssid);
if (item) {
item->last_try = (esp_timer_get_time() / 1000);
return network_wifi_connect(item->ssid, item->password);
}
return ESP_FAIL;
}
esp_err_t network_wifi_connect_active_ssid() {
const wifi_sta_config_t* config = network_wifi_load_active_config();
if (config) {
return network_wifi_connect(ssid_string(config), password_string(config));
}
return ESP_FAIL;
}
void network_wifi_clear_config() {
/* erase configuration */
const wifi_sta_config_t* sta = network_wifi_get_active_config();
network_wifi_delete_ap(ssid_string(sta));
esp_err_t err = ESP_OK;
if ((err = esp_wifi_disconnect()) != ESP_OK) {
ESP_LOGW(TAG, "Could not disconnect from deleted network : %s", esp_err_to_name(err));
}
}
char* get_disconnect_code_desc(uint8_t reason) {
switch (reason) {
ENUM_TO_STRING(WIFI_REASON_UNSPECIFIED);
ENUM_TO_STRING(WIFI_REASON_AUTH_EXPIRE);
ENUM_TO_STRING(WIFI_REASON_AUTH_LEAVE);
ENUM_TO_STRING(WIFI_REASON_ASSOC_EXPIRE);
ENUM_TO_STRING(WIFI_REASON_ASSOC_TOOMANY);
ENUM_TO_STRING(WIFI_REASON_NOT_AUTHED);
ENUM_TO_STRING(WIFI_REASON_NOT_ASSOCED);
ENUM_TO_STRING(WIFI_REASON_ASSOC_LEAVE);
ENUM_TO_STRING(WIFI_REASON_ASSOC_NOT_AUTHED);
ENUM_TO_STRING(WIFI_REASON_DISASSOC_PWRCAP_BAD);
ENUM_TO_STRING(WIFI_REASON_DISASSOC_SUPCHAN_BAD);
ENUM_TO_STRING(WIFI_REASON_IE_INVALID);
ENUM_TO_STRING(WIFI_REASON_MIC_FAILURE);
ENUM_TO_STRING(WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT);
ENUM_TO_STRING(WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT);
ENUM_TO_STRING(WIFI_REASON_IE_IN_4WAY_DIFFERS);
ENUM_TO_STRING(WIFI_REASON_GROUP_CIPHER_INVALID);
ENUM_TO_STRING(WIFI_REASON_PAIRWISE_CIPHER_INVALID);
ENUM_TO_STRING(WIFI_REASON_AKMP_INVALID);
ENUM_TO_STRING(WIFI_REASON_UNSUPP_RSN_IE_VERSION);
ENUM_TO_STRING(WIFI_REASON_INVALID_RSN_IE_CAP);
ENUM_TO_STRING(WIFI_REASON_802_1X_AUTH_FAILED);
ENUM_TO_STRING(WIFI_REASON_CIPHER_SUITE_REJECTED);
ENUM_TO_STRING(WIFI_REASON_INVALID_PMKID);
ENUM_TO_STRING(WIFI_REASON_BEACON_TIMEOUT);
ENUM_TO_STRING(WIFI_REASON_NO_AP_FOUND);
ENUM_TO_STRING(WIFI_REASON_AUTH_FAIL);
ENUM_TO_STRING(WIFI_REASON_ASSOC_FAIL);
ENUM_TO_STRING(WIFI_REASON_HANDSHAKE_TIMEOUT);
ENUM_TO_STRING(WIFI_REASON_CONNECTION_FAIL);
ENUM_TO_STRING(WIFI_REASON_AP_TSF_RESET);
ENUM_TO_STRING(WIFI_REASON_ROAMING);
}
return "";
}
Reference in New Issue View Git Blame Copy Permalink