kerms
/
wireless-proxy-esp32
0
0
Fork 0
Code

feat(wifi) static IP/DNS

This commit is contained in:
kerms 2024-07-15 10:30:29 +08:00
parent c3f4e8f651
commit 22889936ab
10 changed files with 304 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
project_components/wifi_manager/wifi_api.c
View File

@ -6,7 +6,8 @@
void wifi_api_sta_get_ap_info(wifi_api_ap_info_t *ap_info)
{
wifi_ap_record_t ap_record;
wifi_ap_record_t ap_record = {0};
int err;
esp_wifi_sta_get_ap_info(&ap_record);
strncpy(ap_info->ssid, (char *)ap_record.ssid, sizeof(ap_info->ssid));
strncpy(ap_info->mac, (char *)ap_record.bssid, sizeof(ap_info->mac));
@ -19,6 +20,23 @@ void wifi_api_sta_get_ap_info(wifi_api_ap_info_t *ap_info)
ip4_addr_set(&ap_info->ip, &ip_info.ip);
ip4_addr_set(&ap_info->gateway, &ip_info.gw);
ip4_addr_set(&ap_info->netmask, &ip_info.netmask);
esp_netif_dns_info_t dns_info;
err = esp_netif_get_dns_info(wifi_manager_get_sta_netif(),
ESP_NETIF_DNS_MAIN, &dns_info);
if (err) {
ap_info->dns_main.addr = ap_info->gateway.addr;
} else {
ap_info->dns_main.addr = dns_info.ip.u_addr.ip4.addr;
}
err = esp_netif_get_dns_info(wifi_manager_get_sta_netif(),
ESP_NETIF_DNS_BACKUP, &dns_info);
if (err) {
ap_info->dns_backup.addr = ap_info->gateway.addr;
} else {
ap_info->dns_backup.addr = dns_info.ip.u_addr.ip4.addr;
}
}
void wifi_api_ap_get_info(wifi_api_ap_info_t *ap_info)
@ -37,6 +55,23 @@ void wifi_api_ap_get_info(wifi_api_ap_info_t *ap_info)
IP4_ADDR_EXPAND(&ap_info->gateway, WIFI_DEFAULT_AP_GATEWAY);
IP4_ADDR_EXPAND(&ap_info->netmask, WIFI_DEFAULT_AP_NETMASK);
ap_info->rssi = 0;
esp_netif_dns_info_t dns_info;
err = esp_netif_get_dns_info(wifi_manager_get_ap_netif(),
ESP_NETIF_DNS_MAIN, &dns_info);
if (err) {
ap_info->dns_main.addr = ap_info->gateway.addr;
} else {
ap_info->dns_main.addr = dns_info.ip.u_addr.ip4.addr;
}
err = esp_netif_get_dns_info(wifi_manager_get_ap_netif(),
ESP_NETIF_DNS_BACKUP, &dns_info);
if (err) {
ap_info->dns_backup.addr = ap_info->gateway.addr;
} else {
ap_info->dns_backup.addr = dns_info.ip.u_addr.ip4.addr;
}
}
static int rssi_comp(const void *a, const void *b)
@ -103,3 +138,13 @@ int wifi_api_disconnect(void)
{
return wifi_manager_disconnect();
}
int wifi_api_sta_set_static_conf(wifi_api_sta_ap_static_info_t *static_info)
{
int err = wifi_manager_sta_set_static_conf(static_info);
if (err) {
return err;
}
return wifi_data_save_static(static_info);
}

16
project_components/wifi_manager/wifi_api.h
View File

@ -15,6 +15,8 @@ typedef enum wifi_api_json_cmd_t {
WIFI_API_JSON_GET_MODE = 6, /* req:{ }, ret:{mode, [delay_off], [delay_on]} */
WIFI_API_JSON_SET_MODE = 7, /* req:{mode, [delay_off], [delay_on]} */
WIFI_API_JSON_SET_AP_CRED = 8, /* ssid[32] + password[64] */
WIFI_API_JSON_STA_GET_STATIC_INFO = 9,
WIFI_API_JSON_STA_SET_STATIC_CONF = 10, /* static_ip_en: 0/1, static_dns_en: 0/1 */
} wifi_api_json_cmd_t;
typedef struct wifi_api_ap_info_t {
@ -25,6 +27,8 @@ typedef struct wifi_api_ap_info_t {
char password[64+1];
char mac[6];
signed char rssi;
ip4_addr_t dns_main;
ip4_addr_t dns_backup;
} wifi_api_ap_info_t;
typedef struct wifi_api_ap_scan_info_t {
@ -36,6 +40,16 @@ typedef struct wifi_api_ap_scan_info_t {
signed char rssi;
} wifi_api_ap_scan_info_t;
typedef struct wifi_api_sta_ap_static_info_t {
ip4_addr_t ip;
ip4_addr_t gateway;
ip4_addr_t netmask;
ip4_addr_t dns_main;
ip4_addr_t dns_backup;
uint8_t static_ip_en;
uint8_t static_dns_en;
} wifi_api_sta_ap_static_info_t;
typedef enum wifi_apsta_mode_e {
/* permanent */
WIFI_AP_AUTO_STA_ON = 0,
@ -66,5 +80,7 @@ int wifi_api_connect(const char *ssid, const char *password);
int wifi_api_disconnect(void);
int wifi_api_sta_set_static_conf(wifi_api_sta_ap_static_info_t *static_info);
#endif //WIFI_API_H_GUARD

33
project_components/wifi_manager/wifi_api_json.c
View File

@ -24,6 +24,8 @@ static int wifi_api_json_set_mode(api_json_req_t *req);
static int wifi_api_json_get_mode(api_json_req_t *req);
static int wifi_api_json_set_ap_cred(api_json_req_t *req);
static int wifi_api_json_sta_get_static_info(api_json_req_t *req);
static int wifi_api_json_sta_set_static_conf(api_json_req_t *req);
/* the upper caller call cb() with void *, this let us use custom function arg */
static int async_helper_cb(void *arg)
@ -64,6 +66,10 @@ static int on_json_req(uint16_t cmd, api_json_req_t *req, api_json_module_async_
return wifi_api_json_set_mode(req);
case WIFI_API_JSON_SET_AP_CRED:
return wifi_api_json_set_ap_cred(req);
case WIFI_API_JSON_STA_GET_STATIC_INFO:
return wifi_api_json_sta_get_static_info(req);
case WIFI_API_JSON_STA_SET_STATIC_CONF:
return wifi_api_json_sta_set_static_conf(req);
}
ESP_LOGI(TAG, "cmd %d not executed\n", cmd);
@ -222,3 +228,30 @@ int wifi_api_json_set_ap_cred(api_json_req_t *req)
wifi_manager_set_ap_credential(&credential);
return 0;
}
int wifi_api_json_sta_get_static_info(api_json_req_t *req)
{
wifi_api_sta_ap_static_info_t static_info = {0};
int err = wifi_data_get_static(&static_info);
if (err) {
return API_JSON_INTERNAL_ERR;
}
req->out = wifi_api_json_ser_static_info(&static_info);
return API_JSON_OK;
}
int wifi_api_json_sta_set_static_conf(api_json_req_t *req)
{
wifi_api_sta_ap_static_info_t static_info = {0};
int err;
wifi_data_get_static(&static_info);
err = wifi_api_json_deser_static_conf(req->in, &static_info);
if (err) {
return API_JSON_PROPERTY_ERR;
}
wifi_api_sta_set_static_conf(&static_info);
return API_JSON_OK;
}

57
project_components/wifi_manager/wifi_json_utils.c
View File

@ -19,6 +19,8 @@ cJSON *wifi_api_json_serialize_ap_info(wifi_api_ap_info_t *ap_info, wifi_api_jso
cJSON_AddStringToObject(root, "ip", ip4addr_ntoa(&ap_info->ip));
cJSON_AddStringToObject(root, "gateway", ip4addr_ntoa(&ap_info->gateway));
cJSON_AddStringToObject(root, "netmask", ip4addr_ntoa(&ap_info->netmask));
cJSON_AddStringToObject(root, "dns_main", ip4addr_ntoa(&ap_info->dns_main));
cJSON_AddStringToObject(root, "dns_backup", ip4addr_ntoa(&ap_info->dns_backup));
cJSON_AddNumberToObject(root, "rssi", ap_info->rssi);
cJSON_AddStringToObject(root, "ssid", ap_info->ssid);
if (ap_info->password[0]) {
@ -130,3 +132,58 @@ int wifi_api_json_get_credential(cJSON *root, char *ssid, char *password)
password[64] = '\0';
return 0;
}
cJSON *wifi_api_json_ser_static_info(wifi_api_sta_ap_static_info_t *info)
{
cJSON *root;
root = cJSON_CreateObject();
wifi_api_json_set_header(root, WIFI_API_JSON_STA_GET_STATIC_INFO);
cJSON_AddNumberToObject(root, "static_ip_en", info->static_ip_en);
cJSON_AddNumberToObject(root, "static_dns_en", info->static_dns_en);
cJSON_AddStringToObject(root, "ip", ip4addr_ntoa(&info->ip));
cJSON_AddStringToObject(root, "gateway", ip4addr_ntoa(&info->gateway));
cJSON_AddStringToObject(root, "netmask", ip4addr_ntoa(&info->netmask));
cJSON_AddStringToObject(root, "dns_main", ip4addr_ntoa(&info->dns_main));
cJSON_AddStringToObject(root, "dns_backup", ip4addr_ntoa(&info->dns_backup));
return root;
}
int wifi_api_json_deser_static_conf(cJSON *root, wifi_api_sta_ap_static_info_t *static_info)
{
cJSON *static_ip_en = cJSON_GetObjectItemCaseSensitive(root, "static_ip_en");
cJSON *static_dns_en = cJSON_GetObjectItemCaseSensitive(root, "static_dns_en");
if (!cJSON_IsNumber(static_ip_en) || !cJSON_IsNumber(static_dns_en)) {
printf("en error\n");
return 1;
}
static_info->static_dns_en = static_dns_en->valueint;
static_info->static_ip_en = static_ip_en->valueint;
cJSON *ip = cJSON_GetObjectItemCaseSensitive(root, "ip");
cJSON *gateway = cJSON_GetObjectItemCaseSensitive(root, "gateway");
cJSON *netmask = cJSON_GetObjectItemCaseSensitive(root, "netmask");
cJSON *dns_main = cJSON_GetObjectItemCaseSensitive(root, "dns_main");
cJSON *dns_backup = cJSON_GetObjectItemCaseSensitive(root, "dns_backup");
if (cJSON_IsString(ip)) {
ip4addr_aton(ip->valuestring, &static_info->ip);
}
if (cJSON_IsString(gateway)) {
ip4addr_aton(gateway->valuestring, &static_info->gateway);
}
if (cJSON_IsString(netmask)) {
ip4addr_aton(netmask->valuestring, &static_info->netmask);
}
if (cJSON_IsString(dns_main)) {
ip4addr_aton(dns_main->valuestring, &static_info->dns_main);
}
if (cJSON_IsString(dns_backup)) {
ip4addr_aton(dns_backup->valuestring, &static_info->dns_backup);
}
return 0;
}

3
project_components/wifi_manager/wifi_json_utils.h
View File

@ -14,5 +14,8 @@ cJSON *wifi_api_json_create_err_rsp(cJSON *req, const char *msg);
cJSON *wifi_api_json_add_int_item(cJSON *root, const char *name, int item);
int wifi_api_json_utils_get_int(cJSON *req, const char *name, int *out_value);
int wifi_api_json_get_credential(cJSON *root, char *ssid, char *password);
cJSON *wifi_api_json_ser_static_info(wifi_api_sta_ap_static_info_t *info);
int wifi_api_json_deser_static_conf(cJSON *root, wifi_api_sta_ap_static_info_t *static_info);
#endif //WIFI_JSON_UTILS_H_GUARD

72
project_components/wifi_manager/wifi_manager.c
View File

@ -66,8 +66,7 @@ static void set_sta_cred(const char *ssid, const char *password);
static void disconn_handler(void);
static int set_default_sta_cred(void);
static int set_wifi_mode(wifi_apsta_mode_e mode);
static void handle_wifi_connected();
static void handle_wifi_connected(); /* got IP */
static void wifi_led_init();
static void wifi_led_set_blink();
@ -101,12 +100,15 @@ void wifi_manager_init(void)
ctx.try_connect_count = 0;
err = wifi_data_get_wifi_mode(&ctx.permanent_mode);
ESP_LOGI(TAG, "use wifi mode: %d", ctx.permanent_mode);
if (err) {
ESP_LOGI(TAG, "use default mode: %d", ctx.permanent_mode);
ctx.permanent_mode = WIFI_AP_AUTO_STA_ON;
ctx.mode = WIFI_MODE_APSTA;
} else {
ctx.mode = ctx.permanent_mode & 0x3; /* 0b1XX */
if (ctx.mode == WIFI_MODE_STA || ctx.mode == WIFI_MODE_NULL) {
ctx.mode = WIFI_MODE_APSTA;
}
}
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
@ -128,6 +130,12 @@ void wifi_manager_init(void)
ctx.do_fast_connect = 1;
}
wifi_api_sta_ap_static_info_t static_info;
err = wifi_data_get_static(&static_info);
if (err == ESP_OK) {
wifi_manager_sta_set_static_conf(&static_info);
}
/* TODO: Read from nvs */
esp_netif_ip_info_t ip_info;
IP4_ADDR_EXPAND(&ip_info.ip, WIFI_DEFAULT_AP_IP);
@ -395,6 +403,9 @@ int wifi_manager_change_mode(wifi_apsta_mode_e mode)
xSemaphoreGive(ctx.lock);
if (err)
return err;
if (mode >= WIFI_AP_STOP){
return ESP_OK;
}
return wifi_data_save_wifi_mode(mode);
}
@ -450,6 +461,7 @@ int set_wifi_mode(wifi_apsta_mode_e mode)
/* AP -> APSTA */
if (!(ctx.mode & WIFI_MODE_STA) && (new_mode & WIFI_MODE_STA)) {
printf("set mode reco\n");
xSemaphoreGive(ctx.lock);
disconn_handler();
}
ctx.mode = new_mode;
@ -468,14 +480,17 @@ static void set_sta_cred(const char *ssid, const char *password)
memcpy((char *)wifi_config.sta.ssid, ssid, 32);
memcpy((char *)wifi_config.sta.password, password, 64);
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
int err = esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
if (err) {
ESP_LOGE(TAG, "%s", esp_err_to_name(err));
}
}
static void delayed_set_ap_stop(void *arg)
{
uint32_t ret = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(10000));
uint32_t ret = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(30000));
xSemaphoreTake(ctx.lock, pdMS_TO_TICKS(10000));
/* timeout: connected to STA without disconnection for 10 sec: close AP */
/* timeout: connected to STA without disconnection: close AP */
if (ret == 0) {
set_wifi_mode(WIFI_AP_STOP);
ctx.try_connect_count = 0;
@ -640,12 +655,55 @@ int wifi_manager_get_mode(wifi_apsta_mode_e *mode, wifi_mode_t *status)
int wifi_manager_set_ap_credential(wifi_credential_t *cred)
{
wifi_config_t ap_config = {0};
wifi_mode_t mode;
strncpy((char *)ap_config.ap.ssid, cred->ssid, 32);
strncpy((char *)ap_config.ap.password, cred->password, 64);
ap_config.ap.authmode = WIFI_AUTH_WPA2_WPA3_PSK;
ap_config.ap.max_connection = 4;
ap_config.ap.channel = 6;
ap_config.ap.ssid_hidden = 0;
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap_config));
if (esp_wifi_get_mode(&mode)) {
return 1;
}
if (mode & WIFI_MODE_AP) {
int err = esp_wifi_set_config(WIFI_IF_AP, &ap_config);
if (err) {
ESP_LOGE(TAG, "ap conf %s", esp_err_to_name(err));
}
}
return 0;
}
int wifi_manager_sta_set_static_conf(wifi_api_sta_ap_static_info_t *static_info)
{
if (static_info->static_ip_en) {
esp_netif_ip_info_t ip_info;
ip_info.ip.addr = static_info->ip.addr;
ip_info.gw.addr = static_info->gateway.addr;
ip_info.netmask.addr = static_info->netmask.addr;
esp_netif_dhcpc_stop(wifi_manager_get_sta_netif());
esp_netif_set_ip_info(wifi_manager_get_sta_netif(), &ip_info);
} else {
esp_netif_dhcpc_start(wifi_manager_get_sta_netif());
}
if (static_info->static_dns_en) {
esp_netif_dns_info_t dns_info;
dns_info.ip.type = ESP_IPADDR_TYPE_V4;
dns_info.ip.u_addr.ip4.addr = static_info->dns_main.addr;
esp_netif_set_dns_info(wifi_manager_get_sta_netif(), ESP_NETIF_DNS_MAIN, &dns_info);
dns_info.ip.u_addr.ip4.addr = static_info->dns_backup.addr;
esp_netif_set_dns_info(wifi_manager_get_sta_netif(), ESP_NETIF_DNS_BACKUP, &dns_info);
} else {
esp_netif_ip_info_t ip_info;
esp_netif_dns_info_t dns_info;
dns_info.ip.type = ESP_IPADDR_TYPE_V4;
esp_netif_get_ip_info(wifi_manager_get_sta_netif(), &ip_info);
dns_info.ip.u_addr.ip4.addr = ip_info.gw.addr;
dns_info.ip.type = ESP_NETIF_DNS_MAIN;
esp_netif_set_dns_info(wifi_manager_get_sta_netif(), ESP_NETIF_DNS_MAIN, &dns_info);
}
return 0;
}

1
project_components/wifi_manager/wifi_manager.h
View File

@ -20,6 +20,7 @@ int wifi_manager_get_mode(wifi_apsta_mode_e *mode, wifi_mode_t *status);
int wifi_manager_get_ap_auto_delay(int *ap_on_delay, int *ap_off_delay);
int wifi_manager_set_ap_auto_delay(int *ap_on_delay, int *ap_off_delay);
int wifi_manager_set_ap_credential(wifi_credential_t *cred);
int wifi_manager_sta_set_static_conf(wifi_api_sta_ap_static_info_t *static_info);
#endif //WIFI_MANAGER_H_GUARD

96
project_components/wifi_manager/wifi_storage.c
View File

@ -15,22 +15,27 @@ int wifi_data_get_sta_last_conn_cred(wifi_credential_t *ap_credential)
err = wt_nvs_open(WIFI_NVS_NAMESPACE, &handle);
if (err) {
return WT_NVS_ERR;
return err;
}
err = wt_nvs_get(handle, KEY_WIFI_STA_AP_BITMAP, &ap_bitmap, sizeof(ap_bitmap));
if (err || ap_bitmap == 0) {
return WT_NVS_ERR_NOT_FOUND;
if (err) {
goto end;
}
if (ap_bitmap == 0) {
err = WT_NVS_ERR_NOT_FOUND;
goto end;
}
err = wt_nvs_get(handle, KEY_WIFI_STA_LAST_AP_CRED,
ap_credential, sizeof(wifi_credential_t));
ap_credential, sizeof(wifi_credential_t));
if (err) {
return WT_NVS_ERR;
goto end;
}
end:
wt_nvs_close(handle);
return WT_NVS_OK;
return err;
}
/*
@ -50,7 +55,7 @@ int wifi_data_save_sta_ap_credential(wifi_credential_t *ap_credential)
err = wt_nvs_get(handle, KEY_WIFI_STA_AP_BITMAP, &ap_bitmap, sizeof(ap_bitmap));
if (err) {
if (err != ESP_ERR_NVS_NOT_FOUND) {
return err;
goto end;
}
ap_bitmap = 0;
}
@ -64,17 +69,18 @@ int wifi_data_save_sta_ap_credential(wifi_credential_t *ap_credential)
err = wt_nvs_get(handle, KEY_WIFI_STA_LAST_AP_CRED, &credential, sizeof(ap_bitmap));
if (err) {
if (err != ESP_ERR_NVS_NOT_FOUND) {
return err;
goto end;
}
}
err = wt_nvs_set(handle, KEY_WIFI_STA_LAST_AP_CRED, ap_credential, sizeof(wifi_credential_t));
if (err) {
return err;
goto end;
}
end:
wt_nvs_close(handle);
return WT_NVS_OK;
return err;
}
int wifi_data_save_wifi_mode(wifi_apsta_mode_e mode)
@ -90,12 +96,9 @@ int wifi_data_save_wifi_mode(wifi_apsta_mode_e mode)
}
err = wt_nvs_set(handle, KEY_WIFI_APSTA_MODE, &mode_u8, sizeof(mode_u8));
if (err) {
return err;
}
wt_nvs_close(handle);
return WT_NVS_OK;
return err;
}
int wifi_data_get_wifi_mode(wifi_apsta_mode_e *mode)
@ -111,13 +114,10 @@ int wifi_data_get_wifi_mode(wifi_apsta_mode_e *mode)
}
err = wt_nvs_get(handle, KEY_WIFI_APSTA_MODE, &mode_u8, sizeof(mode_u8));
if (err) {
return err;
}
*mode = mode_u8;
wt_nvs_close(handle);
return WT_NVS_OK;
return err;
}
int wifi_data_save_ap_credential(wifi_credential_t *ap_credential)
@ -131,12 +131,9 @@ int wifi_data_save_ap_credential(wifi_credential_t *ap_credential)
}
err = wt_nvs_set(handle, KEY_WIFI_AP_CRED, ap_credential, sizeof(wifi_credential_t));
if (err) {
return err;
}
wt_nvs_close(handle);
return 0;
return err;
}
int wifi_data_get_ap_credential(wifi_credential_t *ap_credential)
@ -150,10 +147,63 @@ int wifi_data_get_ap_credential(wifi_credential_t *ap_credential)
}
err = wt_nvs_get(handle, KEY_WIFI_AP_CRED, ap_credential, sizeof(wifi_credential_t));
wt_nvs_close(handle);
return err;
}
int wifi_data_get_static(wifi_api_sta_ap_static_info_t *static_info)
{
nvs_handle_t handle;
int err;
err = wt_nvs_open(WIFI_NVS_NAMESPACE, &handle);
if (err) {
return err;
}
err = wt_nvs_get(handle, KEY_WIFI_STA_STATIC_BASE,
static_info, sizeof(wifi_api_sta_ap_static_info_t));
if (err == ESP_ERR_NVS_NOT_FOUND) {
static_info->static_ip_en = 0;
static_info->static_dns_en = 0;
err = ESP_OK;
} else if (err) {
printf("err %d\n", err);
goto end;
}
if (static_info->static_ip_en > 1) {
static_info->static_ip_en = 0;
}
if (static_info->static_dns_en > 1) {
static_info->static_dns_en = 0;
}
end:
wt_nvs_close(handle);
return 0;
return err;
}
int wifi_data_save_static(wifi_api_sta_ap_static_info_t *static_info)
{
nvs_handle_t handle;
int err;
err = wt_nvs_open(WIFI_NVS_NAMESPACE, &handle);
if (err) {
return err;
}
err = wt_nvs_set(handle, KEY_WIFI_STA_STATIC_BASE,
static_info, sizeof(wifi_api_sta_ap_static_info_t));
if (err) {
goto end;
}
printf("static info saved\n");
end:
wt_nvs_close(handle);
return err;
}

5
project_components/wifi_manager/wifi_storage.h
View File

@ -21,4 +21,9 @@ int wifi_data_get_ap_credential(wifi_credential_t *ap_credential);
int wifi_data_save_ap_credential(wifi_credential_t *ap_credential);
int wifi_data_get_static(wifi_api_sta_ap_static_info_t *static_info);
int wifi_data_save_static(wifi_api_sta_ap_static_info_t *static_info);
#endif //WIFI_STORAGE_H_GUARD

11
project_components/wifi_manager/wifi_storage_priv.h
View File

@ -15,18 +15,17 @@ typedef enum wt_wifi_key_enum {
/* TODO: should have 1 for each AP */
KEY_WIFI_STA_USE_STATIC = 0x03, /* bit[0:31]=[IP, MASK, GATEWAY, DNS] */
KEY_WIFI_STA_STATIC_IP = 0x04, /* 4B */
KEY_WIFI_STA_STATIC_MASK = 0x05, /* 4B */
KEY_WIFI_STA_STATIC_GATEWAY = 0x06, /* 4B */
KEY_WIFI_STA_STATIC_DNS = 0x07, /* 4B */
KEY_WIFI_STA_USE_STATIC = 0x03, /* bit[0:31]=[IP, MASK, GATEWAY, DNS_MAIN, DNS_BACK] */
/* STA information */
KEY_WIFI_STA_LAST_AP_CRED = 0x08, /*!< ssid[32] + password[64] */
KEY_WIFI_STA_AP_BITMAP = 0x09, /* 32 bit */
KEY_WIFI_STA_STATIC_BASE = 0x10, /* [IP:4B, MASK:4B, GW:4B, DNS1:4B, DNS2:4B] = 20B */
KEY_WIFI_STA_STATIC_LAST = 0x1F, /* [IP:4B, MASK:4B, GW:4B, DNS1:4B, DNS2:4B] */
KEY_WIFI_APSTA_MODE = 0xFF, /* 1B */
KEY_UNUSED_100 = 0x0100, /* avoid: same as 0x1 */
KEY_WIFI_APSTA_MODE = 0x0101, /* 1B */
} wt_wifi_key;
#endif //WIFI_STORAGE_PRIV_H_GUARD