ESPHome 2025.6.0
Loading...
Searching...
No Matches
bsd_sockets_impl.cpp
Go to the documentation of this file.
1#include "socket.h"
4
5#ifdef USE_SOCKET_IMPL_BSD_SOCKETS
6
7#include <cstring>
9
10#ifdef USE_ESP32
11#include <esp_idf_version.h>
12#include <lwip/sockets.h>
13#endif
14
15namespace esphome {
16namespace socket {
17
18std::string format_sockaddr(const struct sockaddr_storage &storage) {
19 if (storage.ss_family == AF_INET) {
20 const struct sockaddr_in *addr = reinterpret_cast<const struct sockaddr_in *>(&storage);
21 char buf[INET_ADDRSTRLEN];
22 if (inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(buf)) != nullptr)
23 return std::string{buf};
24 }
25#if LWIP_IPV6
26 else if (storage.ss_family == AF_INET6) {
27 const struct sockaddr_in6 *addr = reinterpret_cast<const struct sockaddr_in6 *>(&storage);
28 char buf[INET6_ADDRSTRLEN];
29 // Format IPv4-mapped IPv6 addresses as regular IPv4 addresses
30 if (addr->sin6_addr.un.u32_addr[0] == 0 && addr->sin6_addr.un.u32_addr[1] == 0 &&
31 addr->sin6_addr.un.u32_addr[2] == htonl(0xFFFF) &&
32 inet_ntop(AF_INET, &addr->sin6_addr.un.u32_addr[3], buf, sizeof(buf)) != nullptr) {
33 return std::string{buf};
34 }
35 if (inet_ntop(AF_INET6, &addr->sin6_addr, buf, sizeof(buf)) != nullptr)
36 return std::string{buf};
37 }
38#endif
39 return {};
40}
41
42class BSDSocketImpl : public Socket {
43 public:
44 BSDSocketImpl(int fd, bool monitor_loop = false) : fd_(fd) {
45#ifdef USE_SOCKET_SELECT_SUPPORT
46 // Register new socket with the application for select() if monitoring requested
47 if (monitor_loop && fd_ >= 0) {
48 // Only set loop_monitored_ to true if registration succeeds
50 } else {
51 loop_monitored_ = false;
52 }
53#else
54 // Without select support, ignore monitor_loop parameter
55 (void) monitor_loop;
56#endif
57 }
58 ~BSDSocketImpl() override {
59 if (!closed_) {
60 close(); // NOLINT(clang-analyzer-optin.cplusplus.VirtualCall)
61 }
62 }
63 int connect(const struct sockaddr *addr, socklen_t addrlen) override { return ::connect(fd_, addr, addrlen); }
64 std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) override {
65 return accept_impl_(addr, addrlen, false);
66 }
67 std::unique_ptr<Socket> accept_loop_monitored(struct sockaddr *addr, socklen_t *addrlen) override {
68 return accept_impl_(addr, addrlen, true);
69 }
70
71 private:
72 std::unique_ptr<Socket> accept_impl_(struct sockaddr *addr, socklen_t *addrlen, bool loop_monitored) {
73 int fd = ::accept(fd_, addr, addrlen);
74 if (fd == -1)
75 return {};
76 return make_unique<BSDSocketImpl>(fd, loop_monitored);
77 }
78
79 public:
80 int bind(const struct sockaddr *addr, socklen_t addrlen) override { return ::bind(fd_, addr, addrlen); }
81 int close() override {
82 if (!closed_) {
83#ifdef USE_SOCKET_SELECT_SUPPORT
84 // Unregister from select() before closing if monitored
85 if (loop_monitored_) {
87 }
88#endif
89 int ret = ::close(fd_);
90 closed_ = true;
91 return ret;
92 }
93 return 0;
94 }
95 int shutdown(int how) override { return ::shutdown(fd_, how); }
96
97 int getpeername(struct sockaddr *addr, socklen_t *addrlen) override { return ::getpeername(fd_, addr, addrlen); }
98 std::string getpeername() override {
99 struct sockaddr_storage storage;
100 socklen_t len = sizeof(storage);
101 int err = this->getpeername((struct sockaddr *) &storage, &len);
102 if (err != 0)
103 return {};
104 return format_sockaddr(storage);
105 }
106 int getsockname(struct sockaddr *addr, socklen_t *addrlen) override { return ::getsockname(fd_, addr, addrlen); }
107 std::string getsockname() override {
108 struct sockaddr_storage storage;
109 socklen_t len = sizeof(storage);
110 int err = this->getsockname((struct sockaddr *) &storage, &len);
111 if (err != 0)
112 return {};
113 return format_sockaddr(storage);
114 }
115 int getsockopt(int level, int optname, void *optval, socklen_t *optlen) override {
116 return ::getsockopt(fd_, level, optname, optval, optlen);
117 }
118 int setsockopt(int level, int optname, const void *optval, socklen_t optlen) override {
119 return ::setsockopt(fd_, level, optname, optval, optlen);
120 }
121 int listen(int backlog) override { return ::listen(fd_, backlog); }
122 ssize_t read(void *buf, size_t len) override { return ::read(fd_, buf, len); }
123 ssize_t recvfrom(void *buf, size_t len, sockaddr *addr, socklen_t *addr_len) override {
124#if defined(USE_ESP32) || defined(USE_HOST)
125 return ::recvfrom(this->fd_, buf, len, 0, addr, addr_len);
126#else
127 return ::lwip_recvfrom(this->fd_, buf, len, 0, addr, addr_len);
128#endif
129 }
130 ssize_t readv(const struct iovec *iov, int iovcnt) override {
131#if defined(USE_ESP32)
132 return ::lwip_readv(fd_, iov, iovcnt);
133#else
134 return ::readv(fd_, iov, iovcnt);
135#endif
136 }
137 ssize_t write(const void *buf, size_t len) override { return ::write(fd_, buf, len); }
138 ssize_t send(void *buf, size_t len, int flags) { return ::send(fd_, buf, len, flags); }
139 ssize_t writev(const struct iovec *iov, int iovcnt) override {
140#if defined(USE_ESP32)
141 return ::lwip_writev(fd_, iov, iovcnt);
142#else
143 return ::writev(fd_, iov, iovcnt);
144#endif
145 }
146
147 ssize_t sendto(const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen) override {
148 return ::sendto(fd_, buf, len, flags, to, tolen);
149 }
150
151 int setblocking(bool blocking) override {
152 int fl = ::fcntl(fd_, F_GETFL, 0);
153 if (blocking) {
154 fl &= ~O_NONBLOCK;
155 } else {
156 fl |= O_NONBLOCK;
157 }
158 ::fcntl(fd_, F_SETFL, fl);
159 return 0;
160 }
161
162 int get_fd() const override { return fd_; }
163
164 protected:
165 int fd_;
166 bool closed_ = false;
167};
168
169// Helper to create a socket with optional monitoring
170static std::unique_ptr<Socket> create_socket(int domain, int type, int protocol, bool loop_monitored = false) {
171 int ret = ::socket(domain, type, protocol);
172 if (ret == -1)
173 return nullptr;
174 return std::unique_ptr<Socket>{new BSDSocketImpl(ret, loop_monitored)};
175}
176
177std::unique_ptr<Socket> socket(int domain, int type, int protocol) {
178 return create_socket(domain, type, protocol, false);
179}
180
181std::unique_ptr<Socket> socket_loop_monitored(int domain, int type, int protocol) {
182 return create_socket(domain, type, protocol, true);
183}
184
185} // namespace socket
186} // namespace esphome
187
188#endif // USE_SOCKET_IMPL_BSD_SOCKETS
void unregister_socket_fd(int fd)
bool register_socket_fd(int fd)
Register/unregister a socket file descriptor to be monitored for read events.
bool loop_monitored_
Whether this socket is monitored by the event loop.
Definition socket.h:63
uint8_t type
uint32_t socklen_t
Definition headers.h:97
__int64 ssize_t
Definition httplib.h:175
std::string format_sockaddr(const struct sockaddr_storage &storage)
std::unique_ptr< Socket > socket(int domain, int type, int protocol)
Create a socket of the given domain, type and protocol.
std::unique_ptr< Socket > socket_loop_monitored(int domain, int type, int protocol)
Create a socket and monitor it for data in the main loop.
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
std::string size_t len
Definition helpers.h:302
std::unique_ptr< T > make_unique(Args &&...args)
Definition helpers.h:86
Application App
Global storage of Application pointer - only one Application can exist.
struct in6_addr sin6_addr
Definition headers.h:77
struct in_addr sin_addr
Definition headers.h:65
sa_family_t ss_family
Definition headers.h:92