[socket] Refactor socket implementations for memory efficiency and code quality (#12550)

2026-02-27 17:34:22 -07:00 · 2025-12-18 09:07:35 -07:00
parent b47b7d43fd
commit 2cf6ed2af7
5 changed files with 122 additions and 137 deletions
--- a/esphome/components/socket/lwip_sockets_impl.cpp
+++ b/esphome/components/socket/lwip_sockets_impl.cpp
@@ -7,8 +7,7 @@
 #include <cstring>
 #include "esphome/core/application.h"

-namespace esphome {
-namespace socket {
+namespace esphome::socket {

 std::string format_sockaddr(const struct sockaddr_storage &storage) {
  if (storage.ss_family == AF_INET) {
@@ -37,11 +36,11 @@ class LwIPSocketImpl : public Socket {
  LwIPSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
 #ifdef USE_SOCKET_SELECT_SUPPORT
    // Register new socket with the application for select() if monitoring requested
-    if (monitor_loop && fd_ >= 0) {
+    if (monitor_loop && this->fd_ >= 0) {
      // Only set loop_monitored_ to true if registration succeeds
-      loop_monitored_ = App.register_socket_fd(fd_);
+      this->loop_monitored_ = App.register_socket_fd(this->fd_);
    } else {
-      loop_monitored_ = false;
+      this->loop_monitored_ = false;
    }
 #else
    // Without select support, ignore monitor_loop parameter
@@ -49,96 +48,108 @@ class LwIPSocketImpl : public Socket {
 #endif
  }
  ~LwIPSocketImpl() override {
-    if (!closed_) {
-      close();  // NOLINT(clang-analyzer-optin.cplusplus.VirtualCall)
+    if (!this->closed_) {
+      this->close();  // NOLINT(clang-analyzer-optin.cplusplus.VirtualCall)
    }
  }
-  int connect(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_connect(fd_, addr, addrlen); }
+  int connect(const struct sockaddr *addr, socklen_t addrlen) override {
+    return lwip_connect(this->fd_, addr, addrlen);
+  }
  std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) override {
-    return accept_impl_(addr, addrlen, false);
-  }
-  std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) override {
-    return accept_impl_(addr, addrlen, true);
-  }
-
- private:
-  std::unique_ptr<Socket> accept_impl_(struct sockaddr *addr, socklen_t *addrlen, bool loop_monitored) {
-    int fd = lwip_accept(fd_, addr, addrlen);
+    int fd = lwip_accept(this->fd_, addr, addrlen);
    if (fd == -1)
      return {};
-    return make_unique<LwIPSocketImpl>(fd, loop_monitored);
+    return make_unique<LwIPSocketImpl>(fd, false);
+  }
+  std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) override {
+    int fd = lwip_accept(this->fd_, addr, addrlen);
+    if (fd == -1)
+      return {};
+    return make_unique<LwIPSocketImpl>(fd, true);
  }

- public:
-  int bind(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_bind(fd_, addr, addrlen); }
+  int bind(const struct sockaddr *addr, socklen_t addrlen) override { return lwip_bind(this->fd_, addr, addrlen); }
  int close() override {
-    if (!closed_) {
+    if (!this->closed_) {
 #ifdef USE_SOCKET_SELECT_SUPPORT
      // Unregister from select() before closing if monitored
-      if (loop_monitored_) {
-        App.unregister_socket_fd(fd_);
+      if (this->loop_monitored_) {
+        App.unregister_socket_fd(this->fd_);
      }
 #endif
-      int ret = lwip_close(fd_);
-      closed_ = true;
+      int ret = lwip_close(this->fd_);
+      this->closed_ = true;
      return ret;
    }
    return 0;
  }
-  int shutdown(int how) override { return lwip_shutdown(fd_, how); }
+  int shutdown(int how) override { return lwip_shutdown(this->fd_, how); }

-  int getpeername(struct sockaddr *addr, socklen_t *addrlen) override { return lwip_getpeername(fd_, addr, addrlen); }
+  int getpeername(struct sockaddr *addr, socklen_t *addrlen) override {
+    return lwip_getpeername(this->fd_, addr, addrlen);
+  }
  std::string getpeername() override {
    struct sockaddr_storage storage;
    socklen_t len = sizeof(storage);
-    int err = this->getpeername((struct sockaddr *) &storage, &len);
-    if (err != 0)
+    if (lwip_getpeername(this->fd_, (struct sockaddr *) &storage, &len) != 0)
      return {};
    return format_sockaddr(storage);
  }
-  int getsockname(struct sockaddr *addr, socklen_t *addrlen) override { return lwip_getsockname(fd_, addr, addrlen); }
+  int getsockname(struct sockaddr *addr, socklen_t *addrlen) override {
+    return lwip_getsockname(this->fd_, addr, addrlen);
+  }
  std::string getsockname() override {
    struct sockaddr_storage storage;
    socklen_t len = sizeof(storage);
-    int err = this->getsockname((struct sockaddr *) &storage, &len);
-    if (err != 0)
+    if (lwip_getsockname(this->fd_, (struct sockaddr *) &storage, &len) != 0)
      return {};
    return format_sockaddr(storage);
  }
  int getsockopt(int level, int optname, void *optval, socklen_t *optlen) override {
-    return lwip_getsockopt(fd_, level, optname, optval, optlen);
+    return lwip_getsockopt(this->fd_, level, optname, optval, optlen);
  }
  int setsockopt(int level, int optname, const void *optval, socklen_t optlen) override {
-    return lwip_setsockopt(fd_, level, optname, optval, optlen);
+    return lwip_setsockopt(this->fd_, level, optname, optval, optlen);
  }
-  int listen(int backlog) override { return lwip_listen(fd_, backlog); }
-  ssize_t read(void *buf, size_t len) override { return lwip_read(fd_, buf, len); }
+  int listen(int backlog) override { return lwip_listen(this->fd_, backlog); }
+  ssize_t read(void *buf, size_t len) override { return lwip_read(this->fd_, buf, len); }
  ssize_t recvfrom(void *buf, size_t len, sockaddr *addr, socklen_t *addr_len) override {
-    return lwip_recvfrom(fd_, buf, len, 0, addr, addr_len);
+    return lwip_recvfrom(this->fd_, buf, len, 0, addr, addr_len);
  }
-  ssize_t readv(const struct iovec *iov, int iovcnt) override { return lwip_readv(fd_, iov, iovcnt); }
-  ssize_t write(const void *buf, size_t len) override { return lwip_write(fd_, buf, len); }
-  ssize_t send(void *buf, size_t len, int flags) { return lwip_send(fd_, buf, len, flags); }
-  ssize_t writev(const struct iovec *iov, int iovcnt) override { return lwip_writev(fd_, iov, iovcnt); }
+  ssize_t readv(const struct iovec *iov, int iovcnt) override { return lwip_readv(this->fd_, iov, iovcnt); }
+  ssize_t write(const void *buf, size_t len) override { return lwip_write(this->fd_, buf, len); }
+  ssize_t send(void *buf, size_t len, int flags) { return lwip_send(this->fd_, buf, len, flags); }
+  ssize_t writev(const struct iovec *iov, int iovcnt) override { return lwip_writev(this->fd_, iov, iovcnt); }
  ssize_t sendto(const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen) override {
-    return lwip_sendto(fd_, buf, len, flags, to, tolen);
+    return lwip_sendto(this->fd_, buf, len, flags, to, tolen);
  }
  int setblocking(bool blocking) override {
-    int fl = lwip_fcntl(fd_, F_GETFL, 0);
+    int fl = lwip_fcntl(this->fd_, F_GETFL, 0);
    if (blocking) {
      fl &= ~O_NONBLOCK;
    } else {
      fl |= O_NONBLOCK;
    }
-    lwip_fcntl(fd_, F_SETFL, fl);
+    lwip_fcntl(this->fd_, F_SETFL, fl);
    return 0;
  }

-  int get_fd() const override { return fd_; }
+  int get_fd() const override { return this->fd_; }
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  bool ready() const override {
+    if (!this->loop_monitored_)
+      return true;
+    return App.is_socket_ready(this->fd_);
+  }
+#endif

 protected:
  int fd_;
-  bool closed_ = false;
+  bool closed_{false};
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  bool loop_monitored_{false};
+#endif
 };

 // Helper to create a socket with optional monitoring
@@ -157,7 +168,6 @@ std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol
  return create_socket(domain, type, protocol, true);
 }

-}  // namespace socket
-}  // namespace esphome
+}  // namespace esphome::socket

 #endif  // USE_SOCKET_IMPL_LWIP_SOCKETS