133 static std::vector<EthernetClient*>& active_clients() {
134 static std::vector<EthernetClient*> clients;
137 static void cleanupAll(
int sig) {
138 for (
auto* client : active_clients()) {
147 setTimeout(ETHERNET_DEFAULT_READ_TIMEOUT);
148 p_sock = std::make_shared<SocketImpl>();
152 active_clients().push_back(
this);
154 EthernetClient(std::shared_ptr<SocketImpl> sock,
int bufferSize = 256,
long timeout = ETHERNET_DEFAULT_READ_TIMEOUT) {
157 this->bufferSize = bufferSize;
161 is_connected = p_sock->connected();
163 active_clients().push_back(
this);
166 EthernetClient(
int socket) {
167 setTimeout(ETHERNET_DEFAULT_READ_TIMEOUT);
170 p_sock = std::make_shared<SocketImpl>(socket);
171 is_connected = p_sock->connected();
175 virtual uint8_t connected()
override {
176 if (!is_connected || !p_sock)
return false;
181 is_connected = p_sock->connected();
186 operator bool()
override {
return connected(); }
189 virtual int connect(
IPAddress ipAddress, uint16_t port)
override {
190 return connect(ipAddress, port, getConnectionTimeout());
193 int connect(
IPAddress ipAddress, uint16_t port, int32_t timeout_ms) {
197 this->address = ipAddress;
199 return connect(str.c_str(), port, timeout_ms);
203 virtual int connect(
const char* address, uint16_t port)
override {
204 return connect(address, port, getConnectionTimeout());
207 int connect(
const char* address, uint16_t port, int32_t timeout_ms) {
208 Logger.info(WIFICLIENT,
"connect");
210 if (connectedFast()) {
213 uint32_t start_ms = millis();
214 IPAddress adr = resolveAddress(address, timeout_ms);
216 is_connected =
false;
223 int32_t remaining_timeout = timeout_ms;
224 if (timeout_ms >= 0) {
225 uint32_t elapsed_ms = millis() - start_ms;
226 remaining_timeout = elapsed_ms >=
static_cast<uint32_t
>(timeout_ms)
228 : timeout_ms -
static_cast<int32_t
>(elapsed_ms);
232 String str = adr.toString();
233 Logger.info(
"Connecting to ", str.c_str());
240 if (p_sock->connect(str.c_str(), port, remaining_timeout) <= 0) {
241 is_connected =
false;
248 virtual size_t write(
char c) {
return write((uint8_t)c); }
252 virtual size_t write(uint8_t c)
override {
253 if (writeBuffer.availableToWrite() == 0) {
256 return writeBuffer.write(c);
259 virtual size_t write(
const char* str,
int len) {
260 return write((
const uint8_t*)str, len);
264 virtual size_t write(
const uint8_t* str,
size_t len)
override {
266 return p_sock->write(str, len);
269 virtual int print(
const char* str =
"") {
270 int len = strlen(str);
271 return write(str, len);
274 virtual int println(
const char* str =
"") {
275 int len = strlen(str);
276 int result = write(str, len);
284 virtual void flush()
override {
285 Logger.debug(WIFICLIENT,
"flush");
287 int flushSize = writeBuffer.available();
289 uint8_t rbuffer[flushSize];
290 writeBuffer.read(rbuffer, flushSize);
291 p_sock->write(rbuffer, flushSize);
296 virtual int available()
override {
297 Logger.debug(WIFICLIENT,
"available");
298 if (readBuffer.available() > 0) {
299 return readBuffer.available();
301 unsigned long timeout = millis() + getTimeout();
302 int result = p_sock->available();
303 while (result <= 0 && millis() < timeout) {
305 result = p_sock->available();
311 virtual int read()
override {
314 if (readBytes(&c, 1) == 1) {
320 virtual size_t readBytes(
char* buffer,
size_t len) {
321 int result = read((uint8_t*)buffer, len);
322 return result < 0 ? 0 : static_cast<size_t>(result);
325 virtual size_t readBytes(uint8_t* buffer,
size_t len) {
326 int result = read(buffer, len);
327 return result < 0 ? 0 : static_cast<size_t>(result);
331 virtual int peek()
override {
332 return p_sock->peek();
337 virtual void stop()
override { p_sock->close(); }
339 virtual void setInsecure() {}
341 int fd() {
return p_sock->fd(); }
343 uint16_t remotePort() {
return port; }
349 struct sockaddr_in addr;
350 if (!localAddress(addr))
return IPAddress(0, 0, 0, 0);
355 uint16_t localPort() {
356 struct sockaddr_in addr;
357 if (!localAddress(addr))
return 0;
358 return ntohs(addr.sin_port);
361 virtual void setCACert(
const char* cert) {
362 Logger.error(WIFICLIENT,
"setCACert not supported");
365 int read(uint8_t* buffer,
size_t len)
override {
366 Logger.debug(WIFICLIENT,
"read");
368 unsigned long timeout = millis() + getTimeout();
369 result = p_sock->read(buffer, len);
370 while (result == 0 && millis() < timeout) {
372 result = p_sock->read(buffer, len);
376 sprintf(lenStr,
"%d", result);
377 Logger.debug(WIFICLIENT,
"read->", lenStr);
384 if (!p_sock || p_sock->fd() == INVALID_SOCKET_HANDLE)
return false;
385 int flag = noDelay ? 1 : 0;
386 return ::setsockopt(p_sock->fd(), IPPROTO_TCP, TCP_NODELAY, (
const char*)&flag,
391 if (!p_sock || p_sock->fd() == INVALID_SOCKET_HANDLE)
return false;
393 SocketLength len =
sizeof(flag);
394 if (::getsockopt(p_sock->fd(), IPPROTO_TCP, TCP_NODELAY, (
char*)&flag, &len) != 0)
399 void setConnectionTimeout(int32_t timeout) {
400 connectTimeout = timeout;
403 int32_t getConnectionTimeout() {
404 return connectTimeout;
408 const char* WIFICLIENT =
"EthernetClient";
409 int32_t connectTimeout = 5000;
410 std::shared_ptr<SocketImpl> p_sock =
nullptr;
411 int bufferSize = 256;
412 RingBufferExt readBuffer;
413 RingBufferExt writeBuffer;
414 bool is_connected =
false;
415 IPAddress address{0, 0, 0, 0};
420 static IPAddress resolveHostnameBlocking(
const std::string& hostname) {
421 struct addrinfo hints;
422 memset(&hints, 0,
sizeof(hints));
423 hints.ai_family = AF_INET;
424 hints.ai_socktype = SOCK_STREAM;
426 struct addrinfo* result =
nullptr;
427 if (getaddrinfo(hostname.c_str(),
nullptr, &hints, &result) != 0 ||
429 return IPAddress(0, 0, 0, 0);
432 auto* addr =
reinterpret_cast<struct sockaddr_in*
>(result->ai_addr);
433 IPAddress resolved(addr->sin_addr.s_addr);
434 freeaddrinfo(result);
444 IPAddress resolveHostname(
const char* hostname, int32_t timeout_ms) {
445 if (timeout_ms < 0) {
446 IPAddress resolved = resolveHostnameBlocking(hostname);
447 if (resolved == IPAddress(0, 0, 0, 0)) {
448 Logger.error(WIFICLIENT,
"Hostname resolution failed");
453 auto promise = std::make_shared<std::promise<IPAddress>>();
454 std::future<IPAddress> future = promise->get_future();
455 std::string hostname_copy(hostname);
456 std::thread resolver([promise, hostname_copy]() {
457 promise->set_value(resolveHostnameBlocking(hostname_copy));
460 if (future.wait_for(std::chrono::milliseconds(timeout_ms)) ==
461 std::future_status::ready) {
463 IPAddress resolved = future.get();
464 if (resolved == IPAddress(0, 0, 0, 0)) {
465 Logger.error(WIFICLIENT,
"Hostname resolution failed");
471 Logger.error(WIFICLIENT,
"Hostname resolution timeout");
472 return IPAddress(0, 0, 0, 0);
476 IPAddress resolveAddress(
const char* address, int32_t timeout_ms) {
477 struct sockaddr_in serv_addr4;
478 memset(&serv_addr4, 0,
sizeof(serv_addr4));
479 serv_addr4.sin_family = AF_INET;
480 if (::inet_pton(AF_INET, address, &serv_addr4.sin_addr) <= 0) {
481 return resolveHostname(address, timeout_ms);
483 return IPAddress(serv_addr4.sin_addr.s_addr);
486 void registerCleanup() {
487 static bool signal_registered =
false;
488 if (!signal_registered) {
489 SignalHandler::registerHandler(SIGINT, cleanupAll);
490 SignalHandler::registerHandler(SIGTERM, cleanupAll);
491 signal_registered =
true;
496 bool localAddress(
struct sockaddr_in& addr) {
497 memset(&addr, 0,
sizeof(addr));
498 if (!p_sock || p_sock->fd() == INVALID_SOCKET_HANDLE)
return false;
499 SocketLength len =
sizeof(addr);
500 if (::getsockname(p_sock->fd(), (
struct sockaddr*)&addr, &len) != 0)
502 return addr.sin_family == AF_INET;
505 bool connectedFast() {
return is_connected; }