esphome 2025.9.3__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/camera_encoder/esp32_camera_jpeg_encoder.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+
 #ifdef USE_ESP32_CAMERA_JPEG_ENCODER
 
 #include <esp_camera.h>
@@ -24,7 +26,7 @@ class ESP32CameraJPEGEncoder : public camera::Encoder {
   void dump_config() override;
   // -------------------------
  protected:
-  static size_t callback_(void *arg, size_t index, const void *data, size_t len);
+  static size_t callback(void *arg, size_t index, const void *data, size_t len);
   pixformat_t to_internal_(camera::PixelFormat format);
 
   camera::EncoderBuffer *output_{};

esphome/components/canbus/canbus.cpp

@@ -21,8 +21,8 @@ void Canbus::dump_config() {
   }
 }
 
-void Canbus::send_data(uint32_t can_id, bool use_extended_id, bool remote_transmission_request,
-                       const std::vector<uint8_t> &data) {
+canbus::Error Canbus::send_data(uint32_t can_id, bool use_extended_id, bool remote_transmission_request,
+                                const std::vector<uint8_t> &data) {
   struct CanFrame can_message;
 
   uint8_t size = static_cast<uint8_t>(data.size());
@@ -45,13 +45,15 @@ void Canbus::send_data(uint32_t can_id, bool use_extended_id, bool remote_transm
     ESP_LOGVV(TAG, "  data[%d]=%02x", i, can_message.data[i]);
   }
 
-  if (this->send_message(&can_message) != canbus::ERROR_OK) {
+  canbus::Error error = this->send_message(&can_message);
+  if (error != canbus::ERROR_OK) {
     if (use_extended_id) {
-      ESP_LOGW(TAG, "send to extended id=0x%08" PRIx32 " failed!", can_id);
+      ESP_LOGW(TAG, "send to extended id=0x%08" PRIx32 " failed with error %d!", can_id, error);
     } else {
-      ESP_LOGW(TAG, "send to standard id=0x%03" PRIx32 " failed!", can_id);
+      ESP_LOGW(TAG, "send to standard id=0x%03" PRIx32 " failed with error %d!", can_id, error);
     }
   }
+  return error;
 }
 
 void Canbus::add_trigger(CanbusTrigger *trigger) {

esphome/components/canbus/canbus.h

@@ -70,11 +70,11 @@ class Canbus : public Component {
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
   void loop() override;
 
-  void send_data(uint32_t can_id, bool use_extended_id, bool remote_transmission_request,
-                 const std::vector<uint8_t> &data);
-  void send_data(uint32_t can_id, bool use_extended_id, const std::vector<uint8_t> &data) {
+  canbus::Error send_data(uint32_t can_id, bool use_extended_id, bool remote_transmission_request,
+                          const std::vector<uint8_t> &data);
+  canbus::Error send_data(uint32_t can_id, bool use_extended_id, const std::vector<uint8_t> &data) {
     // for backwards compatibility only
-    this->send_data(can_id, use_extended_id, false, data);
+    return this->send_data(can_id, use_extended_id, false, data);
   }
   void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
   void set_use_extended_id(bool use_extended_id) { this->use_extended_id_ = use_extended_id; }

esphome/components/captive_portal/__init__.py

@@ -1,6 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import web_server_base
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
@@ -9,11 +10,19 @@ from esphome.const import (
     PLATFORM_ESP8266,
     PLATFORM_LN882X,
     PLATFORM_RTL87XX,
+    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
 
-AUTO_LOAD = ["web_server_base", "ota.web_server"]
+
+def AUTO_LOAD() -> list[str]:
+    auto_load = ["web_server_base", "ota.web_server"]
+    if CORE.using_esp_idf:
+        auto_load.append("socket")
+    return auto_load
+
+
 DEPENDENCIES = ["wifi"]
 CODEOWNERS = ["@esphome/core"]
 
@@ -58,3 +67,11 @@ async def to_code(config):
             cg.add_library("DNSServer", None)
         if CORE.is_libretiny:
             cg.add_library("DNSServer", None)
+
+
+# Only compile the ESP-IDF DNS server when using ESP-IDF framework
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "dns_server_esp32_idf.cpp": {PlatformFramework.ESP32_IDF},
+    }
+)

esphome/components/captive_portal/captive_portal.cpp

@@ -11,14 +11,14 @@ namespace captive_portal {
 static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
-  AsyncResponseStream *stream = request->beginResponseStream(F("application/json"));
-  stream->addHeader(F("cache-control"), F("public, max-age=0, must-revalidate"));
+  AsyncResponseStream *stream = request->beginResponseStream(ESPHOME_F("application/json"));
+  stream->addHeader(ESPHOME_F("cache-control"), ESPHOME_F("public, max-age=0, must-revalidate"));
 #ifdef USE_ESP8266
-  stream->print(F("{\"mac\":\""));
+  stream->print(ESPHOME_F("{\"mac\":\""));
   stream->print(get_mac_address_pretty().c_str());
-  stream->print(F("\",\"name\":\""));
+  stream->print(ESPHOME_F("\",\"name\":\""));
   stream->print(App.get_name().c_str());
-  stream->print(F("\",\"aps\":[{}"));
+  stream->print(ESPHOME_F("\",\"aps\":[{}"));
 #else
   stream->printf(R"({"mac":"%s","name":"%s","aps":[{})", get_mac_address_pretty().c_str(), App.get_name().c_str());
 #endif
@@ -29,37 +29,35 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
 
       // Assumes no " in ssid, possible unicode isses?
 #ifdef USE_ESP8266
-    stream->print(F(",{\"ssid\":\""));
+    stream->print(ESPHOME_F(",{\"ssid\":\""));
     stream->print(scan.get_ssid().c_str());
-    stream->print(F("\",\"rssi\":"));
+    stream->print(ESPHOME_F("\",\"rssi\":"));
     stream->print(scan.get_rssi());
-    stream->print(F(",\"lock\":"));
+    stream->print(ESPHOME_F(",\"lock\":"));
     stream->print(scan.get_with_auth());
-    stream->print(F("}"));
+    stream->print(ESPHOME_F("}"));
 #else
     stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", scan.get_ssid().c_str(), scan.get_rssi(),
                    scan.get_with_auth());
 #endif
   }
-  stream->print(F("]}"));
+  stream->print(ESPHOME_F("]}"));
   request->send(stream);
 }
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
-  std::string ssid = request->arg("ssid").c_str();
-  std::string psk = request->arg("psk").c_str();
+  std::string ssid = request->arg("ssid").c_str();  // NOLINT(readability-redundant-string-cstr)
+  std::string psk = request->arg("psk").c_str();    // NOLINT(readability-redundant-string-cstr)
   ESP_LOGI(TAG, "Requested WiFi Settings Change:");
   ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);
   wifi::global_wifi_component->start_scanning();
-  request->redirect(F("/?save"));
+  request->redirect(ESPHOME_F("/?save"));
 }
 
 void CaptivePortal::setup() {
-#ifndef USE_ARDUINO
-  // No DNS server needed for non-Arduino frameworks
+  // Disable loop by default - will be enabled when captive portal starts
   this->disable_loop();
-#endif
 }
 void CaptivePortal::start() {
   this->base_->init();
@@ -67,51 +65,47 @@ void CaptivePortal::start() {
     this->base_->add_handler(this);
   }
 
+  network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
+
+#ifdef USE_ESP_IDF
+  // Create DNS server instance for ESP-IDF
+  this->dns_server_ = make_unique<DNSServer>();
+  this->dns_server_->start(ip);
+#endif
 #ifdef USE_ARDUINO
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
-  network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
-  this->dns_server_->start(53, F("*"), ip);
-  // Re-enable loop() when DNS server is started
-  this->enable_loop();
-#endif
-
-  this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {
-    if (!this->active_ || req->host().c_str() == wifi::global_wifi_component->wifi_soft_ap_ip().str()) {
-      req->send(404, F("text/html"), F("File not found"));
-      return;
-    }
-
-#ifdef USE_ESP8266
-    String url = F("http://");
-    url += wifi::global_wifi_component->wifi_soft_ap_ip().str().c_str();
-#else
-    auto url = "http://" + wifi::global_wifi_component->wifi_soft_ap_ip().str();
+  this->dns_server_->start(53, ESPHOME_F("*"), ip);
 #endif
-    req->redirect(url.c_str());
-  });
 
   this->initialized_ = true;
   this->active_ = true;
+
+  // Enable loop() now that captive portal is active
+  this->enable_loop();
+
+  ESP_LOGV(TAG, "Captive portal started");
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-  if (req->url() == F("/")) {
-#ifndef USE_ESP8266
-    auto *response = req->beginResponse(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
-#else
-    auto *response = req->beginResponse_P(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
-#endif
-    response->addHeader(F("Content-Encoding"), F("gzip"));
-    req->send(response);
-    return;
-  } else if (req->url() == F("/config.json")) {
+  if (req->url() == ESPHOME_F("/config.json")) {
     this->handle_config(req);
     return;
-  } else if (req->url() == F("/wifisave")) {
+  } else if (req->url() == ESPHOME_F("/wifisave")) {
     this->handle_wifisave(req);
     return;
   }
+
+  // All other requests get the captive portal page
+  // This includes OS captive portal detection endpoints which will trigger
+  // the captive portal when they don't receive their expected responses
+#ifndef USE_ESP8266
+  auto *response = req->beginResponse(200, ESPHOME_F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+#else
+  auto *response = req->beginResponse_P(200, ESPHOME_F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+#endif
+  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
+  req->send(response);
 }
 
 CaptivePortal::CaptivePortal(web_server_base::WebServerBase *base) : base_(base) { global_captive_portal = this; }

esphome/components/captive_portal/captive_portal.h

@@ -5,6 +5,9 @@
 #ifdef USE_ARDUINO
 #include <DNSServer.h>
 #endif
+#ifdef USE_ESP_IDF
+#include "dns_server_esp32_idf.h"
+#endif
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
@@ -19,41 +22,36 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   CaptivePortal(web_server_base::WebServerBase *base);
   void setup() override;
   void dump_config() override;
-#ifdef USE_ARDUINO
   void loop() override {
+#ifdef USE_ARDUINO
     if (this->dns_server_ != nullptr) {
       this->dns_server_->processNextRequest();
-    } else {
-      this->disable_loop();
     }
-  }
 #endif
+#ifdef USE_ESP_IDF
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->process_next_request();
+    }
+#endif
+  }
   float get_setup_priority() const override;
   void start();
   bool is_active() const { return this->active_; }
   void end() {
     this->active_ = false;
+    this->disable_loop();  // Stop processing DNS requests
     this->base_->deinit();
-#ifdef USE_ARDUINO
-    this->dns_server_->stop();
-    this->dns_server_ = nullptr;
-#endif
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->stop();
+      this->dns_server_ = nullptr;
+    }
   }
 
   bool canHandle(AsyncWebServerRequest *request) const override {
-    if (!this->active_)
-      return false;
-
-    if (request->method() == HTTP_GET) {
-      if (request->url() == F("/"))
-        return true;
-      if (request->url() == F("/config.json"))
-        return true;
-      if (request->url() == F("/wifisave"))
-        return true;
-    }
-
-    return false;
+    // Handle all GET requests when captive portal is active
+    // This allows us to respond with the portal page for any URL,
+    // triggering OS captive portal detection
+    return this->active_ && request->method() == HTTP_GET;
   }
 
   void handle_config(AsyncWebServerRequest *request);
@@ -66,7 +64,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   web_server_base::WebServerBase *base_;
   bool initialized_{false};
   bool active_{false};
-#ifdef USE_ARDUINO
+#if defined(USE_ARDUINO) || defined(USE_ESP_IDF)
   std::unique_ptr<DNSServer> dns_server_{nullptr};
 #endif
 };

esphome/components/captive_portal/dns_server_esp32_idf.cpp

@@ -0,0 +1,205 @@
+#include "dns_server_esp32_idf.h"
+#ifdef USE_ESP_IDF
+
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/socket/socket.h"
+#include <lwip/sockets.h>
+#include <lwip/inet.h>
+
+namespace esphome::captive_portal {
+
+static const char *const TAG = "captive_portal.dns";
+
+// DNS constants
+static constexpr uint16_t DNS_PORT = 53;
+static constexpr uint16_t DNS_QR_FLAG = 1 << 15;
+static constexpr uint16_t DNS_OPCODE_MASK = 0x7800;
+static constexpr uint16_t DNS_QTYPE_A = 0x0001;
+static constexpr uint16_t DNS_QCLASS_IN = 0x0001;
+static constexpr uint16_t DNS_ANSWER_TTL = 300;
+
+// DNS Header structure
+struct DNSHeader {
+  uint16_t id;
+  uint16_t flags;
+  uint16_t qd_count;
+  uint16_t an_count;
+  uint16_t ns_count;
+  uint16_t ar_count;
+} __attribute__((packed));
+
+// DNS Question structure
+struct DNSQuestion {
+  uint16_t type;
+  uint16_t dns_class;
+} __attribute__((packed));
+
+// DNS Answer structure
+struct DNSAnswer {
+  uint16_t ptr_offset;
+  uint16_t type;
+  uint16_t dns_class;
+  uint32_t ttl;
+  uint16_t addr_len;
+  uint32_t ip_addr;
+} __attribute__((packed));
+
+void DNSServer::start(const network::IPAddress &ip) {
+  this->server_ip_ = ip;
+  ESP_LOGV(TAG, "Starting DNS server on %s", ip.str().c_str());
+
+  // Create loop-monitored UDP socket
+  this->socket_ = socket::socket_ip_loop_monitored(SOCK_DGRAM, IPPROTO_UDP);
+  if (this->socket_ == nullptr) {
+    ESP_LOGE(TAG, "Socket create failed");
+    return;
+  }
+
+  // Set socket options
+  int enable = 1;
+  this->socket_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+
+  // Bind to port 53
+  struct sockaddr_storage server_addr = {};
+  socklen_t addr_len = socket::set_sockaddr_any((struct sockaddr *) &server_addr, sizeof(server_addr), DNS_PORT);
+
+  int err = this->socket_->bind((struct sockaddr *) &server_addr, addr_len);
+  if (err != 0) {
+    ESP_LOGE(TAG, "Bind failed: %d", errno);
+    this->socket_ = nullptr;
+    return;
+  }
+  ESP_LOGV(TAG, "Bound to port %d", DNS_PORT);
+}
+
+void DNSServer::stop() {
+  if (this->socket_ != nullptr) {
+    this->socket_->close();
+    this->socket_ = nullptr;
+  }
+  ESP_LOGV(TAG, "Stopped");
+}
+
+void DNSServer::process_next_request() {
+  // Process one request if socket is valid and data is available
+  if (this->socket_ == nullptr || !this->socket_->ready()) {
+    return;
+  }
+  struct sockaddr_in client_addr;
+  socklen_t client_addr_len = sizeof(client_addr);
+
+  // Receive DNS request using raw fd for recvfrom
+  int fd = this->socket_->get_fd();
+  if (fd < 0) {
+    return;
+  }
+
+  ssize_t len = recvfrom(fd, this->buffer_, sizeof(this->buffer_), MSG_DONTWAIT, (struct sockaddr *) &client_addr,
+                         &client_addr_len);
+
+  if (len < 0) {
+    if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
+      ESP_LOGE(TAG, "recvfrom failed: %d", errno);
+    }
+    return;
+  }
+
+  ESP_LOGVV(TAG, "Received %d bytes from %s:%d", len, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
+
+  if (len < static_cast<ssize_t>(sizeof(DNSHeader) + 1)) {
+    ESP_LOGV(TAG, "Request too short: %d", len);
+    return;
+  }
+
+  // Parse DNS header
+  DNSHeader *header = (DNSHeader *) this->buffer_;
+  uint16_t flags = ntohs(header->flags);
+  uint16_t qd_count = ntohs(header->qd_count);
+
+  // Check if it's a standard query
+  if ((flags & DNS_QR_FLAG) || (flags & DNS_OPCODE_MASK) || qd_count != 1) {
+    ESP_LOGV(TAG, "Not a standard query: flags=0x%04X, qd_count=%d", flags, qd_count);
+    return;  // Not a standard query
+  }
+
+  // Parse domain name (we don't actually care about it - redirect everything)
+  uint8_t *ptr = this->buffer_ + sizeof(DNSHeader);
+  uint8_t *end = this->buffer_ + len;
+
+  while (ptr < end && *ptr != 0) {
+    uint8_t label_len = *ptr;
+    if (label_len > 63) {  // Check for invalid label length
+      return;
+    }
+    // Check if we have room for this label plus the length byte
+    if (ptr + label_len + 1 > end) {
+      return;  // Would overflow
+    }
+    ptr += label_len + 1;
+  }
+
+  // Check if we reached a proper null terminator
+  if (ptr >= end || *ptr != 0) {
+    return;  // Name not terminated or truncated
+  }
+  ptr++;  // Skip the null terminator
+
+  // Check we have room for the question
+  if (ptr + sizeof(DNSQuestion) > end) {
+    return;  // Request truncated
+  }
+
+  // Parse DNS question
+  DNSQuestion *question = (DNSQuestion *) ptr;
+  uint16_t qtype = ntohs(question->type);
+  uint16_t qclass = ntohs(question->dns_class);
+
+  // We only handle A queries
+  if (qtype != DNS_QTYPE_A || qclass != DNS_QCLASS_IN) {
+    ESP_LOGV(TAG, "Not an A query: type=0x%04X, class=0x%04X", qtype, qclass);
+    return;  // Not an A query
+  }
+
+  // Build DNS response by modifying the request in-place
+  header->flags = htons(DNS_QR_FLAG | 0x8000);  // Response + Authoritative
+  header->an_count = htons(1);                  // One answer
+
+  // Add answer section after the question
+  size_t question_len = (ptr + sizeof(DNSQuestion)) - this->buffer_ - sizeof(DNSHeader);
+  size_t answer_offset = sizeof(DNSHeader) + question_len;
+
+  // Check if we have room for the answer
+  if (answer_offset + sizeof(DNSAnswer) > sizeof(this->buffer_)) {
+    ESP_LOGW(TAG, "Response too large");
+    return;
+  }
+
+  DNSAnswer *answer = (DNSAnswer *) (this->buffer_ + answer_offset);
+
+  // Pointer to name in question (offset from start of packet)
+  answer->ptr_offset = htons(0xC000 | sizeof(DNSHeader));
+  answer->type = htons(DNS_QTYPE_A);
+  answer->dns_class = htons(DNS_QCLASS_IN);
+  answer->ttl = htonl(DNS_ANSWER_TTL);
+  answer->addr_len = htons(4);
+
+  // Get the raw IP address
+  ip4_addr_t addr = this->server_ip_;
+  answer->ip_addr = addr.addr;
+
+  size_t response_len = answer_offset + sizeof(DNSAnswer);
+
+  // Send response
+  ssize_t sent =
+      this->socket_->sendto(this->buffer_, response_len, 0, (struct sockaddr *) &client_addr, client_addr_len);
+  if (sent < 0) {
+    ESP_LOGV(TAG, "Send failed: %d", errno);
+  } else {
+    ESP_LOGV(TAG, "Sent %d bytes", sent);
+  }
+}
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP_IDF

esphome/components/captive_portal/dns_server_esp32_idf.h

@@ -0,0 +1,27 @@
+#pragma once
+#ifdef USE_ESP_IDF
+
+#include <memory>
+#include "esphome/core/helpers.h"
+#include "esphome/components/network/ip_address.h"
+#include "esphome/components/socket/socket.h"
+
+namespace esphome::captive_portal {
+
+class DNSServer {
+ public:
+  void start(const network::IPAddress &ip);
+  void stop();
+  void process_next_request();
+
+ protected:
+  static constexpr size_t DNS_BUFFER_SIZE = 192;
+
+  std::unique_ptr<socket::Socket> socket_{nullptr};
+  network::IPAddress server_ip_;
+  uint8_t buffer_[DNS_BUFFER_SIZE];
+};
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP_IDF

esphome/components/ccs811/ccs811.cpp

@@ -155,7 +155,7 @@ void CCS811Component::dump_config() {
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "CO2 Sensor", this->co2_);
   LOG_SENSOR("  ", "TVOC Sensor", this->tvoc_);
-  LOG_TEXT_SENSOR("  ", "Firmware Version Sensor", this->version_)
+  LOG_TEXT_SENSOR("  ", "Firmware Version Sensor", this->version_);
   if (this->baseline_) {
     ESP_LOGCONFIG(TAG, "  Baseline: %04X", *this->baseline_);
   } else {

esphome/components/climate/climate.cpp

@@ -367,9 +367,11 @@ void Climate::save_state_() {
     state.uses_custom_fan_mode = true;
     const auto &supported = traits.get_supported_custom_fan_modes();
     std::vector<std::string> vec{supported.begin(), supported.end()};
-    auto it = std::find(vec.begin(), vec.end(), custom_fan_mode);
-    if (it != vec.end()) {
-      state.custom_fan_mode = std::distance(vec.begin(), it);
+    for (size_t i = 0; i < vec.size(); i++) {
+      if (vec[i] == custom_fan_mode) {
+        state.custom_fan_mode = i;
+        break;
+      }
     }
   }
   if (traits.get_supports_presets() && preset.has_value()) {
@@ -380,10 +382,11 @@ void Climate::save_state_() {
     state.uses_custom_preset = true;
     const auto &supported = traits.get_supported_custom_presets();
     std::vector<std::string> vec{supported.begin(), supported.end()};
-    auto it = std::find(vec.begin(), vec.end(), custom_preset);
-    // only set custom preset if value exists, otherwise leave it as is
-    if (it != vec.cend()) {
-      state.custom_preset = std::distance(vec.begin(), it);
+    for (size_t i = 0; i < vec.size(); i++) {
+      if (vec[i] == custom_preset) {
+        state.custom_preset = i;
+        break;
+      }
     }
   }
   if (traits.get_supports_swing_modes()) {

esphome/components/cm1106/cm1106.cpp

@@ -13,7 +13,7 @@ static const uint8_t C_M1106_CMD_SET_CO2_CALIB_RESPONSE[4] = {0x16, 0x01, 0x03,
 
 uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
   uint8_t crc = 0;
-  for (int i = 0; i < len - 1; i++) {
+  for (size_t i = 0; i < len - 1; i++) {
     crc -= response[i];
   }
   return crc;

esphome/components/copy/lock/copy_lock.cpp

@@ -11,7 +11,7 @@ void CopyLock::setup() {
 
   traits.set_assumed_state(source_->traits.get_assumed_state());
   traits.set_requires_code(source_->traits.get_requires_code());
-  traits.set_supported_states(source_->traits.get_supported_states());
+  traits.set_supported_states_mask(source_->traits.get_supported_states_mask());
   traits.set_supports_open(source_->traits.get_supports_open());
 
   this->publish_state(source_->state);

esphome/components/cover/cover.cpp

@@ -1,5 +1,6 @@
 #include "cover.h"
 #include "esphome/core/log.h"
+#include <strings.h>
 
 namespace esphome {
 namespace cover {