Share the lwIP error mapping and address conversion, keep poll_connect in one place, and pin the socket layout

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

AGENTS.md

@@ -553,6 +553,7 @@ file does, and it is the authority when they disagree. The most useful starting
     4.  **Lint:** Run `prek` to ensure code is compliant.
     5.  **Commit:** Commit your changes. There is no strict format for commit messages.
     6.  **Pull Request:** Submit a PR against the `dev` branch. The Pull Request title must start with a `[tag]` prefix. For component work, use the component name (e.g., `[display] Fix bug`, `[abc123] Add new component`); for changes to shared/core code that isn't tied to a single component, use `[core]` (e.g., `[core] Add validator`). Update documentation, examples, and add `CODEOWNERS` entries as needed. Pull requests should always be made using the `.github/PULL_REQUEST_TEMPLATE.md` template - fill out all sections completely without removing any parts of the template.
+    7.  **Comments:** When commenting on GitHub PRs or issues, don't tag contributors, especially bots. Avoid referring to list items (e.g. from reviews) with the form #nn - this will be interpreted by GitHub as a reference to issue or PR nn. Keep comments short and exclude irrelevant details, backstories, restatement of previous comments and anything that is already obvious to the reader.
 
 *   **Documentation Contributions:**
     *   Documentation is hosted in the separate `esphome/esphome.io` repository.

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.14.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.1
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/components/api/api.proto

@@ -70,17 +70,13 @@ service APIConnection {
   rpc zwave_proxy_frame(ZWaveProxyFrame) returns (void) {}
   rpc zwave_proxy_request(ZWaveProxyRequest) returns (void) {}
 
-  rpc zigbee_proxy_request(ZigbeeProxyRequest) returns (void) {}
-
   rpc infrared_rf_transmit_raw_timings(InfraredRFTransmitRawTimingsRequest) returns (void) {}
 
   rpc serial_proxy_configure(SerialProxyConfigureRequest) returns (void) {}
   rpc serial_proxy_write(SerialProxyWriteRequest) returns (void) {}
   rpc serial_proxy_set_modem_pins(SerialProxySetModemPinsRequest) returns (void) {}
   rpc serial_proxy_get_modem_pins(SerialProxyGetModemPinsRequest) returns (void) {}
-  rpc serial_proxy_get_usb_info(SerialProxyGetUsbInfoRequest) returns (void) {}
   rpc serial_proxy_request(SerialProxyRequest) returns (void) {}
-  rpc serial_proxy_set_mode(SerialProxySetModeRequest) returns (void) {}
 }
 
 
@@ -231,11 +227,6 @@ enum SerialProxyPortType {
   SERIAL_PROXY_PORT_TYPE_TTL = 0;
   SERIAL_PROXY_PORT_TYPE_RS232 = 1;
   SERIAL_PROXY_PORT_TYPE_RS485 = 2;
-  // A serial device attached through a USB bridge. Set by the device configuration, never
-  // by the user; identifies ports whose USB identity can be read with
-  // SerialProxyGetUsbInfoRequest. Deliberately not a USB endpoint type: serial_proxy
-  // carries serial devices only, whatever bridge chip connects them.
-  SERIAL_PROXY_PORT_TYPE_USB_SERIAL = 3;
 }
 
 message SerialProxyInfo {
@@ -340,10 +331,6 @@ message DeviceInfoResponse {
   // all-zeros PSK, so the api encryption key can be provisioned without being
   // sent in plaintext (protects against passive sniffing, not active MITM)
   bool api_encryption_provisionable = 26 [(field_ifdef) = "USE_API_NOISE"];
-
-  // Indicates if Zigbee proxy support is available and features supported
-  uint32 zigbee_proxy_feature_flags = 27 [(field_ifdef) = "USE_ZIGBEE_PROXY"];
-  uint64 zigbee_ieee_address = 28 [(field_ifdef) = "USE_ZIGBEE_PROXY"];
 }
 
 // ==================== DEVICE CAPABILITIES ====================
@@ -2739,8 +2726,7 @@ enum SerialProxyParity {
   SERIAL_PROXY_PARITY_ODD = 2;
 }
 
-// Configure UART parameters for a serial proxy instance. Only the subscribed client may
-// configure the port; others are refused with PORT_IN_USE (since API 1.17).
+// Configure UART parameters for a serial proxy instance
 message SerialProxyConfigureRequest {
   option (id) = 138;
   option (source) = SOURCE_CLIENT;
@@ -2766,8 +2752,7 @@ message SerialProxyDataReceived {
   bytes data = 2;               // Raw data received from the serial device
 }
 
-// Write data to a serial device. Only the subscribed client may write; writes from
-// others are ignored (since API 1.17).
+// Write data to a serial device
 message SerialProxyWriteRequest {
   option (id) = 140;
   option (source) = SOURCE_CLIENT;
@@ -2778,8 +2763,7 @@ message SerialProxyWriteRequest {
   bytes data = 2;               // Raw data to write to the serial device
 }
 
-// Set modem control pin states (RTS and DTR). Only the subscribed client may set them;
-// others are refused with PORT_IN_USE (since API 1.17).
+// Set modem control pin states (RTS and DTR)
 message SerialProxySetModemPinsRequest {
   option (id) = 141;
   option (source) = SOURCE_CLIENT;
@@ -2818,7 +2802,6 @@ enum SerialProxyRequestType {
   // error the device answers with INVALID_ARGUMENT.
   SERIAL_PROXY_REQUEST_TYPE_CONFIGURE = 3;      // Acknowledges a SerialProxyConfigureRequest
   SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS = 4; // Acknowledges a SerialProxySetModemPinsRequest
-  SERIAL_PROXY_REQUEST_TYPE_SET_MODE = 5;       // Acknowledges a SerialProxySetModeRequest (since API 1.17)
 }
 
 enum SerialProxyStatus {
@@ -2831,8 +2814,7 @@ enum SerialProxyStatus {
   SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6; // Invalid instance index or parameter value
 }
 
-// Generic request message for simple serial proxy operations. FLUSH requires an active
-// subscription; it is refused with PORT_IN_USE otherwise (since API 1.17).
+// Generic request message for simple serial proxy operations
 message SerialProxyRequest {
   option (id) = 144;
   option (source) = SOURCE_CLIENT;
@@ -2856,59 +2838,6 @@ message SerialProxyRequestResponse {
   string error_message = 4;            // Additional detail on failure (optional)
 }
 
-// How a port treats the bytes passing through it. RAW is a plain byte pipe; PROTOCOL
-// activates the port's protocol-aware tap (if one is configured), letting it observe
-// traffic and inject protocol bytes such as acknowledgements. Which protocol the tap
-// speaks is a property of the device configuration, discoverable from the tap
-// component's own API surface. A client that is about to flash firmware selects RAW
-// first, which definitively disables that injection.
-enum SerialProxyMode {
-  SERIAL_PROXY_MODE_RAW = 0;
-  SERIAL_PROXY_MODE_PROTOCOL = 1;
-}
-
-// Only the subscribed client may change the mode; any other caller -- including one that
-// never subscribed -- is refused with PORT_IN_USE. PROTOCOL is refused with NOT_SUPPORTED
-// when the port has no protocol-aware tap configured.
-message SerialProxySetModeRequest {
-  option (id) = 152;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;
-  SerialProxyMode mode = 2;
-}
-
-// Ask for the USB identity of the device behind a USB_SERIAL port. Read-only, so no
-// subscription is required -- a client typically uses this to decide which port to
-// subscribe to. Answered with NOT_SUPPORTED on ports that are not USB_SERIAL.
-message SerialProxyGetUsbInfoRequest {
-  option (id) = 153;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;
-}
-
-// The USB identity of the device currently behind a port, read live from the cached
-// USB descriptors. Fields are zero/empty while no device is connected.
-message SerialProxyGetUsbInfoResponse {
-  option (id) = 154;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_SERIAL_PROXY";
-
-  uint32 instance = 1;
-  SerialProxyStatus status = 2;   // NOT_SUPPORTED when the port is not USB_SERIAL
-  bool connected = 3;             // True when a USB device is currently attached
-  uint32 vendor_id = 4;
-  uint32 product_id = 5;
-  uint32 bcd_device = 6;
-  uint32 interface_number = 7;    // Channel index on multi-port bridges
-  string manufacturer = 8;
-  string product = 9;
-  string serial_number = 10;
-}
-
 // ==================== BLUETOOTH CONNECTION PARAMS ====================
 message BluetoothSetConnectionParamsRequest {
   option (id) = 145;
@@ -2930,18 +2859,3 @@ message BluetoothSetConnectionParamsResponse {
   uint64 address = 1;
   int32 error = 2;
 }
-
-// ==================== ZIGBEE ====================
-
-enum ZigbeeProxyRequestType {
-  ZIGBEE_PROXY_REQUEST_TYPE_NETWORK_INFO = 0;
-}
-
-message ZigbeeProxyRequest {
-  option (id) = 155;
-  option (source) = SOURCE_BOTH;
-  option (ifdef) = "USE_ZIGBEE_PROXY";
-
-  ZigbeeProxyRequestType type = 1;
-  bytes data = 2;
-}

esphome/components/api/api_connection.cpp

@@ -48,12 +48,6 @@
 #ifdef USE_ZWAVE_PROXY
 #include "esphome/components/zwave_proxy/zwave_proxy.h"
 #endif
-#ifdef USE_ZIGBEE_PROXY
-#include "esphome/components/zigbee_proxy/zigbee_proxy.h"
-#endif
-#ifdef USE_SERIAL_PROXY_USB_INFO
-#include "esphome/components/usb_host/usb_host.h"
-#endif
 #ifdef USE_WATER_HEATER
 #include "esphome/components/water_heater/water_heater.h"
 #endif
@@ -1395,12 +1389,6 @@ void APIConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) {
 }
 #endif
 
-#ifdef USE_ZIGBEE_PROXY
-void APIConnection::on_zigbee_proxy_request(const ZigbeeProxyRequest &msg) {
-  zigbee_proxy::global_zigbee_proxy->zigbee_proxy_request(this, msg);
-}
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
 bool APIConnection::send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
   return this->send_message_smart_(a_alarm_control_panel, AlarmControlPanelStateResponse::MESSAGE_TYPE,
@@ -1654,27 +1642,6 @@ void APIConnection::on_serial_proxy_get_modem_pins_request(const SerialProxyGetM
   }
 }
 
-void APIConnection::on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  SerialProxyGetUsbInfoResponse resp{};
-  resp.instance = msg.instance;
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
-    resp.status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
-  } else {
-#ifdef USE_SERIAL_PROXY_USB_INFO
-    // The response's strings are views into this buffer, which outlives the send below
-    usb_host::UsbDeviceInfo info;
-    proxies[msg.instance]->get_usb_info(info, resp);
-#else
-    resp.status = enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
-#endif
-  }
-  if (!this->send_message(resp)) {
-    API_LOG_MSG_DROPPED(TAG, "Serial proxy response");
-  }
-}
-
 void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
   auto &proxies = App.get_serial_proxies();
   if (msg.instance >= proxies.size()) {
@@ -1694,7 +1661,6 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
       break;
     case enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE:
     case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
-    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE:
       // Response-only discriminators; never valid in a request
       ESP_LOGW(TAG, "Response-only serial proxy request type: %" PRIu32, static_cast<uint32_t>(msg.type));
       status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
@@ -1707,19 +1673,6 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
   send_serial_proxy_ack(this, msg.instance, msg.type, status);
 }
 
-void APIConnection::on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &msg) {
-  auto &proxies = App.get_serial_proxies();
-  if (msg.instance >= proxies.size()) {
-    ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
-    send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE,
-                          enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT);
-    return;
-  }
-  serial_proxy::SerialProxyResult result = proxies[msg.instance]->set_mode_from_client(this, msg.mode);
-  send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE,
-                        serial_proxy_result_to_status(result));
-}
-
 void APIConnection::send_serial_proxy_data(const SerialProxyDataReceived &msg) {
   if (!this->send_message(msg)) {
     ESP_LOGV(TAG, "Serial proxy data dropped, TCP buffer full");
@@ -1831,11 +1784,6 @@ void APIConnection::complete_authentication_() {
     zwave_proxy::global_zwave_proxy->api_connection_authenticated(this);
   }
 #endif
-#ifdef USE_ZIGBEE_PROXY
-  if (zigbee_proxy::global_zigbee_proxy != nullptr) {
-    zigbee_proxy::global_zigbee_proxy->api_connection_authenticated(this);
-  }
-#endif
 }
 
 bool APIConnection::send_hello_response_(const HelloRequest &msg) {
@@ -1851,7 +1799,7 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 17;
+  resp.api_version_minor = 16;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
   resp.server_info = ESPHOME_VERSION_REF;
   resp.name = StringRef(App.get_name());
@@ -1988,10 +1936,6 @@ bool APIConnection::send_device_info_response_() {
     info.configured_line_states = proxy->get_configured_modem_pins();
   }
 #endif
-#ifdef USE_ZIGBEE_PROXY
-  resp.zigbee_proxy_feature_flags = zigbee_proxy::global_zigbee_proxy->get_feature_flags();
-  resp.zigbee_ieee_address = zigbee_proxy::global_zigbee_proxy->get_ieee_address();
-#endif
 #ifdef USE_API_NOISE
   resp.api_encryption_supported = true;
 #ifndef USE_API_NOISE_PSK_FROM_YAML

esphome/components/api/api_connection.h

@@ -223,10 +223,6 @@ class APIConnection final : public APIServerConnectionBase {
   void on_z_wave_proxy_request(const ZWaveProxyRequest &msg);
 #endif
 
-#ifdef USE_ZIGBEE_PROXY
-  void on_zigbee_proxy_request(const ZigbeeProxyRequest &msg);
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
   bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
   void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg);
@@ -247,9 +243,7 @@ class APIConnection final : public APIServerConnectionBase {
   void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg);
   void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg);
   void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg);
-  void on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &msg);
   void on_serial_proxy_request(const SerialProxyRequest &msg);
-  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &msg);
   void send_serial_proxy_data(const SerialProxyDataReceived &msg);
 #endif
 

esphome/components/api/api_pb2.cpp

@@ -175,12 +175,6 @@ uint8_t *DeviceInfoResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_
 #endif
 #ifdef USE_API_NOISE
   ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 26, this->api_encryption_provisionable);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, this->zigbee_proxy_feature_flags);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 28, this->zigbee_ieee_address);
 #endif
   return pos;
 }
@@ -246,12 +240,6 @@ uint32_t DeviceInfoResponse::calculate_size() const {
 #endif
 #ifdef USE_API_NOISE
   size += ProtoSize::calc_bool(2, this->api_encryption_provisionable);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  size += ProtoSize::calc_uint32(2, this->zigbee_proxy_feature_flags);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  size += ProtoSize::calc_uint64(2, this->zigbee_ieee_address);
 #endif
   return size;
 }
@@ -4265,57 +4253,6 @@ uint32_t SerialProxyRequestResponse::calculate_size() const {
   size += ProtoSize::calc_length(1, this->error_message.size());
   return size;
 }
-bool SerialProxySetModeRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value;
-      break;
-    case 2:
-      this->mode = static_cast<enums::SerialProxyMode>(value);
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-bool SerialProxyGetUsbInfoRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
-  switch (field_id) {
-    case 1:
-      this->instance = value;
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-uint8_t *SerialProxyGetUsbInfoResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->status));
-  ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->connected);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->vendor_id);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->product_id);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->bcd_device);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->interface_number);
-  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->manufacturer);
-  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->product);
-  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->serial_number);
-  return pos;
-}
-uint32_t SerialProxyGetUsbInfoResponse::calculate_size() const {
-  uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->instance);
-  size += this->status ? 2 : 0;
-  size += ProtoSize::calc_bool(1, this->connected);
-  size += ProtoSize::calc_uint32(1, this->vendor_id);
-  size += ProtoSize::calc_uint32(1, this->product_id);
-  size += ProtoSize::calc_uint32(1, this->bcd_device);
-  size += ProtoSize::calc_uint32(1, this->interface_number);
-  size += ProtoSize::calc_length(1, this->manufacturer.size());
-  size += ProtoSize::calc_length(1, this->product.size());
-  size += ProtoSize::calc_length(1, this->serial_number.size());
-  return size;
-}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 bool BluetoothSetConnectionParamsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -4353,41 +4290,5 @@ uint32_t BluetoothSetConnectionParamsResponse::calculate_size() const {
   return size;
 }
 #endif
-#ifdef USE_ZIGBEE_PROXY
-bool ZigbeeProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
-  switch (field_id) {
-    case 1:
-      this->type = static_cast<enums::ZigbeeProxyRequestType>(value);
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-bool ZigbeeProxyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
-  switch (field_id) {
-    case 2: {
-      this->data = value.data();
-      this->data_len = value.size();
-      break;
-    }
-    default:
-      return false;
-  }
-  return true;
-}
-uint8_t *ZigbeeProxyRequest::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->type));
-  ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, this->data, this->data_len);
-  return pos;
-}
-uint32_t ZigbeeProxyRequest::calculate_size() const {
-  uint32_t size = 0;
-  size += this->type ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->data_len);
-  return size;
-}
-#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2.h

@@ -23,7 +23,6 @@ enum SerialProxyPortType : uint32_t {
   SERIAL_PROXY_PORT_TYPE_TTL = 0,
   SERIAL_PROXY_PORT_TYPE_RS232 = 1,
   SERIAL_PROXY_PORT_TYPE_RS485 = 2,
-  SERIAL_PROXY_PORT_TYPE_USB_SERIAL = 3,
 };
 enum EntityCategory : uint32_t {
   ENTITY_CATEGORY_NONE = 0,
@@ -357,7 +356,6 @@ enum SerialProxyRequestType : uint32_t {
   SERIAL_PROXY_REQUEST_TYPE_FLUSH = 2,
   SERIAL_PROXY_REQUEST_TYPE_CONFIGURE = 3,
   SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS = 4,
-  SERIAL_PROXY_REQUEST_TYPE_SET_MODE = 5,
 };
 enum SerialProxyStatus : uint32_t {
   SERIAL_PROXY_STATUS_OK = 0,
@@ -368,15 +366,6 @@ enum SerialProxyStatus : uint32_t {
   SERIAL_PROXY_STATUS_PORT_IN_USE = 5,
   SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6,
 };
-enum SerialProxyMode : uint32_t {
-  SERIAL_PROXY_MODE_RAW = 0,
-  SERIAL_PROXY_MODE_PROTOCOL = 1,
-};
-#endif
-#ifdef USE_ZIGBEE_PROXY
-enum ZigbeeProxyRequestType : uint32_t {
-  ZIGBEE_PROXY_REQUEST_TYPE_NETWORK_INFO = 0,
-};
 #endif
 
 }  // namespace enums
@@ -560,7 +549,7 @@ class SerialProxyInfo final : public ProtoMessage {
 class DeviceInfoResponse final : public ProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 10;
-  static constexpr uint16_t ESTIMATED_SIZE = 322;
+  static constexpr uint16_t ESTIMATED_SIZE = 312;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("device_info_response"); }
 #endif
@@ -618,12 +607,6 @@ class DeviceInfoResponse final : public ProtoMessage {
 #endif
 #ifdef USE_API_NOISE
   bool api_encryption_provisionable{false};
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  uint32_t zigbee_proxy_feature_flags{0};
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  uint64_t zigbee_ieee_address{0};
 #endif
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
   uint32_t calculate_size() const;
@@ -3420,62 +3403,6 @@ class SerialProxyRequestResponse final : public ProtoMessage {
 
  protected:
 };
-class SerialProxySetModeRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint16_t MESSAGE_TYPE = 152;
-  static constexpr uint8_t ESTIMATED_SIZE = 6;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("serial_proxy_set_mode_request"); }
-#endif
-  uint32_t instance{0};
-  enums::SerialProxyMode mode{};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
-};
-class SerialProxyGetUsbInfoRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint16_t MESSAGE_TYPE = 153;
-  static constexpr uint8_t ESTIMATED_SIZE = 4;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("serial_proxy_get_usb_info_request"); }
-#endif
-  uint32_t instance{0};
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
-};
-class SerialProxyGetUsbInfoResponse final : public ProtoMessage {
- public:
-  static constexpr uint16_t MESSAGE_TYPE = 154;
-  static constexpr uint8_t ESTIMATED_SIZE = 51;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("serial_proxy_get_usb_info_response"); }
-#endif
-  uint32_t instance{0};
-  enums::SerialProxyStatus status{};
-  bool connected{false};
-  uint32_t vendor_id{0};
-  uint32_t product_id{0};
-  uint32_t bcd_device{0};
-  uint32_t interface_number{0};
-  StringRef manufacturer{};
-  StringRef product{};
-  StringRef serial_number{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 class BluetoothSetConnectionParamsRequest final : public ProtoDecodableMessage {
@@ -3515,27 +3442,5 @@ class BluetoothSetConnectionParamsResponse final : public ProtoMessage {
  protected:
 };
 #endif
-#ifdef USE_ZIGBEE_PROXY
-class ZigbeeProxyRequest final : public ProtoDecodableMessage {
- public:
-  static constexpr uint16_t MESSAGE_TYPE = 155;
-  static constexpr uint8_t ESTIMATED_SIZE = 21;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("zigbee_proxy_request"); }
-#endif
-  enums::ZigbeeProxyRequestType type{};
-  const uint8_t *data{nullptr};
-  uint16_t data_len{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
-  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
-};
-#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2_defines.h

@@ -3,8 +3,10 @@
 #pragma once
 
 #include "esphome/core/defines.h"
+#if defined(USE_BLUETOOTH_PROXY) || defined(USE_BLUETOOTH_PROXY_CONNECTIONS)
 #ifndef USE_API_VARINT64
 #define USE_API_VARINT64
 #endif
+#endif
 
 namespace esphome::api {}  // namespace esphome::api

esphome/components/api/api_pb2_dump.cpp

@@ -143,8 +143,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyPortType>(enums::S
       return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS232");
     case enums::SERIAL_PROXY_PORT_TYPE_RS485:
       return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS485");
-    case enums::SERIAL_PROXY_PORT_TYPE_USB_SERIAL:
-      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_USB_SERIAL");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -856,8 +854,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyRequestType>(enums
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_CONFIGURE");
     case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS");
-    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE:
-      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SET_MODE");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -882,26 +878,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyStatus>(enums::Ser
       return ESPHOME_PSTR("UNKNOWN");
   }
 }
-template<> const char *proto_enum_to_string<enums::SerialProxyMode>(enums::SerialProxyMode value) {
-  switch (value) {
-    case enums::SERIAL_PROXY_MODE_RAW:
-      return ESPHOME_PSTR("SERIAL_PROXY_MODE_RAW");
-    case enums::SERIAL_PROXY_MODE_PROTOCOL:
-      return ESPHOME_PSTR("SERIAL_PROXY_MODE_PROTOCOL");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
-#endif
-#ifdef USE_ZIGBEE_PROXY
-template<> const char *proto_enum_to_string<enums::ZigbeeProxyRequestType>(enums::ZigbeeProxyRequestType value) {
-  switch (value) {
-    case enums::ZIGBEE_PROXY_REQUEST_TYPE_NETWORK_INFO:
-      return ESPHOME_PSTR("ZIGBEE_PROXY_REQUEST_TYPE_NETWORK_INFO");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
 #endif
 
 const char *HelloRequest::dump_to(DumpBuffer &out) const {
@@ -1032,12 +1008,6 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
 #endif
 #ifdef USE_API_NOISE
   dump_field(out, ESPHOME_PSTR("api_encryption_provisionable"), this->api_encryption_provisionable);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  dump_field(out, ESPHOME_PSTR("zigbee_proxy_feature_flags"), this->zigbee_proxy_feature_flags);
-#endif
-#ifdef USE_ZIGBEE_PROXY
-  dump_field(out, ESPHOME_PSTR("zigbee_ieee_address"), this->zigbee_ieee_address);
 #endif
   return out.c_str();
 }
@@ -2835,31 +2805,6 @@ const char *SerialProxyRequestResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("error_message"), this->error_message);
   return out.c_str();
 }
-const char *SerialProxySetModeRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxySetModeRequest"));
-  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
-  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::SerialProxyMode>(this->mode));
-  return out.c_str();
-}
-const char *SerialProxyGetUsbInfoRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetUsbInfoRequest"));
-  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
-  return out.c_str();
-}
-const char *SerialProxyGetUsbInfoResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetUsbInfoResponse"));
-  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
-  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::SerialProxyStatus>(this->status));
-  dump_field(out, ESPHOME_PSTR("connected"), this->connected);
-  dump_field(out, ESPHOME_PSTR("vendor_id"), this->vendor_id);
-  dump_field(out, ESPHOME_PSTR("product_id"), this->product_id);
-  dump_field(out, ESPHOME_PSTR("bcd_device"), this->bcd_device);
-  dump_field(out, ESPHOME_PSTR("interface_number"), this->interface_number);
-  dump_field(out, ESPHOME_PSTR("manufacturer"), this->manufacturer);
-  dump_field(out, ESPHOME_PSTR("product"), this->product);
-  dump_field(out, ESPHOME_PSTR("serial_number"), this->serial_number);
-  return out.c_str();
-}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 const char *BluetoothSetConnectionParamsRequest::dump_to(DumpBuffer &out) const {
@@ -2878,14 +2823,6 @@ const char *BluetoothSetConnectionParamsResponse::dump_to(DumpBuffer &out) const
   return out.c_str();
 }
 #endif
-#ifdef USE_ZIGBEE_PROXY
-const char *ZigbeeProxyRequest::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("ZigbeeProxyRequest"));
-  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ZigbeeProxyRequestType>(this->type));
-  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
-  return out.c_str();
-}
-#endif
 
 }  // namespace esphome::api
 

esphome/components/api/api_pb2_service.cpp

@@ -712,39 +712,6 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
       this->on_device_capabilities_request();
       break;
     }
-#ifdef USE_SERIAL_PROXY
-    case SerialProxySetModeRequest::MESSAGE_TYPE: {
-      SerialProxySetModeRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_set_mode_request"), msg);
-#endif
-      this->on_serial_proxy_set_mode_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_SERIAL_PROXY
-    case SerialProxyGetUsbInfoRequest::MESSAGE_TYPE: {
-      SerialProxyGetUsbInfoRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_serial_proxy_get_usb_info_request"), msg);
-#endif
-      this->on_serial_proxy_get_usb_info_request(msg);
-      break;
-    }
-#endif
-#ifdef USE_ZIGBEE_PROXY
-    case ZigbeeProxyRequest::MESSAGE_TYPE: {
-      ZigbeeProxyRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_zigbee_proxy_request"), msg);
-#endif
-      this->on_zigbee_proxy_request(msg);
-      break;
-    }
-#endif
     default:
       break;
   }

esphome/components/api/api_pb2_service.h

@@ -235,20 +235,9 @@ class APIServerConnectionBase {
   void on_serial_proxy_request(const SerialProxyRequest &value){};
 #endif
 
-#ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &value){};
-#endif
-#ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &value){};
-#endif
-
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
   void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif
-
-#ifdef USE_ZIGBEE_PROXY
-  void on_zigbee_proxy_request(const ZigbeeProxyRequest &value){};
-#endif
 };
 
 }  // namespace esphome::api

esphome/components/api/api_server.cpp

@@ -404,14 +404,6 @@ void APIServer::on_zwave_proxy_request(const ZWaveProxyRequest &msg) {
 }
 #endif
 
-#ifdef USE_ZIGBEE_PROXY
-void APIServer::on_zigbee_proxy_request(const ZigbeeProxyRequest &msg) {
-  // Very infrequent and small - send to all clients rather than tracking a subscription
-  for (auto &c : this->active_clients())
-    c->send_message(msg);
-}
-#endif
-
 #if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
 void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_id, uint32_t key,
                                                const std::vector<int32_t> *timings) {

esphome/components/api/api_server.h

@@ -189,9 +189,6 @@ class APIServer final : public Component,
 #ifdef USE_ZWAVE_PROXY
   void on_zwave_proxy_request(const ZWaveProxyRequest &msg);
 #endif
-#ifdef USE_ZIGBEE_PROXY
-  void on_zigbee_proxy_request(const ZigbeeProxyRequest &msg);
-#endif
 #if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
   void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif

esphome/components/async_tcp/async_tcp_socket.cpp

@@ -6,7 +6,6 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/log.h"
 #include <cerrno>
-#include <sys/select.h>
 
 namespace esphome::async_tcp {
 
@@ -42,7 +41,16 @@ bool AsyncClient::connect(const char *host, uint16_t port) {
     return false;
   }
 
-  socket_->setblocking(false);
+  if (socket_->setblocking(false) != 0) {
+    // Capture before the log and reset() below can clobber errno; a blocking
+    // connect()/read() would otherwise stall the whole loop
+    const int saved_errno = errno;
+    ESP_LOGE(TAG, "Failed to set nonblocking: errno %d", saved_errno);
+    close();
+    if (error_cb_)
+      error_cb_(error_arg_, this, saved_errno);
+    return false;
+  }
 
   int err = socket_->connect((struct sockaddr *) &addr, addrlen);
   if (err == 0) {
@@ -97,45 +105,22 @@ void AsyncClient::loop() {
     return;
 
   if (connecting_) {
-    // For connecting, we need to check writability, not readability
-    // The Application's select() only monitors read FDs, so we do our own check here
-    // For ESP platforms lwip_select() might be faster, but this code isn't used
-    // on those platforms anyway. If it was, we'd fix the Application select()
-    // to report writability instead of doing it this way.
-    int fd = socket_->get_fd();
-    if (fd < 0) {
-      ESP_LOGW(TAG, "Invalid socket fd");
-      close();
-      return;
-    }
-
-    fd_set writefds;
-    FD_ZERO(&writefds);
-    FD_SET(fd, &writefds);
-
-    struct timeval tv = {0, 0};
-    int ret = select(fd + 1, nullptr, &writefds, nullptr, &tv);
-
-    if (ret > 0 && FD_ISSET(fd, &writefds)) {
-      int error = 0;
-      socklen_t len = sizeof(error);
-      if (socket_->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) == 0 && error == 0) {
+    int err = 0;
+    switch (socket::poll_connect(*socket_, err)) {
+      case socket::ConnectPollResult::CONNECT_POLL_PENDING:
+        break;
+      case socket::ConnectPollResult::CONNECT_POLL_CONNECTED:
         connecting_ = false;
         connected_ = true;
         if (connect_cb_)
           connect_cb_(connect_arg_, this);
-      } else {
-        ESP_LOGW(TAG, "Connection failed: %d", error);
+        break;
+      case socket::ConnectPollResult::CONNECT_POLL_ERROR:
+        ESP_LOGW(TAG, "Connection failed: %d", err);
         close();
         if (error_cb_)
-          error_cb_(error_arg_, this, error);
-      }
-    } else if (ret < 0) {
-      const int err = errno;
-      ESP_LOGE(TAG, "Select error: %d", err);
-      close();
-      if (error_cb_)
-        error_cb_(error_arg_, this, err);
+          error_cb_(error_arg_, this, err);
+        break;
     }
   } else if (connected_) {
     // For connected sockets, use the Application's select() results

esphome/components/esp32_ble/ble.cpp

@@ -100,21 +100,38 @@ void ESP32BLE::disable() {
 #ifdef USE_ESP32_BLE_ADVERTISING
 void ESP32BLE::advertising_start() {
   this->advertising_init_();
-  if (!this->is_active())
+  this->advertising_ref_count_++;
+  this->advertising_refresh();
+}
+
+void ESP32BLE::advertising_stop() {
+  if (this->advertising_ref_count_ == 0)
     return;
-  this->advertising_->start();
+  this->advertising_ref_count_--;
+  this->advertising_refresh();
+}
+
+void ESP32BLE::advertising_refresh() {
+  if (this->advertising_ == nullptr || !this->is_active())
+    return;
+  // Advertise while any component still needs it, otherwise stop
+  if (this->advertising_ref_count_ == 0) {
+    this->advertising_->stop();
+  } else {
+    this->advertising_->start();
+  }
 }
 
 void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
   this->advertising_init_();
   this->advertising_->set_service_data(data);
-  this->advertising_start();
+  this->advertising_refresh();
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
-  this->advertising_start();
+  this->advertising_refresh();
 }
 
 void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name) {
@@ -136,7 +153,7 @@ void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> da
     this->advertising_->set_service_data(data);
   }
 
-  this->advertising_start();
+  this->advertising_refresh();
 }
 
 void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback) {
@@ -147,13 +164,13 @@ void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<voi
 void ESP32BLE::advertising_add_service_uuid(ESPBTUUID uuid) {
   this->advertising_init_();
   this->advertising_->add_service_uuid(uuid);
-  this->advertising_start();
+  this->advertising_refresh();
 }
 
 void ESP32BLE::advertising_remove_service_uuid(ESPBTUUID uuid) {
   this->advertising_init_();
   this->advertising_->remove_service_uuid(uuid);
-  this->advertising_start();
+  this->advertising_refresh();
 }
 #endif
 
@@ -575,6 +592,10 @@ void ESP32BLE::loop_handle_state_transition_not_active_() {
     }
 
     this->state_ = BLE_COMPONENT_STATE_ACTIVE;
+#ifdef USE_ESP32_BLE_ADVERTISING
+    // Requests made before the stack was up (or before it was re-enabled) take effect now
+    this->advertising_refresh();
+#endif
   }
 }
 

esphome/components/esp32_ble/ble.h

@@ -114,7 +114,17 @@ class ESP32BLE final : public Component {
   void set_name(const char *name) { this->name_ = name; }
 
 #ifdef USE_ESP32_BLE_ADVERTISING
+  /** Request advertising on behalf of a component.
+   *
+   * Requests are reference counted: advertising runs until every component that called
+   * advertising_start() has released it again with advertising_stop(). Each component must
+   * pair its calls, so nothing advertises until something actually asks for it.
+   */
   void advertising_start();
+  /// Release a request made with advertising_start(); advertising stops at the last release.
+  void advertising_stop();
+  /// Apply the current payload and request count: advertise while requested, otherwise stop.
+  void advertising_refresh();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
@@ -226,6 +236,9 @@ class ESP32BLE final : public Component {
   // 1-byte aligned members (grouped together to minimize padding)
   BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
   bool enable_on_boot_{};                             // 1 byte
+#ifdef USE_ESP32_BLE_ADVERTISING
+  uint8_t advertising_ref_count_{0};  // 1 byte, number of components requesting advertising
+#endif
 
 #ifdef ESPHOME_ESP32_BLE_EXTENDED_AUTH_PARAMS
   optional<esp_ble_auth_req_t> auth_req_mode_;

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -67,6 +67,8 @@ void ESP32BLEBeacon::setup() {
       this->on_advertise_();
     }
   });
+  // A beacon always needs the device to advertise, and never releases the request
+  global_ble->advertising_start();
 }
 
 void ESP32BLEBeacon::on_advertise_() {

esphome/components/esp32_ble_server/__init__.py

@@ -596,6 +596,18 @@ async def to_code(config):
     cg.add(var.set_parent(parent))
     cg.add(parent.advertising_set_appearance(config[CONF_APPEARANCE]))
     cg.add(var.set_max_clients(config[CONF_MAX_CLIENTS]))
+    # Only advertise for the server itself when the configuration gives clients something to
+    # find. A server that is auto-loaded purely to host a runtime service (esp32_improv) stays
+    # silent until that service asks for advertising.
+    cg.add(
+        var.set_advertising_required(
+            CONF_MANUFACTURER_DATA in config
+            or any(
+                not uuid_is(service_config[CONF_UUID], DEVICE_INFORMATION_SERVICE_UUID)
+                for service_config in config[CONF_SERVICES]
+            )
+        )
+    )
     if CONF_MANUFACTURER_DATA in config:
         cg.add(var.set_manufacturer_data(config[CONF_MANUFACTURER_DATA]))
     for service_config in config[CONF_SERVICES]:

esphome/components/esp32_ble_server/ble_server.cpp

@@ -81,6 +81,7 @@ void BLEServer::loop() {
       if (this->device_information_service_->is_running()) {
         this->state_ = RUNNING;
         this->restart_advertising_();
+        this->request_advertising_();
         ESP_LOGD(TAG, "BLE server setup successfully");
       } else if (this->device_information_service_->is_created()) {
         this->device_information_service_->start();
@@ -98,6 +99,20 @@ void BLEServer::restart_advertising_() {
   }
 }
 
+void BLEServer::request_advertising_() {
+  if (!this->advertising_required_ || this->advertising_requested_)
+    return;
+  this->advertising_requested_ = true;
+  this->parent_->advertising_start();
+}
+
+void BLEServer::release_advertising_() {
+  if (!this->advertising_requested_)
+    return;
+  this->advertising_requested_ = false;
+  this->parent_->advertising_stop();
+}
+
 BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char uuid_buf[esp32_ble::UUID_STR_LEN];
@@ -170,7 +185,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
       this->add_client_(param->connect.conn_id);
       // Resume advertising so additional clients can discover and connect
       if (this->client_count_ < this->max_clients_) {
-        this->parent_->advertising_start();
+        this->parent_->advertising_refresh();
       }
       this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
       break;
@@ -178,7 +193,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
     case ESP_GATTS_DISCONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client disconnected");
       this->remove_client_(param->disconnect.conn_id);
-      this->parent_->advertising_start();
+      this->parent_->advertising_refresh();
       this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
       break;
     }
@@ -226,6 +241,8 @@ void BLEServer::remove_client_(uint16_t conn_id) {
 }
 
 void BLEServer::ble_before_disabled_event_handler() {
+  // Advertising is re-requested once the server is running again after BLE is re-enabled
+  this->release_advertising_();
   // Delete all clients
   this->client_count_ = 0;
   // Delete all services

esphome/components/esp32_ble_server/ble_server.h

@@ -38,6 +38,13 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
     this->restart_advertising_();
   }
 
+  /** Whether this server needs the device to advertise so clients can find and connect to it.
+   *
+   * False for a server that only hosts services created at runtime (e.g. esp32_improv), which
+   * request advertising themselves for as long as they need it.
+   */
+  void set_advertising_required(bool required) { this->advertising_required_ = required; }
+
   void set_max_clients(uint8_t max_clients) { this->max_clients_ = max_clients; }
   uint8_t get_max_clients() const { return this->max_clients_; }
 
@@ -82,6 +89,8 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
   };
 
   void restart_advertising_();
+  void request_advertising_();
+  void release_advertising_();
 
   int8_t find_client_index_(uint16_t conn_id) const;
   void add_client_(uint16_t conn_id);
@@ -93,6 +102,8 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
   std::vector<uint8_t> manufacturer_data_{};
   esp_gatt_if_t gatts_if_{0};
   bool registered_{false};
+  bool advertising_required_{true};
+  bool advertising_requested_{false};
 
   uint16_t clients_[USE_ESP32_BLE_MAX_CONNECTIONS]{};
   uint8_t client_count_{0};

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -112,6 +112,7 @@ void ESP32ImprovComponent::loop() {
       this->state_callback_.call(this->state_, this->error_state_);
 #endif
     }
+    this->release_advertising_();
     this->incoming_data_.clear();
     return;
   }
@@ -143,8 +144,9 @@ void ESP32ImprovComponent::loop() {
           ESP_LOGV(TAG, "Starting with device name advertising");
           this->advertising_device_name_ = true;
           this->last_name_adv_time_ = App.get_loop_component_start_time();
+          // Set the payload before requesting, so advertising starts exactly once
           esp32_ble::global_ble->advertising_set_service_data_and_name(std::span<const uint8_t>{}, true);
-          esp32_ble::global_ble->advertising_start();
+          this->request_advertising_();
 
           // Set initial state based on whether we have an authorizer
           this->set_state_(this->get_initial_state_(), false);
@@ -326,6 +328,8 @@ void ESP32ImprovComponent::stop() {
   this->set_timeout("end-service", STOP_ADVERTISING_DELAY, [this] {
     if (this->state_ == improv::STATE_STOPPED || this->service_ == nullptr)
       return;
+    // Release first so removing the service UUID does not restart advertising on the way out
+    this->release_advertising_();
     this->service_->stop();
     this->set_state_(improv::STATE_STOPPED);
   });
@@ -520,6 +524,20 @@ void ESP32ImprovComponent::update_advertising_type_() {
   }
 }
 
+void ESP32ImprovComponent::request_advertising_() {
+  if (this->advertising_requested_)
+    return;
+  this->advertising_requested_ = true;
+  esp32_ble::global_ble->advertising_start();
+}
+
+void ESP32ImprovComponent::release_advertising_() {
+  if (!this->advertising_requested_)
+    return;
+  this->advertising_requested_ = false;
+  esp32_ble::global_ble->advertising_stop();
+}
+
 improv::State ESP32ImprovComponent::get_initial_state_() const {
 #ifdef USE_BINARY_SENSOR
   // If we have an authorizer, start in awaiting authorization state

esphome/components/esp32_improv/esp32_improv_component.h

@@ -104,8 +104,11 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
   bool status_indicator_state_{false};
   uint32_t last_name_adv_time_{0};
   bool advertising_device_name_{false};
+  bool advertising_requested_{false};
   void set_status_indicator_state_(bool state);
   void update_advertising_type_();
+  void request_advertising_();
+  void release_advertising_();
 
   void set_state_(improv::State state, bool update_advertising = true);
   void set_error_(improv::Error error);

esphome/components/esphome/ota/ota_esphome.cpp

@@ -407,7 +407,10 @@ void ESPHomeOTAComponent::handle_data_() {
   tv.tv_usec = 0;
   this->client_->setsockopt(SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
   this->client_->setsockopt(SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
-  this->client_->setblocking(true);
+  if (this->client_->setblocking(true) != 0) {
+    this->log_socket_error_(LOG_STR("blocking"));
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+  }
 
   // Acknowledge auth OK - 1 byte
   this->data_write_byte_(ota::OTA_RESPONSE_AUTH_OK);

esphome/components/serial_proxy/__init__.py

@@ -18,10 +18,9 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_NAME, CONF_UART_ID
+from esphome.const import CONF_ID, CONF_NAME
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-import esphome.final_validate as fv
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@kbx81"]
@@ -31,18 +30,14 @@ MULTI_CONF = True
 
 serial_proxy_ns = cg.esphome_ns.namespace("serial_proxy")
 SerialProxy = serial_proxy_ns.class_("SerialProxy", cg.Component, uart.UARTDevice)
-SerialProxyTap = serial_proxy_ns.class_("SerialProxyTap")
 
 api_enums_ns = cg.esphome_ns.namespace("api").namespace("enums")
 SerialProxyPortType = api_enums_ns.enum("SerialProxyPortType")
-# User-selectable electrical types. USB_SERIAL is deliberately absent: it is derived
-# from the uart_id pointing at a usb_uart channel, never set by the user.
 SERIAL_PROXY_PORT_TYPES = {
     "TTL": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_TTL,
     "RS232": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_RS232,
     "RS485": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_RS485,
 }
-PORT_TYPE_USB_SERIAL = SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_USB_SERIAL
 
 CONF_DTR_PIN = "dtr_pin"
 CONF_PORT_TYPE = "port_type"
@@ -67,7 +62,7 @@ CONFIG_SCHEMA = (
         {
             cv.GenerateID(): cv.declare_id(SerialProxy),
             cv.Required(CONF_NAME): cv.string_strict,
-            cv.Optional(CONF_PORT_TYPE): cv.enum(SERIAL_PROXY_PORT_TYPES, upper=True),
+            cv.Required(CONF_PORT_TYPE): cv.enum(SERIAL_PROXY_PORT_TYPES, upper=True),
             cv.Optional(CONF_RTS_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_DTR_PIN): pins.gpio_output_pin_schema,
         }
@@ -77,26 +72,6 @@ CONFIG_SCHEMA = (
 )
 
 
-def _uses_usb_uart(config: ConfigType, full_config: ConfigType) -> bool:
-    from esphome.components.usb_uart import is_usb_uart_channel
-
-    return is_usb_uart_channel(config[CONF_UART_ID], full_config)
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    if _uses_usb_uart(config, fv.full_config.get()):
-        if CONF_PORT_TYPE in config:
-            raise cv.Invalid(
-                f"{CONF_PORT_TYPE} is set automatically for USB serial ports"
-            )
-    elif CONF_PORT_TYPE not in config:
-        raise cv.Invalid(f"{CONF_PORT_TYPE} is required")
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _add_serial_proxy_count_define() -> None:
     """Emit the SERIAL_PROXY_COUNT define once with the final instance count."""
@@ -111,13 +86,7 @@ async def to_code(config: ConfigType) -> None:
     await uart.register_uart_device(var, config)
     cg.add(cg.App.register_serial_proxy(var))
     cg.add(var.set_name(config[CONF_NAME]))
-    if _uses_usb_uart(config, CORE.config):
-        cg.add(var.set_port_type(PORT_TYPE_USB_SERIAL))
-        channel = await cg.get_variable(config[CONF_UART_ID])
-        cg.add(var.set_usb_channel(channel))
-        cg.add_define("USE_SERIAL_PROXY_USB_INFO")
-    else:
-        cg.add(var.set_port_type(config[CONF_PORT_TYPE]))
+    cg.add(var.set_port_type(config[CONF_PORT_TYPE]))
     cg.add_define("USE_SERIAL_PROXY")
 
     # Track instance count for the FINAL priority define

esphome/components/serial_proxy/serial_proxy.cpp

@@ -12,10 +12,6 @@
 #include "esphome/components/api/api_server.h"
 #endif
 
-#ifdef USE_SERIAL_PROXY_USB_INFO
-#include "esphome/components/usb_uart/usb_uart.h"
-#endif
-
 namespace esphome::serial_proxy {
 
 static const char *const TAG = "serial_proxy";
@@ -33,57 +29,26 @@ void SerialProxy::setup() {
 #ifdef USE_API
   // instance_index_ is fixed at registration time; pre-set it so loop() only needs to update data
   this->outgoing_msg_.instance = this->instance_index_;
-#endif
-#ifdef USE_SERIAL_PROXY_TAP
-  // A tap sets itself up before this runs (its setup priority is higher), so it may
-  // already be waiting on the port -- a boot-time handshake with the device, say. Leaving
-  // the loop enabled is what lets that finish; without it the tap would stall until a
-  // client happened to subscribe.
-  if (this->tap_ != nullptr && this->tap_->tap_needs_port()) {
-    return;
-  }
 #endif
   // No subscriber at startup; disable loop until a client subscribes
   this->disable_loop();
 }
 
-#ifdef USE_SERIAL_PROXY_TAP
-void SerialProxy::reset_mode_() {
-  // The mode belongs to a session, not to the port. Carrying a departed client's choice
-  // over to the next one would inject protocol bytes into a stream that never asked for
-  // them -- a firmware upload, or any client built before this request existed and so
-  // unable to turn it off. Guessing RAW is the safe direction: a client that wanted
-  // protocol handling and did not ask for it merely sends its own acknowledgements.
-  if (this->mode_ == api::enums::SERIAL_PROXY_MODE_RAW) {
-    return;
-  }
-  ESP_LOGD(TAG, "Session ended, returning serial proxy [%" PRIu32 "] to RAW mode", this->instance_index_);
-  this->mode_ = api::enums::SERIAL_PROXY_MODE_RAW;
-}
-#endif
-
 void SerialProxy::loop() {
 #ifdef USE_API
-  // Detect subscriber disconnect
-  if (this->api_connection_ != nullptr && (this->api_connection_->is_marked_for_removal() ||
-                                           !this->api_connection_->is_connection_setup() || !api_is_connected())) {
-    ESP_LOGW(TAG, "Subscriber disconnected");
-    this->api_connection_ = nullptr;
-    this->reset_mode_();
-  }
-
-  // With no subscriber there is normally nothing to do, but a tap may still need the port
-  // read -- it does its protocol work precisely while nobody else is listening.
+  // Safety check — loop should only run when subscribed, but guard against races
   if (this->api_connection_ == nullptr) [[unlikely]] {
-#ifdef USE_SERIAL_PROXY_TAP
-    if (this->tap_ == nullptr || !this->tap_->tap_needs_port()) {
-      this->disable_loop();
-      return;
-    }
-#else
     this->disable_loop();
     return;
-#endif
+  }
+
+  // Detect subscriber disconnect
+  if (this->api_connection_->is_marked_for_removal() || !this->api_connection_->is_connection_setup() ||
+      !api_is_connected()) {
+    ESP_LOGW(TAG, "Subscriber disconnected");
+    this->api_connection_ = nullptr;
+    this->disable_loop();
+    return;
   }
 
   // Read available data from UART and forward to subscribed client
@@ -104,54 +69,11 @@ void __attribute__((noinline)) SerialProxy::read_and_send_(size_t available) {
   if (!this->read_array(buffer, to_read))
     return;
 
-#ifdef USE_SERIAL_PROXY_TAP
-  // Before forwarding, so a tap that answers the device (an acknowledgement, say) is not
-  // waiting on the network round trip to a subscriber that may not even exist.
-  if (this->tap_observing_()) {
-    this->tap_->on_device_rx(buffer, to_read);
-  }
-#endif
-
-  if (this->api_connection_ == nullptr) {
-    return;
-  }
   this->outgoing_msg_.set_data(buffer, to_read);
   this->api_connection_->send_serial_proxy_data(this->outgoing_msg_);
 }
 #endif
 
-#ifdef USE_SERIAL_PROXY_TAP
-
-bool SerialProxy::tap_observing_() const {
-  if (this->tap_ == nullptr) {
-    return false;
-  }
-  // With no subscriber, a tap doing its own protocol work (the boot-time handshake with
-  // the device, say) is served regardless of mode -- nobody has chosen one yet. Once a
-  // subscriber holds the port, the mode alone decides, so RAW stays inert.
-  if (this->api_connection_ == nullptr && this->tap_->tap_needs_port()) {
-    return true;
-  }
-  // Otherwise the mode decides. RAW must be inert: a client that flips to RAW before
-  // flashing firmware is entitled to a byte pipe with nothing injecting protocol bytes
-  // into it, and "the tap turned out not to recognise the stream" is not good enough.
-  return this->mode_ == api::enums::SERIAL_PROXY_MODE_PROTOCOL;
-}
-
-void SerialProxy::tap_pump() {
-#ifdef USE_API
-  // Nothing would consume the bytes; leave them in the FIFO
-  if (!this->tap_observing_() && this->api_connection_ == nullptr) {
-    return;
-  }
-  const size_t available = this->available();
-  if (available > 0) {
-    this->read_and_send_(available);
-  }
-#endif
-}
-#endif
-
 void SerialProxy::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Serial Proxy [%" PRIu32 "]:\n"
@@ -160,10 +82,9 @@ void SerialProxy::dump_config() {
                 "  RTS Pin: %s\n"
                 "  DTR Pin: %s",
                 this->instance_index_, this->name_ != nullptr ? this->name_ : "",
-                this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485        ? LOG_STR_LITERAL("RS485")
-                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232      ? LOG_STR_LITERAL("RS232")
-                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_USB_SERIAL ? LOG_STR_LITERAL("USB_SERIAL")
-                                                                                    : LOG_STR_LITERAL("TTL"),
+                this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485   ? LOG_STR_LITERAL("RS485")
+                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232 ? LOG_STR_LITERAL("RS232")
+                                                                               : LOG_STR_LITERAL("TTL"),
                 this->rts_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured"),
                 this->dtr_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured"));
 }
@@ -171,9 +92,8 @@ void SerialProxy::dump_config() {
 SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uint32_t baudrate, bool flow_control,
                                          uint8_t parity, uint8_t stop_bits, uint8_t data_size) {
 #ifdef USE_API
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring configure request from client without port subscription [%" PRIu32 "]",
-             this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring configure request from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -239,80 +159,24 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
   return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
 }
 
-SerialProxyResult SerialProxy::set_mode_from_client(api::APIConnection *api_connection,
-                                                    api::enums::SerialProxyMode mode) {
-#ifdef USE_API
-  // Only the live subscriber may change the mode, so the mode cannot outlive a session
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring mode request from client without port subscription [%" PRIu32 "]", this->instance_index_);
-    return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
-  }
-#endif
-  // Values come from a remote client
-  if (mode != api::enums::SERIAL_PROXY_MODE_RAW && mode != api::enums::SERIAL_PROXY_MODE_PROTOCOL) {
-    ESP_LOGW(TAG, "Invalid mode: %" PRIu32, static_cast<uint32_t>(mode));
-    return SerialProxyResult::SERIAL_PROXY_RESULT_INVALID_ARGUMENT;
-  }
-  // PROTOCOL on a port with no tap would be a silent no-op; refuse so the client knows
-#ifdef USE_SERIAL_PROXY_TAP
-  const bool has_tap = this->tap_ != nullptr;
-#else
-  const bool has_tap = false;
-#endif
-  if (mode == api::enums::SERIAL_PROXY_MODE_PROTOCOL && !has_tap) {
-    ESP_LOGW(TAG, "No tap on serial proxy [%" PRIu32 "]; PROTOCOL mode unavailable", this->instance_index_);
-    return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
-  }
-  ESP_LOGD(TAG, "Serial proxy [%" PRIu32 "] mode set to %s", this->instance_index_,
-           mode == api::enums::SERIAL_PROXY_MODE_PROTOCOL ? LOG_STR_LITERAL("PROTOCOL") : LOG_STR_LITERAL("RAW"));
-#ifdef USE_SERIAL_PROXY_TAP
-  const bool leaving_protocol_mode =
-      this->mode_ != api::enums::SERIAL_PROXY_MODE_RAW && mode == api::enums::SERIAL_PROXY_MODE_RAW;
-  this->mode_ = mode;
-
-  // Only for an explicit client request, not for reset_mode_() at the end of a session:
-  // an ordinary disconnect says nothing about the device, whereas a client deliberately
-  // asking for raw bytes usually precedes changing what the device is.
-  if (leaving_protocol_mode && this->tap_ != nullptr) {
-    this->tap_->on_protocol_disabled();
-  }
-#endif
-  return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
-}
-
 void SerialProxy::write_from_client(api::APIConnection *api_connection, const uint8_t *data, size_t len) {
 #ifdef USE_API
-  // Bytes from anyone but the live subscriber would interleave with the subscriber's
-  // traffic -- or with an active tap's -- on the wire
-  if (!this->is_subscriber_(api_connection)) {
-    if (this->api_connection_ != nullptr) {
-      ESP_LOGW(TAG, "Ignoring write from client that does not hold serial proxy [%" PRIu32 "]", this->instance_index_);
-    } else {
-      // A legacy client streaming writes without subscribing would flood WARN, one per
-      // request; writes are the only high-rate, unacknowledged operation, so keep this
-      // visible without drowning the log
-      ESP_LOGV(TAG, "Ignoring write from client without port subscription [%" PRIu32 "]", this->instance_index_);
-    }
+  // Bytes from a client other than the live subscriber would interleave with the
+  // subscriber's traffic on the wire
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring write from client without port access [%" PRIu32 "]", this->instance_index_);
     return;
   }
 #endif
   if (data == nullptr || len == 0)
     return;
   this->write_array(data, len);
-
-#ifdef USE_SERIAL_PROXY_TAP
-  // After the write, so the tap observes the same ordering the device does
-  if (this->tap_observing_()) {
-    this->tap_->on_client_tx(data, len);
-  }
-#endif
 }
 
 SerialProxyResult SerialProxy::set_modem_pins(api::APIConnection *api_connection, uint32_t line_states) {
 #ifdef USE_API
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring modem pin request from client without port subscription [%" PRIu32 "]",
-             this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring modem pin request from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -338,27 +202,6 @@ SerialProxyResult SerialProxy::set_modem_pins(api::APIConnection *api_connection
   return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
 }
 
-#if defined(USE_SERIAL_PROXY_USB_INFO) && defined(USE_API)
-void SerialProxy::get_usb_info(usb_host::UsbDeviceInfo &info, api::SerialProxyGetUsbInfoResponse &resp) const {
-  if (this->usb_channel_ == nullptr) {
-    resp.status = api::enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
-    return;
-  }
-  resp.interface_number = this->usb_channel_->get_index();
-  if (!this->usb_channel_->get_parent()->get_device_info(info)) {
-    // No device attached right now; not an error
-    return;
-  }
-  resp.connected = true;
-  resp.vendor_id = info.vendor_id;
-  resp.product_id = info.product_id;
-  resp.bcd_device = info.bcd_device;
-  resp.manufacturer = StringRef(info.manufacturer);
-  resp.product = StringRef(info.product);
-  resp.serial_number = StringRef(info.serial_number);
-}
-#endif
-
 uint32_t SerialProxy::get_modem_pins() const {
   return (this->rts_state_ ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_RTS) : 0u) |
          (this->dtr_state_ ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_DTR) : 0u);
@@ -367,8 +210,8 @@ uint32_t SerialProxy::get_modem_pins() const {
 SerialProxyResult SerialProxy::flush_port(api::APIConnection *api_connection) {
 #ifdef USE_API
   // Flushing stalls the port, so it gets the same ownership check as writes
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring flush from client without port subscription [%" PRIu32 "]", this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring flush from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -387,6 +230,11 @@ SerialProxyResult SerialProxy::flush_port(api::APIConnection *api_connection) {
 }
 
 #ifdef USE_API
+bool SerialProxy::port_claimed_by_other_(api::APIConnection *api_connection) const {
+  return this->api_connection_ != nullptr && this->api_connection_ != api_connection &&
+         this->api_connection_->is_connection_setup();
+}
+
 SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_connection,
                                                     api::enums::SerialProxyRequestType type) {
   switch (type) {
@@ -404,10 +252,6 @@ SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_conn
           return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
         }
         ESP_LOGW(TAG, "Previous subscriber disconnected; taking over subscription");
-        // End the dead client's session before starting the new one, so its mode
-        // cannot leak into a session that never asked for it
-        this->api_connection_ = nullptr;
-        this->reset_mode_();
       }
       this->api_connection_ = api_connection;
       this->enable_loop();
@@ -420,15 +264,7 @@ SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_conn
         return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
       }
       this->api_connection_ = nullptr;
-      this->reset_mode_();
-#ifdef USE_SERIAL_PROXY_TAP
-      // Keep the loop alive for a tap that still needs the port (mirrors loop())
-      if (this->tap_ == nullptr || !this->tap_->tap_needs_port()) {
-        this->disable_loop();
-      }
-#else
       this->disable_loop();
-#endif
       ESP_LOGV(TAG, "API connection unsubscribed from serial proxy [%" PRIu32 "]", this->instance_index_);
       return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
     default:

esphome/components/serial_proxy/serial_proxy.h

@@ -20,22 +20,12 @@
 #include "esphome/components/api/api_pb2.h"
 #endif
 
-#ifdef USE_SERIAL_PROXY_USB_INFO
-namespace esphome::usb_uart {
-class USBUartChannel;
-}  // namespace esphome::usb_uart
-namespace esphome::usb_host {
-struct UsbDeviceInfo;
-}  // namespace esphome::usb_host
-#endif
-
 // Forward-declare types needed outside the USE_API guard.
 namespace esphome::api {
 class APIConnection;
 namespace enums {
 enum SerialProxyPortType : uint32_t;
 enum SerialProxyRequestType : uint32_t;
-enum SerialProxyMode : uint32_t;
 }  // namespace enums
 }  // namespace esphome::api
 
@@ -62,36 +52,6 @@ enum class SerialProxyResult : uint8_t {
 /// Maximum bytes to read from UART in a single loop iteration
 inline constexpr size_t SERIAL_PROXY_MAX_READ_SIZE = 256;
 
-#ifdef USE_SERIAL_PROXY_TAP
-/// Observes a port's traffic without owning it, and may inject bytes of its own.
-///
-/// This exists so protocol-aware behaviour can be layered onto a plain byte pipe without
-/// the pipe knowing anything about the protocol: the tap is compiled in only when some
-/// component asks for one, so a proxy carrying an RS485 meter pays nothing for it.
-///
-/// A tap is an observer, never a gatekeeper -- it cannot suppress or alter the bytes
-/// flowing in either direction, so a misbehaving tap cannot corrupt the stream.
-class SerialProxyTap {
- public:
-  /// Bytes read from the device, before they are forwarded to any subscriber.
-  virtual void on_device_rx(const uint8_t *data, size_t len) = 0;
-
-  /// Bytes a subscriber sent towards the device, after they have been written.
-  virtual void on_client_tx(const uint8_t *data, size_t len) = 0;
-
-  /// True when the port must keep reading even with no subscriber attached, so a tap can
-  /// do its own protocol work while nobody is listening. Honoured only while no
-  /// subscriber holds the port; with one attached, the port mode alone decides.
-  virtual bool tap_needs_port() const = 0;
-
-  /// A client explicitly turned protocol handling off for this port. Distinct from the
-  /// automatic reset when a session ends: this one means a client intends to do something
-  /// else with the device -- reflash it, most likely -- so anything the tap believes about
-  /// it should be treated as suspect.
-  virtual void on_protocol_disabled() = 0;
-};
-#endif
-
 class SerialProxy final : public uart::UARTDevice, public Component {
  public:
   void setup() override;
@@ -117,9 +77,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Get the port type
   api::enums::SerialProxyPortType get_port_type() const { return this->port_type_; }
 
-  /// Handle a mode change requested by an API client
-  SerialProxyResult set_mode_from_client(api::APIConnection *api_connection, api::enums::SerialProxyMode mode);
-
   /// Configure UART parameters and apply them
   /// @param api_connection The API connection requesting the change
   /// @param baudrate Baud rate in bits per second
@@ -164,78 +121,13 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Set the DTR GPIO pin (from YAML configuration)
   void set_dtr_pin(GPIOPin *pin) { this->dtr_pin_ = pin; }
 
-#ifdef USE_SERIAL_PROXY_USB_INFO
-  /// Attach the USB UART channel behind this port (from code generation)
-  void set_usb_channel(usb_uart::USBUartChannel *channel) { this->usb_channel_ = channel; }
-
-#ifdef USE_API
-  /// Fill a USB info response for this port. The response's strings are views into
-  /// info, so info must outlive the send.
-  void get_usb_info(usb_host::UsbDeviceInfo &info, api::SerialProxyGetUsbInfoResponse &resp) const;
-#endif
-#endif
-
-#ifdef USE_SERIAL_PROXY_TAP
-  /// Attach a traffic observer. At most one, set once at setup time.
-  void set_tap(SerialProxyTap *tap) { this->tap_ = tap; }
-
-  /// Write bytes originating from the tap rather than from a client. Bypasses the
-  /// subscriber ownership check, but only while the tap is being served bytes -- so a
-  /// port in RAW mode with a subscriber attached stays inert. Returns false when the
-  /// bytes were dropped for that reason.
-  bool write_from_tap(const uint8_t *data, size_t len) {
-    if (!this->tap_observing_()) {
-      return false;
-    }
-    this->write_array(data, len);
-    return true;
-  }
-
-  /// Whether the tap is currently being served bytes. Can flip false with no callback
-  /// (a subscriber attaching in RAW mode, say), so a tap should check before starting
-  /// protocol work and when a reply seems overdue.
-  bool tap_is_observed() const { return this->tap_observing_(); }
-
-  /// Resume reading after a tap's needs change. loop() disables itself when there is
-  /// neither a subscriber nor a tap that wants the port, so a tap starting fresh work
-  /// must ask for it back. Must be called from the main loop.
-  void tap_request_port() { this->enable_loop(); }
-
-  /// Whether the underlying device is present. On a USB UART this tracks enumeration, so
-  /// a tap can notice the device being unplugged and plugged back in.
-  bool is_device_connected() const { return this->parent_->is_connected(); }
-
-  /// Run one read-and-dispatch cycle immediately. Lets a tap make progress before the
-  /// main loop is running -- during setup, for instance, while a component is still
-  /// blocking on can_proceed(). Must not be called from on_device_rx() or
-  /// on_client_tx(): each nested cycle costs a 256-byte stack frame.
-  void tap_pump();
-#endif
-
  protected:
 #ifdef USE_API
-  /// Read from UART, hand the bytes to any tap, and forward them to a subscriber
-  /// (slow path with a 256-byte stack buffer)
+  /// Read from UART and send to API client (slow path with 256-byte stack buffer)
   void read_and_send_(size_t available);
 
-  /// True when the given connection is the live subscriber. Every port operation
-  /// (write, configure, modem pins, flush, mode) requires this, so an unsubscribed
-  /// client can never share the wire with the subscriber or an active tap.
-  bool is_subscriber_(api::APIConnection *api_connection) const { return this->api_connection_ == api_connection; }
-#endif
-
-#ifdef USE_SERIAL_PROXY_TAP
-  /// Return the port to RAW when a subscriber goes away, so the mode never outlives it
-  void reset_mode_();
-#else
-  /// Without a tap, PROTOCOL is refused, so the mode is fixed at RAW and there is
-  /// nothing to reset
-  void reset_mode_() {}
-#endif
-
-#ifdef USE_SERIAL_PROXY_TAP
-  /// True when the tap should be shown the traffic passing through this port
-  bool tap_observing_() const;
+  /// True when a live subscriber other than the given connection holds the port
+  bool port_claimed_by_other_(api::APIConnection *api_connection) const;
 #endif
 
   /// Instance index for identifying this proxy in API messages
@@ -255,11 +147,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Port type
   api::enums::SerialProxyPortType port_type_{};
 
-#ifdef USE_SERIAL_PROXY_TAP
-  /// How the bytes passing through are treated; zero is SERIAL_PROXY_MODE_RAW
-  api::enums::SerialProxyMode mode_{};
-#endif
-
   /// Optional GPIO pins for modem control
   GPIOPin *rts_pin_{nullptr};
   GPIOPin *dtr_pin_{nullptr};
@@ -267,15 +154,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Current modem pin states
   bool rts_state_{false};
   bool dtr_state_{false};
-
-#ifdef USE_SERIAL_PROXY_TAP
-  SerialProxyTap *tap_{nullptr};
-#endif
-
-#ifdef USE_SERIAL_PROXY_USB_INFO
-  /// The USB UART channel behind this port; nullptr on non-USB ports
-  usb_uart::USBUartChannel *usb_channel_{nullptr};
-#endif
 };
 
 }  // namespace esphome::serial_proxy

esphome/components/socket/bsd_sockets_impl.cpp

@@ -59,13 +59,15 @@ int BSDSocketImpl::close() {
 
 int BSDSocketImpl::setblocking(bool blocking) {
   int fl = ::fcntl(this->fd_, F_GETFL, 0);
+  if (fl < 0) {
+    return fl;
+  }
   if (blocking) {
     fl &= ~O_NONBLOCK;
   } else {
     fl |= O_NONBLOCK;
   }
-  ::fcntl(this->fd_, F_SETFL, fl);
-  return 0;
+  return ::fcntl(this->fd_, F_SETFL, fl);
 }
 
 size_t BSDSocketImpl::getpeername_to(std::span<char, SOCKADDR_STR_LEN> buf) {

esphome/components/socket/headers.h

@@ -205,6 +205,13 @@ static constexpr size_t SOCKADDR_STR_LEN = 46;  // INET6_ADDRSTRLEN
 static constexpr size_t SOCKADDR_STR_LEN = 16;  // INET_ADDRSTRLEN
 #endif
 
+/// Outcome of polling a non-blocking connect(); see socket::poll_connect().
+enum class ConnectPollResult : uint8_t {
+  CONNECT_POLL_PENDING,
+  CONNECT_POLL_CONNECTED,
+  CONNECT_POLL_ERROR,
+};
+
 }  // namespace esphome::socket
 
 #endif

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -48,8 +48,33 @@ static const char *const TAG = "socket";
 #ifdef USE_ESP8266
 // optimistic_yield() rate limit in microseconds of CONT time; cheap when hot.
 static constexpr uint32_t ESP8266_YIELD_INTERVAL_US = 1000;
+// Let SYS run so queued WiFi traffic reaches lwip; CONT and SYS are cooperative
+static inline void yield_to_sys() { optimistic_yield(ESP8266_YIELD_INTERVAL_US); }
+#else
+static inline void yield_to_sys() {}
 #endif
 
+// errno for a failed tcp_* call
+static int lwip_err_to_errno(err_t err) {
+  switch (err) {
+    case ERR_MEM:
+      return ENOMEM;
+    case ERR_BUF:
+      return EAGAIN;  // no free local port
+    case ERR_RTE:
+      return EHOSTUNREACH;  // no route or no address yet
+    case ERR_VAL:
+    case ERR_ARG:
+      return EINVAL;
+    case ERR_USE:
+      return EADDRINUSE;
+    case ERR_ISCONN:
+      return EISCONN;
+    default:
+      return EIO;
+  }
+}
+
 // set to 1 to enable verbose lwip logging
 #if 0  // NOLINT(readability-avoid-unconditional-preprocessor-if)
 #define LWIP_LOG(msg, ...) ESP_LOGVV(TAG, "socket %p: " msg, this, ##__VA_ARGS__)
@@ -63,7 +88,8 @@ static constexpr uint32_t ESP8266_YIELD_INTERVAL_US = 1000;
 // tcp_abort() triggers the err callback synchronously, which would
 // otherwise call back into a partially-destroyed object.
 // tcp_sent/tcp_poll are not cleared because this implementation
-// never registers them.
+// never registers them, and the tcp_connect callback only fires on
+// SYN_SENT -> ESTABLISHED, which cannot follow an abort or close.
 static void pcb_detach_abort(struct tcp_pcb *pcb) {
   tcp_arg(pcb, nullptr);
   tcp_recv(pcb, nullptr);
@@ -76,8 +102,8 @@ static void pcb_detach_abort(struct tcp_pcb *pcb) {
 // After tcp_close(), the PCB remains alive during the TCP close handshake
 // (FIN_WAIT, TIME_WAIT states). Without clearing callbacks first, LWIP
 // would call recv/err on a destroyed socket object, corrupting the heap.
-// tcp_sent/tcp_poll are not cleared because this implementation
-// never registers them.
+// tcp_sent/tcp_poll and the tcp_connect callback are not cleared for the
+// same reasons as in pcb_detach_abort().
 // Returns ERR_OK on success; on failure the PCB is aborted instead.
 static err_t pcb_detach_close(struct tcp_pcb *pcb) {
   tcp_arg(pcb, nullptr);
@@ -101,67 +127,51 @@ LWIPRawCommon::~LWIPRawCommon() {
   }
 }
 
+bool LWIPRawCommon::sockaddr2ip_(const struct sockaddr *name, socklen_t addrlen, ip_addr_t *ip, uint16_t *port) const {
+  if (name == nullptr) {
+    errno = EINVAL;
+    return false;
+  }
+#if LWIP_IPV6
+  if (this->family_ == AF_INET6) {
+    if (addrlen < sizeof(sockaddr_in6)) {
+      errno = EINVAL;
+      return false;
+    }
+    auto *addr6 = reinterpret_cast<const sockaddr_in6 *>(name);
+    *port = ntohs(addr6->sin6_port);
+    inet6_addr_to_ip6addr(ip_2_ip6(ip), &addr6->sin6_addr);
+    // ANY lets bind() accept both families; connect() picks the concrete type
+    IP_SET_TYPE_VAL(*ip, IPADDR_TYPE_ANY);
+    return true;
+  }
+#endif
+  if (this->family_ != AF_INET || addrlen < sizeof(sockaddr_in)) {
+    errno = EINVAL;
+    return false;
+  }
+  auto *addr4 = reinterpret_cast<const sockaddr_in *>(name);
+  *port = ntohs(addr4->sin_port);
+  ip_addr_set_ip4_u32(ip, addr4->sin_addr.s_addr);
+  return true;
+}
+
 int LWIPRawCommon::bind(const struct sockaddr *name, socklen_t addrlen) {
   LWIP_LOCK();
   if (this->pcb_ == nullptr) {
     errno = EBADF;
     return -1;
   }
-  if (name == nullptr) {
-    errno = EINVAL;
-    return -1;
-  }
   ip_addr_t ip;
-  in_port_t port;
-#if LWIP_IPV6
-  if (this->family_ == AF_INET) {
-    if (addrlen < sizeof(sockaddr_in)) {
-      errno = EINVAL;
-      return -1;
-    }
-    auto *addr4 = reinterpret_cast<const sockaddr_in *>(name);
-    port = ntohs(addr4->sin_port);
-    ip.type = IPADDR_TYPE_V4;
-    ip.u_addr.ip4.addr = addr4->sin_addr.s_addr;
-    LWIP_LOG("tcp_bind(%p ip=%s port=%u)", this->pcb_, ip4addr_ntoa(&ip.u_addr.ip4), port);
-  } else if (this->family_ == AF_INET6) {
-    if (addrlen < sizeof(sockaddr_in6)) {
-      errno = EINVAL;
-      return -1;
-    }
-    auto *addr6 = reinterpret_cast<const sockaddr_in6 *>(name);
-    port = ntohs(addr6->sin6_port);
-    ip.type = IPADDR_TYPE_ANY;
-    memcpy(&ip.u_addr.ip6.addr, &addr6->sin6_addr.un.u8_addr, 16);
-    LWIP_LOG("tcp_bind(%p ip=%s port=%u)", this->pcb_, ip6addr_ntoa(&ip.u_addr.ip6), port);
-  } else {
-    errno = EINVAL;
+  uint16_t port;
+  if (!this->sockaddr2ip_(name, addrlen, &ip, &port)) {
     return -1;
   }
-#else
-  if (this->family_ != AF_INET) {
-    errno = EINVAL;
-    return -1;
-  }
-  auto *addr4 = reinterpret_cast<const sockaddr_in *>(name);
-  port = ntohs(addr4->sin_port);
-  ip.addr = addr4->sin_addr.s_addr;
-  LWIP_LOG("tcp_bind(%p ip=%u port=%u)", this->pcb_, ip.addr, port);
-#endif
+  LWIP_LOG("tcp_bind(%p ip=%s port=%u)", this->pcb_, ipaddr_ntoa(&ip), port);
   err_t err = tcp_bind(this->pcb_, &ip, port);
-  if (err == ERR_USE) {
-    LWIP_LOG("  -> err ERR_USE");
-    errno = EADDRINUSE;
-    return -1;
-  }
-  if (err == ERR_VAL) {
-    LWIP_LOG("  -> err ERR_VAL");
-    errno = EINVAL;
-    return -1;
-  }
   if (err != ERR_OK) {
     LWIP_LOG("  -> err %d", err);
-    errno = EIO;
+    errno = lwip_err_to_errno(err);
     return -1;
   }
   return 0;
@@ -178,7 +188,7 @@ int LWIPRawCommon::close() {
   this->pcb_ = nullptr;
   if (err != ERR_OK) {
     LWIP_LOG("  -> err %d", err);
-    errno = err == ERR_MEM ? ENOMEM : EIO;
+    errno = lwip_err_to_errno(err);
     return -1;
   }
   return 0;
@@ -205,7 +215,7 @@ int LWIPRawCommon::shutdown(int how) {
   err_t err = tcp_shutdown(this->pcb_, shut_rx, shut_tx);
   if (err != ERR_OK) {
     LWIP_LOG("  -> err %d", err);
-    errno = err == ERR_MEM ? ENOMEM : EIO;
+    errno = lwip_err_to_errno(err);
     return -1;
   }
   return 0;
@@ -425,7 +435,79 @@ void LWIPRawImpl::s_err_fn(void *arg, err_t err) {
   // ERR_ABRT: aborted through tcp_abort or TCP timer
   auto *arg_this = reinterpret_cast<LWIPRawImpl *>(arg);
   ESP_LOGVV(TAG, "socket %p: err(err=%d)", arg_this, err);
+  if (arg_this->connect_err_ == EINPROGRESS) {
+    // A connect that never established: RST is a refusal, anything else is
+    // the SYN retransmits giving up. Written before pcb_ so poll_connect()
+    // never sees a dead pcb without its reason.
+    arg_this->connect_err_ = err == ERR_RST ? ECONNREFUSED : ETIMEDOUT;
+  }
   arg_this->pcb_ = nullptr;
+  esphome::wake_loop_any_context();
+}
+
+err_t LWIPRawImpl::s_connected_fn(void *arg, struct tcp_pcb *pcb, err_t err) {
+  // LWIP CALLBACK — same constraints as s_err_fn. err is always ERR_OK; a
+  // failed connect arrives through s_err_fn instead.
+  auto *arg_this = reinterpret_cast<LWIPRawImpl *>(arg);
+  arg_this->connect_err_ = 0;
+  esphome::wake_loop_any_context();
+  return ERR_OK;
+}
+
+int LWIPRawImpl::connect(const struct sockaddr *addr, socklen_t addrlen) {
+  LWIP_LOCK();
+  if (this->pcb_ == nullptr) {
+    errno = EBADF;
+    return -1;
+  }
+  if (this->connect_err_ != 0) {
+    errno = EALREADY;
+    return -1;
+  }
+  ip_addr_t ip;
+  uint16_t port;
+  if (!this->sockaddr2ip_(addr, addrlen, &ip, &port)) {
+    return -1;
+  }
+#if LWIP_IPV6
+  // tcp_connect needs a concrete address type. A remembered IPv4 peer on an
+  // IPv6 build arrives as a v4-mapped address and must be dialed as IPv4.
+  if (IP_IS_ANY_TYPE_VAL(ip)) {
+    if (ip6_addr_isipv4mappedipv6(ip_2_ip6(&ip))) {
+      unmap_ipv4_mapped_ipv6(ip_2_ip4(&ip), ip_2_ip6(&ip));
+      IP_SET_TYPE_VAL(ip, IPADDR_TYPE_V4);
+    } else {
+      IP_SET_TYPE_VAL(ip, IPADDR_TYPE_V6);
+    }
+  }
+#endif
+  LWIP_LOG("tcp_connect(%p ip=%s port=%u)", this->pcb_, ipaddr_ntoa(&ip), port);
+  err_t err = tcp_connect(this->pcb_, &ip, port, LWIPRawImpl::s_connected_fn);
+  if (err != ERR_OK) {
+    LWIP_LOG("  -> err %d", err);
+    errno = lwip_err_to_errno(err);
+    return -1;
+  }
+  this->connect_err_ = EINPROGRESS;
+  errno = EINPROGRESS;
+  return -1;
+}
+
+ConnectPollResult LWIPRawImpl::poll_connect(int &err_out) const {
+  // pcb_ first; see the ordering note on the declaration
+  if (this->pcb_ == nullptr) {
+    err_out = this->connect_err_ == 0 || this->connect_err_ == EINPROGRESS ? ECONNRESET : this->connect_err_;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  if (this->connect_err_ == EINPROGRESS) {
+    yield_to_sys();  // so the SYN-ACK is processed between polls
+    return ConnectPollResult::CONNECT_POLL_PENDING;
+  }
+  if (this->connect_err_ != 0) {
+    err_out = this->connect_err_;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  return ConnectPollResult::CONNECT_POLL_CONNECTED;
 }
 
 err_t LWIPRawImpl::s_recv_fn(void *arg, struct tcp_pcb *pcb, struct pbuf *pb, err_t err) {
@@ -540,14 +622,12 @@ ssize_t LWIPRawImpl::read_locked_(void *buf, size_t len) {
 }
 
 ssize_t LWIPRawImpl::read(void *buf, size_t len) {
-#ifdef USE_ESP8266
-  // Would block: yield to SYS so queued WiFi RX reaches lwip and this read
-  // may succeed. Without this, inbound segments can sit unprocessed for
-  // seconds while the main loop polls (CONT/SYS are cooperative on ESP8266).
+  // Would block: let queued WiFi RX reach lwip first so this read may
+  // succeed; otherwise inbound segments can sit unprocessed for seconds
+  // while the main loop polls
   if (this->waiting_for_data_()) {
-    optimistic_yield(ESP8266_YIELD_INTERVAL_US);
+    yield_to_sys();
   }
-#endif
   // See waiting_for_data_() for safety of unlocked reads.
   if (this->recv_timeout_cs_ > 0 && this->waiting_for_data_()) {
     this->wait_for_data_();
@@ -636,12 +716,10 @@ int LWIPRawImpl::internal_output_() {
       return -1;
     }
   }
-#ifdef USE_ESP8266
   // Flushed: yield to SYS so the queued segments reach the WiFi driver
   // instead of waiting seconds for an unrelated SYS slot. Callers only get
   // here after a successful tcp_write, so idle paths never yield.
-  optimistic_yield(ESP8266_YIELD_INTERVAL_US);
-#endif
+  yield_to_sys();
   return 0;
 }
 

esphome/components/socket/lwip_raw_tcp_impl.h

@@ -50,6 +50,9 @@ class LWIPRawCommon {
 
  protected:
   int ip2sockaddr_(ip_addr_t *ip, uint16_t port, struct sockaddr *name, socklen_t *addrlen);
+  /// Convert a sockaddr of this socket's family to an lwip address and port.
+  /// Returns false with errno set on a family or length mismatch.
+  bool sockaddr2ip_(const struct sockaddr *name, socklen_t addrlen, ip_addr_t *ip, uint16_t *port) const;
 
   // Member ordering optimized to minimize padding on 32-bit systems
   struct tcp_pcb *pcb_;
@@ -58,7 +61,16 @@ class LWIPRawCommon {
   bool nodelay_ = false;
   sa_family_t family_ = 0;
   uint8_t recv_timeout_cs_ = 0;  // SO_RCVTIMEO in centiseconds (0 = no timeout, max 2.55s)
+  // State of a connect() started on this socket: 0 when none is pending (or
+  // it completed), EINPROGRESS while the SYN is out, otherwise the errno the
+  // lwip callbacks recorded for its failure. Fits the padding byte here.
+  uint8_t connect_err_ = 0;
+  static_assert(EINPROGRESS < 256 && ECONNREFUSED < 256 && ECONNRESET < 256 && ETIMEDOUT < 256,
+                "connect_err_ stores errno values in a byte");
 };
+// The connect state must stay inside the padding: no socket, listening or
+// accepted, pays RAM for it
+static_assert(sizeof(LWIPRawCommon) == sizeof(struct tcp_pcb *) + 4, "LWIPRawCommon grew past one word of flags");
 
 /// Connected socket implementation for LWIP raw TCP.
 /// No virtual methods — callers always use the concrete type.
@@ -83,6 +95,13 @@ class LWIPRawImpl : public LWIPRawCommon {
     errno = EOPNOTSUPP;
     return -1;
   }
+  /// Start a non-blocking connect. Always returns -1 with errno EINPROGRESS
+  /// when the SYN was queued; completion is reported by poll_connect().
+  int connect(const struct sockaddr *addr, socklen_t addrlen);
+  // Intentionally unlocked like ready(): reads one pointer and one byte that
+  // the callbacks write in the order the checks depend on (error byte first,
+  // then pcb_), so a torn read only costs one extra poll.
+  ConnectPollResult poll_connect(int &err_out) const;
   ssize_t read(void *buf, size_t len);
   ssize_t readv(const struct iovec *iov, int iovcnt);
   ssize_t recvfrom(void *, size_t, sockaddr *, socklen_t *) {
@@ -120,6 +139,7 @@ class LWIPRawImpl : public LWIPRawCommon {
 
   static void s_err_fn(void *arg, err_t err);
   static err_t s_recv_fn(void *arg, struct tcp_pcb *pcb, struct pbuf *pb, err_t err);
+  static err_t s_connected_fn(void *arg, struct tcp_pcb *pcb, err_t err);
 
  protected:
   // True when the socket could receive data but none has arrived yet.
@@ -137,6 +157,8 @@ class LWIPRawImpl : public LWIPRawCommon {
   size_t rx_buf_offset_ = 0;
   bool rx_closed_ = false;
 };
+static_assert(sizeof(LWIPRawImpl) == sizeof(LWIPRawCommon) + sizeof(pbuf *) + sizeof(size_t) + sizeof(void *),
+              "LWIPRawImpl layout changed");
 
 /// Listening socket implementation for LWIP raw TCP.
 /// Separate from LWIPRawImpl — no virtual dispatch needed.

esphome/components/socket/lwip_sockets_impl.cpp

@@ -49,13 +49,15 @@ int LwIPSocketImpl::close() {
 
 int LwIPSocketImpl::setblocking(bool blocking) {
   int fl = lwip_fcntl(this->fd_, F_GETFL, 0);
+  if (fl < 0) {
+    return fl;
+  }
   if (blocking) {
     fl &= ~O_NONBLOCK;
   } else {
     fl |= O_NONBLOCK;
   }
-  lwip_fcntl(this->fd_, F_SETFL, fl);
-  return 0;
+  return lwip_fcntl(this->fd_, F_SETFL, fl);
 }
 
 size_t LwIPSocketImpl::getpeername_to(std::span<char, SOCKADDR_STR_LEN> buf) {

esphome/components/socket/socket.cpp

@@ -2,6 +2,9 @@
 #if defined(USE_SOCKET_IMPL_LWIP_TCP) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || defined(USE_SOCKET_IMPL_BSD_SOCKETS)
 #include <cerrno>
 #include <cstring>
+#ifdef USE_SOCKET_IMPL_BSD_SOCKETS
+#include <sys/select.h>
+#endif
 #include <string>
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
@@ -165,7 +168,10 @@ socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const char *ip_
 #else
     // Use LWIP-specific functions
     ip6_addr_t ip6;
-    inet6_aton(ip_address, &ip6);
+    if (inet6_aton(ip_address, &ip6) == 0) {
+      errno = EINVAL;
+      return 0;
+    }
     memcpy(server->sin6_addr.un.u32_addr, ip6.addr, sizeof(ip6.addr));
 #endif
     return sizeof(sockaddr_in6);
@@ -185,12 +191,58 @@ socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const char *ip_
     return 0;
   }
 #else
-  server->sin_addr.s_addr = inet_addr(ip_address);
+  // Unlike inet_addr(), inet_aton() can signal failure while still
+  // accepting the broadcast address 255.255.255.255
+  if (inet_aton(ip_address, &server->sin_addr) == 0) {
+    errno = EINVAL;
+    return 0;
+  }
 #endif
   server->sin_port = htons(port);
   return sizeof(sockaddr_in);
 }
 
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
+ConnectPollResult poll_connect(Socket &sock, int &err_out) {
+  int fd = sock.get_fd();
+  if (fd < 0 || fd >= FD_SETSIZE) {
+    // FD_SET on either is undefined behavior
+    err_out = EBADF;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  // Connect completion is a write event; the main loop only selects on reads
+  fd_set writefds;
+  FD_ZERO(&writefds);
+  FD_SET(fd, &writefds);
+  struct timeval tv = {0, 0};
+#ifdef USE_SOCKET_IMPL_LWIP_SOCKETS
+  // LWIP_COMPAT_SOCKETS may be off (LibreTiny), so use the lwip symbol directly
+  int ret = lwip_select(fd + 1, nullptr, &writefds, nullptr, &tv);
+#else
+  // Global-scope select: the entity namespace esphome::select shadows it here
+  int ret = ::select(fd + 1, nullptr, &writefds, nullptr, &tv);
+#endif
+  if (ret < 0) {
+    err_out = errno;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  if (ret == 0) {
+    return ConnectPollResult::CONNECT_POLL_PENDING;
+  }
+  int error = 0;
+  socklen_t len = sizeof(error);
+  if (sock.getsockopt(SOL_SOCKET, SO_ERROR, &error, &len) != 0) {
+    err_out = errno;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  if (error != 0) {
+    err_out = error;
+    return ConnectPollResult::CONNECT_POLL_ERROR;
+  }
+  return ConnectPollResult::CONNECT_POLL_CONNECTED;
+}
+#endif
+
 socklen_t set_sockaddr_any(struct sockaddr *addr, socklen_t addrlen, uint16_t port) {
 #if USE_NETWORK_IPV6
   if (addrlen < sizeof(sockaddr_in6)) {

esphome/components/socket/socket.h

@@ -145,6 +145,16 @@ inline socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const st
 /// Set a sockaddr to the any address and specified port for the IP version used by socket_ip().
 socklen_t set_sockaddr_any(struct sockaddr *addr, socklen_t addrlen, uint16_t port);
 
+/// Check a non-blocking connect() for completion without blocking. On
+/// CONNECT_POLL_ERROR, err_out holds the socket's SO_ERROR (or errno when the
+/// poll itself failed) on fd based implementations, and the failure recorded
+/// by the lwip callbacks on the raw lwip implementation.
+#ifdef USE_SOCKET_IMPL_LWIP_TCP
+inline ConnectPollResult poll_connect(Socket &sock, int &err_out) { return sock.poll_connect(err_out); }
+#else
+ConnectPollResult poll_connect(Socket &sock, int &err_out);
+#endif
+
 /// Format sockaddr into caller-provided buffer, returns length written (excluding null)
 size_t format_sockaddr_to(const struct sockaddr *addr_ptr, socklen_t len, std::span<char, SOCKADDR_STR_LEN> buf);
 

esphome/components/udp/udp_component.cpp

@@ -13,7 +13,12 @@ void UDPComponent::setup() {
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
   for (const auto &address : this->addresses_) {
     struct sockaddr saddr {};
-    socket::set_sockaddr(&saddr, sizeof(saddr), address, this->broadcast_port_);
+    if (socket::set_sockaddr(&saddr, sizeof(saddr), address, this->broadcast_port_) == 0) {
+      ESP_LOGW(TAG, "Invalid address %s", address);
+      // A dropped address silently receives nothing; surface the misconfiguration
+      this->status_set_warning(LOG_STR("invalid address"));
+      continue;
+    }
     this->sockaddrs_.push_back(saddr);
   }
   // set up broadcast socket
@@ -94,7 +99,11 @@ void UDPComponent::setup() {
   // 8266 and RP2040 `Duino
   for (const auto &address : this->addresses_) {
     auto ipaddr = IPAddress();
-    ipaddr.fromString(address);
+    if (!ipaddr.fromString(address)) {
+      ESP_LOGW(TAG, "Invalid address %s", address);
+      this->status_set_warning(LOG_STR("invalid address"));
+      continue;
+    }
     this->ipaddrs_.push_back(ipaddr);
   }
   if (this->should_listen_)

esphome/components/usb_host/usb_host.h

@@ -117,20 +117,6 @@ struct UsbEvent {
 
 // callback function type.
 
-// USB string descriptors hold at most 126 characters; one more for the terminator
-static constexpr size_t DESC_STRING_BUF_SIZE = 128;
-
-/// Identity of a connected USB device, copied out of the descriptors the USB host
-/// stack caches for the lifetime of the connection
-struct UsbDeviceInfo {
-  uint16_t vendor_id;
-  uint16_t product_id;
-  uint16_t bcd_device;
-  char manufacturer[DESC_STRING_BUF_SIZE];
-  char product[DESC_STRING_BUF_SIZE];
-  char serial_number[DESC_STRING_BUF_SIZE];
-};
-
 enum ClientState {
   USB_CLIENT_INIT = 0,
   USB_CLIENT_OPEN,
@@ -158,10 +144,6 @@ class USBClient : public Component {
   bool control_transfer(uint8_t type, uint8_t request, uint16_t value, uint16_t index, const transfer_cb_t &callback,
                         const std::vector<uint8_t> &data = {});
 
-  /// Copy the connected device's identity out of the cached USB descriptors.
-  /// Returns false when no device is connected.
-  bool get_device_info(UsbDeviceInfo &info) const;
-
   // Lock-free event queue and pool for USB task to main loop communication
   // Must be public for access from static callbacks
   LockFreeQueue<UsbEvent, USB_EVENT_QUEUE_SIZE> event_queue;

esphome/components/usb_host/usb_host_client.cpp

@@ -143,8 +143,10 @@ static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc
   } while (next_desc != NULL);
 }
 #endif
-// bLength (uint8_t, max 255) includes the 2-byte header (bLength and bDescriptorType),
-// so character count = (bLength - 2) / 2.
+// USB string descriptors: bLength (uint8_t, max 255) includes the 2-byte header (bLength and bDescriptorType).
+// Character count = (bLength - 2) / 2, max 126 chars + null terminator.
+static constexpr size_t DESC_STRING_BUF_SIZE = 128;
+
 static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
   if (desc == nullptr || desc->bLength < 2)
     return "(unspecified)";
@@ -160,41 +162,6 @@ static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<c
   return buffer.data();
 }
 
-// A missing descriptor copies as an empty string, unlike the "(unspecified)"
-// placeholder the logging helper above uses
-static void copy_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
-  buffer[0] = '\0';
-  if (desc == nullptr || desc->bLength < 2)
-    return;
-  int char_count = (desc->bLength - 2) / 2;
-  char *p = buffer.data();
-  char *end = p + buffer.size() - 1;
-  for (int i = 0; i != char_count && p < end; i++) {
-    auto c = desc->wData[i];
-    if (c < 0x100)
-      *p++ = static_cast<char>(c);
-  }
-  *p = '\0';
-}
-
-bool USBClient::get_device_info(UsbDeviceInfo &info) const {
-  if (this->state_ != USB_CLIENT_CONNECTED)
-    return false;
-  const usb_device_desc_t *desc;
-  if (usb_host_get_device_descriptor(this->device_handle_, &desc) != ESP_OK)
-    return false;
-  info.vendor_id = desc->idVendor;
-  info.product_id = desc->idProduct;
-  info.bcd_device = desc->bcdDevice;
-  usb_device_info_t dev_info;
-  if (usb_host_device_info(this->device_handle_, &dev_info) != ESP_OK)
-    return false;
-  copy_descriptor_string(dev_info.str_desc_manufacturer, info.manufacturer);
-  copy_descriptor_string(dev_info.str_desc_product, info.product);
-  copy_descriptor_string(dev_info.str_desc_serial_num, info.serial_number);
-  return true;
-}
-
 // CALLBACK CONTEXT: USB task (called from usb_host_client_handle_events in USB task)
 static void client_event_cb(const usb_host_client_event_msg_t *event_msg, void *ptr) {
   auto *client = static_cast<USBClient *>(ptr);

esphome/components/usb_uart/__init__.py

@@ -16,7 +16,7 @@ from esphome.const import (
     CONF_DUMMY_RECEIVER,
     CONF_ID,
 )
-from esphome.core import CORE, ID
+from esphome.core import CORE
 from esphome.cpp_types import Component
 from esphome.types import ConfigType
 
@@ -27,16 +27,6 @@ usb_uart_ns = cg.esphome_ns.namespace("usb_uart")
 USBUartComponent = usb_uart_ns.class_("USBUartComponent", Component)
 USBUartChannel = usb_uart_ns.class_("USBUartChannel", UARTComponent)
 
-
-def is_usb_uart_channel(uart_id: ID, full_config: ConfigType) -> bool:
-    """Return True if the given ID refers to a channel of a configured usb_uart device."""
-    return any(
-        channel[CONF_ID] == uart_id
-        for device in full_config.get("usb_uart") or []
-        for channel in device[CONF_CHANNELS]
-    )
-
-
 UARTParityOptions = usb_uart_ns.enum("UARTParityOptions")
 UART_PARITY_OPTIONS = {
     "NONE": UARTParityOptions.UART_CONFIG_PARITY_NONE,

esphome/components/usb_uart/usb_uart.cpp

@@ -434,11 +434,12 @@ void USBUartTypeCdcAcm::on_connected() {
       auto err_comm = usb_host_interface_claim(this->handle_, this->device_handle_,
                                                channel->cdc_dev_.interrupt_interface_number, 0);
       if (err_comm != ESP_OK) {
+        // Continue anyway: the interface number stays valid for CDC request addressing
         ESP_LOGW(TAG, "Could not claim comm interface %d: %s", channel->cdc_dev_.interrupt_interface_number,
                  esp_err_to_name(err_comm));
-        channel->cdc_dev_.interrupt_interface_number = 0xFF;  // Mark as unavailable, but continue anyway
       } else {
         ESP_LOGD(TAG, "Claimed comm interface %d", channel->cdc_dev_.interrupt_interface_number);
+        channel->cdc_dev_.interrupt_interface_claimed = true;
       }
     }
     auto err =
@@ -465,14 +466,15 @@ void USBUartTypeCdcAcm::on_disconnected() {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
     }
-    if (channel->cdc_dev_.notify_ep != nullptr) {
+    // Only tear down the notify pipe when we claimed its interface ourselves;
+    // no transfer is ever submitted on it, so there is nothing else to cancel.
+    if (channel->cdc_dev_.notify_ep != nullptr && channel->cdc_dev_.interrupt_interface_claimed) {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
     }
-    if (channel->cdc_dev_.interrupt_interface_number != 0xFF &&
-        channel->cdc_dev_.interrupt_interface_number != channel->cdc_dev_.bulk_interface_number) {
+    if (channel->cdc_dev_.interrupt_interface_claimed) {
       usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.interrupt_interface_number);
-      channel->cdc_dev_.interrupt_interface_number = 0xFF;
+      channel->cdc_dev_.interrupt_interface_claimed = false;
     }
     usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number);
     // Reset the input and output started flags to their initial state to avoid the possibility of spurious restarts

esphome/components/usb_uart/usb_uart.h

@@ -34,7 +34,10 @@ struct CdcEps {
   const usb_ep_desc_t *in_ep;
   const usb_ep_desc_t *out_ep;
   uint8_t bulk_interface_number;
+  // Also the wIndex target for CDC class requests (SET_LINE_CODING etc.), so it
+  // must remain valid even when the interface itself is not claimed.
   uint8_t interrupt_interface_number;
+  bool interrupt_interface_claimed{false};
 };
 
 enum CH34xChipType : uint8_t {
@@ -164,9 +167,6 @@ class USBUartChannelBase : public uart::UARTComponent, public Parented<USBUartCo
   /// they arrive, eliminating one full main-loop-wakeup cycle of latency.
   void set_rx_callback(std::function<void()> cb) { this->rx_callback_ = std::move(cb); }
 
-  /// Channel index on the bridge (interface number on multi-port bridges)
-  uint8_t get_index() const { return this->index_; }
-
  protected:
   // Not directly instantiable; construct a concrete channel type instead.
   USBUartChannelBase(uint8_t index, uint16_t buffer_size) : input_buffer_(RingBuffer(buffer_size)), index_(index) {}

esphome/components/wake_on_lan/wake_on_lan.cpp

@@ -34,6 +34,10 @@ void WakeOnLanButton::press_action() {
   struct sockaddr_storage saddr {};
   auto addr_len =
       socket::set_sockaddr(reinterpret_cast<sockaddr *>(&saddr), sizeof(saddr), "255.255.255.255", this->port_);
+  if (addr_len == 0) {
+    ESP_LOGW(TAG, "Invalid broadcast address");
+    return;
+  }
   uint8_t buffer[6 + sizeof this->macaddr_ * 16];
   memcpy(buffer, PREFIX, sizeof(PREFIX));
   for (size_t i = 0; i != 16; i++) {

esphome/components/zigbee_proxy/__init__.py

@@ -1,80 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import serial_proxy
-import esphome.config_validation as cv
-from esphome.const import CONF_BUFFER_SIZE, CONF_ID, CONF_POWER_SAVE_MODE, CONF_WIFI
-import esphome.final_validate as fv
-
-CODEOWNERS = ["@kbx81"]
-DEPENDENCIES = ["api", "serial_proxy"]
-
-CONF_INITIAL_TIMEOUT = "initial_timeout"
-CONF_MIN_TIMEOUT = "min_timeout"
-CONF_MAX_TIMEOUT = "max_timeout"
-CONF_SERIAL_PROXY_ID = "serial_proxy_id"
-
-# Default ACK timeout values for the boot-time metadata harvest
-_DEFAULT_INITIAL_TIMEOUT = 1600
-_DEFAULT_MIN_TIMEOUT = 400
-_DEFAULT_MAX_TIMEOUT = 3200
-
-zigbee_proxy_ns = cg.esphome_ns.namespace("zigbee_proxy")
-ZigbeeProxy = zigbee_proxy_ns.class_(
-    "ZigbeeProxy", cg.Component, serial_proxy.SerialProxyTap
-)
-
-
-def final_validate(config):
-    full_config = fv.full_config.get()
-    if (wifi_conf := full_config.get(CONF_WIFI)) and (
-        wifi_conf.get(CONF_POWER_SAVE_MODE, "").lower() != "none"
-    ):
-        raise cv.Invalid(
-            f"{CONF_WIFI} {CONF_POWER_SAVE_MODE} must be set to 'none' when using Zigbee proxy"
-        )
-    return config
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ZigbeeProxy),
-            cv.Required(CONF_SERIAL_PROXY_ID): cv.use_id(serial_proxy.SerialProxy),
-            cv.Optional(CONF_BUFFER_SIZE): cv.SplitDefault(
-                cv.int_range(min=256, max=2048),
-                esp8266=512,
-                default=1024,
-            ),
-            cv.Optional(
-                CONF_INITIAL_TIMEOUT, default=_DEFAULT_INITIAL_TIMEOUT
-            ): cv.int_range(min=10, max=10000),
-            cv.Optional(CONF_MIN_TIMEOUT, default=_DEFAULT_MIN_TIMEOUT): cv.int_range(
-                min=10, max=5000
-            ),
-            cv.Optional(CONF_MAX_TIMEOUT, default=_DEFAULT_MAX_TIMEOUT): cv.int_range(
-                min=50, max=10000
-            ),
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-)
-
-FINAL_VALIDATE_SCHEMA = final_validate
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-
-    sp = await cg.get_variable(config[CONF_SERIAL_PROXY_ID])
-    cg.add(var.set_serial_proxy(sp))
-
-    cg.add_define("USE_ZIGBEE_PROXY")
-    # Compiles the tap interface into serial_proxy; without it the port is a plain byte pipe
-    cg.add_define("USE_SERIAL_PROXY_TAP")
-
-    # Set buffer size via define for compile-time allocation
-    if CONF_BUFFER_SIZE in config:
-        cg.add_define("ZIGBEE_PROXY_BUFFER_SIZE", config[CONF_BUFFER_SIZE])
-
-    cg.add(var.set_initial_timeout(config[CONF_INITIAL_TIMEOUT]))
-    cg.add(var.set_min_timeout(config[CONF_MIN_TIMEOUT]))
-    cg.add(var.set_max_timeout(config[CONF_MAX_TIMEOUT]))

esphome/components/zigbee_proxy/ash_detector.cpp

@@ -1,256 +0,0 @@
-#include "ash_detector.h"
-
-#ifdef USE_ZIGBEE_PROXY
-
-namespace esphome::zigbee_proxy {
-
-// Control byte of an RSTACK, and the only ASH version byte that can follow it
-static constexpr uint8_t ASH_RSTACK_CONTROL = 0xC1;
-static constexpr uint8_t ASH_PROTOCOL_VERSION = 0x02;
-static constexpr size_t ASH_RSTACK_BODY_SIZE = 3;  // control, version, reset code
-static constexpr size_t ASH_CRC_SIZE = 2;
-// Smallest legal frame on the wire: a bare control byte plus its CRC
-static constexpr size_t ASH_MIN_FRAME_SIZE = 1 + ASH_CRC_SIZE;
-
-// The opening EZSP version command is a constant: control 0x00 (frmNum 0, ackNum 0)
-// followed by [seq=0][frameControl=0][frameId=0] randomized by 0x42 0x21 0xA8. Only the
-// requested version varies, as version ^ 0x54, so it can be recovered for free.
-static constexpr uint8_t EZSP_VERSION_CMD_PREFIX[] = {0x00, 0x42, 0x21, 0xA8};
-static constexpr size_t EZSP_VERSION_CMD_SIZE = 5;
-static constexpr uint8_t EZSP_VERSION_RANDOM_MASK = 0x54;
-
-// Consecutive frames we could not accept, with neither a good frame nor a retransmission
-// in between, before concluding the peer is no longer speaking ASH. A real ASH peer must
-// retransmit an unacknowledged frame, so the absence of one is the positive evidence
-// here -- garbage on the line is not, since noise proves nothing either way.
-static constexpr uint8_t MAX_UNCONFIRMED_REJECTS = 4;
-
-bool ash_reset_code_is_known(uint8_t code) {
-  switch (code) {
-    case 0x00:  // RESET_UNKNOWN
-    case 0x01:  // RESET_EXTERNAL
-    case 0x02:  // RESET_POWER_ON
-    case 0x03:  // RESET_WATCHDOG
-    case 0x06:  // RESET_ASSERT
-    case 0x09:  // RESET_BOOTLOADER
-    case 0x0B:  // RESET_SOFTWARE
-    case 0x51:  // ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT
-    case 0x80:  // ERROR_CHIP_SPECIFIC
-    case 0x81:  // RESET_CHIP_SPECIFIC
-      return true;
-    default:
-      return false;
-  }
-}
-
-void AshFrameScanner::begin_frame_() {
-  this->index_ = 0;
-  this->crc_ = ASH_CRC_INIT;
-  this->escaped_ = false;
-  this->poisoned_ = false;
-}
-
-void AshFrameScanner::reset() {
-  this->begin_frame_();
-  this->frame_length_ = 0;
-  this->discarding_ = false;
-}
-
-ScanResult AshFrameScanner::feed(uint8_t byte) {
-  if (byte == ASH_FLAG_BYTE) {
-    // Snapshot everything the verdict depends on: begin_frame_() clears all of it.
-    const bool discarding = this->discarding_;
-    const bool poisoned = this->poisoned_;
-    const bool escaped = this->escaped_;
-    const size_t index = this->index_;
-    const uint16_t crc = this->crc_;
-    // A FLAG always starts the next frame afresh, whatever preceded it
-    this->begin_frame_();
-    this->discarding_ = false;
-
-    if (discarding || index == 0) {
-      // Consecutive delimiters carry no frame at all, so there is nothing to judge
-      this->frame_length_ = 0;
-      return ScanResult::NONE;
-    }
-    // Running the CRC over the body *and* its trailing CRC bytes leaves zero when
-    // correct, so validity needs no second pass over the frame.
-    if (poisoned || escaped || index < ASH_MIN_FRAME_SIZE || crc != 0) {
-      this->frame_length_ = 0;
-      return ScanResult::INVALID;
-    }
-    this->frame_length_ = index - ASH_CRC_SIZE;
-    return ScanResult::FRAME;
-  }
-
-  if (this->discarding_) {
-    return ScanResult::NONE;
-  }
-
-  switch (byte) {
-    case ASH_CANCEL_BYTE:
-      // Everything received since the last FLAG is to be ignored
-      this->begin_frame_();
-      return ScanResult::NONE;
-
-    case ASH_SUBSTITUTE_BYTE:
-      // A low-level error was flagged; ignore everything up to the next FLAG
-      this->discarding_ = true;
-      return ScanResult::NONE;
-
-    case ASH_XON_BYTE:
-    case ASH_XOFF_BYTE:
-      // Transport flow control, not frame content: skip it without disturbing the frame
-      return ScanResult::NONE;
-
-    case ASH_ESCAPE_BYTE:
-      this->escaped_ = true;
-      return ScanResult::NONE;
-
-    default:
-      break;
-  }
-
-  uint8_t value = byte;
-  if (this->escaped_) {
-    this->escaped_ = false;
-    value = byte ^ ASH_XOR_BYTE;
-    // An escape must decode to a reserved byte; anything else is not ASH framing at all
-    if (!ash_is_reserved(value)) {
-      this->poisoned_ = true;
-      return ScanResult::NONE;
-    }
-  }
-
-  if (this->index_ >= sizeof(this->buffer_)) {
-    this->poisoned_ = true;
-    return ScanResult::NONE;
-  }
-
-  this->buffer_[this->index_++] = value;
-  this->crc_ = ash_crc16(&value, 1, this->crc_);
-  return ScanResult::NONE;
-}
-
-void AshDetector::reset() {
-  this->ncp_scanner_.reset();
-  this->host_scanner_.reset();
-  this->state_ = AshDetectState::IDLE;
-  this->rx_sequence_ = 0;
-  this->ack_owed_ = false;
-  this->data_frame_ready_ = false;
-  this->unconfirmed_rejects_ = 0;
-  this->negotiated_version_ = 0;
-}
-
-void AshDetector::from_ncp(uint8_t byte) {
-  this->data_frame_ready_ = false;
-  switch (this->ncp_scanner_.feed(byte)) {
-    case ScanResult::FRAME:
-      this->handle_ncp_frame_();
-      break;
-    case ScanResult::INVALID:
-      // A delimited chunk that is not a frame. While armed this may be a corrupted ASH
-      // frame, which the peer will retransmit, or a sign the peer stopped speaking ASH.
-      // reject_() distinguishes the two by whether a retransmission ever arrives.
-      this->reject_();
-      break;
-    case ScanResult::NONE:
-      break;
-  }
-}
-
-void AshDetector::handle_ncp_frame_() {
-  const uint8_t *body = this->ncp_scanner_.frame();
-  const size_t length = this->ncp_scanner_.length();
-  const uint8_t control = body[0];
-
-  // RSTACK is the only way into the handshake, and the only way back after a firmware
-  // swap: a Spinel or bootloader NCP never emits one, so those stay unarmed forever.
-  if (control == ASH_RSTACK_CONTROL) {
-    if (length == ASH_RSTACK_BODY_SIZE && body[1] == ASH_PROTOCOL_VERSION && ash_reset_code_is_known(body[2])) {
-      this->state_ = AshDetectState::SAW_RSTACK;
-      this->rx_sequence_ = 0;
-      this->ack_owed_ = false;
-      this->unconfirmed_rejects_ = 0;
-    }
-    return;
-  }
-
-  if (this->state_ != AshDetectState::ARMED) {
-    return;
-  }
-
-  if ((control & 0x80) != 0) {
-    return;  // ACK/NAK/RST/ERROR: nothing is owed for these
-  }
-
-  const uint8_t frame_num = (control >> 4) & ASH_MAX_SEQUENCE;
-  const bool re_tx = (control & 0x08) != 0;
-
-  if (frame_num != this->rx_sequence_) {
-    // A retransmission still proves the peer is speaking ASH even though we cannot use
-    // this copy, so it clears the suspicion without being acknowledged.
-    if (re_tx) {
-      this->unconfirmed_rejects_ = 0;
-    } else {
-      this->reject_();
-    }
-    return;
-  }
-
-  this->rx_sequence_ = (this->rx_sequence_ + 1) & ASH_MAX_SEQUENCE;
-  this->pending_ack_ = this->rx_sequence_;
-  this->ack_owed_ = true;
-  this->data_frame_ready_ = true;
-  this->unconfirmed_rejects_ = 0;
-}
-
-void AshDetector::reject_() {
-  if (this->state_ != AshDetectState::ARMED) {
-    return;
-  }
-  if (++this->unconfirmed_rejects_ >= MAX_UNCONFIRMED_REJECTS) {
-    this->state_ = AshDetectState::IDLE;
-    this->unconfirmed_rejects_ = 0;
-  }
-}
-
-void AshDetector::from_host(uint8_t byte) {
-  if (this->host_scanner_.feed(byte) != ScanResult::FRAME) {
-    return;
-  }
-
-  if (this->state_ != AshDetectState::SAW_RSTACK) {
-    return;
-  }
-
-  const uint8_t *body = this->host_scanner_.frame();
-  if (this->host_scanner_.length() != EZSP_VERSION_CMD_SIZE) {
-    return;
-  }
-  for (size_t i = 0; i < sizeof(EZSP_VERSION_CMD_PREFIX); i++) {
-    if (body[i] != EZSP_VERSION_CMD_PREFIX[i]) {
-      return;
-    }
-  }
-
-  this->negotiated_version_ = body[4] ^ EZSP_VERSION_RANDOM_MASK;
-  this->state_ = AshDetectState::ARMED;
-  this->rx_sequence_ = 0;
-  this->ack_owed_ = false;
-  this->unconfirmed_rejects_ = 0;
-}
-
-bool AshDetector::take_pending_ack(uint8_t &ack_num) {
-  if (!this->ack_owed_) {
-    return false;
-  }
-  this->ack_owed_ = false;
-  ack_num = this->pending_ack_;
-  return true;
-}
-
-}  // namespace esphome::zigbee_proxy
-
-#endif  // USE_ZIGBEE_PROXY

esphome/components/zigbee_proxy/ash_detector.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_ZIGBEE_PROXY
-
-#include "ash_protocol.h"
-
-#include <cstddef>
-#include <cstdint>
-
-namespace esphome::zigbee_proxy {
-
-// Decides when it is safe to acknowledge NCP frames on a client's behalf.
-//
-// The client suppresses its own ACKs, so nobody else will send them, and injecting ASH
-// bytes into a stream that is not ASH would corrupt it. Detection is therefore one-sided:
-// arm only on the session handshake, which is a fixed byte string, and never on frame
-// validity, which non-ASH traffic can satisfy by luck.
-//
-//   RSTACK  (NCP -> host)   c1 02 <reset_code> <crc> 7e
-//   version (host -> NCP)   00 42 21 a8 <version^0x54> <crc> 7e
-//
-// Requiring both, in that order, in opposite directions cannot be satisfied by a
-// unidirectional byte stream whatever it contains -- which is exactly the situation
-// during a firmware upload. Verified against real .gbl images and real Spinel traffic:
-// zero false arms, and neither pattern occurs even as a substring.
-//
-// Getting it wrong in the other direction is cheap: a frame we decline to acknowledge is
-// retransmitted by the NCP, so we see a clean copy and lose only the ack timeout. That
-// asymmetry is why this errs towards silence everywhere.
-
-enum class AshDetectState : uint8_t {
-  IDLE,        // Not ASH, or not yet proven to be
-  SAW_RSTACK,  // Handshake half-complete; watching for the version command
-  ARMED,       // Session confirmed; acknowledging on the client's behalf
-};
-
-enum class ScanResult : uint8_t {
-  NONE,     // Mid-frame, or a delimiter that carried nothing
-  FRAME,    // frame()/length() hold a complete body with a verified CRC
-  INVALID,  // A delimited chunk arrived but was not a well-formed ASH frame
-};
-
-// Reassembles one direction of the byte stream into unstuffed, CRC-checked frames.
-// Mirrors bellows' AshProtocol.data_received: FLAG ends a frame, CANCEL discards what
-// precedes it, SUBSTITUTE poisons everything up to the next FLAG, and XON/XOFF are
-// transport flow control removed without disturbing the frame around them.
-class AshFrameScanner {
- public:
-  ScanResult feed(uint8_t byte);
-  void reset();
-
-  // Valid only until the next feed() call, which begins overwriting the buffer.
-  const uint8_t *frame() const { return this->buffer_; }
-  size_t length() const { return this->frame_length_; }
-
- private:
-  void begin_frame_();
-
-  // Frames are bounded by the ASH maximum, so a stream carrying no delimiters cannot
-  // grow the buffer without limit; it just keeps failing.
-  uint8_t buffer_[MAX_ASH_FRAME_SIZE];
-  size_t index_{0};         // accumulation position for the frame being read
-  size_t frame_length_{0};  // body length of the last completed frame
-  uint16_t crc_{ASH_CRC_INIT};
-  bool escaped_{false};
-  bool discarding_{false};
-  bool poisoned_{false};
-};
-
-class AshDetector {
- public:
-  void reset();
-
-  // Feed observed traffic. Neither call gates forwarding: the detector only watches.
-  void from_ncp(uint8_t byte);
-  void from_host(uint8_t byte);
-
-  bool armed() const { return this->state_ == AshDetectState::ARMED; }
-
-  // True only while the host direction can affect the state machine, i.e. while waiting
-  // for the version command. Lets the caller skip scanning that direction entirely the
-  // rest of the time -- it is the one carrying firmware uploads.
-  bool needs_host_scan() const { return this->state_ == AshDetectState::SAW_RSTACK; }
-
-  // An acknowledgement became owed after the last from_ncp() call. Clears the flag.
-  bool take_pending_ack(uint8_t &ack_num);
-
-  // The EZSP frame carried by the DATA frame just accepted, for metadata sniffing. The
-  // ASH control byte is skipped, so offset 0 is the EZSP sequence number. Still
-  // randomized, and valid only until the next from_ncp() call.
-  const uint8_t *last_ezsp_frame() const { return this->ncp_scanner_.frame() + 1; }
-  size_t last_ezsp_frame_length() const {
-    const size_t length = this->ncp_scanner_.length();
-    return length > 0 ? length - 1 : 0;
-  }
-
-  AshDetectState state() const { return this->state_; }
-  uint8_t negotiated_version() const { return this->negotiated_version_; }
-
- protected:
-  void handle_ncp_frame_();
-  void reject_();
-
-  AshFrameScanner ncp_scanner_;
-  AshFrameScanner host_scanner_;
-  AshDetectState state_{AshDetectState::IDLE};
-  uint8_t rx_sequence_{0};
-  uint8_t pending_ack_{0};
-  bool ack_owed_{false};
-  bool data_frame_ready_{false};
-  uint8_t unconfirmed_rejects_{0};
-  uint8_t negotiated_version_{0};
-};
-
-}  // namespace esphome::zigbee_proxy
-
-#endif  // USE_ZIGBEE_PROXY

esphome/components/zigbee_proxy/ash_protocol.cpp

@@ -1,444 +0,0 @@
-#include "zigbee_proxy.h"
-
-#ifdef USE_ZIGBEE_PROXY
-
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome::zigbee_proxy {
-
-static const char *const TAG = "zigbee_proxy";
-
-static constexpr size_t ASH_MAX_LOG_BYTES = 168;  // Cap verbose hex dumps (168 * 3 = 504 byte buffer)
-
-// CRC-CCITT lookup table for polynomial 0x1021 (x^16 + x^12 + x^5 + 1)
-static const uint16_t CRC_TABLE[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD,
-    0xE1CE, 0xF1EF, 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A,
-    0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B,
-    0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
-    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861,
-    0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96,
-    0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87,
-    0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
-    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
-    0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3,
-    0x5004, 0x4025, 0x7046, 0x6067, 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290,
-    0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
-    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E,
-    0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F,
-    0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D, 0xDB5C,
-    0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
-    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83,
-    0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
-    0x2E93, 0x3EB2, 0x0ED1, 0x1EF0};
-
-void ash_randomize(uint8_t *data, size_t length) {
-  uint8_t rand = 0x42;
-  for (size_t i = 0; i < length; i++) {
-    data[i] ^= rand;
-    rand = (rand & 0x01) ? static_cast<uint8_t>((rand >> 1) ^ 0xB8) : static_cast<uint8_t>(rand >> 1);
-  }
-}
-
-uint16_t ash_crc16(const uint8_t *data, size_t length, uint16_t init) {
-  uint16_t crc = init;
-  for (size_t i = 0; i < length; i++) {
-    crc = (crc << 8) ^ CRC_TABLE[(crc >> 8) ^ data[i]];
-  }
-  return crc;
-}
-
-uint16_t ZigbeeProxy::calculate_crc_(const uint8_t *data, size_t length, uint16_t init) {
-  return ash_crc16(data, length, init);
-}
-
-bool ZigbeeProxy::validate_frame_crc_() {
-  // CRC is calculated over control byte + data
-  // rx_buffer_[0] contains control byte, rx_buffer_[1..rx_buffer_index_-3] contains data
-  // rx_buffer_[rx_buffer_index_-2] and rx_buffer_[rx_buffer_index_-1] contain CRC
-  if (this->rx_buffer_index_ < 3) {
-    // Frame too short to contain CRC
-    return false;
-  }
-
-  // Calculate CRC over control + data (exclude CRC bytes)
-  uint16_t calculated = this->calculate_crc_(this->rx_buffer_.data(), this->rx_buffer_index_ - 2);
-
-  // Extract received CRC (big-endian)
-  uint16_t received = (static_cast<uint16_t>(this->rx_buffer_[this->rx_buffer_index_ - 2]) << 8) |
-                      this->rx_buffer_[this->rx_buffer_index_ - 1];
-
-  if (calculated != received) {
-    ESP_LOGW(TAG, "CRC validation failed: calculated=0x%04X, received=0x%04X", calculated, received);
-    return false;
-  }
-
-  return true;
-}
-
-bool ZigbeeProxy::handle_ack_num_(uint8_t ack_num) {
-  // ackNum means "I expect frame N next", i.e. everything up to N-1 arrived, so a
-  // pending frame numbered ack_num-1 has been acknowledged. Carried by DATA, ACK
-  // and NAK alike.
-  if (!this->tx_buffer_pending_ || ack_num != ((this->tx_pending_frame_num_ + 1) & ASH_MAX_SEQUENCE)) {
-    return false;
-  }
-
-  uint32_t rtt = millis() - this->ack_timer_start_;
-  this->update_adaptive_timeout_(rtt);
-  ESP_LOGV(TAG, "Frame %d acknowledged, RTT: %u ms", this->tx_pending_frame_num_, rtt);
-  this->clear_tx_buffer_();
-  return true;
-}
-
-void ZigbeeProxy::parse_control_byte_(uint8_t control) {
-  // Decode frame type based on bit patterns:
-  // DATA:  0xxxxxxx (bit 7 = 0)
-  // ACK:   10x0xxxx (bits 7-6 = 10, bit 5 = 0)
-  // NAK:   10x1xxxx (bits 7-6 = 10, bit 5 = 1)
-  // RST:   11000000 (0xC0)
-  // RSTACK: 11000001 (0xC1)
-  // ERROR: 11000010 (0xC2)
-
-  AshFrameType frame_type;
-  if ((control & 0x80) == 0) {
-    // Bit 7 = 0: DATA frame
-    frame_type = AshFrameType::DATA;
-  } else if ((control & 0xC0) == 0x80) {
-    // Bits 7-6 = 10: ACK or NAK
-    // ACK format: 100nrPPP (bit 5 = 0)
-    // NAK format: 101nrPPP (bit 5 = 1)
-    if ((control & 0x20) == 0) {
-      frame_type = AshFrameType::ACK;
-    } else {
-      frame_type = AshFrameType::NAK;
-    }
-  } else {
-    // Bits 7-6 = 11: control frames (RST, RSTACK, ERROR)
-    uint8_t control_bits = control & 0x07;
-    if (control_bits == 0x00) {
-      frame_type = AshFrameType::RST;
-    } else if (control_bits == 0x01) {
-      frame_type = AshFrameType::RSTACK;
-    } else if (control_bits == 0x02) {
-      frame_type = AshFrameType::ERROR;
-    } else {
-      ESP_LOGW(TAG, "Unknown control frame type: 0x%02X", control);
-      return;
-    }
-  }
-
-  // Extract sequence numbers from DATA frame format: 0ffrPPPP
-  // Bits 6-4 = frmNum, bit 3 = reTx, bits 2-0 = ackNum
-  uint8_t frame_num = (control >> 4) & 0x07;  // Bits 6-4
-  uint8_t ack_num = control & 0x07;           // Bits 2-0
-  bool retx = (control & 0x08) != 0;          // Bit 3 (for DATA frames)
-
-  ESP_LOGV(TAG, "Parsed control byte: type=%d, frmNum=%d, ackNum=%d, reTx=%d", static_cast<int>(frame_type), frame_num,
-           ack_num, retx);
-
-  // Handle frame based on type
-  switch (frame_type) {
-    case AshFrameType::DATA: {
-      // Process the piggybacked ACK first: ackNum is valid regardless of the DATA
-      // frame's own sequence ordering
-      if (this->handle_ack_num_(ack_num)) {
-        ESP_LOGV(TAG, "ACK received (piggybacked in DATA)");
-      }
-
-      // Check sequence number
-      if (frame_num != this->rx_sequence_) {
-        if (retx && frame_num == ((this->rx_sequence_ - 1) & ASH_MAX_SEQUENCE)) {
-          // Retransmission of a frame we already ACKed (our ACK was lost) - re-ACK and discard
-          ESP_LOGV(TAG, "Duplicate DATA frame %d, re-sending ACK", frame_num);
-          this->send_ack_frame_(this->rx_sequence_);
-        } else {
-          ESP_LOGW(TAG, "Out of sequence DATA frame: expected %d, got %d", this->rx_sequence_, frame_num);
-          this->send_nak_frame_(this->rx_sequence_);
-        }
-        return;
-      }
-
-      // Increment RX sequence and send ACK (ack_num = next expected frame)
-      this->increment_rx_sequence_();
-      this->send_ack_frame_(this->rx_sequence_);
-
-      // Extract payload (skip control byte, exclude CRC)
-      size_t payload_length = this->rx_buffer_index_ > 3 ? this->rx_buffer_index_ - 3 : 0;
-      const uint8_t *payload = this->rx_buffer_.data() + 1;
-
-      // This path only runs during the boot harvest, where this component is the ASH
-      // endpoint and consumes frames itself, so they must be derandomized. A subscribed
-      // client is served by the transparent relay instead, which never reaches here.
-      if (payload_length > 0) {
-        ash_randomize(this->rx_buffer_.data() + 1, payload_length);
-        this->handle_boot_data_frame_(payload, payload_length);
-      }
-      break;
-    }
-
-    case AshFrameType::ACK:
-      this->handle_ack_num_(ack_num);
-      break;
-
-    case AshFrameType::NAK:
-      // A NAK carries valid ACK information like any other frame: ackNum is the
-      // next frame the NCP expects, so everything before it did arrive. Honour
-      // that first -- retransmitting an already-acknowledged frame otherwise
-      // burns all ASH_MAX_RETRIES and drops the link. bellows applies the same
-      // ACK handling to DATA, ACK and NAK alike.
-      if (this->handle_ack_num_(ack_num)) {
-        ESP_LOGW(TAG, "NAK received for frame %d (already acknowledged, not retransmitting)", ack_num);
-        break;
-      }
-      ESP_LOGW(TAG, "NAK received for frame %d, retransmitting", ack_num);
-      if (this->tx_buffer_pending_) {
-        this->handle_retransmission_();
-      }
-      break;
-
-    case AshFrameType::RST: {
-      // An NCP never sends RST in normal operation; treat it as a reset indication
-      // and run the RSTACK handling to resynchronize state (nothing is transmitted here)
-      ESP_LOGW(TAG, "Received unexpected RST frame from NCP, resynchronizing");
-      uint8_t rstack_data[] = {0x02, 0x01, 0x00};  // Synthesized RSTACK payload
-      this->handle_rstack_frame_(rstack_data, sizeof(rstack_data));
-      break;
-    }
-
-    case AshFrameType::RSTACK:
-      this->handle_rstack_frame_(this->rx_buffer_.data() + 1, this->rx_buffer_index_ - 3);
-      break;
-
-    case AshFrameType::ERROR:
-      this->handle_error_frame_(this->rx_buffer_.data() + 1, this->rx_buffer_index_ - 3);
-      break;
-  }
-}
-
-bool ZigbeeProxy::parse_byte_(uint8_t byte) {
-  static constexpr uint8_t ASH_CAN_BYTE = 0x1A;
-  static constexpr uint8_t ASH_XON_BYTE = 0x11;
-  static constexpr uint8_t ASH_XOFF_BYTE = 0x13;
-
-  // Reserved bytes are only meaningful when they appear *bare* in the stream, so
-  // they must be filtered here, before unescaping, and never afterwards. A frame
-  // whose control or data byte happens to equal one of them arrives stuffed (0x11
-  // is sent as 7D 31), and unescaping yields the real value -- so filtering after
-  // unescaping silently eats a valid control byte, shifting the whole frame by one
-  // and failing CRC on every retransmission. This mirrors bellows, which strips
-  // flow control from the raw buffer and only then unstuffs.
-  if (!this->escape_next_byte_) {
-    if (byte == ASH_CAN_BYTE) {
-      // Cancel: discard any partial frame
-      this->rx_buffer_index_ = 0;
-      this->parsing_state_ = ParsingState::WAIT_FLAG_START;
-      return false;
-    }
-    if (byte == ASH_XON_BYTE || byte == ASH_XOFF_BYTE) {
-      // Flow control: not part of any frame, may appear anywhere
-      return false;
-    }
-  }
-
-  switch (this->parsing_state_) {
-    case ParsingState::WAIT_FLAG_START:
-      // Handle escape sequences - NCP may send escaped control byte at frame start
-      if (byte == ASH_ESCAPE_BYTE) {
-        this->escape_next_byte_ = true;
-        return false;
-      }
-
-      if (this->escape_next_byte_) {
-        byte ^= ASH_XOR_BYTE;
-        this->escape_next_byte_ = false;
-      }
-
-      if (byte == ASH_FLAG_BYTE) {
-        // Start of frame with FLAG delimiter
-        this->rx_buffer_index_ = 0;
-        this->escape_next_byte_ = false;
-        this->parsing_state_ = ParsingState::WAIT_CONTROL;
-        ESP_LOGV(TAG, "Frame start detected (FLAG)");
-      } else if (this->ash_state_ == AshState::CONNECTED) {
-        // When connected, NCP often omits leading FLAG on responses
-        // Any byte could be a control byte:
-        //   - DATA frames: 0x00-0x7F (bit 7 = 0)
-        //   - ACK frames:  0x80-0x9F (bits 7-6 = 10, bit 5 = 0)
-        //   - NAK frames:  0xA0-0xBF (bits 7-6 = 10, bit 5 = 1)
-        //   - RST/RSTACK/ERROR: 0xC0-0xC2 (bits 7-6 = 11)
-        // Bare flow-control bytes were already filtered above, so anything
-        // reaching here is genuine frame content.
-        this->rx_buffer_index_ = 0;
-        this->rx_buffer_[this->rx_buffer_index_++] = byte;
-        this->parsing_state_ = ParsingState::WAIT_DATA;
-        ESP_LOGV(TAG, "Frame start detected (control byte 0x%02X)", byte);
-      } else if ((byte & 0x80) != 0) {
-        // Before connected, only accept control/management frames (bit 7 set)
-        // This handles RSTACK (0xC1), ACK (0x8X), NAK (0xAX), ERROR (0xC2)
-        this->rx_buffer_index_ = 0;
-        this->rx_buffer_[this->rx_buffer_index_++] = byte;
-        this->parsing_state_ = ParsingState::WAIT_DATA;
-        ESP_LOGV(TAG, "Frame start detected (control byte 0x%02X)", byte);
-      }
-      break;
-
-    case ParsingState::WAIT_CONTROL:
-      if (byte == ASH_FLAG_BYTE) {
-        // Empty frame or repeated FLAG
-        ESP_LOGV(TAG, "Empty frame or repeated FLAG, restarting");
-        this->rx_buffer_index_ = 0;
-        return false;
-      }
-
-      if (byte == ASH_ESCAPE_BYTE) {
-        this->escape_next_byte_ = true;
-        return false;
-      }
-
-      if (this->escape_next_byte_) {
-        byte ^= ASH_XOR_BYTE;
-        this->escape_next_byte_ = false;
-      }
-
-      // Store control byte
-      this->rx_buffer_[this->rx_buffer_index_++] = byte;
-      this->parsing_state_ = ParsingState::WAIT_DATA;
-      break;
-
-    case ParsingState::WAIT_DATA:
-      if (byte == ASH_FLAG_BYTE) {
-        // End of frame - validate and process
-        ESP_LOGV(TAG, "Frame complete, %u bytes in buffer", this->rx_buffer_index_);
-        if (this->validate_frame_crc_()) {
-          this->parse_control_byte_(this->rx_buffer_[0]);
-        } else {
-          // CRC failed - WARN logs byte count only; hex dump at VERBOSE (truncated to ASH_MAX_LOG_BYTES)
-          ESP_LOGW(TAG, "CRC failed (%u bytes)", this->rx_buffer_index_);
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-          char hex_buf[format_hex_pretty_size(ASH_MAX_LOG_BYTES)];
-#endif
-          ESP_LOGV(TAG, "CRC failed frame: %s",
-                   format_hex_pretty_to(hex_buf, this->rx_buffer_.data(), this->rx_buffer_index_));
-          this->send_nak_frame_(this->rx_sequence_);
-        }
-        this->parsing_state_ = ParsingState::WAIT_FLAG_START;
-        return true;
-      }
-
-      if (byte == ASH_ESCAPE_BYTE) {
-        this->escape_next_byte_ = true;
-        return false;
-      }
-
-      if (this->escape_next_byte_) {
-        byte ^= ASH_XOR_BYTE;
-        this->escape_next_byte_ = false;
-      }
-
-      // Check buffer overflow
-      if (this->rx_buffer_index_ >= MAX_ASH_FRAME_SIZE) {
-        ESP_LOGE(TAG, "RX buffer overflow, frame too large");
-        this->parsing_state_ = ParsingState::WAIT_FLAG_START;
-        return false;
-      }
-
-      // Store data byte
-      this->rx_buffer_[this->rx_buffer_index_++] = byte;
-      break;
-
-    default:
-      this->parsing_state_ = ParsingState::WAIT_FLAG_START;
-      break;
-  }
-
-  return false;
-}
-
-// Appends a byte with ASH stuffing (reserved: FLAG, ESCAPE, XON, XOFF, SUB, CAN);
-// returns false if it would exceed capacity
-static bool append_byte_stuffed(uint8_t *output, size_t capacity, size_t &pos, uint8_t byte) {
-  const bool reserved = byte == ASH_FLAG_BYTE || byte == ASH_ESCAPE_BYTE || byte == 0x11 || byte == 0x13 ||
-                        byte == ASH_SUBSTITUTE_BYTE || byte == 0x1A;
-  if (pos + (reserved ? 2 : 1) > capacity) {
-    return false;
-  }
-  if (reserved) {
-    output[pos++] = ASH_ESCAPE_BYTE;
-    output[pos++] = byte ^ ASH_XOR_BYTE;
-  } else {
-    output[pos++] = byte;
-  }
-  return true;
-}
-
-size_t ZigbeeProxy::build_frame_(uint8_t *output, size_t capacity, const uint8_t *data, size_t length,
-                                 AshFrameType type, uint8_t frame_num, uint8_t ack_num, bool retx) {
-  size_t pos = 0;
-
-  // Start with FLAG
-  if (capacity < 1) {
-    return 0;
-  }
-  output[pos++] = ASH_FLAG_BYTE;
-
-  // Build control byte
-  uint8_t control = 0;
-  switch (type) {
-    case AshFrameType::DATA:
-      // DATA frame format: 0ffrPPPP
-      // Bit 7 = 0 (DATA indicator), bits 6-4 = frmNum, bit 3 = reTx, bits 2-0 = ackNum
-      control = (frame_num << 4) | (retx ? 0x08 : 0x00) | ack_num;
-      break;
-    case AshFrameType::ACK:
-      control = 0x80 | ack_num;
-      break;
-    case AshFrameType::NAK:
-      control = 0xA0 | ack_num;
-      break;
-    case AshFrameType::RST:
-      control = 0xC0;
-      break;
-    case AshFrameType::RSTACK:
-      control = 0xC1;
-      break;
-    case AshFrameType::ERROR:
-      control = 0xC2;
-      break;
-  }
-
-  // Add control byte with stuffing
-  if (!append_byte_stuffed(output, capacity, pos, control)) {
-    ESP_LOGE(TAG, "Frame too large for buffer (%u byte payload, %u byte buffer)", length, capacity);
-    return 0;
-  }
-
-  // Add data payload with stuffing
-  for (size_t i = 0; i < length; i++) {
-    if (!append_byte_stuffed(output, capacity, pos, data[i])) {
-      ESP_LOGE(TAG, "Frame too large for buffer (%u byte payload, %u byte buffer)", length, capacity);
-      return 0;
-    }
-  }
-
-  // Calculate CRC incrementally over control byte then data (avoids a MAX_ASH_FRAME_SIZE stack copy)
-  uint16_t crc = this->calculate_crc_(&control, 1);
-  if (length > 0) {
-    crc = this->calculate_crc_(data, length, crc);
-  }
-
-  // Add CRC with stuffing (big-endian), then the end FLAG
-  if (!append_byte_stuffed(output, capacity, pos, (crc >> 8) & 0xFF) ||
-      !append_byte_stuffed(output, capacity, pos, crc & 0xFF) || pos + 1 > capacity) {
-    ESP_LOGE(TAG, "Frame too large for buffer (%u byte payload, %u byte buffer)", length, capacity);
-    return 0;
-  }
-  output[pos++] = ASH_FLAG_BYTE;
-
-  return pos;
-}
-
-}  // namespace esphome::zigbee_proxy
-
-#endif  // USE_ZIGBEE_PROXY

esphome/components/zigbee_proxy/ash_protocol.h

@@ -1,115 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstddef>
-
-namespace esphome::zigbee_proxy {
-
-// ASH Protocol Constants
-static constexpr uint8_t ASH_FLAG_BYTE = 0x7E;        // Frame delimiter
-static constexpr uint8_t ASH_ESCAPE_BYTE = 0x7D;      // Escape/substitution byte
-static constexpr uint8_t ASH_XOR_BYTE = 0x20;         // XOR mask for escaped bytes
-static constexpr uint8_t ASH_SUBSTITUTE_BYTE = 0x18;  // Substitution for invalid bytes
-
-static constexpr uint8_t ASH_XON_BYTE = 0x11;     // Resume transmission
-static constexpr uint8_t ASH_XOFF_BYTE = 0x13;    // Pause transmission
-static constexpr uint8_t ASH_CANCEL_BYTE = 0x1A;  // Discards the partial frame before it
-
-// A reserved byte can never appear literally inside a frame; it is escaped as
-// ESCAPE followed by the byte XOR 0x20. Rejecting frames that contain one is what
-// eliminates most non-ASH traffic before its CRC is ever computed: real firmware
-// images and Spinel payloads are dense in 0x11/0x13/0x18/0x1A.
-inline bool ash_is_reserved(uint8_t byte) {
-  return byte == ASH_FLAG_BYTE || byte == ASH_ESCAPE_BYTE || byte == ASH_XON_BYTE || byte == ASH_XOFF_BYTE ||
-         byte == ASH_SUBSTITUTE_BYTE || byte == ASH_CANCEL_BYTE;
-}
-
-// CRC-CCITT (init 0xFFFF, polynomial 0x1021, transmitted big-endian). Note this is a
-// different variant from the Kermit FCS that Spinel/HDLC-lite uses over the same
-// 0x7E framing, so Spinel frames systematically fail this check.
-uint16_t ash_crc16(const uint8_t *data, size_t length, uint16_t init = 0xFFFF);
-
-// Buffer size configuration
-#ifdef ZIGBEE_PROXY_BUFFER_SIZE
-static constexpr size_t MAX_ASH_FRAME_SIZE = ZIGBEE_PROXY_BUFFER_SIZE;
-#else
-#ifdef USE_ESP8266
-static constexpr size_t MAX_ASH_FRAME_SIZE = 512;  // Limited RAM on ESP8266
-#else
-static constexpr size_t MAX_ASH_FRAME_SIZE = 1024;  // Full buffer on ESP32/RP2040
-#endif
-#endif
-
-// Protocol limits
-static constexpr uint8_t ASH_MAX_SEQUENCE = 7;       // 3-bit sequence number (0-7)
-static constexpr uint8_t ASH_TX_WINDOW_SIZE = 1;     // Only 1 unacknowledged frame allowed
-static constexpr uint8_t ASH_MAX_RETRIES = 5;        // Maximum retransmission attempts
-static constexpr uint16_t ASH_CRC_INIT = 0xFFFF;     // CRC-CCITT initial value
-static constexpr uint32_t ASH_RESET_TIMEOUT = 3000;  // RST/RSTACK timeout in milliseconds
-
-// IEEE address size
-static constexpr size_t ZIGBEE_IEEE_ADDR_SIZE = 8;  // 64-bit IEEE address
-
-// ASH data randomization. The Data Field of every DATA frame is XORed with a
-// pseudo-random sequence (LFSR seeded at 0x42, polynomial 0xB8) before
-// transmission and again after reception; the operation is its own inverse.
-//
-// Proxied client traffic must NOT be passed through this: the client randomizes
-// and the NCP derandomizes, so payloads travel end to end untouched and the
-// proxy stays transparent. Apply it only to frames this component originates or
-// consumes itself, i.e. the boot-harvest EZSP commands and their responses.
-// Sending an unrandomized command makes the NCP derandomize it into garbage and
-// answer with an error frame that decodes as a plausible-looking wrong value.
-void ash_randomize(uint8_t *data, size_t length);
-
-// ASH Frame Types (encoded in control byte)
-// DATA format:    0ffrPPPP - bit 7=0, bits 6-4=frmNum, bit 3=reTx, bits 2-0=ackNum
-// ACK/NAK format: 10XnrPPP - bit 5 distinguishes ACK(0) from NAK(1)
-enum class AshFrameType : uint8_t {
-  DATA = 0x00,    // Data frame (bit 7 = 0)
-  ACK = 0x80,     // Acknowledge frame (100nrPPP, bit 5 = 0)
-  NAK = 0xA0,     // Negative acknowledge (101nrPPP, bit 5 = 1)
-  RST = 0xC0,     // Reset request (bits 7-6 = 11, bits 2-0 = 000)
-  RSTACK = 0xC1,  // Reset acknowledgment (bits 7-6 = 11, bits 2-0 = 001)
-  ERROR = 0xC2,   // Error indication (bits 7-6 = 11, bits 2-0 = 010)
-};
-
-// ASH Connection State
-enum class AshState : uint8_t {
-  DISCONNECTED,  // Initial state, no connection
-  CONNECTING,    // Sent RST, waiting for RSTACK
-  CONNECTED,     // Normal operation
-  FAILED,        // Too many errors/timeouts, requires reset
-};
-
-// Frame Parsing State Machine
-enum class ParsingState : uint8_t {
-  WAIT_FLAG_START,  // Looking for frame start FLAG (0x7E)
-  WAIT_CONTROL,     // Reading control byte
-  WAIT_DATA,        // Reading data payload
-  WAIT_CRC_HIGH,    // Reading CRC high byte
-  WAIT_CRC_LOW,     // Reading CRC low byte
-  WAIT_FLAG_END,    // Expecting end FLAG (0x7E)
-};
-
-// Bootloader detection states
-enum class BootloaderState : uint8_t {
-  NORMAL,    // Normal operation
-  DETECTED,  // Bootloader mode detected
-  MENU,      // In bootloader menu
-};
-
-// EZSP Error Codes (from ERROR frame)
-enum class EzspError : uint8_t {
-  VERSION_NOT_SET = 0x00,
-  RESET_UNKNOWN = 0x01,
-  RESET_EXTERNAL = 0x02,
-  RESET_POWER_ON = 0x03,
-  RESET_WATCHDOG = 0x04,
-  RESET_ASSERT = 0x05,
-  RESET_BOOTLOADER = 0x06,
-  RESET_SOFTWARE = 0x07,
-  EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT = 0x51,
-};
-
-}  // namespace esphome::zigbee_proxy

esphome/components/zigbee_proxy/ezsp_commands.h

@@ -1,88 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace esphome::zigbee_proxy {
-
-// EZSP Protocol Versions
-static constexpr uint8_t EZSP_MIN_VERSION = 13;  // Minimum supported version
-static constexpr uint8_t EZSP_MAX_VERSION = 13;  // Maximum version we request
-
-// EZSP Frame Control bits
-static constexpr uint8_t EZSP_FRAME_CONTROL_COMMAND = 0x00;   // Host to NCP
-static constexpr uint8_t EZSP_FRAME_CONTROL_RESPONSE = 0x80;  // NCP to Host
-static constexpr uint8_t EZSP_FRAME_CONTROL_CALLBACK = 0x90;  // Async callback from NCP
-
-// High byte of the 16-bit frame control, carrying frameFormatVersion = 1. Every
-// command after version negotiation must set this: omitting it leaves the NCP
-// reading the frame ID's low byte as frame_control_high, so the command is
-// discarded and the reply is an error frame rather than the expected response.
-static constexpr uint8_t EZSP_FRAME_CONTROL_EXTENDED = 0x01;
-
-// Legacy EZSP frame format (v4-v7): [sequence] [frame_control] [frame_id]
-// Extended EZSP frame format (v8+): [sequence] [frame_control_low] [frame_control_high] [frame_id_low] [frame_id_high]
-//
-// Only the `version` command and its response use the legacy format, because the
-// NCP starts in legacy mode and has not yet learned the negotiated version.
-// Everything after that is extended, with no per-NCP exceptions.
-
-// EZSP Frame IDs - Callbacks (NCP to host, async)
-static constexpr uint16_t EZSP_STACK_STATUS_HANDLER = 0x0019;  // Stack up/down notification
-
-// EZSP Frame IDs - Commands (host to NCP)
-static constexpr uint16_t EZSP_VERSION = 0x0000;                 // Version negotiation
-static constexpr uint16_t EZSP_GET_EUI64 = 0x0026;               // Get IEEE address
-static constexpr uint16_t EZSP_GET_NETWORK_PARAMETERS = 0x0028;  // Get network parameters
-static constexpr uint16_t EZSP_GET_TOKEN_DATA = 0x0102;          // Read an NVM3 token
-
-// Extended EZSP header: [sequence] [frame_control_lo] [frame_control_hi] [id_lo] [id_hi]
-static constexpr size_t EZSP_EXTENDED_HEADER_SIZE = 5;
-
-// Network metadata comes straight out of NVM3 instead of from a running stack.
-// NVM3KEY_STACK_NODE_DATA holds the PAN ID, channel, extended PAN ID and node type of
-// the network this radio is commissioned onto, and reading it requires nothing beyond a
-// completed version negotiation: no stack configuration, no networkInit, no waiting on
-// stackStatusHandler, and above all no joining the network -- so simply plugging the
-// device in never brings the radio up.
-//
-// Note the 0x0001 domain prefix on the NVM3 object key. The bare creator ID
-// 0x0000EE64 is a different thing and getTokenData answers FAIL for it.
-static constexpr uint32_t NVM3KEY_STACK_NODE_DATA = 0x0001EE64;
-
-// getTokenData response: [status (4)] [length (4)] [value (length)]
-static constexpr size_t TOKEN_DATA_VALUE_OFFSET = 8;
-
-// NV3StackNodeData value layout (16 bytes, little-endian):
-// [panId (2)] [radioTxPower (1)] [radioFreqChannel (1)] [stackProfile (1)]
-// [nodeType (1)] [zigbeeNodeId (2)] [extendedPanId (8)]
-static constexpr size_t NV3_NODE_DATA_SIZE = 16;
-static constexpr size_t NV3_NODE_DATA_PAN_ID_OFFSET = 0;
-static constexpr size_t NV3_NODE_DATA_CHANNEL_OFFSET = 3;
-static constexpr size_t NV3_NODE_DATA_NODE_TYPE_OFFSET = 5;
-static constexpr size_t NV3_NODE_DATA_EXT_PAN_ID_OFFSET = 8;
-
-// A radio with no network still has the token, holding a sentinel rather than being
-// absent: panId reads 0xFFFF and nodeType reads UNKNOWN_DEVICE. Detecting "no network"
-// therefore means inspecting nodeType, not treating the read as failed.
-static constexpr uint8_t NV3_NODE_TYPE_UNKNOWN_DEVICE = 0x00;
-
-// Status codes (subset). EZSP v13+ / EmberZNet 8.x report sl_status_t, not the
-// legacy 8-bit EmberStatus.
-enum class SlStatus : uint8_t {
-  OK = 0x00,
-  NETWORK_UP = 0x15,
-  NETWORK_DOWN = 0x16,
-};
-
-// getNetworkParameters response layout, used when sniffing a client's own traffic. This
-// is a different shape from the NV3 token the boot harvest reads: 25 bytes of
-// [status (4)] [nodeType (1)] [extendedPanId (8)] [panId (2)] [radioTxPower (1)]
-// [radioChannel (1)] [joinMethod (1)] [nwkManagerId (2)] [nwkUpdateId (1)] [channels (4)]
-static constexpr size_t NETWORK_PARAMS_RESPONSE_SIZE = 25;
-static constexpr size_t NETWORK_PARAMS_STATUS_OFFSET = 0;
-static constexpr size_t NETWORK_PARAMS_EXT_PAN_ID_OFFSET = 5;
-static constexpr size_t NETWORK_PARAMS_PAN_ID_OFFSET = 13;
-static constexpr size_t NETWORK_PARAMS_CHANNEL_OFFSET = 16;
-
-}  // namespace esphome::zigbee_proxy

esphome/components/zigbee_proxy/zigbee_proxy.h

@@ -1,250 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_ZIGBEE_PROXY
-
-#include "esphome/components/api/api_connection.h"
-#include "esphome/components/api/api_pb2.h"
-#include "esphome/components/serial_proxy/serial_proxy.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-#include "ash_protocol.h"
-#include "ash_detector.h"
-
-#include <array>
-
-namespace esphome::zigbee_proxy {
-
-// Timeout configuration structure
-struct TimeoutConfig {
-  uint32_t initial_timeout_ms{1600};  // Initial ACK timeout
-  uint32_t min_timeout_ms{400};       // Minimum adaptive timeout
-  uint32_t max_timeout_ms{3200};      // Maximum adaptive timeout
-  uint32_t current_timeout_ms{1600};  // Current adaptive timeout
-};
-
-// Network information structure
-struct NetworkInfo {
-  std::array<uint8_t, ZIGBEE_IEEE_ADDR_SIZE> ieee_address{};
-  uint16_t pan_id{0};
-  std::array<uint8_t, 8> extended_pan_id{};
-  uint8_t channel{0};
-  bool valid{false};
-};
-
-enum ZigbeeProxyFeature : uint32_t {
-  FEATURE_ZIGBEE_PROXY_ENABLED = 1 << 0,
-  // Set only when the harvest actually read a network off the radio. Without it a client
-  // cannot tell "a Zigbee radio with no network formed" from "not a Zigbee radio at all"
-  // -- both otherwise present as ENABLED with an all-zero payload, and the second happens
-  // whenever the NCP has been reflashed to Thread or is simply not responding.
-  FEATURE_ZIGBEE_NETWORK_INFO_VALID = 1 << 1,
-};
-
-// Boot-time initialization state machine
-enum class BootState : uint8_t {
-  IDLE,               // Not initializing
-  WAIT_RSTACK,        // Sent RST, waiting for RSTACK
-  SEND_VERSION,       // Send EZSP version command
-  WAIT_VERSION,       // Waiting for version response
-  SEND_TOKEN_DATA,    // Send getTokenData(NVM3KEY_STACK_NODE_DATA)
-  WAIT_TOKEN_DATA,    // Waiting for token data response
-  SEND_GET_EUI64,     // Send getEui64 command
-  WAIT_EUI64,         // Waiting for EUI64 response
-  SEND_FINAL_RST,     // Send final RST to reset NCP
-  WAIT_FINAL_RSTACK,  // Waiting for final RSTACK
-  COMPLETE,           // Boot sequence complete
-  FAILED,             // Boot sequence failed
-};
-
-// Watches a `serial_proxy` port carrying an EZSP NCP and reports what it learns about the
-// Zigbee network. It never carries client traffic: the serial proxy owns the port and the
-// bytes, and this component only observes them, plus two exceptions where it writes to the
-// port itself -- the boot-time metadata harvest, which runs before any client connects, and
-// the ASH acknowledgements a client asks it to send on its behalf.
-class ZigbeeProxy : public serial_proxy::SerialProxyTap, public Component {
- public:
-  ZigbeeProxy();
-
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-  float get_setup_priority() const override;
-  bool can_proceed() override;
-
-  void set_serial_proxy(serial_proxy::SerialProxy *parent) { this->parent_ = parent; }
-
-  // SerialProxyTap
-  void on_device_rx(const uint8_t *data, size_t len) override;
-  void on_client_tx(const uint8_t *data, size_t len) override;
-  bool tap_needs_port() const override {
-    if (this->boot_sequence_active_) {
-      return true;
-    }
-    // A pending re-harvest waits for the port to go idle. Starting one under a subscriber
-    // would inject our own ASH frames into whatever it is doing -- most likely the very
-    // firmware upload that invalidated the metadata.
-    return this->reharvest_pending_ && this->parent_->get_api_connection() == nullptr;
-  }
-
-  /// The port stopped handling our protocol, so whatever we know about the radio may no
-  /// longer be true -- a client asking for raw bytes is usually about to reflash it.
-  void on_protocol_disabled() override;
-
-  /// The radio was unplugged or a new one appeared; metadata describes neither.
-  void on_device_presence_changed_(bool connected);
-
-  // API integration
-  void api_connection_authenticated(api::APIConnection *conn);
-  void zigbee_proxy_request(api::APIConnection *api_connection, const api::ZigbeeProxyRequest &msg);
-
-  // Feature flags
-  uint32_t get_feature_flags() const {
-    uint32_t flags = ZigbeeProxyFeature::FEATURE_ZIGBEE_PROXY_ENABLED;
-    if (this->network_info_.valid) {
-      flags |= ZigbeeProxyFeature::FEATURE_ZIGBEE_NETWORK_INFO_VALID;
-    }
-    return flags;
-  }
-
-  // Network information accessors
-  const NetworkInfo &get_network_info() const { return this->network_info_; }
-  uint64_t get_ieee_address() const;
-
-  // Timeout configuration (callable from Python/API)
-  void set_timeout_config(uint32_t initial_ms, uint32_t min_ms, uint32_t max_ms);
-  void set_initial_timeout(uint32_t timeout_ms) { this->timeout_config_.initial_timeout_ms = timeout_ms; }
-  void set_min_timeout(uint32_t timeout_ms) { this->timeout_config_.min_timeout_ms = timeout_ms; }
-  void set_max_timeout(uint32_t timeout_ms) { this->timeout_config_.max_timeout_ms = timeout_ms; }
-
- protected:
-  // ASH Protocol State Machine
-  void reset_ash_protocol_();
-  void send_rst_frame_();
-  void handle_rstack_frame_(const uint8_t *data, size_t length);
-  void handle_error_frame_(const uint8_t *data, size_t length);
-  // Applies a frame's ackNum to the pending TX frame. Returns true if it
-  // acknowledged one. Valid on DATA, ACK and NAK frames alike.
-  bool handle_ack_num_(uint8_t ack_num);
-  bool send_ack_frame_(uint8_t ack_num);
-  bool send_nak_frame_(uint8_t ack_num);
-  bool send_data_frame_(const uint8_t *data, size_t length, bool retransmit = false);
-
-  // Frame parsing and building (implemented in ash_protocol.cpp)
-  bool parse_byte_(uint8_t byte);
-  void parse_control_byte_(uint8_t control);
-  bool validate_frame_crc_();
-  // Builds a stuffed frame into output; returns 0 if the frame (worst case 2*length + 8
-  // bytes after byte stuffing) would exceed capacity.
-  size_t build_frame_(uint8_t *output, size_t capacity, const uint8_t *data, size_t length, AshFrameType type,
-                      uint8_t frame_num = 0, uint8_t ack_num = 0, bool retx = false);
-  uint16_t calculate_crc_(const uint8_t *data, size_t length, uint16_t init = ASH_CRC_INIT);
-
-  // Sequence number management
-  void increment_tx_sequence_() { this->tx_sequence_ = (this->tx_sequence_ + 1) & ASH_MAX_SEQUENCE; }
-  void increment_rx_sequence_() { this->rx_sequence_ = (this->rx_sequence_ + 1) & ASH_MAX_SEQUENCE; }
-
-  // Timeout management
-  void update_adaptive_timeout_(uint32_t measured_rtt_ms);
-  void start_ack_timer_() { this->ack_timer_start_ = millis(); }
-  bool check_ack_timeout_();
-
-  // Retransmission
-  void handle_retransmission_();
-  void clear_tx_buffer_() {
-    this->tx_buffer_pending_ = false;
-    this->tx_retry_count_ = 0;
-  }
-
-  // Boot-time NCP initialization
-  void advance_boot_state_();
-  void check_boot_timeouts_();
-  void handle_boot_data_frame_(const uint8_t *data, size_t length);
-  void send_ezsp_version_();
-  void send_get_eui64_();
-  void send_get_token_data_();
-  void handle_version_response_(const uint8_t *data, size_t length);
-  void handle_eui64_response_(const uint8_t *data, size_t length);
-  void handle_token_data_response_(const uint8_t *data, size_t length);
-
-  // IEEE address and network info
-  bool set_ieee_address_(const uint8_t *new_address);
-  void send_network_info_changed_msg_(api::APIConnection *conn = nullptr);
-
-  // WiFi/Zigbee channel conflict detection
-  void check_wifi_zigbee_conflict_();
-
-  // Bootloader detection (fed consecutive raw byte pairs while not CONNECTED)
-  void check_bootloader_mode_(uint8_t prev_byte, uint8_t byte);
-
-  // Reads network metadata out of a proxied getNetworkParameters response. Read-only, so a
-  // misparse costs a missed update rather than corrupting anything.
-  void sniff_network_info_(const uint8_t *frame, size_t length);
-  // Invalidates network metadata when the stack reports it has left the network.
-  void sniff_stack_status_(const uint8_t *frame, size_t length);
-
-  // NCP-side ASH buffers
-  std::array<uint8_t, MAX_ASH_FRAME_SIZE> rx_buffer_;
-  std::array<uint8_t, MAX_ASH_FRAME_SIZE> tx_buffer_;
-  std::array<uint8_t, MAX_ASH_FRAME_SIZE> tx_pending_buffer_;  // For retransmission
-
-  // Network information
-  NetworkInfo network_info_;
-
-  // Timeout configuration
-  TimeoutConfig timeout_config_;
-
-  // The port this component observes. Owns the UART and the bytes; every write we make
-  // goes through it.
-  serial_proxy::SerialProxy *parent_{nullptr};
-
-  uint32_t setup_time_{0};       // Time when last RST frame was sent
-  uint32_t boot_start_time_{0};  // Time when the boot sequence began (for overall timeout)
-  uint32_t ack_timer_start_{0};  // Time when ACK timer started
-  uint32_t last_rtt_ms_{0};      // Last measured round-trip time
-
-  uint16_t rx_buffer_index_{0};    // Index for populating rx_buffer_
-  uint16_t tx_pending_length_{0};  // Length of pending TX frame for retransmission
-  uint16_t calculated_crc_{0};     // CRC calculated during frame reception
-
-  uint8_t tx_sequence_{0};           // TX sequence number (0-7)
-  uint8_t rx_sequence_{0};           // RX sequence number (0-7)
-  uint8_t tx_retry_count_{0};        // Number of retransmission attempts
-  uint8_t tx_pending_frame_num_{0};  // Frame number of pending TX frame
-  uint8_t last_ack_sent_{0};         // Last ACK number sent
-  uint8_t last_rx_byte_{0};          // Previous raw RX byte (bootloader detection)
-
-  AshState ash_state_{AshState::DISCONNECTED};
-  ParsingState parsing_state_{ParsingState::WAIT_FLAG_START};
-  BootloaderState bootloader_state_{BootloaderState::NORMAL};
-  BootState boot_state_{BootState::IDLE};
-
-  uint8_t ezsp_version_{0};            // NCP's EZSP protocol version
-  uint8_t ezsp_sequence_{0};           // EZSP frame sequence number
-  uint8_t ezsp_requested_version_{0};  // Version we last requested (for re-negotiation)
-  // The NCP keeps using legacy framing until `version` is repeated in the
-  // negotiated (extended) format; until then it rejects every extended command
-  // with frame ID 0x0058. Tracks whether that second handshake has happened.
-  bool ezsp_version_confirmed_{false};
-
-  bool tx_buffer_pending_{false};  // True if waiting for ACK from NCP
-  bool escape_next_byte_{false};   // True if next NCP byte should be unescaped
-
-  bool boot_sequence_active_{false};  // True during boot-time init
-  // Set when the metadata was discarded and a fresh harvest is owed once the port frees up
-  bool reharvest_pending_{false};
-  // Last observed device presence, for spotting a hot-plug
-  bool was_connected_{false};
-  // Earliest millis() at which a pending re-harvest may start
-  uint32_t reharvest_after_{0};
-
-  // Decides when acknowledging on the client's behalf is safe. Armed only by the ASH
-  // session handshake, so a bootloader or Thread NCP never triggers it.
-  AshDetector detector_;
-};
-
-extern ZigbeeProxy *global_zigbee_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-}  // namespace esphome::zigbee_proxy
-
-#endif  // USE_ZIGBEE_PROXY

esphome/core/defines.h

@@ -180,7 +180,6 @@
 #define USE_SENSOR
 #define USE_SENSOR_FILTER
 #define USE_SERIAL_PROXY
-#define USE_SERIAL_PROXY_TAP
 #define USE_SETUP_PRIORITY_OVERRIDE
 #define USE_STATUS_LED
 #define USE_STATUS_SENSOR
@@ -198,7 +197,6 @@
 #define USE_VALVE
 #define USE_WATER_HEATER
 #define USE_WATER_HEATER_VISUAL_OVERRIDES
-#define USE_ZIGBEE_PROXY
 #define USE_ZWAVE_PROXY
 
 // Feature flags which do not work for zephyr
@@ -395,10 +393,6 @@
 #define USB_HOST_MAX_REQUESTS 16
 #define USB_HOST_MAX_PACKET_SIZE 64
 #define USB_UART_OUTPUT_CHUNK_COUNT 5
-// USB identity on serial proxy ports needs the usb_host stack
-#ifdef USE_ESP32
-#define USE_SERIAL_PROXY_USB_INFO
-#endif
 
 #ifdef USE_ARDUINO
 #define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 7)

requirements.txt

@@ -27,7 +27,7 @@ bleak==3.0.2
 smpclient==7.2.0
 requests==2.34.2
 py7zr==1.1.3
-platformdirs==4.11.5  # native esp-idf toolchain global cache dir
+platformdirs==4.11.7  # native esp-idf toolchain global cache dir
 ninja==1.13.2  # native esp8266 arduino toolchain build driver
 filelock==3.32.5  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 

requirements_test.txt

@@ -2,7 +2,7 @@ pylint==4.0.8
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
 ruff==0.16.5  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
-prek==0.5.0  # also change in .github/workflows/ci.yml when updating
+prek==0.5.1  # also change in .github/workflows/ci.yml when updating
 
 # Unit tests
 pytest==9.1.1

tests/benchmarks/stubs/esphome/components/serial_proxy/serial_proxy.h

@@ -40,9 +40,6 @@ class SerialProxy {
     return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
   }
   void write_from_client(api::APIConnection *api_connection, const uint8_t *data, size_t len) {}
-  SerialProxyResult set_mode_from_client(api::APIConnection *api_connection, api::enums::SerialProxyMode mode) {
-    return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
-  }
   SerialProxyResult set_modem_pins(api::APIConnection *api_connection, uint32_t line_states) {
     return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
   }

tests/component_tests/esp32_ble_server/config/improv_only.yaml

@@ -0,0 +1,13 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32
+
+wifi:
+  ssid: MySSID
+  password: password1
+
+# esp32_ble_server is only auto-loaded here, so it has no services of its own.
+esp32_improv:
+  authorizer: none

tests/component_tests/esp32_ble_server/config/manufacturer_data_only.yaml

@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32
+
+esp32_ble_server:
+  id: ble_server
+  manufacturer_data: [0x72, 0x04, 0x00, 0x23]

tests/component_tests/esp32_ble_server/config/own_service.yaml

@@ -0,0 +1,14 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32
+
+esp32_ble_server:
+  id: ble_server
+  services:
+    - uuid: 2a24b789-7aab-4535-af3e-ee76a35cc12d
+      characteristics:
+        - uuid: cad48e28-7fbe-41cf-bae9-d77a6c233423
+          read: true
+          value: [1, 2, 3, 4]

tests/component_tests/esp32_ble_server/test_esp32_ble_server.py

@@ -1,5 +1,10 @@
 """Tests for esp32_ble_server configuration helpers."""
 
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
 import pytest
 
 from esphome.components.esp32_ble_server import (
@@ -45,3 +50,26 @@ def test_uuid_is_matches_descriptor_short_strings(uuid16) -> None:
     assert uuid_is(uuid16, uuid16)
     assert uuid_is(f"{uuid16:04X}", uuid16)
     assert uuid_is(f"{uuid16:08X}", uuid16)
+
+
+@pytest.mark.parametrize(
+    ("config_file", "required"),
+    [
+        # Auto-loaded by esp32_improv only: nothing to find until Improv asks for it
+        ("improv_only.yaml", False),
+        # The configuration defines a service clients are meant to connect to
+        ("own_service.yaml", True),
+        # Manufacturer data is only useful if it is actually broadcast
+        ("manufacturer_data_only.yaml", True),
+    ],
+)
+def test_advertising_required(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+    required: bool,
+) -> None:
+    """The server only requests advertising when the configuration needs it."""
+    main_cpp = generate_main(component_config_path(config_file))
+
+    assert f"set_advertising_required({str(required).lower()})" in main_cpp

tests/components/serial_proxy/test-tap.esp32-idf.yaml

@@ -1,14 +0,0 @@
-substitutions:
-  tx_pin: GPIO4
-  rx_pin: GPIO5
-
-# Compile the tap code paths; no tap is attached, so this exercises the
-# null-tap branches that a normal build never defines.
-esphome:
-  platformio_options:
-    build_flags:
-      - "-DUSE_SERIAL_PROXY_TAP"
-
-packages:
-  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
-  serial_proxy: !include common.yaml

tests/components/serial_proxy/test-usb.esp32-s3-idf.yaml

@@ -1,21 +0,0 @@
-wifi:
-  ssid: MySSID
-  password: password1
-
-api:
-
-usb_host:
-
-# port_type is omitted deliberately: a port on a USB UART channel derives USB_SERIAL
-usb_uart:
-  - type: CDC_ACM
-    vid: 0x303A
-    pid: 0x831A
-    channels:
-      - id: usb_serial_channel
-        baud_rate: 460800
-
-serial_proxy:
-  - id: serial_proxy_usb
-    uart_id: usb_serial_channel
-    name: USB Serial Port

tests/components/socket/test-ipv6.rp2040-ard.yaml

@@ -0,0 +1,4 @@
+substitutions:
+  network_enable_ipv6: "true"
+
+<<: !include common.yaml

tests/components/zigbee_proxy/.gitignore

@@ -1,5 +0,0 @@
-# Gitignore settings for ESPHome
-# This is an example and may include too much for your use-case.
-# You can modify this file to suit your needs.
-/.esphome/
-/secrets.yaml

tests/components/zigbee_proxy/common.yaml

@@ -1,22 +0,0 @@
-esphome:
-  name: test
-
-wifi:
-  ssid: test
-  password: password
-  power_save_mode: none
-
-api:
-
-uart:
-  - id: zigbee_uart
-    tx_pin: ${tx_pin}
-    rx_pin: ${rx_pin}
-    baud_rate: 115200
-
-# The port owns the UART and carries every byte; zigbee_proxy only taps it
-serial_proxy:
-  - id: zigbee_serial
-    uart_id: zigbee_uart
-    name: Zigbee
-    port_type: TTL

tests/components/zigbee_proxy/test-usb.esp32-s3-idf.yaml

@@ -1,26 +0,0 @@
-wifi:
-  ssid: test
-  password: password
-  power_save_mode: none
-
-api:
-
-usb_host:
-
-usb_uart:
-  - type: CDC_ACM
-    vid: 0x303A
-    pid: 0x831A
-    channels:
-      - id: zigbee_usb_channel
-        baud_rate: 460800
-
-# The tapped port may be a USB CDC ACM channel just as well as a hardware UART:
-# zigbee_proxy never touches the UART itself, so it does not care which it is.
-serial_proxy:
-  - id: zigbee_usb_serial
-    uart_id: zigbee_usb_channel
-    name: Zigbee
-
-zigbee_proxy:
-  serial_proxy_id: zigbee_usb_serial

tests/components/zigbee_proxy/test.esp32-idf.yaml

@@ -1,15 +0,0 @@
-substitutions:
-  tx_pin: GPIO17
-  rx_pin: GPIO16
-
-esp32:
-  board: esp32dev
-
-<<: !include common.yaml
-
-zigbee_proxy:
-  serial_proxy_id: zigbee_serial
-  buffer_size: 1024
-  initial_timeout: 1600
-  min_timeout: 400
-  max_timeout: 3200

tests/components/zigbee_proxy/test.esp8266-ard.yaml

@@ -1,12 +0,0 @@
-substitutions:
-  tx_pin: GPIO1
-  rx_pin: GPIO3
-
-esp8266:
-  board: nodemcuv2
-
-<<: !include common.yaml
-
-zigbee_proxy:
-  serial_proxy_id: zigbee_serial
-  buffer_size: 512

tests/components/zigbee_proxy/test.rp2040-ard.yaml

@@ -1,8 +0,0 @@
-substitutions:
-  tx_pin: GPIO0
-  rx_pin: GPIO1
-
-<<: !include common.yaml
-
-zigbee_proxy:
-  serial_proxy_id: zigbee_serial