Simulate the unreadable partitions.csv instead of chmod

esphome/build_gen/espidf.py

@@ -90,9 +90,10 @@ def get_project_cmakelists(
     """
     idf_target = variant_to_idf_target(get_esp32_variant())
 
-    # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
-    # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
-    # --format=raw because the legacy mode doesn't support it.
+    # esp_idf_size 2.x (IDF >=6.0) made NG the default and removed --ng;
+    # 1.x (IDF 5.5) needs --ng for --format=json2. 1.x json2 also lacks
+    # total_size, hence the ELF fallback in espidf/size_summary.py; both
+    # go away together when 1.x support is dropped.
     size_ng_flag = "--ng" if idf_version() < cv.Version(6, 0, 0) else ""
 
     # Project-wide compile options: -D defines and -W warning flags (skip
@@ -211,10 +212,12 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)
 
 project({CORE.name})
 
-# Emit raw JSON size data for ESPHome to read post-build.
+# Emit per-memory-type JSON size data for ESPHome to read post-build.
+# json2 stays small; raw dumps every symbol (~2s on a large map) and
+# this command runs inside the link edge, blocking everything downstream.
 add_custom_command(
     TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
-    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=raw
+    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
             -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
             ${{CMAKE_PROJECT_NAME}}.map
     WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}

esphome/components/socket/__init__.py

@@ -187,9 +187,7 @@ async def to_code(config: ConfigType) -> None:
 # for the selected implementation.
 FILTER_SOURCE_FILES = filter_source_files_from_defines(
     {
-        "lwip_raw_common_impl.cpp": "USE_SOCKET_IMPL_LWIP_TCP",
         "lwip_raw_tcp_impl.cpp": "USE_SOCKET_IMPL_LWIP_TCP",
-        "lwip_raw_udp_impl.cpp": "USE_SOCKET_IMPL_LWIP_TCP",
         "bsd_sockets_impl.cpp": "USE_SOCKET_IMPL_BSD_SOCKETS",
         "lwip_sockets_impl.cpp": "USE_SOCKET_IMPL_LWIP_SOCKETS",
     }

esphome/components/socket/bsd_sockets_impl.h

@@ -144,9 +144,6 @@ class BSDSocketImpl {
 
   int get_fd() const { return this->fd_; }
 
-  /// UDP rx drop counter parity with LWIPRawUDPImpl; drops are not counted here.
-  uint16_t get_rx_dropped() const { return 0; }
-
  protected:
   // fd_ < 0 means "not open" — used both pre-open (initial state) and post-close. This
   // replaces a separate closed_ flag: close() sets fd_ = -1 after ::close(), and the

esphome/components/socket/headers.h

@@ -20,16 +20,6 @@
 
 #define IPPROTO_IP 0
 #define IPPROTO_TCP 6
-#define IPPROTO_UDP 17
-
-#define IP_ADD_MEMBERSHIP 3
-#define IP_DROP_MEMBERSHIP 4
-
-// NOLINTNEXTLINE(readability-identifier-naming)
-struct ip_mreq {
-  struct in_addr imr_multiaddr;
-  struct in_addr imr_interface;
-};
 
 #if LWIP_IPV6
 #define AF_INET6 10

esphome/components/socket/lwip_raw_common_impl.cpp

@@ -1,109 +0,0 @@
-#include "lwip_raw_common_impl.h"
-#include "esphome/core/defines.h"
-
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-
-#include <cerrno>
-#include <cstring>
-
-namespace esphome::socket {
-
-int lwip_ip_to_sockaddr(sa_family_t family, const ip_addr_t *ip, uint16_t port_host, struct sockaddr *name,
-                        socklen_t *addrlen) {
-  if (family == AF_INET) {
-    if (*addrlen < sizeof(struct sockaddr_in)) {
-      errno = EINVAL;
-      return -1;
-    }
-    auto *addr = reinterpret_cast<struct sockaddr_in *>(name);
-    addr->sin_family = AF_INET;
-    *addrlen = addr->sin_len = sizeof(struct sockaddr_in);
-    addr->sin_port = htons(port_host);
-    inet_addr_from_ip4addr(&addr->sin_addr, ip_2_ip4(ip));
-    return 0;
-  }
-#if LWIP_IPV6
-  if (family == AF_INET6) {
-    if (*addrlen < sizeof(struct sockaddr_in6)) {
-      errno = EINVAL;
-      return -1;
-    }
-    auto *addr = reinterpret_cast<struct sockaddr_in6 *>(name);
-    addr->sin6_family = AF_INET6;
-    *addrlen = addr->sin6_len = sizeof(struct sockaddr_in6);
-    addr->sin6_port = htons(port_host);
-    // AF_INET6 sockets may receive IPv4 packets; convert to IPv4-mapped IPv6.
-    if (IP_IS_V4(ip)) {
-      ip_addr_t mapped;
-      ip4_2_ipv4_mapped_ipv6(ip_2_ip6(&mapped), ip_2_ip4(ip));
-      inet6_addr_from_ip6addr(&addr->sin6_addr, ip_2_ip6(&mapped));
-    } else {
-      inet6_addr_from_ip6addr(&addr->sin6_addr, ip_2_ip6(ip));
-    }
-    return 0;
-  }
-#endif
-  errno = EAFNOSUPPORT;
-  return -1;
-}
-
-bool sockaddr_to_lwip(const struct sockaddr *addr, socklen_t addrlen, ip_addr_t *ip, uint16_t *port) {
-  // headers.h defines sockaddr and sockaddr_in with the same size, so this covers AF_INET
-  if (addrlen < sizeof(struct sockaddr))
-    return false;
-  // Zero the whole struct — the IPv6 zone byte would otherwise be stack garbage
-  memset(ip, 0, sizeof(*ip));
-  if (addr->sa_family == AF_INET) {
-    auto *addr4 = reinterpret_cast<const sockaddr_in *>(addr);
-    *port = ntohs(addr4->sin_port);
-    IP_SET_TYPE_VAL(*ip, IPADDR_TYPE_V4);
-    ip_2_ip4(ip)->addr = addr4->sin_addr.s_addr;
-    return true;
-  }
-#if LWIP_IPV6
-  if (addr->sa_family == AF_INET6) {
-    if (addrlen < sizeof(sockaddr_in6))
-      return false;
-    auto *addr6 = reinterpret_cast<const sockaddr_in6 *>(addr);
-    *port = ntohs(addr6->sin6_port);
-    IP_SET_TYPE_VAL(*ip, IPADDR_TYPE_V6);
-    memcpy(&ip_2_ip6(ip)->addr, &addr6->sin6_addr.un.u8_addr, 16);
-    // Unmap ::ffff:a.b.c.d so replies to recvfrom addresses route as IPv4
-    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);
-    }
-    return true;
-  }
-#endif
-  return false;
-}
-
-bool sockaddr_to_lwip_bind(sa_family_t family, const struct sockaddr *addr, socklen_t addrlen, ip_addr_t *ip,
-                           uint16_t *port) {
-  if (!sockaddr_to_lwip(addr, addrlen, ip, port))
-    return false;
-#if LWIP_IPV6
-  // Only promote wildcard binds — a specific address must keep filtering
-  if (family == AF_INET6 && ip_addr_isany_val(*ip))
-    IP_SET_TYPE_VAL(*ip, IPADDR_TYPE_ANY);
-#endif
-  return true;
-}
-
-int lwip_bind_err(err_t err) {
-  if (err == ERR_OK)
-    return 0;
-  if (err == ERR_USE) {
-    errno = EADDRINUSE;
-  } else if (err == ERR_VAL) {
-    errno = EINVAL;
-  } else {
-    errno = EIO;
-  }
-  return -1;
-}
-
-}  // namespace esphome::socket
-
-#endif  // USE_SOCKET_IMPL_LWIP_TCP

esphome/components/socket/lwip_raw_common_impl.h

@@ -1,53 +0,0 @@
-#pragma once
-#include "esphome/core/defines.h"
-
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-
-#include "headers.h"
-#include "lwip/ip.h"
-
-namespace esphome::socket {
-
-// ---- LWIP thread safety ----
-//
-// On RP2040 (Pico W), arduino-pico sets PICO_CYW43_ARCH_THREADSAFE_BACKGROUND=1.
-// This means lwip callbacks (recv_fn, accept_fn, err_fn) run from a low-priority
-// user IRQ context, not the main loop (see low_priority_irq_handler() in pico-sdk
-// async_context_threadsafe_background.c). They can preempt main-loop code at any point.
-//
-// Without locking, this causes race conditions between recv_fn and read() on the
-// shared rx_buf_ pbuf chain — recv_fn calls pbuf_cat() while read() is freeing
-// nodes, leading to use-after-free and infinite-loop crashes. See esphome#10681.
-//
-// On ESP8266, lwip callbacks run from the SYS context which cooperates with user
-// code (CONT context) — they never preempt each other, so no locking is needed.
-//
-// esphome::LwIPLock is the platform-provided RAII guard (see helpers.h/helpers.cpp).
-// On RP2040, it acquires cyw43_arch_lwip_begin/end (WiFi) or ethernet_arch_lwip_begin/end
-// (Ethernet). On ESP8266, it's a no-op.
-//
-// Each .cpp file that needs locking defines its own LWIP_LOCK() macro:
-//   #define LWIP_LOCK() esphome::LwIPLock lwip_lock_guard
-// This is a per-TU convenience macro, not defined here to avoid macro leaking.
-
-/// Convert lwip ip_addr_t + host-order port to sockaddr, based on the socket's address family.
-/// TCP callers pass ntohs(pcb port) to preserve historical getpeername/getsockname output.
-int lwip_ip_to_sockaddr(sa_family_t family, const ip_addr_t *ip, uint16_t port_host, struct sockaddr *name,
-                        socklen_t *addrlen);
-
-/// Convert sockaddr to lwip ip_addr_t and host-order port.
-/// For IPv6, sets type to IPADDR_TYPE_V6 — correct for sendto destinations.
-/// Bind paths must use sockaddr_to_lwip_bind() instead.
-bool sockaddr_to_lwip(const struct sockaddr *addr, socklen_t addrlen, ip_addr_t *ip, uint16_t *port);
-
-/// sockaddr_to_lwip variant for bind: promotes AF_INET6 sockets to
-/// IPADDR_TYPE_ANY so they accept both IPv4 and IPv6 (dual-stack).
-bool sockaddr_to_lwip_bind(sa_family_t family, const struct sockaddr *addr, socklen_t addrlen, ip_addr_t *ip,
-                           uint16_t *port);
-
-/// Map lwip bind error to errno. Returns 0 on success, -1 on error with errno set.
-int lwip_bind_err(err_t err);
-
-}  // namespace esphome::socket
-
-#endif  // USE_SOCKET_IMPL_LWIP_TCP

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -10,7 +10,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/wake.h"
 #include "esphome/core/log.h"
-#include "lwip_raw_common_impl.h"
 
 #ifdef USE_OTA_PLATFORM_ESPHOME
 extern "C" void esphome_wake_ota_component_any_context();
@@ -25,9 +24,23 @@ extern "C" void esphome_wake_ota_component_any_context();
 
 namespace esphome::socket {
 
-// LWIP thread safety — see lwip_raw_common_impl.h for full explanation.
-// esphome::LwIPLock is the platform-provided RAII guard.
-// On RP2040, it acquires cyw43_arch_lwip_begin/end. On ESP8266, it's a no-op.
+// ---- LWIP thread safety ----
+//
+// On RP2040 (Pico W), arduino-pico sets PICO_CYW43_ARCH_THREADSAFE_BACKGROUND=1.
+// This means lwip callbacks (recv_fn, accept_fn, err_fn) run from a low-priority
+// user IRQ context, not the main loop (see low_priority_irq_handler() in pico-sdk
+// async_context_threadsafe_background.c). They can preempt main-loop code at any point.
+//
+// Without locking, this causes race conditions between recv_fn and read() on the
+// shared rx_buf_ pbuf chain — recv_fn calls pbuf_cat() while read() is freeing
+// nodes, leading to use-after-free and infinite-loop crashes. See esphome#10681.
+//
+// On ESP8266, lwip callbacks run from the SYS context which cooperates with user
+// code (CONT context) — they never preempt each other, so no locking is needed.
+//
+// esphome::LwIPLock is the platform-provided RAII guard (see helpers.h/helpers.cpp).
+// On RP2040, it acquires cyw43_arch_lwip_begin/end (WiFi) or ethernet_arch_lwip_begin/end
+// (Ethernet). On ESP8266, it's a no-op.
 #define LWIP_LOCK() esphome::LwIPLock lwip_lock_guard  // NOLINT
 
 static const char *const TAG = "socket";
@@ -99,14 +112,59 @@ int LWIPRawCommon::bind(const struct sockaddr *name, socklen_t addrlen) {
     return -1;
   }
   ip_addr_t ip;
-  uint16_t port;
-  if (!sockaddr_to_lwip_bind(this->family_, name, addrlen, &ip, &port)) {
+  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;
     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
   err_t err = tcp_bind(this->pcb_, &ip, port);
-  LWIP_LOG("  -> err %d", err);
-  return lwip_bind_err(err);
+  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;
+    return -1;
+  }
+  return 0;
 }
 
 int LWIPRawCommon::close() {
@@ -291,8 +349,43 @@ int LWIPRawCommon::setsockopt(int level, int optname, const void *optval, sockle
 }
 
 int LWIPRawCommon::ip2sockaddr_(ip_addr_t *ip, uint16_t port, struct sockaddr *name, socklen_t *addrlen) {
-  // lwip pcb ports are host order; ntohs preserves historical byte-swapped sin_port output
-  return lwip_ip_to_sockaddr(this->family_, ip, ntohs(port), name, addrlen);
+  if (this->family_ == AF_INET) {
+    if (*addrlen < sizeof(struct sockaddr_in)) {
+      errno = EINVAL;
+      return -1;
+    }
+
+    struct sockaddr_in *addr = reinterpret_cast<struct sockaddr_in *>(name);
+    addr->sin_family = AF_INET;
+    *addrlen = addr->sin_len = sizeof(struct sockaddr_in);
+    addr->sin_port = port;
+    inet_addr_from_ip4addr(&addr->sin_addr, ip_2_ip4(ip));
+    return 0;
+  }
+#if LWIP_IPV6
+  else if (this->family_ == AF_INET6) {
+    if (*addrlen < sizeof(struct sockaddr_in6)) {
+      errno = EINVAL;
+      return -1;
+    }
+
+    struct sockaddr_in6 *addr = reinterpret_cast<struct sockaddr_in6 *>(name);
+    addr->sin6_family = AF_INET6;
+    *addrlen = addr->sin6_len = sizeof(struct sockaddr_in6);
+    addr->sin6_port = port;
+
+    // AF_INET6 sockets are bound to IPv4 as well, so we may encounter IPv4 addresses that must be converted to IPv6.
+    if (IP_IS_V4(ip)) {
+      ip_addr_t mapped;
+      ip4_2_ipv4_mapped_ipv6(ip_2_ip6(&mapped), ip_2_ip4(ip));
+      inet6_addr_from_ip6addr(&addr->sin6_addr, ip_2_ip6(&mapped));
+    } else {
+      inet6_addr_from_ip6addr(&addr->sin6_addr, ip_2_ip6(ip));
+    }
+    return 0;
+  }
+#endif
+  return -1;
 }
 
 // ---- LWIPRawImpl methods ----
@@ -794,11 +887,11 @@ err_t LWIPRawListenImpl::accept_fn_(struct tcp_pcb *newpcb, err_t err) {
   return ERR_OK;
 }
 
-// ---- TCP Factory functions ----
+// ---- Factory functions ----
 
 std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
   if (type != SOCK_STREAM) {
-    ESP_LOGE(TAG, "Use socket_udp() for UDP sockets on this platform");
+    ESP_LOGE(TAG, "UDP sockets not supported on this platform, use WiFiUDP");
     errno = EPROTOTYPE;
     return nullptr;
   }
@@ -818,7 +911,7 @@ std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol
 
 std::unique_ptr<ListenSocket> socket_listen(int domain, int type, int protocol) {
   if (type != SOCK_STREAM) {
-    ESP_LOGE(TAG, "Use socket_udp() for UDP sockets on this platform");
+    ESP_LOGE(TAG, "UDP sockets not supported on this platform, use WiFiUDP");
     errno = EPROTOTYPE;
     return nullptr;
   }

esphome/components/socket/lwip_raw_udp_impl.cpp

@@ -1,328 +0,0 @@
-#include "socket.h"
-#include "esphome/core/defines.h"
-
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-
-#include <cerrno>
-#include <cstring>
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-#include "esphome/core/wake.h"
-#include "lwip_raw_common_impl.h"
-
-#include "lwip/igmp.h"
-#include "lwip/pbuf.h"
-#include "lwip/udp.h"
-
-namespace esphome::socket {
-
-// LWIP thread safety — see lwip_raw_common_impl.h for full explanation.
-// esphome::LwIPLock is the platform-provided RAII guard.
-// On RP2040, it acquires cyw43_arch_lwip_begin/end. On ESP8266, it's a no-op.
-#define LWIP_LOCK() esphome::LwIPLock lwip_lock_guard  // NOLINT
-
-// ---- LWIPRawUDPSendImpl (send-only) methods ----
-
-LWIPRawUDPSendImpl::~LWIPRawUDPSendImpl() {
-  // Guard avoids acquiring the lwip lock when already closed
-  if (this->pcb_ != nullptr)
-    this->close();
-}
-
-int LWIPRawUDPSendImpl::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;
-  uint16_t port;
-  if (!sockaddr_to_lwip_bind(this->family_, name, addrlen, &ip, &port)) {
-    errno = EINVAL;
-    return -1;
-  }
-  return lwip_bind_err(udp_bind(this->pcb_, &ip, port));
-}
-
-int LWIPRawUDPSendImpl::close() {
-  LWIP_LOCK();
-  return this->close_internal_locked_();
-}
-
-int LWIPRawUDPSendImpl::close_internal_locked_() {
-  // Caller must hold LWIP_LOCK
-  if (this->pcb_ == nullptr) {
-    errno = EBADF;
-    return -1;
-  }
-  udp_remove(this->pcb_);
-  this->pcb_ = nullptr;
-  return 0;
-}
-
-int LWIPRawUDPSendImpl::ip2sockaddr_(const ip_addr_t *ip, uint16_t port, struct sockaddr *name, socklen_t *addrlen) {
-  // UDP recv callback provides port in host byte order
-  return lwip_ip_to_sockaddr(this->family_, ip, port, name, addrlen);
-}
-
-ssize_t LWIPRawUDPSendImpl::sendto(const void *buf, size_t len, int flags, const struct sockaddr *dest_addr,
-                                   socklen_t addrlen) {
-  (void) flags;  // Flags (MSG_DONTWAIT, etc.) are ignored; raw lwip is always non-blocking
-  if (buf == nullptr || dest_addr == nullptr) {
-    errno = EINVAL;
-    return -1;
-  }
-
-  // pbuf_alloc takes u16_t length; reject oversized packets
-  if (len > UINT16_MAX) {
-    errno = EMSGSIZE;
-    return -1;
-  }
-
-  ip_addr_t dst_ip;
-  uint16_t dst_port;
-  if (!sockaddr_to_lwip(dest_addr, addrlen, &dst_ip, &dst_port)) {
-    errno = EINVAL;
-    return -1;
-  }
-
-  LWIP_LOCK();
-  if (this->pcb_ == nullptr) {
-    errno = EBADF;
-    return -1;
-  }
-
-  // Allocate pbuf and copy data
-  struct pbuf *pb = pbuf_alloc(PBUF_TRANSPORT, (uint16_t) len, PBUF_RAM);
-  if (pb == nullptr) {
-    errno = ENOMEM;
-    return -1;
-  }
-  memcpy(pb->payload, buf, len);
-
-  err_t err = udp_sendto(this->pcb_, pb, &dst_ip, dst_port);
-  pbuf_free(pb);
-
-  if (err != ERR_OK) {
-    errno = err == ERR_MEM ? ENOMEM : EIO;
-    return -1;
-  }
-  return (ssize_t) len;
-}
-
-int LWIPRawUDPSendImpl::setsockopt(int level, int optname, const void *optval, socklen_t optlen) {
-  LWIP_LOCK();
-  if (this->pcb_ == nullptr) {
-    errno = EBADF;
-    return -1;
-  }
-  if (level == SOL_SOCKET && optname == SO_REUSEADDR) {
-    if (optval == nullptr || optlen < sizeof(int)) {
-      errno = EINVAL;
-      return -1;
-    }
-    // Effective only where lwip is built with SO_REUSE=1 (ESP8266 yes, RP2040 currently no)
-    if (*reinterpret_cast<const int *>(optval)) {
-      ip_set_option(this->pcb_, SOF_REUSEADDR);
-    } else {
-      ip_reset_option(this->pcb_, SOF_REUSEADDR);
-    }
-    return 0;
-  }
-  if (level == SOL_SOCKET && optname == SO_BROADCAST) {
-    if (optval == nullptr || optlen < sizeof(int)) {
-      errno = EINVAL;
-      return -1;
-    }
-    int val = *reinterpret_cast<const int *>(optval);
-    if (val) {
-      ip_set_option(this->pcb_, SOF_BROADCAST);
-    } else {
-      ip_reset_option(this->pcb_, SOF_BROADCAST);
-    }
-    return 0;
-  }
-  if (level == IPPROTO_IP && (optname == IP_ADD_MEMBERSHIP || optname == IP_DROP_MEMBERSHIP)) {
-    if (optval == nullptr || optlen < sizeof(struct ip_mreq)) {
-      errno = EINVAL;
-      return -1;
-    }
-    auto *mreq = reinterpret_cast<const struct ip_mreq *>(optval);
-    ip4_addr_t multiaddr{mreq->imr_multiaddr.s_addr};
-    ip4_addr_t ifaddr{mreq->imr_interface.s_addr};
-    err_t err =
-        optname == IP_ADD_MEMBERSHIP ? igmp_joingroup(&ifaddr, &multiaddr) : igmp_leavegroup(&ifaddr, &multiaddr);
-    if (err != ERR_OK) {
-      errno = EIO;
-      return -1;
-    }
-    return 0;
-  }
-  errno = ENOPROTOOPT;
-  return -1;
-}
-
-int LWIPRawUDPSendImpl::getsockopt(int level, int optname, void *optval, socklen_t *optlen) {
-  LWIP_LOCK();
-  if (this->pcb_ == nullptr) {
-    errno = EBADF;
-    return -1;
-  }
-  if (level == SOL_SOCKET && optname == SO_REUSEADDR) {
-    if (optval == nullptr || optlen == nullptr || *optlen < sizeof(int)) {
-      errno = EINVAL;
-      return -1;
-    }
-    *reinterpret_cast<int *>(optval) = ip_get_option(this->pcb_, SOF_REUSEADDR) ? 1 : 0;
-    *optlen = sizeof(int);
-    return 0;
-  }
-  errno = ENOPROTOOPT;
-  return -1;
-}
-
-int LWIPRawUDPSendImpl::setblocking(bool blocking) {
-  if (blocking) {
-    // blocking operation not supported on raw lwip
-    errno = EINVAL;
-    return -1;
-  }
-  return 0;
-}
-
-// ---- LWIPRawUDPImpl methods ----
-
-LWIPRawUDPImpl::LWIPRawUDPImpl(sa_family_t family, struct udp_pcb *pcb) : LWIPRawUDPSendImpl(family, pcb) {
-  // Registered here (not in bind) so unbound client sockets can receive replies
-  udp_recv(this->pcb_, LWIPRawUDPImpl::s_recv_fn, this);
-}
-
-LWIPRawUDPImpl::~LWIPRawUDPImpl() {
-  // Flush rx queue and unregister callback before base destructor removes pcb
-  if (this->pcb_ != nullptr)
-    this->close();
-}
-
-int LWIPRawUDPImpl::close() {
-  LWIP_LOCK();
-  // Unregister recv callback before removing pcb
-  if (this->pcb_ != nullptr) {
-    udp_recv(this->pcb_, nullptr, nullptr);
-  }
-  // Flush queued rx packets; slots within rx_count_ always hold a live pbuf
-  for (; this->rx_count_ > 0; this->rx_count_--) {
-    pbuf_free(this->rx_queue_[this->rx_read_idx_].pb);
-    this->rx_read_idx_ = (this->rx_read_idx_ + 1) & UDP_RX_MASK;
-  }
-  // close_internal_locked_() returns EBADF if already closed, which is fine from destructor
-  return this->close_internal_locked_();
-}
-
-ssize_t LWIPRawUDPImpl::read(void *buf, size_t len) { return this->recvfrom(buf, len, nullptr, nullptr); }
-
-ssize_t LWIPRawUDPImpl::recvfrom(void *buf, size_t len, struct sockaddr *src_addr, socklen_t *addrlen) {
-  if (buf == nullptr && len > 0) {
-    errno = EINVAL;
-    return -1;
-  }
-  LWIP_LOCK();
-  if (this->pcb_ == nullptr) {
-    errno = EBADF;
-    return -1;
-  }
-  if (this->rx_count_ == 0) {
-    errno = EWOULDBLOCK;
-    return -1;
-  }
-
-  auto &pkt = this->rx_queue_[this->rx_read_idx_];
-  // On address conversion failure, still consume the packet — the failure is
-  // deterministic (family_ and *addrlen), so keeping it would wedge the queue
-  ssize_t ret = -1;
-  if (src_addr == nullptr || addrlen == nullptr ||
-      this->ip2sockaddr_(&pkt.src_addr, pkt.src_port, src_addr, addrlen) == 0) {
-    ret = (ssize_t) std::min(len, (size_t) pkt.pb->tot_len);
-    pbuf_copy_partial(pkt.pb, buf, ret, 0);
-  }
-  pbuf_free(pkt.pb);
-  this->rx_read_idx_ = (this->rx_read_idx_ + 1) & UDP_RX_MASK;
-  this->rx_count_--;
-  return ret;
-}
-
-void LWIPRawUDPImpl::s_recv_fn(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) {
-  auto *self = reinterpret_cast<LWIPRawUDPImpl *>(arg);
-  self->recv_fn_(p, addr, port);
-}
-
-// LWIP CALLBACK — runs from IRQ context on RP2040 (low-priority user IRQ).
-// No heap allocation allowed — malloc is not IRQ-safe (see #14687).
-// No LWIP_LOCK() needed — lwip core already holds the async_context lock.
-void LWIPRawUDPImpl::recv_fn_(struct pbuf *p, const ip_addr_t *addr, u16_t port) {
-  if (p == nullptr)
-    return;
-
-  // Check if queue is full
-  if (this->rx_count_ >= UDP_RX_QUEUE_SIZE) {
-    // Drop packet — queue full. Can't log from IRQ context, so count it
-    // (saturating) for consumers to surface via get_rx_dropped().
-    if (this->rx_dropped_ != UINT16_MAX)
-      this->rx_dropped_++;
-    pbuf_free(p);
-    return;
-  }
-
-  // Enqueue the packet
-  uint8_t write_idx = (this->rx_read_idx_ + this->rx_count_) & UDP_RX_MASK;
-  auto &slot = this->rx_queue_[write_idx];
-  slot.pb = p;
-  slot.src_addr = *addr;
-  slot.src_port = port;
-  this->rx_count_++;
-
-  esphome::wake_loop_any_context();
-}
-
-// ---- UDP Factory functions ----
-
-static struct udp_pcb *new_udp_pcb(int domain) {
-#if LWIP_IPV6
-  return udp_new_ip_type(domain == AF_INET6 ? IPADDR_TYPE_ANY : IPADDR_TYPE_V4);
-#else
-  return udp_new();
-#endif
-}
-
-std::unique_ptr<UDPSendSocket> socket_udp_send(int domain, int protocol) {
-  (void) protocol;  // Raw lwip UDP ignores protocol; kept for API compatibility
-  LWIP_LOCK();
-  auto *pcb = new_udp_pcb(domain);
-  if (pcb == nullptr) {
-    errno = ENOMEM;
-    return nullptr;
-  }
-  return make_unique<LWIPRawUDPSendImpl>((sa_family_t) domain, pcb);
-}
-
-std::unique_ptr<UDPSocket> socket_udp(int domain, int protocol) {
-  (void) protocol;  // Raw lwip UDP ignores protocol; kept for API compatibility
-  LWIP_LOCK();
-  auto *pcb = new_udp_pcb(domain);
-  if (pcb == nullptr) {
-    errno = ENOMEM;
-    return nullptr;
-  }
-  // Ctor registers the recv callback under the lock held here
-  return make_unique<LWIPRawUDPImpl>((sa_family_t) domain, pcb);
-}
-
-#undef LWIP_LOCK
-
-}  // namespace esphome::socket
-
-#endif  // USE_SOCKET_IMPL_LWIP_TCP

esphome/components/socket/lwip_raw_udp_impl.h

@@ -1,113 +0,0 @@
-#pragma once
-#include "esphome/core/defines.h"
-
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-
-#include <array>
-#include <cstdint>
-
-#include "headers.h"
-#include "lwip/ip.h"
-#include "lwip/udp.h"
-
-namespace esphome::socket {
-
-/// Send-only UDP socket implementation for LWIP raw API.
-/// Non-virtual, concrete type. Uses lwip/udp.h raw API.
-/// No receive capability — use LWIPRawUDPImpl for sockets that need to receive.
-class LWIPRawUDPSendImpl {
- public:
-  /// The pcb is allocated by the factory (like the TCP impl); never null here.
-  LWIPRawUDPSendImpl(sa_family_t family, struct udp_pcb *pcb) : pcb_(pcb), family_(family) {}
-  ~LWIPRawUDPSendImpl();
-  LWIPRawUDPSendImpl(const LWIPRawUDPSendImpl &) = delete;
-  LWIPRawUDPSendImpl &operator=(const LWIPRawUDPSendImpl &) = delete;
-
-  int bind(const struct sockaddr *name, socklen_t addrlen);
-  int close();
-
-  /// Send a UDP packet to the specified destination.
-  ssize_t sendto(const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
-
-  int setsockopt(int level, int optname, const void *optval, socklen_t optlen);
-  int getsockopt(int level, int optname, void *optval, socklen_t *optlen);
-
-  int setblocking(bool blocking);
-
-  bool ready() const { return false; }
-  int get_fd() const { return -1; }
-
- protected:
-  /// Convert lwip ip_addr_t and port to sockaddr.
-  int ip2sockaddr_(const ip_addr_t *ip, uint16_t port, struct sockaddr *name, socklen_t *addrlen);
-
-  /// Shared close logic — removes the udp pcb. Caller must hold LWIP_LOCK.
-  int close_internal_locked_();
-
-  struct udp_pcb *pcb_;
-  sa_family_t family_;
-};
-
-/// UDP socket with receive support for LWIP raw API.
-/// Extends LWIPRawUDPSendImpl with a fixed-size ring buffer for incoming packets.
-/// Inheritance is private (base dtor is non-virtual; converting to a base
-/// pointer would leak queued pbufs on destruction).
-class LWIPRawUDPImpl : private LWIPRawUDPSendImpl {
- public:
-  /// Caller (the factory) must hold the lwip lock; registers the recv callback.
-  LWIPRawUDPImpl(sa_family_t family, struct udp_pcb *pcb);
-  ~LWIPRawUDPImpl();
-
-  using LWIPRawUDPSendImpl::bind;
-  using LWIPRawUDPSendImpl::get_fd;
-  using LWIPRawUDPSendImpl::getsockopt;
-  using LWIPRawUDPSendImpl::sendto;
-  using LWIPRawUDPSendImpl::setblocking;
-  using LWIPRawUDPSendImpl::setsockopt;
-
-  /// Close the socket, flushing any queued rx packets first.
-  int close();
-
-  /// Read the next queued packet, discarding source address info.
-  /// If buf is smaller than the packet, data is silently truncated (returns bytes copied).
-  /// Note: unlike POSIX MSG_TRUNC, this does not return the original packet length on truncation.
-  ssize_t read(void *buf, size_t len);
-  /// Read the next queued packet and return the source address.
-  /// If buf is smaller than the packet, data is silently truncated (returns bytes copied).
-  /// Note: unlike POSIX MSG_TRUNC, this does not return the original packet length on truncation.
-  ssize_t recvfrom(void *buf, size_t len, struct sockaddr *src_addr, socklen_t *addrlen);
-
-  /// Returns true if there are packets available to read.
-  /// Intentionally unlocked — same rationale as LWIPRawImpl::ready().
-  bool ready() const { return this->rx_count_ > 0; }
-
-  /// Number of packets dropped because the rx queue was full (saturating).
-  uint16_t get_rx_dropped() const { return this->rx_dropped_; }
-
- protected:
-  static void s_recv_fn(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port);
-  void recv_fn_(struct pbuf *p, const ip_addr_t *addr, u16_t port);
-
-  /// Ring buffer for received UDP packets.
-  /// Both producer (recv callback) and consumer (main loop) are serialized by the
-  /// lwip lock — the callback runs under lwip core lock, and consumer methods hold
-  /// LWIP_LOCK(). All 4 slots are usable (no wasted slot for full/empty distinction).
-  /// No heap allocation in the recv callback — packets are dropped if the queue is full.
-  static constexpr uint8_t UDP_RX_QUEUE_SIZE = 4;
-  static constexpr uint8_t UDP_RX_MASK = UDP_RX_QUEUE_SIZE - 1;
-  static_assert((UDP_RX_QUEUE_SIZE & UDP_RX_MASK) == 0, "UDP_RX_QUEUE_SIZE must be power of 2");
-  // Fields are written by recv_fn_ before rx_count_ makes a slot visible
-  struct UDPRxPacket {
-    ip_addr_t src_addr;
-    struct pbuf *pb;
-    uint16_t src_port;
-  };
-  std::array<UDPRxPacket, UDP_RX_QUEUE_SIZE> rx_queue_{};
-  uint16_t rx_dropped_{0};
-  uint8_t rx_read_idx_{0};
-  uint8_t rx_count_{0};
-};
-
-}  // namespace esphome::socket
-
-#endif  // USE_SOCKET_IMPL_LWIP_TCP

esphome/components/socket/lwip_sockets_impl.h

@@ -84,9 +84,6 @@ class LwIPSocketImpl {
 
   int get_fd() const { return this->fd_; }
 
-  /// UDP rx drop counter parity with LWIPRawUDPImpl; drops are not counted here.
-  uint16_t get_rx_dropped() const { return 0; }
-
  protected:
   // fd_ < 0 means "not open" — used both pre-open (initial state) and post-close. This
   // replaces a separate closed_ flag: close() sets fd_ = -1 after lwip_close(), and the

esphome/components/socket/socket.cpp

@@ -116,7 +116,25 @@ size_t format_sockaddr_to(const struct sockaddr *addr_ptr, socklen_t len, std::s
   return 0;
 }
 
-std::unique_ptr<Socket> socket_ip(int type, int protocol) { return socket(IP_DOMAIN, type, protocol); }
+std::unique_ptr<Socket> socket_ip(int type, int protocol) {
+#if USE_NETWORK_IPV6
+  return socket(AF_INET6, type, protocol);
+#else
+  return socket(AF_INET, type, protocol);
+#endif /* USE_NETWORK_IPV6 */
+}
+
+#ifdef USE_SOCKET_IMPL_LWIP_TCP
+// LWIP_TCP has separate Socket/ListenSocket types — needs out-of-line factory.
+// BSD and LWIP_SOCKETS define this inline in socket.h.
+std::unique_ptr<ListenSocket> socket_ip_loop_monitored(int type, int protocol) {
+#if USE_NETWORK_IPV6
+  return socket_listen_loop_monitored(AF_INET6, type, protocol);
+#else
+  return socket_listen_loop_monitored(AF_INET, type, protocol);
+#endif /* USE_NETWORK_IPV6 */
+}
+#endif
 
 socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const char *ip_address, uint16_t port) {
 #if USE_NETWORK_IPV6

esphome/components/socket/socket.h

@@ -20,7 +20,6 @@
 #include "lwip_sockets_impl.h"
 #elif defined(USE_SOCKET_IMPL_LWIP_TCP)
 #include "lwip_raw_tcp_impl.h"
-#include "lwip_raw_udp_impl.h"
 #endif
 
 namespace esphome::socket {
@@ -28,32 +27,17 @@ namespace esphome::socket {
 // Type aliases — only one implementation is active per build.
 // Socket is the concrete type for connected sockets.
 // ListenSocket is the concrete type for listening/server sockets.
-// UDPSocket is the concrete type for UDP sockets (send + receive).
-// UDPSendSocket is the concrete type for send-only UDP sockets.
-// On BSD and LWIP_SOCKETS, all aliases resolve to the same type.
+// On BSD and LWIP_SOCKETS, both aliases resolve to the same type.
 // On LWIP_TCP, they are different types (no virtual dispatch between them).
 #ifdef USE_SOCKET_IMPL_BSD_SOCKETS
 using Socket = BSDSocketImpl;
 using ListenSocket = BSDSocketImpl;
-using UDPSendSocket = BSDSocketImpl;
-using UDPSocket = BSDSocketImpl;
 #elif defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
 using Socket = LwIPSocketImpl;
 using ListenSocket = LwIPSocketImpl;
-using UDPSendSocket = LwIPSocketImpl;
-using UDPSocket = LwIPSocketImpl;
 #elif defined(USE_SOCKET_IMPL_LWIP_TCP)
 using Socket = LWIPRawImpl;
 using ListenSocket = LWIPRawListenImpl;
-using UDPSendSocket = LWIPRawUDPSendImpl;
-using UDPSocket = LWIPRawUDPImpl;
-#endif
-
-// Domain used by the socket_ip_* helpers: newest available IP domain.
-#if USE_NETWORK_IPV6
-inline constexpr int IP_DOMAIN = AF_INET6;
-#else
-inline constexpr int IP_DOMAIN = AF_INET;
 #endif
 
 #ifdef USE_LWIP_FAST_SELECT
@@ -120,36 +104,6 @@ std::unique_ptr<Socket> socket_ip(int type, int protocol);
 /// File descriptors >= FD_SETSIZE will not be monitored and will log an error.
 std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol);
 
-/// Create a send-only UDP socket (socket_udp_send), a UDP socket with receive
-/// support (socket_udp), or a UDP socket monitored for data in the main loop
-/// (socket_udp_loop_monitored).
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-std::unique_ptr<UDPSendSocket> socket_udp_send(int domain, int protocol);
-std::unique_ptr<UDPSocket> socket_udp(int domain, int protocol);
-// Wake is built into the recv callback, so monitoring needs nothing extra.
-inline std::unique_ptr<UDPSocket> socket_udp_loop_monitored(int domain, int protocol) {
-  return socket_udp(domain, protocol);
-}
-#else
-inline std::unique_ptr<UDPSendSocket> socket_udp_send(int domain, int protocol) {
-  return esphome::socket::socket(domain, SOCK_DGRAM, protocol);
-}
-inline std::unique_ptr<UDPSocket> socket_udp(int domain, int protocol) {
-  return esphome::socket::socket(domain, SOCK_DGRAM, protocol);
-}
-// Registers the socket with the Application's select() loop.
-inline std::unique_ptr<UDPSocket> socket_udp_loop_monitored(int domain, int protocol) {
-  return socket_loop_monitored(domain, SOCK_DGRAM, protocol);
-}
-#endif
-
-/// socket_udp* variants using the newest available IP domain.
-inline std::unique_ptr<UDPSendSocket> socket_ip_udp_send(int protocol) { return socket_udp_send(IP_DOMAIN, protocol); }
-inline std::unique_ptr<UDPSocket> socket_ip_udp(int protocol) { return socket_udp(IP_DOMAIN, protocol); }
-inline std::unique_ptr<UDPSocket> socket_ip_udp_loop_monitored(int protocol) {
-  return socket_udp_loop_monitored(IP_DOMAIN, protocol);
-}
-
 /// Create a listening socket of the given domain, type and protocol.
 /// Create a listening socket and monitor it for data in the main loop.
 /// Create a listening socket in the newest available IP domain and monitor it.
@@ -157,6 +111,7 @@ inline std::unique_ptr<UDPSocket> socket_ip_udp_loop_monitored(int protocol) {
 // LWIP_TCP has separate Socket/ListenSocket types — needs distinct factory functions.
 std::unique_ptr<ListenSocket> socket_listen(int domain, int type, int protocol);
 std::unique_ptr<ListenSocket> socket_listen_loop_monitored(int domain, int type, int protocol);
+std::unique_ptr<ListenSocket> socket_ip_loop_monitored(int type, int protocol);
 #else
 // BSD and LWIP_SOCKETS: Socket == ListenSocket, so listen variants just delegate.
 inline std::unique_ptr<ListenSocket> socket_listen(int domain, int type, int protocol) {
@@ -165,10 +120,14 @@ inline std::unique_ptr<ListenSocket> socket_listen(int domain, int type, int pro
 inline std::unique_ptr<ListenSocket> socket_listen_loop_monitored(int domain, int type, int protocol) {
   return socket_loop_monitored(domain, type, protocol);
 }
-#endif
 inline std::unique_ptr<ListenSocket> socket_ip_loop_monitored(int type, int protocol) {
-  return socket_listen_loop_monitored(IP_DOMAIN, type, protocol);
+#if USE_NETWORK_IPV6
+  return socket_loop_monitored(AF_INET6, type, protocol);
+#else
+  return socket_loop_monitored(AF_INET, type, protocol);
+#endif
 }
+#endif
 
 /// Set a sockaddr to the specified address and port for the IP version used by socket_ip().
 /// @param addr Destination sockaddr structure

esphome/espidf/size_summary.py

@@ -9,16 +9,19 @@ byte-identical to PlatformIO's output:
     Flash: [===       ]  48.4% (used 888511 bytes from 1835008 bytes)
 
 The format matches ``script/ci_memory_impact_extract.py`` so CI memory
-analysis works unchanged on native ESP-IDF builds. RAM total is the
-DRAM region size from the linker map; Flash total is taken from
+analysis works unchanged on native ESP-IDF builds. RAM usage comes from
+the DRAM (or unified DIRAM) region of the linker map. Flash used is the
+exact image size matching the ``Total image size`` line: json2
+``total_size`` when present, otherwise derived from the ELF (see
+``_image_size_from_elf``). Flash total is taken from
 ``partitions.csv`` using PlatformIO's rule (first app partition whose
 subtype is ``factory`` or ``ota_0``; see
 ``platform-espressif32/builder/main.py::_update_max_upload_size``).
 
 Structured size data is produced at link time by a CMake POST_BUILD
 custom command (see ``build_gen/espidf.py``) which writes
-``esp_idf_size.json`` next to the ELF. We read that file here rather
-than re-running ``esp_idf_size`` from Python.
+``esp_idf_size.json`` (``--format=json2``, a per-memory-type summary)
+next to the ELF; we read that rather than re-running ``esp_idf_size``.
 """
 
 from __future__ import annotations
@@ -27,6 +30,7 @@ import csv
 import json
 import logging
 from pathlib import Path
+import struct
 
 from esphome.build_helpers.size_summary import print_size_line
 
@@ -69,11 +73,43 @@ def _find_app_partition_size(partitions_csv: Path) -> int:
     raise ValueError(f"No app+factory or app+ota_0 partition in {partitions_csv}")
 
 
-def print_summary(size_json: Path, partitions_csv: Path | None) -> None:
+def _image_size_from_elf(elf: Path) -> int:
+    """Sum the allocated PROGBITS section sizes from an ELF32 file.
+
+    Matches ``esp_idf_size.ng.memorymap._get_image_size`` byte for byte;
+    esptool's ``ELFFile`` filters sections differently and would not.
+    Raises ``ValueError`` for anything but a well-formed ELF32 LE file.
+    """
+    with elf.open("rb") as f:
+        header = f.read(52)  # ELF32 header
+        if len(header) < 52 or header[:6] != b"\x7fELF\x01\x01":
+            raise ValueError(f"{elf} is not a 32-bit little-endian ELF")
+        (e_shoff,) = struct.unpack_from("<I", header, 0x20)  # e_shoff
+        e_shentsize, e_shnum = struct.unpack_from("<HH", header, 0x2E)
+        if e_shentsize < 40:  # sizeof(Elf32_Shdr)
+            raise ValueError(f"{elf} has an invalid section header size")
+        f.seek(e_shoff)
+        table = f.read(e_shnum * e_shentsize)
+    if len(table) < e_shnum * e_shentsize:
+        raise ValueError(f"{elf} has a truncated section header table")
+    total = 0
+    for off in range(0, e_shnum * e_shentsize, e_shentsize):
+        sh_type, sh_flags = struct.unpack_from("<II", table, off + 4)
+        (sh_size,) = struct.unpack_from("<I", table, off + 20)
+        if sh_type == 1 and sh_flags & 0x2:  # SHT_PROGBITS with SHF_ALLOC
+            total += sh_size
+    if total == 0:
+        # A used-0-bytes Flash line would read as a real measurement
+        raise ValueError(f"{elf} has no allocated PROGBITS sections")
+    return total
+
+
+def print_summary(size_json: Path, partitions_csv: Path, firmware_elf: Path) -> None:
     """Print PlatformIO-shaped RAM and Flash one-liners.
 
     Failures are non-fatal: the build has already succeeded, we just couldn't
-    summarize. Logs the cause at debug level.
+    summarize. Anomalies (missing region, unreadable ELF) warn; expected
+    optional inputs (no size json, no partitions.csv) log at debug.
     """
     if not size_json.is_file():
         _LOGGER.debug("Skipping size summary: %s not found", size_json)
@@ -83,20 +119,49 @@ def print_summary(size_json: Path, partitions_csv: Path | None) -> None:
     except (OSError, json.JSONDecodeError) as e:
         _LOGGER.debug("Skipping size summary: %s", e)
         return
-
-    memory_types = data.get("memory_types", {})
-    ram_region = memory_types.get("DRAM") or memory_types.get("DIRAM") or {}
-    ram_used = ram_region.get("used")
-    ram_total = ram_region.get("size")
-    if ram_total and ram_used is not None:
-        print_size_line("RAM", ram_used, ram_total)
-
-    image_size = data.get("image_size")
-    if image_size is None or partitions_csv is None:
+    if not isinstance(data, dict):
+        _LOGGER.warning("Skipping size summary: unexpected json shape in %s", size_json)
         return
+
+    layout = data.get("layout")
+    regions = {
+        entry.get("name"): entry
+        for entry in (layout if isinstance(layout, list) else [])
+        if isinstance(entry, dict)
+    }
+    # Every chip has a DRAM or DIRAM region, so a warning here usually
+    # means the esp_idf_size json schema changed
+    ram_region = regions.get("DRAM") or regions.get("DIRAM")
+    if ram_region is None:
+        _LOGGER.warning("Skipping RAM summary: no DRAM/DIRAM region in %s", size_json)
+    elif (
+        isinstance(ram_total := ram_region.get("total"), int)
+        and ram_total > 0
+        and isinstance(ram_used := ram_region.get("used"), int)
+    ):
+        print_size_line("RAM", ram_used, ram_total)
+    else:
+        _LOGGER.warning(
+            "Skipping RAM summary: unusable region %s in %s", ram_region, size_json
+        )
+
+    # esp-idf-size >= 2.1 (IDF >= 6.0) reports the exact image size in
+    # json2; older 1.x omits it, so derive the same figure from the ELF.
+    flash_used = data.get("total_size")
+    if not (isinstance(flash_used, int) and flash_used > 0):
+        _LOGGER.debug("No total_size in %s, deriving from %s", size_json, firmware_elf)
+        try:
+            flash_used = _image_size_from_elf(firmware_elf)
+        except (OSError, ValueError) as e:
+            # The ELF must be present and well formed after a successful build
+            _LOGGER.warning("Skipping Flash summary: %s", e)
+            return
     try:
         app_size = _find_app_partition_size(partitions_csv)
-    except ValueError as e:
+    except (OSError, ValueError) as e:
         _LOGGER.debug("Skipping Flash summary: %s", e)
         return
-    print_size_line("Flash", image_size, app_size)
+    if app_size <= 0:
+        _LOGGER.debug("Skipping Flash summary: app partition size is 0")
+        return
+    print_size_line("Flash", flash_used, app_size)

esphome/espidf/toolchain.py

@@ -542,7 +542,7 @@ def run_compile(config, verbose: bool) -> int:
     if rc == 0:
         size_json = CORE.relative_build_path("build", "esp_idf_size.json")
         partitions = CORE.relative_build_path("partitions.csv")
-        print_summary(size_json, partitions if partitions.is_file() else None)
+        print_summary(size_json, partitions, get_built_elf_path())
     return rc
 
 
@@ -579,6 +579,16 @@ def get_ota_firmware_path() -> Path:
     return build_dir / "firmware.ota.bin"
 
 
+def get_built_elf_path() -> Path:
+    """Path to the ELF idf.py writes directly, ``<build>/<name>.elf``.
+
+    Exists as soon as the build finishes, unlike the ``firmware.elf``
+    copy that ``create_elf_copy`` makes later.
+    """
+    build_dir = CORE.relative_build_path("build")
+    return build_dir / f"{CORE.name}.elf"
+
+
 def get_elf_path() -> Path:
     """Get the path to the firmware ELF file.
 
@@ -706,8 +716,7 @@ def create_elf_copy() -> bool:
     "download ELF" link requests the literal filename ``firmware.elf``
     (PlatformIO convention), so copy it to that name.
     """
-    build_dir = CORE.relative_build_path("build")
-    src_elf = build_dir / f"{CORE.name}.elf"
+    src_elf = get_built_elf_path()
     dst_elf = get_elf_path()
 
     if not src_elf.is_file():

tests/unit_tests/build_gen/test_espidf.py

@@ -163,6 +163,18 @@ def test_has_discovered_components_after_configure(tmp_path: Path) -> None:
     assert has_discovered_components()
 
 
+def test_get_project_cmakelists_size_command_uses_json2() -> None:
+    """The POST_BUILD size command uses the cheap json2 format, with --ng
+    only on the 1.x tool bundled with IDF < 6."""
+    content = _render()
+    assert "-m esp_idf_size --ng --format=json2" in content
+
+    CORE.data[KEY_ESP32][KEY_IDF_VERSION] = cv.Version(6, 0, 0)
+    content = _render()
+    assert "--ng" not in content
+    assert "--format=json2" in content
+
+
 def test_get_project_cmakelists_uses_supplied_builtin_components() -> None:
     """A cached list replaces project_description.json and is still filtered
     by EXCLUDE_COMPONENTS."""

tests/unit_tests/test_espidf_toolchain.py

@@ -638,6 +638,43 @@ def test_run_compile_passes_compile_process_limit(setup_core: Path) -> None:
     mock_run.assert_called_once_with("build", "size", jobs=1)
 
 
+def test_run_compile_passes_size_summary_paths(setup_core: Path) -> None:
+    """print_summary receives the size json, partitions.csv, and the built
+    ELF from get_built_elf_path, which must stay in lockstep with the
+    project() name in the generated CMakeLists."""
+    _setup_build(setup_core)
+    config = {CONF_ESPHOME: {}}
+
+    with (
+        patch.object(toolchain, "need_reconfigure", return_value=False),
+        patch.object(toolchain, "run_idf_py", return_value=0),
+        patch.object(toolchain, "print_summary") as mock_summary,
+    ):
+        assert toolchain.run_compile(config, verbose=False) == 0
+
+    mock_summary.assert_called_once_with(
+        CORE.relative_build_path("build", "esp_idf_size.json"),
+        CORE.relative_build_path("partitions.csv"),
+        CORE.relative_build_path("build", f"{CORE.name}.elf"),
+    )
+
+
+def test_create_elf_copy(setup_core: Path) -> None:
+    """The built <name>.elf is copied to the firmware.elf dashboard name."""
+    _setup_build(setup_core)
+    src = toolchain.get_built_elf_path()
+    src.parent.mkdir(parents=True, exist_ok=True)
+    src.write_bytes(b"elf")
+    assert toolchain.create_elf_copy() is True
+    assert toolchain.get_elf_path().read_bytes() == b"elf"
+
+
+def test_create_elf_copy_missing_source(setup_core: Path) -> None:
+    """A missing built ELF is a warning and False, not a crash."""
+    _setup_build(setup_core)
+    assert toolchain.create_elf_copy() is False
+
+
 def test_run_compile_without_compile_process_limit(setup_core: Path) -> None:
     """When no compile_process_limit is set, no job limit is passed to idf.py."""
     _setup_build(setup_core)

tests/unit_tests/test_size_summary.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+import struct
+from unittest.mock import patch
 
 import pytest
 
@@ -17,64 +19,106 @@ def _write_size_json(tmp_path: Path, data: dict) -> Path:
     return out
 
 
+def _write_partitions(tmp_path: Path) -> Path:
+    """Drop a partitions.csv with a 0x1C0000 (1835008 byte) app slot."""
+    out = tmp_path / "partitions.csv"
+    out.write_text(
+        "# name, type, subtype, offset, size, flags\n"
+        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    )
+    return out
+
+
+def _elf_bytes(sections: list[tuple[int, int, int]], shentsize: int = 40) -> bytes:
+    """Build a minimal ELF32 LE whose section headers carry the given
+    (sh_type, sh_flags, sh_size) triples."""
+    out = bytearray(52)
+    out[0:4] = b"\x7fELF"
+    out[4] = out[5] = 1  # 32-bit, little-endian
+    struct.pack_into("<I", out, 0x20, 52)  # e_shoff
+    struct.pack_into("<HH", out, 0x2E, shentsize, len(sections))
+    for sh_type, sh_flags, sh_size in sections:
+        shdr = bytearray(40)
+        struct.pack_into("<II", shdr, 4, sh_type, sh_flags)
+        struct.pack_into("<I", shdr, 20, sh_size)
+        out += shdr
+    return bytes(out)
+
+
 def _esp32_size_data() -> dict:
-    """Synthetic esp_idf_size.json for the original ESP32 (split IRAM/DRAM)."""
+    """Synthetic json2 for the original ESP32 (split IRAM/DRAM), in the
+    esp-idf-size >= 2.1 shape that carries ``total_size``."""
     return {
-        "image_size": 827455,
-        "memory_types": {
-            "DRAM": {
-                "size": 180736,
+        "version": "1.1",
+        "total_size": 827455,
+        "layout": [
+            {
+                "name": "DRAM",
+                "total": 180736,
                 "used": 47332,
-                "sections": {
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 30616},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 16716},
+                "free": 133404,
+                "parts": {
+                    ".bss": {"size": 30616},
+                    ".data": {"size": 16716},
                 },
             },
-            "IRAM": {
-                "size": 131072,
+            {
+                "name": "IRAM",
+                "total": 131072,
                 "used": 80351,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 79323},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 50721,
+                "parts": {
+                    ".text": {"size": 79323},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
 def _s3_size_data() -> dict:
-    """Synthetic esp_idf_size.json for ESP32-S3 (unified DIRAM)."""
+    """Synthetic json2 for ESP32-S3 (unified DIRAM), in the esp-idf-size 1.x
+    shape without ``total_size``."""
     return {
-        "image_size": 724215,
-        "memory_types": {
-            "DIRAM": {
-                "size": 341760,
+        "version": "1.1",
+        "layout": [
+            {
+                "name": "DIRAM",
+                "total": 341760,
                 "used": 104999,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 58051},
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 27088},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 19708},
-                    ".noinit": {"abbrev_name": ".noinit", "size": 152},
+                "free": 236761,
+                "parts": {
+                    ".text": {"size": 58051},
+                    ".bss": {"size": 27088},
+                    ".data": {"size": 19708},
+                    ".noinit": {"size": 152},
                 },
             },
-            "IRAM": {
-                "size": 16384,
+            {
+                "name": "IRAM",
+                "total": 16384,
                 "used": 16384,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 15356},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 0,
+                "parts": {
+                    ".text": {"size": 15356},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
+def _print_summary_ram_only(tmp_path: Path, size_json: Path) -> None:
+    """Call print_summary with no partitions.csv or ELF on disk."""
+    print_summary(size_json, tmp_path / "partitions.csv", tmp_path / "firmware.elf")
+
+
 def test_print_summary_esp32_uses_dram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """Original ESP32: DRAM has no ``.text``, so RAM = DRAM.used / DRAM.size unchanged."""
+    """Original ESP32: RAM = DRAM.used / DRAM.total."""
     size_json = _write_size_json(tmp_path, _esp32_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" in out
     assert "used 47332 bytes from 180736 bytes" in out
@@ -83,63 +127,193 @@ def test_print_summary_esp32_uses_dram(
 def test_print_summary_s3_falls_back_to_diram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """ESP32-S3 with no DRAM key falls back to DIRAM and reports raw region usage."""
+    """ESP32-S3 with no DRAM entry falls back to DIRAM and reports raw region usage."""
     size_json = _write_size_json(tmp_path, _s3_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "used 104999 bytes from 341760 bytes" in out
 
 
 def test_print_summary_skips_when_diram_total_collapses(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
     """A zero-size region drops the RAM line rather than divide by zero."""
     size_json = _write_size_json(
         tmp_path,
         {
-            "memory_types": {
-                "DIRAM": {
-                    "size": 0,
-                    "used": 0,
-                    "sections": {},
-                },
-            },
+            "version": "1.1",
+            "layout": [{"name": "DIRAM", "total": 0, "used": 0}],
         },
     )
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" not in out
+    assert "unusable region" in caplog.text
 
 
 def test_print_summary_handles_missing_json(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
     """Missing size json is non-fatal and prints nothing."""
-    print_summary(tmp_path / "does_not_exist.json", partitions_csv=None)
+    _print_summary_ram_only(tmp_path, tmp_path / "does_not_exist.json")
     assert capsys.readouterr().out == ""
 
 
-def test_print_summary_handles_no_memory_types(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+def test_print_summary_handles_no_layout(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """A size json without ``memory_types`` still doesn't crash."""
-    size_json = _write_size_json(tmp_path, {"image_size": 0})
-    print_summary(size_json, partitions_csv=None)
+    """A size json without ``layout`` warns so schema drift is visible."""
+    size_json = _write_size_json(tmp_path, {"version": "1.1"})
+    _print_summary_ram_only(tmp_path, size_json)
     assert capsys.readouterr().out == ""
-
-
-def test_print_summary_flash_line(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    """A partition table with an app row yields the Flash line in the exact
-    padded shape script/ci_memory_impact_extract.py greps."""
-    size_json = _write_size_json(tmp_path, _esp32_size_data())
-    partitions = tmp_path / "partitions.csv"
-    partitions.write_text(
-        "# name, type, subtype, offset, size, flags\n"
-        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    assert any(
+        r.levelname == "WARNING" and "no DRAM/DIRAM region" in r.message
+        for r in caplog.records
     )
-    print_summary(size_json, partitions)
+
+
+def test_print_summary_flash_line_prefers_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """With ``total_size`` in the json, that figure wins without reading the
+    ELF, in the exact shape script/ci_memory_impact_extract.py greps."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
     out = capsys.readouterr().out
     assert "Flash: " in out
     assert "(used 827455 bytes from 1835008 bytes)" in out
+
+
+def test_print_summary_flash_line_derives_from_elf(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A 1.x json without ``total_size`` sums the ELF's loadable PROGBITS
+    sections; NOBITS and non-alloc sections are excluded."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(
+        _elf_bytes(
+            [
+                (1, 0x6, 700000),  # PROGBITS, alloc+exec: counted
+                (1, 0x2, 24215),  # PROGBITS, alloc: counted
+                (8, 0x2, 50000),  # NOBITS (.bss): excluded
+                (1, 0x0, 12345),  # PROGBITS, no alloc (.debug_*): excluded
+            ]
+        )
+    )
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 724215 bytes from 1835008 bytes)" in out
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pytest.param([1, 2], id="top_level_list"),
+        pytest.param({"version": "1.1", "layout": None}, id="layout_null"),
+        pytest.param({"version": "1.1", "layout": 7}, id="layout_scalar"),
+    ],
+)
+def test_print_summary_handles_unexpected_shapes(
+    data: object, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A foreign-schema size json degrades to a warning, never a traceback."""
+    size_json = _write_size_json(tmp_path, data)
+    _print_summary_ram_only(tmp_path, size_json)
+    assert capsys.readouterr().out == ""
+
+
+def test_print_summary_skips_flash_on_zero_app_partition(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero-size app partition skips the Flash line rather than printing
+    a from-0-bytes figure CI would record."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = tmp_path / "partitions.csv"
+    partitions.write_text(
+        "# name, type, subtype, offset, size, flags\napp0, app, ota_0, 0x10000, 0x0,\n"
+    )
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    out = capsys.readouterr().out
+    assert "Flash:" not in out
+
+
+def test_print_summary_skips_flash_on_unreadable_partitions(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """An unreadable partitions.csv is non-fatal (chmod tricks don't work
+    for root in CI containers, so simulate the OSError instead)."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    with patch(
+        "esphome.espidf.size_summary._find_app_partition_size",
+        side_effect=PermissionError("denied"),
+    ):
+        print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    assert "Flash:" not in capsys.readouterr().out
+
+
+def test_print_summary_flash_falls_back_on_bad_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero or non-int total_size falls back to the ELF instead of
+    printing a used-0-bytes line CI would read as a real measurement."""
+    data = _s3_size_data()
+    data["total_size"] = 0
+    size_json = _write_size_json(tmp_path, data)
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(_elf_bytes([(1, 0x2, 4096)]))
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 4096 bytes from 1835008 bytes)" in out
+
+
+_GOOD_ELF = _elf_bytes([(1, 0x2, 1024)])
+
+
+@pytest.mark.parametrize(
+    ("elf_bytes", "with_partitions"),
+    [
+        pytest.param(None, True, id="missing_elf"),
+        pytest.param(b"junk", True, id="not_an_elf"),
+        pytest.param(
+            _elf_bytes([(1, 0x2, 1024)], shentsize=0), True, id="bad_shentsize"
+        ),
+        pytest.param(_GOOD_ELF[:60], True, id="truncated_table"),
+        pytest.param(_elf_bytes([]), True, id="no_sections"),
+        pytest.param(_elf_bytes([(8, 0x2, 50000)]), True, id="no_progbits"),
+        pytest.param(_GOOD_ELF, False, id="missing_partitions"),
+    ],
+)
+def test_print_summary_skips_flash_on_bad_input(
+    elf_bytes: bytes | None,
+    with_partitions: bool,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """An unusable ELF or missing partitions.csv skips the Flash line, not the RAM line."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    firmware_elf = tmp_path / "firmware.elf"
+    if elf_bytes is not None:
+        firmware_elf.write_bytes(elf_bytes)
+    if with_partitions:
+        _write_partitions(tmp_path)
+    print_summary(size_json, tmp_path / "partitions.csv", firmware_elf)
+    out = capsys.readouterr().out
+    assert "RAM:" in out
+    assert "Flash:" not in out
+    # ELF problems warn (anomaly after a successful build); a missing
+    # partitions.csv stays at debug
+    warned = any(
+        r.levelname == "WARNING" and "Skipping Flash summary" in r.message
+        for r in caplog.records
+    )
+    assert warned == with_partitions