10#include <esp_system.h>
12#include <esp_wifi_types.h>
13#include <freertos/FreeRTOS.h>
14#include <freertos/event_groups.h>
15#include <freertos/task.h>
21#ifdef USE_WIFI_WPA2_EAP
22#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
23#include <esp_eap_client.h>
34#include "dhcpserver/dhcpserver.h"
37#ifdef USE_CAPTIVE_PORTAL
41#include "lwip/apps/sntp.h"
44#if USE_NETWORK_IPV6 || defined(USE_WIFI_LEASE_CACHE)
45#include <esp_netif_net_stack.h>
46#include "lwip/netif.h"
48#ifdef USE_WIFI_LEASE_CACHE
49#include <esp_rtc_time.h>
63static EventGroupHandle_t s_wifi_event_group;
68static bool s_sta_connected =
false;
69static bool s_sta_connect_not_found =
false;
70static bool s_sta_connect_error =
false;
71static bool s_sta_connecting =
false;
72static bool s_wifi_started =
false;
74static ExpectedDisconnect s_expected_disconnect;
79static void copy_terminated(
char *dst,
const uint8_t *
src,
size_t len) {
86 esp_event_base_t event_base;
89 wifi_event_sta_scan_done_t sta_scan_done;
90 wifi_event_sta_connected_t sta_connected;
91 wifi_event_sta_disconnected_t sta_disconnected;
92 wifi_event_sta_authmode_change_t sta_authmode_change;
93 wifi_event_ap_staconnected_t ap_staconnected;
94 wifi_event_ap_stadisconnected_t ap_stadisconnected;
95 wifi_event_ap_probe_req_rx_t ap_probe_req_rx;
96 wifi_event_bss_rssi_low_t bss_rssi_low;
98 SavedWifiSettings *dpp_credentials;
99 wifi_event_dpp_failed_t dpp_failed;
101 ip_event_got_ip_t ip_got_ip;
103 ip_event_got_ip6_t ip_got_ip6;
105#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
106 ip_event_assigned_ip_to_client_t ip_assigned_ip_to_client;
108 ip_event_ap_staipassigned_t ip_ap_staipassigned;
115void event_handler(
void *arg, esp_event_base_t event_base, int32_t
event_id,
void *event_data) {
117 memset(&event, 0,
sizeof(IDFWiFiEvent));
118 event.event_base = event_base;
120 if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_STA_START) {
122 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_STA_STOP) {
124 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) {
125 memcpy(&event.data.sta_authmode_change, event_data,
sizeof(wifi_event_sta_authmode_change_t));
126 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_STA_CONNECTED) {
127 memcpy(&event.data.sta_connected, event_data,
sizeof(wifi_event_sta_connected_t));
128 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_STA_DISCONNECTED) {
129 memcpy(&event.data.sta_disconnected, event_data,
sizeof(wifi_event_sta_disconnected_t));
130 }
else if (event_base == IP_EVENT &&
event_id == IP_EVENT_STA_GOT_IP) {
131 memcpy(&event.data.ip_got_ip, event_data,
sizeof(ip_event_got_ip_t));
133 }
else if (event_base == IP_EVENT &&
event_id == IP_EVENT_GOT_IP6) {
134 memcpy(&event.data.ip_got_ip6, event_data,
sizeof(ip_event_got_ip6_t));
136#if defined(USE_WIFI_AP_WISP) && !defined(USE_WIFI_AP_WISP_STATIC_DNS)
137 }
else if (event_base == IP_EVENT &&
141 }
else if (event_base == IP_EVENT &&
event_id == IP_EVENT_STA_LOST_IP) {
143 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_SCAN_DONE) {
144 memcpy(&event.data.sta_scan_done, event_data,
sizeof(wifi_event_sta_scan_done_t));
145 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_AP_START) {
147 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_AP_STOP) {
149 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_AP_PROBEREQRECVED) {
150 memcpy(&event.data.ap_probe_req_rx, event_data,
sizeof(wifi_event_ap_probe_req_rx_t));
151 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_AP_STACONNECTED) {
152 memcpy(&event.data.ap_staconnected, event_data,
sizeof(wifi_event_ap_staconnected_t));
153 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_AP_STADISCONNECTED) {
154 memcpy(&event.data.ap_stadisconnected, event_data,
sizeof(wifi_event_ap_stadisconnected_t));
156 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_DPP_URI_READY) {
158 const auto *uri =
static_cast<const wifi_event_dpp_uri_ready_t *
>(event_data);
159 const size_t len = strnlen(uri->uri, uri->uri_data_len);
160 auto copy = std::make_unique<char[]>(
len + 1);
161 copy_terminated(copy.get(),
reinterpret_cast<const uint8_t *
>(uri->uri),
len);
163 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_DPP_CFG_RECVD) {
164 const auto &sta =
static_cast<const wifi_event_dpp_config_received_t *
>(event_data)->wifi_cfg.sta;
165 auto *credentials =
new SavedWifiSettings;
166 copy_terminated(credentials->ssid, sta.ssid,
sizeof(sta.ssid));
167 copy_terminated(credentials->password, sta.password,
sizeof(sta.password));
168 event.data.dpp_credentials = credentials;
169 }
else if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_DPP_FAILED) {
170 memcpy(&event.data.dpp_failed, event_data,
sizeof(wifi_event_dpp_failed_t));
172#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
173 }
else if (event_base == IP_EVENT &&
event_id == IP_EVENT_ASSIGNED_IP_TO_CLIENT) {
174 memcpy(&event.data.ip_assigned_ip_to_client, event_data,
sizeof(ip_event_assigned_ip_to_client_t));
176 }
else if (event_base == IP_EVENT &&
event_id == IP_EVENT_AP_STAIPASSIGNED) {
177 memcpy(&event.data.ip_ap_staipassigned, event_data,
sizeof(ip_event_ap_staipassigned_t));
185 auto *to_send =
new IDFWiFiEvent;
186 memcpy(to_send, &event,
sizeof(IDFWiFiEvent));
189 if (event_base == WIFI_EVENT &&
event_id == WIFI_EVENT_DPP_CFG_RECVD)
190 delete to_send->data.dpp_credentials;
198 s_wifi_event_group = xEventGroupCreate();
199 if (s_wifi_event_group ==
nullptr) {
200 ESP_LOGE(TAG,
"xEventGroupCreate failed");
203 esp_event_handler_instance_t instance_wifi_id, instance_ip_id;
205 esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &
event_handler,
nullptr, &instance_wifi_id);
207 ESP_LOGE(TAG,
"esp_event_handler_instance_register failed: %s",
esp_err_to_name(err));
210 err = esp_event_handler_instance_register(IP_EVENT, ESP_EVENT_ANY_ID, &
event_handler,
nullptr, &instance_ip_id);
212 ESP_LOGE(TAG,
"esp_event_handler_instance_register failed: %s",
esp_err_to_name(err));
229 if (s_sta_netif ==
nullptr)
230 s_sta_netif = esp_netif_create_default_wifi_sta();
231 if (s_sta_netif ==
nullptr) {
233 ESP_LOGE(TAG,
"esp_netif_create_default_wifi_sta failed");
238 if (s_ap_netif ==
nullptr)
239 s_ap_netif = esp_netif_create_default_wifi_ap();
255 if (esp_wifi_get_mode(&
mode) == ESP_OK) {
256 ESP_LOGD(TAG,
"WiFi driver already started without STA netif; restarting to bind it");
264 err = esp_wifi_set_storage(WIFI_STORAGE_RAM);
266 ESP_LOGW(TAG,
"esp_wifi_set_storage failed: %s",
esp_err_to_name(err));
268 err = esp_wifi_start();
273 s_wifi_started =
true;
281 wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
283 ESP_LOGW(TAG,
"starting wifi without nvs");
284 cfg.nvs_enable =
false;
291 err = esp_wifi_set_storage(WIFI_STORAGE_RAM);
293 ESP_LOGE(TAG,
"esp_wifi_set_storage failed: %s",
esp_err_to_name(err));
306#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
309 esp_err_t err = esp_supp_dpp_init(
nullptr);
312 ESP_LOGW(TAG,
"%s failed: %s", LOG_STR_LITERAL(
"esp_supp_dpp_init"),
esp_err_to_name(err));
317 ESP_LOGW(TAG,
"%s failed: %s", LOG_STR_LITERAL(
"esp_supp_dpp_bootstrap_gen"),
esp_err_to_name(err));
324 wifi_mode_t current_mode = WIFI_MODE_NULL;
325 if (s_wifi_started) {
326 err = esp_wifi_get_mode(¤t_mode);
332 bool current_sta = current_mode == WIFI_MODE_STA || current_mode == WIFI_MODE_APSTA;
333 bool current_ap = current_mode == WIFI_MODE_AP || current_mode == WIFI_MODE_APSTA;
335 bool set_sta = sta.value_or(current_sta);
336 bool set_ap = ap.value_or(current_ap);
338 wifi_mode_t set_mode;
340 set_mode = WIFI_MODE_APSTA;
342 set_mode = WIFI_MODE_STA;
344 set_mode = WIFI_MODE_AP;
346 set_mode = WIFI_MODE_NULL;
349 if (current_mode == set_mode)
353 ESP_LOGV(TAG,
"Enabling STA");
354 }
else if (!
set_sta && current_sta) {
355 ESP_LOGV(TAG,
"Disabling STA");
357 if (
set_ap && !current_ap) {
358 ESP_LOGV(TAG,
"Enabling AP");
359 }
else if (!
set_ap && current_ap) {
360 ESP_LOGV(TAG,
"Disabling AP");
363 if (set_mode == WIFI_MODE_NULL && s_wifi_started) {
364 err = esp_wifi_stop();
369 s_wifi_started =
false;
373 err = esp_wifi_set_mode(set_mode);
379 if (set_mode != WIFI_MODE_NULL && !s_wifi_started) {
380 err = esp_wifi_start();
385 s_wifi_started =
true;
394 int8_t
val =
static_cast<int8_t
>(output_power * 4);
395 return esp_wifi_set_max_tx_power(
val) == ESP_OK;
399 wifi_ps_type_t power_save;
402 power_save = WIFI_PS_MIN_MODEM;
405 power_save = WIFI_PS_MAX_MODEM;
409 power_save = WIFI_PS_NONE;
412 bool success = esp_wifi_set_ps(power_save) == ESP_OK;
413#ifdef USE_WIFI_POWER_SAVE_LISTENERS
423#ifdef SOC_WIFI_SUPPORT_5G
428 s_expected_disconnect.clear();
439 memset(&conf, 0,
sizeof(conf));
440 if (ap.ssid_.size() >
sizeof(conf.sta.ssid)) {
441 ESP_LOGE(TAG,
"SSID too long");
444 if (ap.password_.size() >
sizeof(conf.sta.password)) {
445 ESP_LOGE(TAG,
"Password too long");
448 memcpy(
reinterpret_cast<char *
>(conf.sta.ssid), ap.ssid_.c_str(), ap.ssid_.size());
449 memcpy(
reinterpret_cast<char *
>(conf.sta.password), ap.password_.c_str(), ap.password_.size());
452 if (ap.password_.empty()) {
453 conf.sta.threshold.authmode = WIFI_AUTH_OPEN;
458 conf.sta.threshold.authmode = WIFI_AUTH_WPA_PSK;
461 conf.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
464 conf.sta.threshold.authmode = WIFI_AUTH_WPA3_PSK;
469#ifdef USE_WIFI_WPA2_EAP
470 if (ap.get_eap().has_value()) {
471 conf.sta.threshold.authmode = WIFI_AUTH_WPA2_ENTERPRISE;
475#ifdef USE_WIFI_11KV_SUPPORT
476 conf.sta.btm_enabled = this->
btm_;
477 conf.sta.rm_enabled = this->
rrm_;
480 if (ap.has_bssid()) {
481 conf.sta.bssid_set =
true;
482 memcpy(conf.sta.bssid, ap.get_bssid().data(), 6);
484 conf.sta.bssid_set =
false;
486 if (ap.has_channel()) {
487 conf.sta.channel = ap.get_channel();
488 conf.sta.scan_method = WIFI_FAST_SCAN;
490 conf.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
494 conf.sta.listen_interval = 0;
498 conf.sta.pmf_cfg.capable =
true;
499 conf.sta.pmf_cfg.required =
false;
503 conf.sta.threshold.rssi = -127;
505 wifi_config_t current_conf;
507 err = esp_wifi_get_config(WIFI_IF_STA, ¤t_conf);
513 if (memcmp(¤t_conf, &conf,
sizeof(wifi_config_t)) != 0) {
515 const bool disconnected = s_expected_disconnect.disconnect_and_expect_leave(
517 wifi_ap_record_t old_ap{};
518 if (esp_wifi_sta_get_ap_info(&old_ap) != ESP_OK)
520 std::copy_n(old_ap.bssid,
sizeof(old_ap.bssid), bssid);
524 err = esp_wifi_disconnect();
525 return err == ESP_OK;
532 s_sta_connecting =
false;
536 err = esp_wifi_set_config(WIFI_IF_STA, &conf);
542#ifdef USE_WIFI_MANUAL_IP
553#ifdef USE_WIFI_WPA2_EAP
554 const auto &eap_opt = ap.get_eap();
555 if (eap_opt.has_value()) {
557 const EAPAuth &eap = *eap_opt;
558#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
559 err = esp_eap_client_set_identity((uint8_t *) eap.identity.c_str(), eap.identity.length());
561 err = esp_wifi_sta_wpa2_ent_set_identity((uint8_t *) eap.identity.c_str(), eap.identity.length());
564 ESP_LOGV(TAG,
"set_identity failed %d", err);
566 int ca_cert_len = strlen(eap.ca_cert);
567 int client_cert_len = strlen(eap.client_cert);
568 int client_key_len = strlen(eap.client_key);
570#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
571 err = esp_eap_client_set_ca_cert((uint8_t *) eap.ca_cert, ca_cert_len + 1);
573 err = esp_wifi_sta_wpa2_ent_set_ca_cert((uint8_t *) eap.ca_cert, ca_cert_len + 1);
576 ESP_LOGV(TAG,
"set_ca_cert failed %d", err);
581 if (client_cert_len && client_key_len) {
583#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
584 err = esp_eap_client_set_certificate_and_key((uint8_t *) eap.client_cert, client_cert_len + 1,
585 (uint8_t *) eap.client_key, client_key_len + 1,
586 (uint8_t *) eap.password.c_str(), eap.password.length());
588 err = esp_wifi_sta_wpa2_ent_set_cert_key((uint8_t *) eap.client_cert, client_cert_len + 1,
589 (uint8_t *) eap.client_key, client_key_len + 1,
590 (uint8_t *) eap.password.c_str(), eap.password.length());
593 ESP_LOGV(TAG,
"set_cert_key failed %d", err);
597#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
598 err = esp_eap_client_set_username((uint8_t *) eap.username.c_str(), eap.username.length());
600 err = esp_wifi_sta_wpa2_ent_set_username((uint8_t *) eap.username.c_str(), eap.username.length());
603 ESP_LOGV(TAG,
"set_username failed %d", err);
605#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
606 err = esp_eap_client_set_password((uint8_t *) eap.password.c_str(), eap.password.length());
608 err = esp_wifi_sta_wpa2_ent_set_password((uint8_t *) eap.password.c_str(), eap.password.length());
611 ESP_LOGV(TAG,
"set_password failed %d", err);
614#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
615 err = esp_eap_client_set_ttls_phase2_method(eap.ttls_phase_2);
617 err = esp_wifi_sta_wpa2_ent_set_ttls_phase2_method(eap.ttls_phase_2);
620 ESP_LOGV(TAG,
"set_ttls_phase2_method failed %d", err);
623#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
624 err = esp_wifi_sta_enterprise_enable();
626 err = esp_wifi_sta_wpa2_ent_enable();
629 ESP_LOGV(TAG,
"enterprise_enable failed %d", err);
636 s_sta_connecting =
true;
637 s_sta_connect_error =
false;
638 s_sta_connect_not_found =
false;
642 err = esp_wifi_connect();
646 s_sta_connecting =
false;
654 s_sta_connected =
false;
662static void disable_dhcp_sntp() {
663#if SNTP_GET_SERVERS_FROM_DHCP || SNTP_GET_SERVERS_FROM_DHCPV6
666 sntp_servermode_dhcp(
false);
669#ifdef USE_WIFI_LEASE_CACHE
671static constexpr uint32_t LEASE_APPLY_MARGIN_SECS = 60;
674static uint32_t lease_cache_age_secs(
const SavedWifiLeaseSettings &lease) {
676 return now >= lease.saved_at ? now - lease.saved_at : UINT32_MAX;
680static uint32_t lease_renew_at_secs(
const SavedWifiLeaseSettings &lease) {
682 if (renew_at == 0 || renew_at >= lease.lease_secs)
683 renew_at = lease.lease_secs / 2;
689 ESP_LOGI(TAG,
"Cached lease renew deadline reached; re-acquiring the address over DHCP, connections may drop");
693 esp_err_t err = esp_netif_dhcpc_start(s_sta_netif);
695 ESP_LOGW(TAG,
"Lease renew: starting DHCP client failed: %s, retrying in 60 s",
esp_err_to_name(err));
702 if (lease.version != SAVED_WIFI_LEASE_VERSION || this->selected_sta_index_ < 0 ||
703 lease.ap_index != this->selected_sta_index_)
706 esp_reset_reason_t reason = esp_reset_reason();
707 if (reason != ESP_RST_DEEPSLEEP && reason != ESP_RST_SW)
709 uint32_t age = lease_cache_age_secs(lease);
710 if (age == UINT32_MAX)
715 if (age >= lease_renew_at_secs(lease))
718 uint32_t margin = std::max<uint32_t>(LEASE_APPLY_MARGIN_SECS, lease.lease_secs / 16);
719 return lease.lease_secs > age + margin;
729 if (s_sta_netif ==
nullptr) {
730 ESP_LOGW(TAG,
"STA interface not initialized");
734 esp_netif_dhcp_status_t dhcp_status;
735 esp_err_t err = esp_netif_dhcpc_get_status(s_sta_netif, &dhcp_status);
737 ESP_LOGV(TAG,
"esp_netif_dhcpc_get_status failed: %s",
esp_err_to_name(err));
741#ifdef USE_WIFI_LEASE_CACHE
743 optional<ManualIP> effective_ip = manual_ip;
746 if (!effective_ip.has_value() && this->lease_valid_for_apply_()) {
748 esp_ip4_addr_t ip4{lease.ip}, mask4{lease.netmask}, gw4{lease.gateway}, dns1_4{lease.dns1}, dns2_4{lease.dns2};
750 cached.static_ip = network::IPAddress(&ip4);
751 cached.gateway = network::IPAddress(&gw4);
752 cached.subnet = network::IPAddress(&mask4);
753 cached.dns1 = network::IPAddress(&dns1_4);
754 cached.dns2 = network::IPAddress(&dns2_4);
755 effective_ip = cached;
758 uint32_t age = lease_cache_age_secs(lease);
759 uint32_t remaining = lease.lease_secs > age ? lease.lease_secs - age : 0;
760 ESP_LOGI(TAG,
"Applying cached lease " IPSTR
", ~%" PRIu32
"s left, skipping DHCP", IP2STR(&ip4), remaining);
763 uint32_t renew_in = lease_renew_at_secs(lease) - age;
766 static_cast<uint32_t>(std::min<uint64_t>(
static_cast<uint64_t
>(renew_in) * 1000ULL, UINT32_MAX - 1));
770 const optional<ManualIP> &effective_ip = manual_ip;
773 if (!effective_ip.has_value()) {
780 if (dhcp_status != ESP_NETIF_DHCP_STARTED) {
781 err = esp_netif_dhcpc_start(s_sta_netif);
783 ESP_LOGV(TAG,
"Starting DHCP client failed: %d", err);
785 return err == ESP_OK;
790 esp_netif_ip_info_t info;
791 info.ip = effective_ip->static_ip;
792 info.gw = effective_ip->gateway;
793 info.netmask = effective_ip->subnet;
794 err = esp_netif_dhcpc_stop(s_sta_netif);
795 if (err != ESP_OK && err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STOPPED) {
796 ESP_LOGV(TAG,
"Stopping DHCP client failed: %s",
esp_err_to_name(err));
799 err = esp_netif_set_ip_info(s_sta_netif, &info);
801 ESP_LOGV(TAG,
"Setting manual IP info failed: %s",
esp_err_to_name(err));
804 esp_netif_dns_info_t dns;
805 if (effective_ip->dns1.is_set()) {
806 dns.ip = effective_ip->dns1;
807 esp_netif_set_dns_info(s_sta_netif, ESP_NETIF_DNS_MAIN, &dns);
809 if (effective_ip->dns2.is_set()) {
810 dns.ip = effective_ip->dns2;
811 esp_netif_set_dns_info(s_sta_netif, ESP_NETIF_DNS_BACKUP, &dns);
817#ifdef USE_WIFI_LEASE_CACHE
823#ifdef USE_WIFI_MANUAL_IP
828 esp_netif_ip_info_t info;
829 if (esp_netif_get_ip_info(s_sta_netif, &info) != ESP_OK || info.ip.addr == 0)
832 SavedWifiLeaseSettings lease{};
833 lease.version = SAVED_WIFI_LEASE_VERSION;
835 lease.ip = info.ip.addr;
836 lease.netmask = info.netmask.addr;
837 lease.gateway = info.gw.addr;
839 esp_netif_dns_info_t dns;
840 if (esp_netif_get_dns_info(s_sta_netif, ESP_NETIF_DNS_MAIN, &dns) == ESP_OK && dns.ip.type == ESP_IPADDR_TYPE_V4) {
841 lease.dns1 = dns.ip.u_addr.ip4.addr;
843 if (esp_netif_get_dns_info(s_sta_netif, ESP_NETIF_DNS_BACKUP, &dns) == ESP_OK && dns.ip.type == ESP_IPADDR_TYPE_V4) {
844 lease.dns2 = dns.ip.u_addr.ip4.addr;
848 bool have_timing =
false;
849 if (
auto *impl =
static_cast<struct netif *
>(esp_netif_get_netif_impl(s_sta_netif))) {
851 if (
struct dhcp *d = netif_dhcp_data(impl)) {
852 lease.lease_secs = d->offered_t0_lease;
853 lease.t1_renew = d->offered_t1_renew;
860 lease.saved_at =
static_cast<uint32_t>(esp_rtc_get_time_us() / 1000000ULL);
864#ifdef USE_WIFI_LEASE_CACHE_IN_FLASH
865 constexpr size_t compare_len = offsetof(SavedWifiLeaseSettings, saved_at);
867 constexpr size_t compare_len =
sizeof(SavedWifiLeaseSettings);
869 const SavedWifiLeaseSettings &previous = this->
cached_lease_;
870 if (previous.saved_at <= lease.saved_at && memcmp(&previous, &lease, compare_len) == 0)
876 ESP_LOGD(TAG,
"Lease cache: saved " IPSTR
" (network %d, lease %" PRIu32
"s)", IP2STR(&info.ip), lease.ap_index,
887 esp_netif_ip_info_t ip;
888 esp_err_t err = esp_netif_get_ip_info(s_sta_netif, &ip);
890 ESP_LOGV(TAG,
"esp_netif_get_ip_info failed: %s",
esp_err_to_name(err));
894 addresses[0] = network::IPAddress(&ip.ip);
912 case WIFI_AUTH_WPA_PSK:
914 case WIFI_AUTH_WPA2_PSK:
916 case WIFI_AUTH_WPA_WPA2_PSK:
917 return "WPA/WPA2 PSK";
918 case WIFI_AUTH_WPA2_ENTERPRISE:
919 return "WPA2 Enterprise";
920 case WIFI_AUTH_WPA3_PSK:
922 case WIFI_AUTH_WPA2_WPA3_PSK:
923 return "WPA2/WPA3 PSK";
924 case WIFI_AUTH_WAPI_PSK:
933 case WIFI_REASON_AUTH_EXPIRE:
934 return "Auth Expired";
935 case WIFI_REASON_AUTH_LEAVE:
937#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
938 case WIFI_REASON_DISASSOC_DUE_TO_INACTIVITY:
939 return "Disassociated Due to Inactivity";
941 case WIFI_REASON_ASSOC_EXPIRE:
942 return "Association Expired";
944 case WIFI_REASON_ASSOC_TOOMANY:
945 return "Too Many Associations";
946#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
947 case WIFI_REASON_CLASS2_FRAME_FROM_NONAUTH_STA:
948 return "Class 2 Frame from Non-Authenticated STA";
949 case WIFI_REASON_CLASS3_FRAME_FROM_NONASSOC_STA:
950 return "Class 3 Frame from Non-Associated STA";
952 case WIFI_REASON_NOT_AUTHED:
953 return "Not Authenticated";
954 case WIFI_REASON_NOT_ASSOCED:
955 return "Not Associated";
957 case WIFI_REASON_ASSOC_LEAVE:
958 return "Association Leave";
959 case WIFI_REASON_ASSOC_NOT_AUTHED:
960 return "Association not Authenticated";
961 case WIFI_REASON_DISASSOC_PWRCAP_BAD:
962 return "Disassociate Power Cap Bad";
963 case WIFI_REASON_DISASSOC_SUPCHAN_BAD:
964 return "Disassociate Supported Channel Bad";
965 case WIFI_REASON_IE_INVALID:
967 case WIFI_REASON_MIC_FAILURE:
968 return "Mic Failure";
969 case WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT:
970 return "4-Way Handshake Timeout";
971 case WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT:
972 return "Group Key Update Timeout";
973 case WIFI_REASON_IE_IN_4WAY_DIFFERS:
974 return "IE In 4-Way Handshake Differs";
975 case WIFI_REASON_GROUP_CIPHER_INVALID:
976 return "Group Cipher Invalid";
977 case WIFI_REASON_PAIRWISE_CIPHER_INVALID:
978 return "Pairwise Cipher Invalid";
979 case WIFI_REASON_AKMP_INVALID:
980 return "AKMP Invalid";
981 case WIFI_REASON_UNSUPP_RSN_IE_VERSION:
982 return "Unsupported RSN IE version";
983 case WIFI_REASON_INVALID_RSN_IE_CAP:
984 return "Invalid RSN IE Cap";
985 case WIFI_REASON_802_1X_AUTH_FAILED:
986 return "802.1x Authentication Failed";
987 case WIFI_REASON_CIPHER_SUITE_REJECTED:
988 return "Cipher Suite Rejected";
989 case WIFI_REASON_BEACON_TIMEOUT:
990 return "Beacon Timeout";
991 case WIFI_REASON_NO_AP_FOUND:
992 return "AP Not Found";
993 case WIFI_REASON_AUTH_FAIL:
994 return "Authentication Failed";
995 case WIFI_REASON_ASSOC_FAIL:
996 return "Association Failed";
997 case WIFI_REASON_HANDSHAKE_TIMEOUT:
998 return "Handshake Failed";
999 case WIFI_REASON_CONNECTION_FAIL:
1000 return "Connection Failed";
1001 case WIFI_REASON_AP_TSF_RESET:
1002 return "AP TSF reset";
1003 case WIFI_REASON_ROAMING:
1004 return "Station Roaming";
1005 case WIFI_REASON_ASSOC_COMEBACK_TIME_TOO_LONG:
1006 return "Association comeback time too long";
1007 case WIFI_REASON_SA_QUERY_TIMEOUT:
1008 return "SA query timeout";
1009#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0)
1010 case WIFI_REASON_NO_AP_FOUND_W_COMPATIBLE_SECURITY:
1011 return "No AP found with compatible security";
1012 case WIFI_REASON_NO_AP_FOUND_IN_AUTHMODE_THRESHOLD:
1013 return "No AP found in auth mode threshold";
1014 case WIFI_REASON_NO_AP_FOUND_IN_RSSI_THRESHOLD:
1015 return "No AP found in RSSI threshold";
1017 case WIFI_REASON_UNSPECIFIED:
1019 return "Unspecified";
1025static void read_ap_clients(uint8_t &
count) {
1026 wifi_sta_list_t sta_list;
1027 if (esp_wifi_ap_get_sta_list(&sta_list) == ESP_OK)
1028 count = sta_list.num;
1036 if (data ==
nullptr)
1048 ESP_LOGW(TAG,
"Dropped %u WiFi events due to buffer overflow", dropped);
1050 s_expected_disconnect.clear();
1064 if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_STA_START) {
1065 ESP_LOGV(TAG,
"STA start");
1068 if (err != ERR_OK) {
1069 ESP_LOGW(TAG,
"esp_netif_set_hostname failed: %s",
esp_err_to_name(err));
1074#ifdef SOC_WIFI_SUPPORT_5G
1078 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_STA_STOP) {
1079 s_expected_disconnect.clear();
1080 ESP_LOGV(TAG,
"STA stop");
1081 s_sta_connecting =
false;
1083 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) {
1084 const auto &it =
data->data.sta_authmode_change;
1087 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_STA_CONNECTED) {
1088 const auto &it =
data->data.sta_connected;
1089 if (s_expected_disconnect.is_previous_ap(it.bssid)) {
1090 ESP_LOGD(TAG,
"Ignoring queued connection from previous AP");
1093 s_expected_disconnect.clear();
1094#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
1095 char bssid_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1097 ESP_LOGV(TAG,
"Connected ssid='%.*s' bssid=" LOG_SECRET(
"%s")
" channel=%u, authmode=%s", it.ssid_len,
1100 s_sta_connected =
true;
1106 if (
auto *netif =
static_cast<struct netif *
>(esp_netif_get_netif_impl(s_sta_netif)); netif !=
nullptr) {
1107 if (esp_err_t err = esp_netif_tcpip_exec(
1108 [](
void *ctx) -> esp_err_t {
1109 netif_create_ip6_linklocal_address(
static_cast<struct netif *
>(ctx), 1);
1114 ESP_LOGW(TAG,
"IPv6 link-local not created: %s",
esp_err_to_name(err));
1116 ESP_LOGD(TAG,
"IPv6 link-local address created");
1119 ESP_LOGW(TAG,
"No lwIP netif, IPv6 link-local not created");
1125#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_INFO
1126 char roam_bssid_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1128 ESP_LOGI(TAG,
"Roamed ssid='%.*s' bssid=" LOG_SECRET(
"%s")
" channel=%u", it.ssid_len, (
const char *) it.ssid,
1129 roam_bssid_s, it.channel);
1132 std::copy(it.bssid, it.bssid + 6, roam_bssid.begin());
1135#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
1138 this->
pending_.connect_state =
true;
1141#if defined(USE_WIFI_IP_STATE_LISTENERS) && (defined(USE_WIFI_MANUAL_IP) || defined(USE_WIFI_LEASE_CACHE))
1142 bool static_ip =
false;
1143#ifdef USE_WIFI_MANUAL_IP
1145 static_ip = config && config->has_manual_ip();
1147#ifdef USE_WIFI_LEASE_CACHE
1155 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_STA_DISCONNECTED) {
1156 const auto &it =
data->data.sta_disconnected;
1157 if (it.reason == WIFI_REASON_ROAMING) {
1158 ESP_LOGI(TAG,
"Disconnected ssid='%.*s' reason='Station Roaming'", it.ssid_len, (
const char *) it.ssid);
1161 const ExpectedLeave expected = s_expected_disconnect.consume_disconnect(
1162 it.bssid, it.reason == WIFI_REASON_ASSOC_LEAVE || it.reason == WIFI_REASON_STA_LEAVING);
1164 if (expected_disconnect) {
1165 ESP_LOGD(TAG,
"Expected leave of the previous %s",
1167 }
else if (it.reason == WIFI_REASON_NO_AP_FOUND) {
1168 ESP_LOGW(TAG,
"Disconnected ssid='%.*s' reason='Probe Request Unsuccessful'", it.ssid_len,
1169 (
const char *) it.ssid);
1170 s_sta_connect_not_found =
true;
1172 char bssid_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1174 ESP_LOGW(TAG,
"Disconnected ssid='%.*s' bssid=" LOG_SECRET(
"%s")
" reason='%s'", it.ssid_len,
1176 s_sta_connect_error =
true;
1178 s_sta_connected =
false;
1179 if (!expected_disconnect) {
1180 s_sta_connecting =
false;
1185#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
1191#if defined(USE_WIFI_AP_WISP) && !defined(USE_WIFI_AP_WISP_STATIC_DNS)
1192 }
else if (data->event_base == IP_EVENT &&
1193 (
data->event_id == IP_EVENT_ETH_GOT_IP ||
data->event_id == IP_EVENT_PPP_GOT_IP)) {
1196 }
else if (data->event_base == IP_EVENT &&
data->event_id == IP_EVENT_STA_GOT_IP) {
1197 const auto &it =
data->data.ip_got_ip;
1198 esp_netif_ip_info_t current_ip{};
1199 if (!s_sta_connected || !esp_netif_is_netif_up(s_sta_netif) ||
1200 esp_netif_get_ip_info(s_sta_netif, ¤t_ip) != ESP_OK || current_ip.ip.addr != it.ip_info.ip.addr) {
1201 ESP_LOGV(TAG,
"Ignoring stale IPv4 address event");
1204 ESP_LOGV(TAG,
"static_ip=" IPSTR
" gateway=" IPSTR, IP2STR(&it.ip_info.ip), IP2STR(&it.ip_info.gw));
1206#if defined(USE_WIFI_AP_WISP) && !defined(USE_WIFI_AP_WISP_STATIC_DNS)
1209#ifdef USE_WIFI_LEASE_CACHE
1212#ifdef USE_WIFI_IP_STATE_LISTENERS
1217 }
else if (data->event_base == IP_EVENT &&
data->event_id == IP_EVENT_GOT_IP6) {
1218 const auto &it =
data->data.ip_got_ip6;
1219 if (!s_sta_connected) {
1220 ESP_LOGV(TAG,
"Ignoring IPv6 address event before association");
1223 esp_ip6_addr_t addresses[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
1228 ESP_LOGV(TAG,
"IPv6 address=" IPV6STR, IPV62STR(it.ip6_info.ip));
1229#ifdef USE_WIFI_IP_STATE_LISTENERS
1234 }
else if (data->event_base == IP_EVENT &&
data->event_id == IP_EVENT_STA_LOST_IP) {
1235 ESP_LOGV(TAG,
"Lost IP");
1238 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_SCAN_DONE) {
1239 const auto &it =
data->data.sta_scan_done;
1240 ESP_LOGV(TAG,
"Scan done: status=%" PRIu32
" number=%u scan_id=%u", it.status, it.number, it.scan_id);
1242 uint16_t number = it.number;
1251 if (it.status != 0) {
1261 const size_t wanted = filtered ? std::min<size_t>(number, WIFI_SCAN_RESULT_BOUND) : number;
1264 if (this->
scan_result_.capacity() < wanted && !this->scan_result_.try_init(wanted)) {
1265 esp_wifi_clear_ap_list();
1266 ESP_LOGW(TAG,
"No memory for %zu scan results", wanted);
1270#ifdef USE_ESP32_HOSTED
1274 static constexpr size_t SCAN_RECORD_STACK_COUNT = 3904 /
sizeof(wifi_ap_record_t);
1275 SmallBufferWithHeapFallback<SCAN_RECORD_STACK_COUNT, wifi_ap_record_t> records(number);
1276 err = esp_wifi_scan_get_ap_records(&number, records.get());
1277 if (err != ESP_OK) {
1278 esp_wifi_clear_ap_list();
1279 ESP_LOGW(TAG,
"esp_wifi_scan_get_ap_records failed: %s",
esp_err_to_name(err));
1282 for (uint16_t i = 0; i < number; i++) {
1283 wifi_ap_record_t &record = records.get()[i];
1286 for (uint16_t i = 0; i < number; i++) {
1287 wifi_ap_record_t record;
1288 err = esp_wifi_scan_get_ap_record(&record);
1289 if (err != ESP_OK) {
1290 ESP_LOGW(TAG,
"esp_wifi_scan_get_ap_record failed: %s",
esp_err_to_name(err));
1291 esp_wifi_clear_ap_list();
1296 const char *ssid_cstr =
reinterpret_cast<const char *
>(record.ssid);
1302 std::copy(record.bssid, record.bssid + 6, bssid.begin());
1304 this->
scan_result_.emplace_back(bssid, ssid_cstr, strlen(ssid_cstr), record.primary, record.rssi,
1305 record.authmode != WIFI_AUTH_OPEN, ssid_cstr[0] ==
'\0');
1313 if (res.get_rssi() < weakest->get_rssi())
1316 if (record.rssi <= weakest->get_rssi()) {
1321 weakest->~WiFiScanResult();
1322 new (weakest) WiFiScanResult(bssid, ssid_cstr, strlen(ssid_cstr), record.primary, record.rssi,
1323 record.authmode != WIFI_AUTH_OPEN, ssid_cstr[0] ==
'\0');
1326 ESP_LOGV(TAG,
"Scan complete: %u found, %zu stored%s", number, this->scan_result_.size(),
1327 filtered ? LOG_STR_LITERAL(
" (driver filtered)") : LOG_STR_LITERAL(
""));
1328#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
1332 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_AP_START) {
1333 ESP_LOGV(TAG,
"AP start");
1335#ifdef USE_WIFI_AP_WISP
1338 if (esp_err_t err = esp_netif_napt_enable(s_ap_netif); err != ESP_OK) {
1344 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_AP_STOP) {
1345 ESP_LOGV(TAG,
"AP stop");
1348 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_AP_PROBEREQRECVED) {
1349#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
1350 const auto &it =
data->data.ap_probe_req_rx;
1351 char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1353 ESP_LOGVV(TAG,
"AP receive Probe Request MAC=%s RSSI=%d", mac_buf, it.rssi);
1356 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_AP_STACONNECTED) {
1360#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
1361 const auto &it =
data->data.ap_staconnected;
1362 char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1364 ESP_LOGV(TAG,
"AP client connected MAC=%s", mac_buf);
1367 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_AP_STADISCONNECTED) {
1371#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
1372 const auto &it =
data->data.ap_stadisconnected;
1373 char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
1375 ESP_LOGV(TAG,
"AP client disconnected MAC=%s", mac_buf);
1379 }
else if (
data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_DPP_URI_READY) {
1380 ESP_LOGD(TAG,
"DPP URI: %s", this->
dpp_uri_.get());
1381#ifdef USE_WIFI_DPP_URI_TRIGGER
1385 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_DPP_CFG_RECVD) {
1386 const std::unique_ptr<SavedWifiSettings> credentials(
data->data.dpp_credentials);
1388 ESP_LOGI(TAG,
"DPP configured network " LOG_SECRET(
"'%s'"), credentials->ssid);
1392 this->
save_wifi_sta(credentials->ssid, credentials->password);
1398 }
else if (data->event_base == WIFI_EVENT &&
data->event_id == WIFI_EVENT_DPP_FAILED) {
1403#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
1404 }
else if (
data->event_base == IP_EVENT &&
data->event_id == IP_EVENT_ASSIGNED_IP_TO_CLIENT) {
1405 const auto &it =
data->data.ip_assigned_ip_to_client;
1407 }
else if (
data->event_base == IP_EVENT &&
data->event_id == IP_EVENT_AP_STAIPASSIGNED) {
1408 const auto &it =
data->data.ip_ap_staipassigned;
1410 ESP_LOGV(TAG,
"AP client assigned IP " IPSTR, IP2STR(&it.ip));
1416#if USE_NETWORK_IPV6 && (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
1424 if (s_sta_connect_error) {
1427 if (s_sta_connect_not_found) {
1430 if (s_sta_connecting) {
1440 wifi_scan_config_t config{};
1441 config.ssid =
nullptr;
1442 config.bssid =
nullptr;
1443#ifndef USE_WIFI_MULTI_SSID
1450 config.ssid =
const_cast<uint8_t *
>(
reinterpret_cast<const uint8_t *
>(this->
sta_[0].get_ssid().c_str()));
1454 config.show_hidden =
true;
1455 config.scan_type = passive ? WIFI_SCAN_TYPE_PASSIVE : WIFI_SCAN_TYPE_ACTIVE;
1457 config.scan_time.passive = 300;
1459 config.scan_time.active.min = 100;
1460 config.scan_time.active.max = 300;
1464#ifdef CONFIG_SOC_WIFI_SUPPORTED
1466 config.coex_background_scan =
true;
1470 esp_err_t err = esp_wifi_scan_start(&config,
false);
1471 if (err != ESP_OK) {
1472 ESP_LOGV(TAG,
"esp_wifi_scan_start failed: %s",
esp_err_to_name(err));
1485 if (s_ap_netif ==
nullptr) {
1486 ESP_LOGW(TAG,
"AP interface not initialized");
1490 esp_netif_ip_info_t info;
1491 if (manual_ip.has_value()) {
1492 info.ip = manual_ip->static_ip;
1493 info.gw = manual_ip->gateway;
1494 info.netmask = manual_ip->subnet;
1496 info.ip = network::IPAddress(192, 168, 4, 1);
1497 info.gw = network::IPAddress(192, 168, 4, 1);
1498 info.netmask = network::IPAddress(255, 255, 255, 0);
1501 err = esp_netif_dhcps_stop(s_ap_netif);
1502 if (err != ESP_OK && err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STOPPED) {
1503 ESP_LOGE(TAG,
"esp_netif_dhcps_stop failed: %s",
esp_err_to_name(err));
1507 err = esp_netif_set_ip_info(s_ap_netif, &info);
1508 if (err != ESP_OK) {
1509 ESP_LOGE(TAG,
"esp_netif_set_ip_info failed: %d", err);
1513 dhcps_lease_t lease;
1514 lease.enable =
true;
1515 network::IPAddress start_address = network::IPAddress(&info.ip);
1516 start_address += 99;
1517 lease.start_ip = start_address;
1518#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
1519 char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
1521 ESP_LOGV(TAG,
"DHCP server IP lease start: %s", start_address.str_to(ip_buf));
1522 start_address += 10;
1523 lease.end_ip = start_address;
1524 ESP_LOGV(TAG,
"DHCP server IP lease end: %s", start_address.str_to(ip_buf));
1525 err = esp_netif_dhcps_option(s_ap_netif, ESP_NETIF_OP_SET, ESP_NETIF_REQUESTED_IP_ADDRESS, &lease,
sizeof(lease));
1527 if (err != ESP_OK) {
1528 ESP_LOGE(TAG,
"esp_netif_dhcps_option failed: %d", err);
1532#if (defined(USE_CAPTIVE_PORTAL) || defined(USE_WEBSERVER_CAPTIVE)) && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
1535 static char captive_portal_uri[24];
1536 memcpy(captive_portal_uri,
"http://", 7);
1537 network::IPAddress(&info.ip).str_to(captive_portal_uri + 7);
1538 err = esp_netif_dhcps_option(s_ap_netif, ESP_NETIF_OP_SET, ESP_NETIF_CAPTIVEPORTAL_URI, captive_portal_uri,
1539 strlen(captive_portal_uri));
1540 if (err != ESP_OK) {
1541 ESP_LOGV(TAG,
"Failed to set DHCP captive portal URI: %s",
esp_err_to_name(err));
1543 ESP_LOGV(TAG,
"DHCP Captive Portal URI set to: %s", captive_portal_uri);
1547#ifdef USE_WIFI_AP_WISP
1550 uint8_t dns_offer = 1;
1552 esp_netif_dhcps_option(s_ap_netif, ESP_NETIF_OP_SET, ESP_NETIF_DOMAIN_NAME_SERVER, &dns_offer,
sizeof(dns_offer));
1553 if (err != ESP_OK) {
1554 ESP_LOGE(TAG,
"Failed to enable DHCP DNS option: %s",
esp_err_to_name(err));
1560 err = esp_netif_dhcps_start(s_ap_netif);
1562 if (err != ESP_OK && err != ESP_ERR_ESP_NETIF_IF_NOT_READY) {
1563 ESP_LOGE(TAG,
"esp_netif_dhcps_start failed: %d", err);
1573#ifdef USE_WIFI_MANUAL_IP
1578 ESP_LOGE(TAG,
"wifi_ap_ip_config_ failed:");
1587 memset(&conf, 0,
sizeof(conf));
1588 if (ap.ssid_.size() >
sizeof(conf.ap.ssid)) {
1589 ESP_LOGE(TAG,
"AP SSID too long");
1592 memcpy(
reinterpret_cast<char *
>(conf.ap.ssid), ap.ssid_.c_str(), ap.ssid_.size());
1593 conf.ap.channel = ap.has_channel() ? ap.get_channel() : 1;
1594 conf.ap.ssid_hidden = ap.get_hidden();
1595 conf.ap.max_connection = 5;
1596 conf.ap.beacon_interval = 100;
1598 if (ap.password_.empty()) {
1599 conf.ap.authmode = WIFI_AUTH_OPEN;
1600 *conf.ap.password = 0;
1602 conf.ap.authmode = WIFI_AUTH_WPA2_PSK;
1603 if (ap.password_.size() >
sizeof(conf.ap.password)) {
1604 ESP_LOGE(TAG,
"AP password too long");
1607 memcpy(
reinterpret_cast<char *
>(conf.ap.password), ap.password_.c_str(), ap.password_.size());
1611 conf.ap.pairwise_cipher = WIFI_CIPHER_TYPE_CCMP;
1613 esp_err_t err = esp_wifi_set_config(WIFI_IF_AP, &conf);
1614 if (err != ESP_OK) {
1615 ESP_LOGE(TAG,
"esp_wifi_set_config failed: %d", err);
1622 esp_netif_ip_info_t ip;
1623 esp_netif_get_ip_info(s_ap_netif, &ip);
1624 return network::IPAddress(&ip.ip);
1630 esp_err_t err = esp_supp_dpp_start_listen();
1631 if (err != ESP_OK) {
1632 ESP_LOGW(TAG,
"%s failed: %s", LOG_STR_LITERAL(
"esp_supp_dpp_start_listen"),
esp_err_to_name(err));
1635 ESP_LOGD(TAG,
"DPP listening for a configurator");
1649 wifi_ap_record_t ap_info;
1650 if (esp_wifi_sta_get_ap_info(&ap_info) != ESP_OK)
1652 ESP_LOGD(TAG,
"Disconnecting before powerdown");
1653 esp_wifi_disconnect();
1661 wifi_ap_record_t info;
1662 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
1663 if (err != ESP_OK) {
1665 ESP_LOGVV(TAG,
"esp_wifi_sta_get_ap_info failed: %s",
esp_err_to_name(err));
1668 std::copy(info.bssid, info.bssid + 6, bssid.begin());
1672 wifi_ap_record_t info{};
1673 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
1674 if (err != ESP_OK) {
1679 size_t len = strnlen(
reinterpret_cast<const char *
>(info.ssid), 32);
1685 wifi_ap_record_t info;
1686 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
1687 if (err != ESP_OK) {
1689 ESP_LOGVV(TAG,
"esp_wifi_sta_get_ap_info failed: %s",
esp_err_to_name(err));
1690 return WIFI_RSSI_DISCONNECTED;
1696 wifi_second_chan_t
second;
1698 if (err != ESP_OK) {
1699 ESP_LOGW(TAG,
"esp_wifi_get_channel failed: %s",
esp_err_to_name(err));
1705 esp_netif_ip_info_t ip;
1706 esp_err_t err = esp_netif_get_ip_info(s_sta_netif, &ip);
1707 if (err != ESP_OK) {
1708 ESP_LOGW(TAG,
"esp_netif_get_ip_info failed: %s",
esp_err_to_name(err));
1711 return network::IPAddress(&ip.netmask);
1714 esp_netif_ip_info_t ip;
1715 esp_err_t err = esp_netif_get_ip_info(s_sta_netif, &ip);
1716 if (err != ESP_OK) {
1717 ESP_LOGW(TAG,
"esp_netif_get_ip_info failed: %s",
esp_err_to_name(err));
1720 return network::IPAddress(&ip.gw);
1723 const ip_addr_t *dns_ip = dns_getserver(num);
1724 return network::IPAddress(dns_ip);
1727#ifdef USE_WIFI_AP_WISP
1729#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
1730static constexpr size_t AP_DNS_COUNT = 2;
1732static constexpr size_t AP_DNS_COUNT = 1;
1734#ifdef USE_WIFI_AP_WISP_STATIC_DNS
1736static constexpr uint32_t AP_DNS[] = {
1738#ifdef WIFI_AP_WISP_DNS_1
1744static uint32_t upstream_dns(
size_t i) {
1745#ifdef USE_WIFI_AP_WISP_STATIC_DNS
1746 return i < std::size(AP_DNS) ? AP_DNS[i] : 0;
1748 return ip_addr_get_ip4_u32(dns_getserver(i));
1752static uint32_t ap_dns_to_offer(
size_t i, [[maybe_unused]]
bool own) {
1753#ifdef USE_WIFI_AP_WISP_PORTAL
1755 esp_netif_ip_info_t ip{};
1756 if (s_ap_netif !=
nullptr && esp_netif_get_ip_info(s_ap_netif, &ip) == ESP_OK)
1758 ESP_LOGW(TAG,
"Failed to read the AP address to offer as resolver");
1762 const uint32_t addr = upstream_dns(i);
1763 return addr != 0 ? addr : upstream_dns(0);
1765 return upstream_dns(i);
1771#ifdef USE_WIFI_AP_WISP_PORTAL
1778#ifdef USE_WIFI_AP_WISP_PORTAL
1782 const bool own =
false;
1785 for (
size_t i = 0; i < AP_DNS_COUNT; i++) {
1786 const uint32_t addr = ap_dns_to_offer(i, own);
1791 esp_netif_dns_info_t info{};
1792 info.ip.type = ESP_IPADDR_TYPE_V4;
1793 info.ip.u_addr.ip4.addr = addr;
1794 esp_err_t err = esp_netif_set_dns_info(s_ap_netif,
static_cast<esp_netif_dns_type_t
>(i), &info);
1795 if (err != ESP_OK) {
1796 ESP_LOGW(TAG,
"Failed to set DHCP DNS server %u: %s", (
unsigned) i,
esp_err_to_name(err));
1799 ESP_LOGV(TAG,
"DHCP DNS server: " IPSTR, IP2STR(&info.ip.u_addr.ip4));
1805#ifndef USE_WIFI_AP_WISP_STATIC_DNS
1812#ifdef USE_WIFI_AP_WISP_PORTAL
1815 const bool own =
false;
1817 bool changed =
false;
1818 for (
size_t i = 0; i < AP_DNS_COUNT && !changed; i++) {
1819 const uint32_t addr = ap_dns_to_offer(i, own);
1820 esp_netif_dns_info_t current{};
1823 (addr == 0 && own) ||
1824 (addr != 0 && (esp_netif_get_dns_info(s_ap_netif,
static_cast<esp_netif_dns_type_t
>(i), ¤t) != ESP_OK ||
1825 current.ip.u_addr.ip4.addr != addr));
1829#ifdef USE_WIFI_AP_WISP_PORTAL
1834#ifdef USE_WIFI_MANUAL_IP
1843#ifdef USE_WIFI_AP_WISP_PORTAL
1849#ifdef USE_WIFI_AP_WISP_PORTAL
1851 static constexpr uint8_t MAX_ATTEMPTS = 5;
1857 if (attempt + 1 >= MAX_ATTEMPTS) {
1858 ESP_LOGW(TAG,
"Failed to drop AP clients so they pick up the new resolver: %s; restarting AP",
1863 ESP_LOGW(TAG,
"Failed to drop AP clients so they pick up the new resolver: %s; retrying",
esp_err_to_name(err));
BedjetMode mode
BedJet operating mode.
const StringRef & get_name() const
Get the name of this Application set by pre_setup().
uint32_t IRAM_ATTR HOT get_loop_component_start_time() const
Get the cached time in milliseconds from when the current component started its loop execution.
bool cancel_timeout(const char *name)
Cancel a timeout function.
void set_timeout(const char *name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a const char* name.
uint16_t get_and_reset_dropped_count()
constexpr const char * c_str() const
bool has_manual_ip() const
optional< ManualIP > get_manual_ip() const
void notify_scan_results_listeners_()
Notify scan results listeners with current scan results.
bool error_from_callback_
bool wifi_apply_power_save_()
void set_ap(const WiFiAP &ap)
Setup an Access Point that should be created if no connection to a station can be made.
void set_sta(const WiFiAP &ap)
WiFiPowerSaveMode power_save_
const WiFiAP * get_selected_sta_() const
WiFiSTAConnectStatus wifi_sta_connect_status_() const
void set_last_connected_(uint32_t now)
friend class ScanResultsLock
void save_wifi_sta(const std::string &ssid, const std::string &password)
bool wifi_dpp_start_listen_()
SavedWifiLeaseSettings cached_lease_
WiFiComponentState state_
wifi_scan_vector_t< WiFiScanResult > scan_result_
bool wifi_apply_band_mode_()
void notify_ip_state_listeners_()
Notify IP state listeners with current addresses.
bool is_scan_driver_filtered_() const
bool applied_cached_lease_
void start_connecting(const WiFiAP &ap)
ESPPreferenceObject lease_cache_pref_
bool wifi_sta_ip_config_(const optional< ManualIP > &manual_ip)
esp_netif_t * get_esp_netif_sta()
esp_netif handle of the station interface, used by network for default-route arbitration.
bool ap_dns_known_()
Whether there is an IPv4 resolver to offer AP clients: a configured one, or the station's.
void drop_ap_clients_(uint8_t attempt=0)
Disconnect the AP clients so they rejoin with the resolver now offered; a few retries,...
void apply_ap_dns_()
Pass the station's resolvers on to AP clients when they changed.
wifi_band_mode_t band_mode_
void wifi_dpp_stop_listen_()
void wifi_process_event_(IDFWiFiEvent *data)
bool lease_valid_for_apply_() const
int8_t selected_sta_index_
void notify_disconnect_state_listeners_()
Notify connect state listeners of disconnection.
friend void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
bool wifi_start_ap_(const WiFiAP &ap)
void log_discarded_scan_result_(const char *ssid, const uint8_t *bssid, int8_t rssi, uint8_t channel)
Log a discarded scan result at VERBOSE level (skipped during roaming scans to avoid log overflow)
int32_t get_wifi_channel()
const char * wifi_ssid_to(std::span< char, SSID_BUFFER_SIZE > buffer)
Write SSID to buffer without heap allocation.
network::IPAddress wifi_subnet_mask_()
void save_lease_settings_()
network::IPAddress wifi_soft_ap_ip()
CallbackManager< void(const char *)> dpp_uri_callback_
network::IPAddress wifi_gateway_ip_()
bool is_roaming_scan_active() const
True while a post-connect roaming scan holds the radio off-channel.
bool scan_driver_filtered_
bool is_ap_portal_active_()
captive_portal or the web_server AP mode is serving a user on the access point
bool offer_own_dns_()
DHCP offers the AP's own address while the portal is up for a station that is down,...
network::IPAddress wifi_dns_ip_(int num)
bool wifi_apply_hostname_()
bool wifi_sta_pre_setup_()
bool matches_configured_network_(const char *ssid, const uint8_t *bssid) const
void disable_ap_()
End the portals and turn the AP off.
const char * dpp_device_info_
FixedVector< WiFiAP > sta_
const char * dpp_channels_
bool wifi_ap_ip_config_(const optional< ManualIP > &manual_ip)
void update_connected_state_()
uint32_t lease_cache_max_age_
bool needs_full_scan_results_() const
Check if full scan results are needed (captive portal active, improv, listeners)
LockFreeQueue< IDFWiFiEvent, 17 > event_queue_
void on_powerdown() override
StaticVector< WiFiPowerSaveListener *, ESPHOME_WIFI_POWER_SAVE_LISTENERS > power_save_listeners_
WifiMinAuthMode min_auth_mode_
bool wifi_apply_output_power_(float output_power)
bool wifi_sta_connect_(const WiFiAP &ap)
bool wifi_mode_(optional< bool > sta, optional< bool > ap)
network::IPAddresses wifi_sta_ip_addresses()
uint8_t num_ipv6_addresses_
std::unique_ptr< char[]> dpp_uri_
void renew_cached_lease_()
void clear_sta_session_()
bool wifi_scan_start_(bool passive)
void handle_driver_roam_(const bssid_t &bssid, uint8_t channel)
Redo post-connect bookkeeping after a driver-initiated roam (e.g.
bool write_ap_dns_()
Hand the AP DHCP server its resolvers; false when one could not be set.
struct esphome::wifi::WiFiComponent::@199 pending_
const char * esp_err_to_name(esp_err_t err)
std::span< const uint8_t > data
std::array< IPAddress, 5 > IPAddresses
void fill_ip6_addresses(esp_netif_t *netif, IPAddresses &addresses)
Copies the IPv6 addresses of an esp_netif into addresses[1..], warning once when some do not fit.
std::array< uint8_t, 6 > bssid_t
const LogString * get_auth_mode_str(uint8_t mode)
ESPHOME_LOG_TAG(TAG, "wifi")
const LogString * get_disconnect_reason_str(uint8_t reason)
@ WIFI_MIN_AUTH_MODE_WPA2
@ WIFI_MIN_AUTH_MODE_WPA3
ExpectedLeave
Which expected leave a disconnect matched.
@ EXPECTED_LEAVE_ATTEMPT
An attempt that never associated, so no BSSID.
@ ERROR_NETWORK_NOT_FOUND
WiFiComponent * global_wifi_component
@ WIFI_COMPONENT_STATE_AP
WiFi is in AP-only mode and internal AP is already enabled.
@ WIFI_COMPONENT_STATE_OFF
Nothing has been initialized yet.
@ WIFI_COMPONENT_STATE_STA_CONNECTED
WiFi is in STA(+AP) mode and successfully connected.
ESPPreferences * global_preferences
void HOT delay(uint32_t ms)
Application App
Global storage of Application pointer - only one Application can exist.
char * format_mac_addr_upper(const uint8_t *mac, char *output)
Format MAC address as XX:XX:XX:XX:XX:XX (uppercase, colon separators)
struct esp_netif_obj esp_netif_t