@alteriom/painlessmesh 1.7.4 → 1.7.5

package/examples/alteriom/.pio/libdeps/esp32/AsyncTCP/src/AsyncTCP.cpp

@@ -1,1612 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov
-
-#include "AsyncTCP.h"
-#include "AsyncTCPLogging.h"
-#include "AsyncTCPSimpleIntrusiveList.h"
-
-/**
- * LibreTiny specific configurations
- */
-#if defined(LIBRETINY)
-#include <Arduino.h>
-// LibreTiny does not support IDF - disable code that expects it to be available
-#define ESP_IDF_VERSION_MAJOR (0)
-// xTaskCreatePinnedToCore is not available, force single-core operation
-#define CONFIG_FREERTOS_UNICORE 1
-// ESP watchdog is not available
-#undef CONFIG_ASYNC_TCP_USE_WDT
-#define CONFIG_ASYNC_TCP_USE_WDT 0
-#endif  // LIBRETINY
-
-/**
- * Arduino specific configurations
- */
-#if defined(ARDUINO) && !defined(LIBRETINY)
-#include <Arduino.h>
-#include <esp_idf_version.h>
-#if (ESP_IDF_VERSION_MAJOR >= 5)
-#include <NetworkInterface.h>
-#endif  // ESP_IDF_VERSION_MAJOR
-#endif  // ARDUINO
-
-/**
- * ESP-IDF specific configurations
- */
-#if !defined(LIBRETINY) && !defined(ARDUINO)
-#include "esp_timer.h"
-static unsigned long millis() {
-  return (unsigned long)(esp_timer_get_time() / 1000ULL);
-}
-#endif  // !LIBRETINY && !ARDUINO
-
-extern "C" {
-#include "lwip/dns.h"
-#include "lwip/err.h"
-#include "lwip/inet.h"
-#include "lwip/opt.h"
-#include "lwip/tcp.h"
-#include "lwip/tcpip.h"
-}
-
-#if CONFIG_ASYNC_TCP_USE_WDT
-#include "esp_task_wdt.h"
-#endif
-
-// Required for:
-// https://github.com/espressif/arduino-esp32/blob/3.0.3/libraries/Network/src/NetworkInterface.cpp#L37-L47
-
-#if CONFIG_ASYNC_TCP_USE_WDT
-#include "esp_task_wdt.h"
-#define ASYNC_TCP_MAX_TASK_SLEEP (pdMS_TO_TICKS(1000 * CONFIG_ESP_TASK_WDT_TIMEOUT_S) / 4)
-#else
-#define ASYNC_TCP_MAX_TASK_SLEEP portMAX_DELAY
-#endif
-
-// https://github.com/espressif/arduino-esp32/issues/10526
-namespace {
-#ifdef CONFIG_LWIP_TCPIP_CORE_LOCKING
-struct tcp_core_guard {
-  bool do_lock;
-  inline tcp_core_guard() : do_lock(!sys_thread_tcpip(LWIP_CORE_LOCK_QUERY_HOLDER)) {
-    if (do_lock) {
-      LOCK_TCPIP_CORE();
-    }
-  }
-  inline ~tcp_core_guard() {
-    if (do_lock) {
-      UNLOCK_TCPIP_CORE();
-    }
-  }
-  tcp_core_guard(const tcp_core_guard &) = delete;
-  tcp_core_guard(tcp_core_guard &&) = delete;
-  tcp_core_guard &operator=(const tcp_core_guard &) = delete;
-  tcp_core_guard &operator=(tcp_core_guard &&) = delete;
-} __attribute__((unused));
-#else   // CONFIG_LWIP_TCPIP_CORE_LOCKING
-struct tcp_core_guard {
-} __attribute__((unused));
-#endif  // CONFIG_LWIP_TCPIP_CORE_LOCKING
-}  // anonymous namespace
-
-#define INVALID_CLOSED_SLOT -1
-
-/*
-  TCP poll interval is specified in terms of the TCP coarse timer interval, which is called twice a second
-  https://github.com/espressif/esp-lwip/blob/2acf959a2bb559313cd2bf9306c24612ba3d0e19/src/core/tcp.c#L1895
-*/
-#define CONFIG_ASYNC_TCP_POLL_TIMER 1
-
-/*
- * TCP/IP Event Task
- * */
-
-typedef enum {
-  LWIP_TCP_SENT,
-  LWIP_TCP_RECV,
-  LWIP_TCP_FIN,
-  LWIP_TCP_ERROR,
-  LWIP_TCP_POLL,
-  LWIP_TCP_ACCEPT,
-  LWIP_TCP_CONNECTED,
-  LWIP_TCP_DNS
-} lwip_tcp_event_t;
-
-struct lwip_tcp_event_packet_t {
-  lwip_tcp_event_packet_t *next;
-  lwip_tcp_event_t event;
-  AsyncClient *client;
-  union {
-    struct {
-      tcp_pcb *pcb;
-      int8_t err;
-    } connected;
-    struct {
-      int8_t err;
-    } error;
-    struct {
-      tcp_pcb *pcb;
-      uint16_t len;
-    } sent;
-    struct {
-      tcp_pcb *pcb;
-      pbuf *pb;
-      int8_t err;
-    } recv;
-    struct {
-      tcp_pcb *pcb;
-      int8_t err;
-    } fin;
-    struct {
-      tcp_pcb *pcb;
-    } poll;
-    struct {
-      AsyncServer *server;
-    } accept;
-    struct {
-      const char *name;
-      ip_addr_t addr;
-    } dns;
-  };
-
-  inline lwip_tcp_event_packet_t(lwip_tcp_event_t _event, AsyncClient *_client) : next(nullptr), event(_event), client(_client){};
-};
-
-// Detail class for interacting with AsyncClient internals, but without exposing the API
-class AsyncTCP_detail {
-public:
-  // Helper functions
-  static void __attribute__((visibility("internal"))) handle_async_event(lwip_tcp_event_packet_t *event);
-
-  // LwIP TCP event callbacks that (will) require privileged access
-  static int8_t __attribute__((visibility("internal"))) tcp_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *pb, int8_t err);
-  static int8_t __attribute__((visibility("internal"))) tcp_sent(void *arg, struct tcp_pcb *pcb, uint16_t len);
-  static void __attribute__((visibility("internal"))) tcp_error(void *arg, int8_t err);
-  static int8_t __attribute__((visibility("internal"))) tcp_poll(void *arg, struct tcp_pcb *pcb);
-  static int8_t __attribute__((visibility("internal"))) tcp_accept(void *arg, tcp_pcb *pcb, int8_t err);
-};
-
-// Guard class for the global queue
-namespace {
-
-static SemaphoreHandle_t _async_queue_mutex = nullptr;
-
-class queue_mutex_guard {
-  bool holds_mutex;
-
-public:
-  inline queue_mutex_guard() : holds_mutex(xSemaphoreTake(_async_queue_mutex, portMAX_DELAY)){};
-  inline ~queue_mutex_guard() {
-    if (holds_mutex) {
-      xSemaphoreGive(_async_queue_mutex);
-    }
-  };
-  inline explicit operator bool() const {
-    return holds_mutex;
-  };
-};
-}  // anonymous namespace
-
-static SimpleIntrusiveList<lwip_tcp_event_packet_t> _async_queue;
-static TaskHandle_t _async_service_task_handle = NULL;
-
-static uint32_t _xor_shift_state = 31;  // any nonzero seed will do
-static uint32_t _xor_shift_next() {
-  uint32_t x = _xor_shift_state;
-  x ^= x << 13;
-  x ^= x >> 17;
-  x ^= x << 5;
-  return _xor_shift_state = x;
-}
-
-static void _free_event(lwip_tcp_event_packet_t *evpkt) {
-  if ((evpkt->event == LWIP_TCP_RECV) && (evpkt->recv.pb != nullptr)) {
-    pbuf_free(evpkt->recv.pb);
-  }
-  delete evpkt;
-}
-
-static inline void _send_async_event(lwip_tcp_event_packet_t *e) {
-  if (e == nullptr) {
-    return;
-  }
-  _async_queue.push_back(e);
-  xTaskNotifyGive(_async_service_task_handle);
-}
-
-static inline void _prepend_async_event(lwip_tcp_event_packet_t *e) {
-  if (e == nullptr) {
-    return;
-  }
-  _async_queue.push_front(e);
-  xTaskNotifyGive(_async_service_task_handle);
-}
-
-static inline lwip_tcp_event_packet_t *_get_async_event() {
-  queue_mutex_guard guard;
-  while (1) {
-    lwip_tcp_event_packet_t *e = _async_queue.pop_front();
-
-    if ((!e) || (e->event != LWIP_TCP_POLL)) {
-      return e;
-    }
-
-    /*
-      Let's try to coalesce two (or more) consecutive poll events into one
-      this usually happens with poor implemented user-callbacks that are runs too long and makes poll events to stack in the queue
-      if consecutive user callback for a same connection runs longer that poll time then it will fill the queue with events until it deadlocks.
-      This is a workaround to mitigate such poor designs and won't let other events/connections to starve the task time.
-      It won't be effective if user would run multiple simultaneous long running callbacks due to message interleaving.
-      todo: implement some kind of fair dequeuing or (better) simply punish user for a bad designed callbacks by resetting hog connections
-    */
-    for (lwip_tcp_event_packet_t *next_pkt = _async_queue.begin(); next_pkt && (next_pkt->client == e->client) && (next_pkt->event == LWIP_TCP_POLL);
-         next_pkt = _async_queue.begin()) {
-      // if the next event that will come is a poll event for the same connection, we can discard it and continue
-      _free_event(_async_queue.pop_front());
-      async_tcp_log_d("coalescing polls, network congestion or async callbacks might be too slow!");
-    }
-
-    /*
-      now we have to decide if to proceed with poll callback handler or discard it?
-      poor designed apps using asynctcp without proper dataflow control could flood the queue with interleaved pool/ack events.
-      I.e. on each poll app would try to generate more data to send, which in turn results in additional ack event triggering chain effect
-      for long connections. Or poll callback could take long time starving other connections. Anyway our goal is to keep the queue length
-      grows under control (if possible) and poll events are the safest to discard.
-      Let's discard poll events processing using linear-increasing probability curve when queue size grows over 3/4
-      Poll events are periodic and connection could get another chance next time
-    */
-    if (_async_queue.size() > (_xor_shift_next() % CONFIG_ASYNC_TCP_QUEUE_SIZE / 4 + CONFIG_ASYNC_TCP_QUEUE_SIZE * 3 / 4)) {
-      _free_event(e);
-      async_tcp_log_d("discarding poll due to queue congestion");
-      continue;
-    }
-
-    return e;
-  }
-}
-
-static size_t _remove_events_for_client(AsyncClient *client) {
-  lwip_tcp_event_packet_t *removed_event_chain;
-  {
-    queue_mutex_guard guard;
-    removed_event_chain = _async_queue.remove_if([=](lwip_tcp_event_packet_t &pkt) {
-      return pkt.client == client;
-    });
-  }
-
-  size_t count = 0;
-  while (removed_event_chain) {
-    ++count;
-    auto t = removed_event_chain;
-    removed_event_chain = t->next;
-    _free_event(t);
-  }
-  return count;
-};
-
-void AsyncTCP_detail::handle_async_event(lwip_tcp_event_packet_t *e) {
-  if (e->client == NULL) {
-    // do nothing when arg is NULL
-    // ets_printf("event arg == NULL: 0x%08x\n", e->recv.pcb);
-  } else if (e->event == LWIP_TCP_RECV) {
-    // ets_printf("-R: 0x%08x\n", e->recv.pcb);
-    e->client->_recv(e->recv.pcb, e->recv.pb, e->recv.err);
-    e->recv.pb = nullptr;  // given to client
-  } else if (e->event == LWIP_TCP_FIN) {
-    // ets_printf("-F: 0x%08x\n", e->fin.pcb);
-    e->client->_fin(e->fin.pcb, e->fin.err);
-  } else if (e->event == LWIP_TCP_SENT) {
-    // ets_printf("-S: 0x%08x\n", e->sent.pcb);
-    e->client->_sent(e->sent.pcb, e->sent.len);
-  } else if (e->event == LWIP_TCP_POLL) {
-    // ets_printf("-P: 0x%08x\n", e->poll.pcb);
-    e->client->_poll(e->poll.pcb);
-  } else if (e->event == LWIP_TCP_ERROR) {
-    // ets_printf("-E: 0x%08x %d\n", e->client, e->error.err);
-    e->client->_error(e->error.err);
-  } else if (e->event == LWIP_TCP_CONNECTED) {
-    // ets_printf("C: 0x%08x 0x%08x %d\n", e->client, e->connected.pcb, e->connected.err);
-    e->client->_connected(e->connected.pcb, e->connected.err);
-  } else if (e->event == LWIP_TCP_ACCEPT) {
-    // ets_printf("A: 0x%08x 0x%08x\n", e->client, e->accept.client);
-    e->accept.server->_accepted(e->client);
-  } else if (e->event == LWIP_TCP_DNS) {
-    // ets_printf("D: 0x%08x %s = %s\n", e->client, e->dns.name, ipaddr_ntoa(&e->dns.addr));
-    e->client->_dns_found(&e->dns.addr);
-  }
-  _free_event(e);
-}
-
-static void _async_service_task(void *pvParameters) {
-#if CONFIG_ASYNC_TCP_USE_WDT
-  if (esp_task_wdt_add(NULL) != ESP_OK) {
-    async_tcp_log_w("Failed to add async task to WDT");
-  }
-#endif
-  for (;;) {
-    while (auto packet = _get_async_event()) {
-      AsyncTCP_detail::handle_async_event(packet);
-#if CONFIG_ASYNC_TCP_USE_WDT
-      esp_task_wdt_reset();
-#endif
-    }
-    // queue is empty
-    // DEBUG_PRINTF("Async task waiting 0x%08",(intptr_t)_async_queue_head);
-    ulTaskNotifyTake(pdTRUE, ASYNC_TCP_MAX_TASK_SLEEP);
-    // DEBUG_PRINTF("Async task woke = %d 0x%08x",q, (intptr_t)_async_queue_head);
-#if CONFIG_ASYNC_TCP_USE_WDT
-    esp_task_wdt_reset();
-#endif
-  }
-#if CONFIG_ASYNC_TCP_USE_WDT
-  esp_task_wdt_delete(NULL);
-#endif
-  vTaskDelete(NULL);
-  _async_service_task_handle = NULL;
-}
-
-/*
-static void _stop_async_task(){
-    if(_async_service_task_handle){
-        vTaskDelete(_async_service_task_handle);
-        _async_service_task_handle = NULL;
-    }
-}
-*/
-
-static bool customTaskCreateUniversal(
-  TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority,
-  TaskHandle_t *const pxCreatedTask, const BaseType_t xCoreID
-) {
-#ifndef CONFIG_FREERTOS_UNICORE
-  if (xCoreID >= 0 && xCoreID < 2) {
-    return xTaskCreatePinnedToCore(pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, xCoreID);
-  } else {
-#endif
-    return xTaskCreate(pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask);
-#ifndef CONFIG_FREERTOS_UNICORE
-  }
-#endif
-}
-
-static bool _start_async_task() {
-  if (!_async_queue_mutex) {
-    _async_queue_mutex = xSemaphoreCreateMutex();
-    if (!_async_queue_mutex) {
-      return false;
-    }
-  }
-
-  if (!_async_service_task_handle) {
-    customTaskCreateUniversal(
-      _async_service_task, "async_tcp", CONFIG_ASYNC_TCP_STACK_SIZE, NULL, CONFIG_ASYNC_TCP_PRIORITY, &_async_service_task_handle, CONFIG_ASYNC_TCP_RUNNING_CORE
-    );
-    if (!_async_service_task_handle) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/*
- * LwIP Callbacks
- * */
-
-static void _bind_tcp_callbacks(tcp_pcb *pcb, AsyncClient *client) {
-  tcp_arg(pcb, client);
-  tcp_recv(pcb, &AsyncTCP_detail::tcp_recv);
-  tcp_sent(pcb, &AsyncTCP_detail::tcp_sent);
-  tcp_err(pcb, &AsyncTCP_detail::tcp_error);
-  tcp_poll(pcb, &AsyncTCP_detail::tcp_poll, CONFIG_ASYNC_TCP_POLL_TIMER);
-}
-
-static void _reset_tcp_callbacks(tcp_pcb *pcb, AsyncClient *client) {
-  tcp_arg(pcb, NULL);
-  tcp_sent(pcb, NULL);
-  tcp_recv(pcb, NULL);
-  tcp_err(pcb, NULL);
-  tcp_poll(pcb, NULL, 0);
-  if (client) {
-    _remove_events_for_client(client);
-  }
-}
-
-static int8_t _tcp_connected(void *arg, tcp_pcb *pcb, int8_t err) {
-  // ets_printf("+C: 0x%08x\n", pcb);
-  AsyncClient *client = reinterpret_cast<AsyncClient *>(arg);
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_CONNECTED, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return ERR_MEM;
-  }
-  e->connected.pcb = pcb;
-  e->connected.err = err;
-  queue_mutex_guard guard;
-  _send_async_event(e);
-  return ERR_OK;
-}
-
-int8_t AsyncTCP_detail::tcp_poll(void *arg, struct tcp_pcb *pcb) {
-  // throttle polling events queueing when event queue is getting filled up, let it handle _onack's
-  {
-    queue_mutex_guard guard;
-    // async_tcp_log_d("qs:%u", _async_queue.size());
-    if (_async_queue.size() > (_xor_shift_next() % CONFIG_ASYNC_TCP_QUEUE_SIZE / 2 + CONFIG_ASYNC_TCP_QUEUE_SIZE / 4)) {
-      async_tcp_log_d("throttling");
-      return ERR_OK;
-    }
-  }
-
-  // ets_printf("+P: 0x%08x\n", pcb);
-  AsyncClient *client = reinterpret_cast<AsyncClient *>(arg);
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_POLL, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return ERR_MEM;
-  }
-  e->poll.pcb = pcb;
-
-  queue_mutex_guard guard;
-  _send_async_event(e);
-  return ERR_OK;
-}
-
-int8_t AsyncTCP_detail::tcp_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *pb, int8_t err) {
-  AsyncClient *client = reinterpret_cast<AsyncClient *>(arg);
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_RECV, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return ERR_MEM;
-  }
-  if (pb) {
-    // ets_printf("+R: 0x%08x\n", pcb);
-    e->recv.pcb = pcb;
-    e->recv.pb = pb;
-    e->recv.err = err;
-  } else {
-    // ets_printf("+F: 0x%08x\n", pcb);
-    e->event = LWIP_TCP_FIN;
-    e->fin.pcb = pcb;
-    e->fin.err = err;
-    // close the PCB in LwIP thread
-    client->_lwip_fin(e->fin.pcb, e->fin.err);
-  }
-
-  queue_mutex_guard guard;
-  _send_async_event(e);
-  return ERR_OK;
-}
-
-int8_t AsyncTCP_detail::tcp_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
-  // ets_printf("+S: 0x%08x\n", pcb);
-  AsyncClient *client = reinterpret_cast<AsyncClient *>(arg);
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_SENT, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return ERR_MEM;
-  }
-  e->sent.pcb = pcb;
-  e->sent.len = len;
-
-  queue_mutex_guard guard;
-  _send_async_event(e);
-  return ERR_OK;
-}
-
-void AsyncTCP_detail::tcp_error(void *arg, int8_t err) {
-  // ets_printf("+E: 0x%08x\n", arg);
-  AsyncClient *client = reinterpret_cast<AsyncClient *>(arg);
-  if (client && client->_pcb) {
-    // The pcb has already been freed by LwIP; do not attempt to clear the callbacks!
-    _remove_events_for_client(client);
-    client->_pcb = nullptr;
-  }
-
-  // enqueue event to be processed in the async task for the user callback
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_ERROR, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return;
-  }
-  e->error.err = err;
-
-  queue_mutex_guard guard;
-  _send_async_event(e);
-}
-
-static void _tcp_dns_found(const char *name, ip_addr_t *ipaddr, void *arg) {
-  // ets_printf("+DNS: name=%s ipaddr=0x%08x arg=%x\n", name, ipaddr, arg);
-  auto client = reinterpret_cast<AsyncClient *>(arg);
-
-  lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_DNS, client};
-  if (!e) {
-    async_tcp_log_e("Failed to allocate event packet");
-    return;
-  }
-
-  e->dns.name = name;
-  if (ipaddr) {
-    memcpy(&e->dns.addr, ipaddr, sizeof(ip_addr_t));
-  } else {
-    memset(&e->dns.addr, 0, sizeof(e->dns.addr));
-  }
-
-  queue_mutex_guard guard;
-  _send_async_event(e);
-}
-
-/*
- * TCP/IP API Calls
- * */
-
-#include "lwip/priv/tcpip_priv.h"
-
-typedef struct {
-  struct tcpip_api_call_data call;
-  tcp_pcb **pcb;
-  int8_t err;
-  union {
-    AsyncClient *close;
-    struct {
-      const char *data;
-      size_t size;
-      uint8_t apiflags;
-    } write;
-    size_t received;
-    struct {
-      ip_addr_t *addr;
-      uint16_t port;
-      tcp_connected_fn cb;
-    } connect;
-    struct {
-      ip_addr_t *addr;
-      uint16_t port;
-    } bind;
-    uint8_t backlog;
-  };
-} tcp_api_call_t;
-
-static err_t _tcp_output_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = ERR_CONN;
-  if (*msg->pcb) {
-    msg->err = tcp_output(*msg->pcb);
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_output(tcp_pcb **pcb) {
-  if (!pcb || !*pcb) {
-    return ERR_CONN;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  tcpip_api_call(_tcp_output_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_write_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = ERR_CONN;
-  if (*msg->pcb) {
-    msg->err = tcp_write(*msg->pcb, msg->write.data, msg->write.size, msg->write.apiflags);
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_write(tcp_pcb **pcb, const char *data, size_t size, uint8_t apiflags) {
-  if (!pcb || !*pcb) {
-    return ERR_CONN;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  msg.write.data = data;
-  msg.write.size = size;
-  msg.write.apiflags = apiflags;
-  tcpip_api_call(_tcp_write_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_recved_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = ERR_CONN;
-  if (*msg->pcb) {
-    msg->err = 0;
-    tcp_recved(*msg->pcb, msg->received);
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_recved(tcp_pcb **pcb, size_t len) {
-  if (!pcb || !*pcb) {
-    return ERR_CONN;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  msg.received = len;
-  tcpip_api_call(_tcp_recved_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_close_api(struct tcpip_api_call_data *api_call_msg) {
-  // Unlike the other calls, this is not a direct wrapper of the LwIP function;
-  // we perform the AsyncClient teardown interlocked safely with the LwIP task.
-
-  // As a postcondition, the queue must not have any events referencing
-  // the AsyncClient in api_call_msg->close.  This is because it is possible for
-  // an error event to have been queued, clearing the pcb*, but after the async
-  // thread has committed to closing/destructing the AsyncClient object.
-
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = ERR_CONN;
-  if (*msg->pcb) {
-    tcp_pcb *pcb = *msg->pcb;
-    _reset_tcp_callbacks(pcb, msg->close);
-    if (tcp_close(pcb) != ERR_OK) {
-      // We do not permit failure here: abandon the pcb anyways.
-      tcp_abort(pcb);
-    }
-    msg->err = ERR_OK;
-    *msg->pcb = nullptr;  // PCB is now the property of LwIP
-  } else {
-    // Ensure there is not an error event queued for this client
-    if (_remove_events_for_client(msg->close)) {
-      msg->err = ERR_OK;  // dispose needs to be run
-    }
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_close(tcp_pcb **pcb, AsyncClient *client) {
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  msg.close = client;
-  tcpip_api_call(_tcp_close_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_abort_api(struct tcpip_api_call_data *api_call_msg) {
-  // Like close(), we must ensure that the queue is cleared
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  if (*msg->pcb) {
-    tcp_abort(*msg->pcb);
-    *msg->pcb = nullptr;  // PCB is now the property of LwIP
-    msg->err = ERR_ABRT;
-  } else {
-    msg->err = ERR_CONN;
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_abort(tcp_pcb **pcb, AsyncClient *client) {
-  if (!pcb || !*pcb) {
-    return ERR_CONN;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  msg.close = client;
-  tcpip_api_call(_tcp_abort_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_connect_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = tcp_connect(*msg->pcb, msg->connect.addr, msg->connect.port, msg->connect.cb);
-  return msg->err;
-}
-
-static esp_err_t _tcp_connect(tcp_pcb *pcb, ip_addr_t *addr, uint16_t port, tcp_connected_fn cb) {
-  if (!pcb) {
-    return ESP_FAIL;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = &pcb;  // cannot be invalidated by LwIP at this point
-  msg.connect.addr = addr;
-  msg.connect.port = port;
-  msg.connect.cb = cb;
-  tcpip_api_call(_tcp_connect_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_bind_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  tcp_pcb *pcb = *msg->pcb;
-  msg->err = tcp_bind(pcb, msg->bind.addr, msg->bind.port);
-  if (msg->err != ERR_OK) {
-    // Close the pcb on behalf of the server without an extra round-trip through the LwIP lock
-    if (tcp_close(pcb) != ERR_OK) {
-      tcp_abort(pcb);
-    }
-    *msg->pcb = nullptr;  // PCB is now owned by LwIP
-  }
-  return msg->err;
-}
-
-static esp_err_t _tcp_bind(tcp_pcb **pcb, ip_addr_t *addr, uint16_t port) {
-  if (!pcb || !*pcb) {
-    return ESP_FAIL;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = pcb;
-  msg.bind.addr = addr;
-  msg.bind.port = port;
-  tcpip_api_call(_tcp_bind_api, (struct tcpip_api_call_data *)&msg);
-  return msg.err;
-}
-
-static err_t _tcp_listen_api(struct tcpip_api_call_data *api_call_msg) {
-  tcp_api_call_t *msg = (tcp_api_call_t *)api_call_msg;
-  msg->err = 0;
-  *msg->pcb = tcp_listen_with_backlog(*msg->pcb, msg->backlog);
-  return msg->err;
-}
-
-static tcp_pcb *_tcp_listen_with_backlog(tcp_pcb *pcb, uint8_t backlog) {
-  if (!pcb) {
-    return NULL;
-  }
-  tcp_api_call_t msg;
-  msg.pcb = &pcb;
-  msg.backlog = backlog ? backlog : 0xFF;
-  tcpip_api_call(_tcp_listen_api, (struct tcpip_api_call_data *)&msg);
-  return pcb;
-}
-
-/*
-  Async TCP Client
- */
-
-AsyncClient::AsyncClient(tcp_pcb *pcb)
-  : _connect_cb(0), _connect_cb_arg(0), _discard_cb(0), _discard_cb_arg(0), _sent_cb(0), _sent_cb_arg(0), _error_cb(0), _error_cb_arg(0), _recv_cb(0),
-    _recv_cb_arg(0), _pb_cb(0), _pb_cb_arg(0), _timeout_cb(0), _timeout_cb_arg(0), _poll_cb(0), _poll_cb_arg(0), _ack_pcb(true), _tx_last_packet(0),
-    _rx_timeout(0), _rx_last_ack(0), _ack_timeout(CONFIG_ASYNC_TCP_MAX_ACK_TIME), _connect_port(0) {
-  _pcb = pcb;
-  if (_pcb) {
-    _rx_last_packet = millis();
-    _bind_tcp_callbacks(_pcb, this);
-  }
-}
-
-AsyncClient::~AsyncClient() {
-  if (_pcb) {
-    _close();
-  }
-}
-
-/*
- * Operators
- * */
-
-bool AsyncClient::operator==(const AsyncClient &other) const {
-  return _pcb == other._pcb;
-}
-
-/*
- * Callback Setters
- * */
-
-void AsyncClient::onConnect(AcConnectHandler cb, void *arg) {
-  _connect_cb = cb;
-  _connect_cb_arg = arg;
-}
-
-void AsyncClient::onDisconnect(AcConnectHandler cb, void *arg) {
-  _discard_cb = cb;
-  _discard_cb_arg = arg;
-}
-
-void AsyncClient::onAck(AcAckHandler cb, void *arg) {
-  _sent_cb = cb;
-  _sent_cb_arg = arg;
-}
-
-void AsyncClient::onError(AcErrorHandler cb, void *arg) {
-  _error_cb = cb;
-  _error_cb_arg = arg;
-}
-
-void AsyncClient::onData(AcDataHandler cb, void *arg) {
-  _recv_cb = cb;
-  _recv_cb_arg = arg;
-}
-
-void AsyncClient::onPacket(AcPacketHandler cb, void *arg) {
-  _pb_cb = cb;
-  _pb_cb_arg = arg;
-}
-
-void AsyncClient::onTimeout(AcTimeoutHandler cb, void *arg) {
-  _timeout_cb = cb;
-  _timeout_cb_arg = arg;
-}
-
-void AsyncClient::onPoll(AcConnectHandler cb, void *arg) {
-  _poll_cb = cb;
-  _poll_cb_arg = arg;
-}
-
-/*
- * Main Public Methods
- * */
-
-bool AsyncClient::connect(ip_addr_t addr, uint16_t port) {
-  if (_pcb) {
-    async_tcp_log_d("already connected, state %d", _pcb->state);
-    return false;
-  }
-  if (!_start_async_task()) {
-    async_tcp_log_e("failed to start task");
-    return false;
-  }
-
-  tcp_pcb *pcb;
-  {
-    tcp_core_guard tcg;
-#if LWIP_IPV4 && LWIP_IPV6
-    pcb = tcp_new_ip_type(addr.type);
-#else
-    pcb = tcp_new_ip_type(IPADDR_TYPE_V4);
-#endif
-    if (!pcb) {
-      async_tcp_log_e("pcb == NULL");
-      return false;
-    }
-    _bind_tcp_callbacks(pcb, this);
-  }
-
-  esp_err_t err = _tcp_connect(pcb, &addr, port, (tcp_connected_fn)&_tcp_connected);
-  return err == ESP_OK;
-}
-
-#ifdef ARDUINO
-bool AsyncClient::connect(const IPAddress &ip, uint16_t port) {
-  ip_addr_t addr;
-#if ESP_IDF_VERSION_MAJOR < 5
-#if LWIP_IPV4 && LWIP_IPV6
-  // if both IPv4 and IPv6 are enabled, ip_addr_t has a union field and the address type
-  addr.u_addr.ip4.addr = ip;
-  addr.type = IPADDR_TYPE_V4;
-#else
-  addr.addr = ip;
-#endif
-#else
-  ip.to_ip_addr_t(&addr);
-#endif
-
-  return connect(addr, port);
-}
-#endif
-
-#if LWIP_IPV6 && ESP_IDF_VERSION_MAJOR < 5
-bool AsyncClient::connect(const IPv6Address &ip, uint16_t port) {
-  auto ipaddr = static_cast<const uint32_t *>(ip);
-  ip_addr_t addr = IPADDR6_INIT(ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
-
-  return connect(addr, port);
-}
-#endif
-
-bool AsyncClient::connect(const char *host, uint16_t port) {
-  ip_addr_t addr;
-
-  if (!_start_async_task()) {
-    async_tcp_log_e("failed to start task");
-    return false;
-  }
-
-  err_t err;
-  {
-    tcp_core_guard tcg;
-    err = dns_gethostbyname(host, &addr, (dns_found_callback)&_tcp_dns_found, this);
-  }
-
-  if (err == ERR_OK) {
-#if ESP_IDF_VERSION_MAJOR < 5
-#if LWIP_IPV6
-    if (addr.type == IPADDR_TYPE_V6) {
-      return connect(IPv6Address(addr.u_addr.ip6.addr), port);
-    }
-    return connect(IPAddress(addr.u_addr.ip4.addr), port);
-#else
-    return connect(IPAddress(addr.addr), port);
-#endif
-#else
-    return connect(addr, port);
-#endif
-  } else if (err == ERR_INPROGRESS) {
-    _connect_port = port;
-    return true;
-  }
-  async_tcp_log_d("error: %d", err);
-  return false;
-}
-
-void AsyncClient::close(bool now) {
-  if (_pcb) {
-    _tcp_recved(&_pcb, _rx_ack_len);
-  }
-  _close();
-}
-
-int8_t AsyncClient::abort() {
-  return _tcp_abort(&_pcb, this);
-  // _pcb is now NULL
-}
-
-size_t AsyncClient::space() const {
-  if ((_pcb != NULL) && (_pcb->state == ESTABLISHED)) {
-    return tcp_sndbuf(_pcb);
-  }
-  return 0;
-}
-
-size_t AsyncClient::add(const char *data, size_t size, uint8_t apiflags) {
-  if (!_pcb || size == 0 || data == NULL) {
-    return 0;
-  }
-  size_t room = space();
-  if (!room) {
-    return 0;
-  }
-  size_t will_send = (room < size) ? room : size;
-  int8_t err = ERR_OK;
-  err = _tcp_write(&_pcb, data, will_send, apiflags);
-  if (err != ERR_OK) {
-    return 0;
-  }
-  return will_send;
-}
-
-bool AsyncClient::send() {
-  auto backup = _tx_last_packet;
-  _tx_last_packet = millis();
-  if (_tcp_output(&_pcb) == ERR_OK) {
-    return true;
-  }
-  _tx_last_packet = backup;
-  return false;
-}
-
-size_t AsyncClient::ack(size_t len) {
-  if (len > _rx_ack_len) {
-    len = _rx_ack_len;
-  }
-  if (len) {
-    _tcp_recved(&_pcb, len);
-  }
-  _rx_ack_len -= len;
-  return len;
-}
-
-void AsyncClient::ackPacket(struct pbuf *pb) {
-  if (!pb) {
-    return;
-  }
-  _tcp_recved(&_pcb, pb->len);
-  pbuf_free(pb);
-}
-
-/*
- * Main Private Methods
- * */
-
-int8_t AsyncClient::_close() {
-  // ets_printf("X: 0x%08x\n", (uint32_t)this);
-  int8_t err = _tcp_close(&_pcb, this);
-  // _pcb is now NULL
-  if ((err == ERR_OK) && _discard_cb) {
-    // _pcb was closed here
-    _discard_cb(_discard_cb_arg, this);
-  }
-  return err;
-}
-
-/*
- * Private Callbacks
- * */
-
-int8_t AsyncClient::_connected(tcp_pcb *pcb, int8_t err) {
-  _pcb = reinterpret_cast<tcp_pcb *>(pcb);
-  if (_pcb) {
-    _rx_last_packet = millis();
-  }
-  _tx_last_packet = 0;
-  _rx_last_ack = 0;
-  if (_connect_cb) {
-    _connect_cb(_connect_cb_arg, this);
-  }
-  return ERR_OK;
-}
-
-void AsyncClient::_error(int8_t err) {
-  if (_error_cb) {
-    _error_cb(_error_cb_arg, this, err);
-  }
-  if (_discard_cb) {
-    _discard_cb(_discard_cb_arg, this);
-  }
-}
-
-// In LwIP Thread
-int8_t AsyncClient::_lwip_fin(tcp_pcb *pcb, int8_t err) {
-  if (!_pcb || pcb != _pcb) {
-    async_tcp_log_d("0x%08" PRIx32 " != 0x%08" PRIx32, (uint32_t)pcb, (uint32_t)_pcb);
-    return ERR_OK;
-  }
-  _reset_tcp_callbacks(_pcb, this);
-  if (tcp_close(_pcb) != ERR_OK) {
-    tcp_abort(_pcb);
-  }
-  _pcb = NULL;
-  return ERR_OK;
-}
-
-// In Async Thread
-int8_t AsyncClient::_fin(tcp_pcb *pcb, int8_t err) {
-  if (_discard_cb) {
-    _discard_cb(_discard_cb_arg, this);
-  }
-  return ERR_OK;
-}
-
-int8_t AsyncClient::_sent(tcp_pcb *pcb, uint16_t len) {
-  _rx_last_ack = _rx_last_packet = millis();
-  if (_sent_cb) {
-    _sent_cb(_sent_cb_arg, this, len, (_rx_last_packet - _tx_last_packet));
-  }
-  return ERR_OK;
-}
-
-int8_t AsyncClient::_recv(tcp_pcb *pcb, pbuf *pb, int8_t err) {
-  while (pb != NULL) {
-    _rx_last_packet = millis();
-    // we should not ack before we assimilate the data
-    _ack_pcb = true;
-    pbuf *b = pb;
-    pb = b->next;
-    b->next = NULL;
-    if (_pb_cb) {
-      _pb_cb(_pb_cb_arg, this, b);
-    } else {
-      if (_recv_cb) {
-        _recv_cb(_recv_cb_arg, this, b->payload, b->len);
-      }
-      if (!_ack_pcb) {
-        _rx_ack_len += b->len;
-      } else if (_pcb) {
-        _tcp_recved(&_pcb, b->len);
-      }
-      pbuf_free(b);
-    }
-  }
-  return ERR_OK;
-}
-
-int8_t AsyncClient::_poll(tcp_pcb *pcb) {
-  if (!_pcb) {
-    // async_tcp_log_d("pcb is NULL");
-    return ERR_OK;
-  }
-  if (pcb != _pcb) {
-    async_tcp_log_d("0x%08" PRIx32 " != 0x%08" PRIx32, (uint32_t)pcb, (uint32_t)_pcb);
-    return ERR_OK;
-  }
-
-  uint32_t now = millis();
-
-  // ACK Timeout
-  if (_ack_timeout) {
-    const uint32_t one_day = 86400000;
-    bool last_tx_is_after_last_ack = (_rx_last_ack - _tx_last_packet + one_day) < one_day;
-    if (last_tx_is_after_last_ack && (now - _tx_last_packet) >= _ack_timeout) {
-      async_tcp_log_d("ack timeout %d", pcb->state);
-      if (_timeout_cb) {
-        _timeout_cb(_timeout_cb_arg, this, (now - _tx_last_packet));
-      }
-      return ERR_OK;
-    }
-  }
-  // RX Timeout
-  if (_rx_timeout && (now - _rx_last_packet) >= (_rx_timeout * 1000)) {
-    async_tcp_log_d("rx timeout %d", pcb->state);
-    _close();
-    return ERR_OK;
-  }
-  // Everything is fine
-  if (_poll_cb) {
-    _poll_cb(_poll_cb_arg, this);
-  }
-  return ERR_OK;
-}
-
-void AsyncClient::_dns_found(ip_addr_t *ipaddr) {
-  if (ipaddr) {
-    connect(*ipaddr, _connect_port);
-  } else {
-    if (_error_cb) {
-      _error_cb(_error_cb_arg, this, -55);
-    }
-    if (_discard_cb) {
-      _discard_cb(_discard_cb_arg, this);
-    }
-  }
-}
-
-/*
- * Public Helper Methods
- * */
-
-bool AsyncClient::free() {
-  if (!_pcb) {
-    return true;
-  }
-  if (_pcb->state == CLOSED || _pcb->state > ESTABLISHED) {
-    return true;
-  }
-  return false;
-}
-
-size_t AsyncClient::write(const char *data, size_t size, uint8_t apiflags) {
-  size_t will_send = add(data, size, apiflags);
-  if (!will_send || !send()) {
-    return 0;
-  }
-  return will_send;
-}
-
-void AsyncClient::setRxTimeout(uint32_t timeout) {
-  _rx_timeout = timeout;
-}
-
-uint32_t AsyncClient::getRxTimeout() const {
-  return _rx_timeout;
-}
-
-uint32_t AsyncClient::getAckTimeout() const {
-  return _ack_timeout;
-}
-
-void AsyncClient::setAckTimeout(uint32_t timeout) {
-  _ack_timeout = timeout;
-}
-
-void AsyncClient::setNoDelay(bool nodelay) const {
-  if (!_pcb) {
-    return;
-  }
-  if (nodelay) {
-    tcp_nagle_disable(_pcb);
-  } else {
-    tcp_nagle_enable(_pcb);
-  }
-}
-
-bool AsyncClient::getNoDelay() {
-  if (!_pcb) {
-    return false;
-  }
-  return tcp_nagle_disabled(_pcb);
-}
-
-void AsyncClient::setKeepAlive(uint32_t ms, uint8_t cnt) {
-  if (ms != 0) {
-    _pcb->so_options |= SOF_KEEPALIVE;  // Turn on TCP Keepalive for the given pcb
-    // Set the time between keepalive messages in milli-seconds
-    _pcb->keep_idle = ms;
-    _pcb->keep_intvl = ms;
-    _pcb->keep_cnt = cnt;  // The number of unanswered probes required to force closure of the socket
-  } else {
-    _pcb->so_options &= ~SOF_KEEPALIVE;  // Turn off TCP Keepalive for the given pcb
-  }
-}
-
-uint16_t AsyncClient::getMss() const {
-  if (!_pcb) {
-    return 0;
-  }
-  return tcp_mss(_pcb);
-}
-
-uint32_t AsyncClient::getRemoteAddress() const {
-  if (!_pcb) {
-    return 0;
-  }
-#if LWIP_IPV4 && LWIP_IPV6
-  return _pcb->remote_ip.u_addr.ip4.addr;
-#else
-  return _pcb->remote_ip.addr;
-#endif
-}
-
-#if LWIP_IPV6
-ip6_addr_t AsyncClient::getRemoteAddress6() const {
-  if (_pcb && _pcb->remote_ip.type == IPADDR_TYPE_V6) {
-    return _pcb->remote_ip.u_addr.ip6;
-  } else {
-    ip6_addr_t nulladdr;
-    ip6_addr_set_zero(&nulladdr);
-    return nulladdr;
-  }
-}
-
-ip6_addr_t AsyncClient::getLocalAddress6() const {
-  if (_pcb && _pcb->local_ip.type == IPADDR_TYPE_V6) {
-    return _pcb->local_ip.u_addr.ip6;
-  } else {
-    ip6_addr_t nulladdr;
-    ip6_addr_set_zero(&nulladdr);
-    return nulladdr;
-  }
-}
-#ifdef ARDUINO
-#if ESP_IDF_VERSION_MAJOR < 5
-IPv6Address AsyncClient::remoteIP6() const {
-  return IPv6Address(getRemoteAddress6().addr);
-}
-
-IPv6Address AsyncClient::localIP6() const {
-  return IPv6Address(getLocalAddress6().addr);
-}
-#else
-IPAddress AsyncClient::remoteIP6() const {
-  if (!_pcb) {
-    return IPAddress(IPType::IPv6);
-  }
-  IPAddress ip;
-  ip.from_ip_addr_t(&(_pcb->remote_ip));
-  return ip;
-}
-
-IPAddress AsyncClient::localIP6() const {
-  if (!_pcb) {
-    return IPAddress(IPType::IPv6);
-  }
-  IPAddress ip;
-  ip.from_ip_addr_t(&(_pcb->local_ip));
-  return ip;
-}
-#endif
-#endif
-#endif
-
-uint16_t AsyncClient::getRemotePort() const {
-  if (!_pcb) {
-    return 0;
-  }
-  return _pcb->remote_port;
-}
-
-uint32_t AsyncClient::getLocalAddress() const {
-  if (!_pcb) {
-    return 0;
-  }
-#if LWIP_IPV4 && LWIP_IPV6
-  return _pcb->local_ip.u_addr.ip4.addr;
-#else
-  return _pcb->local_ip.addr;
-#endif
-}
-
-uint16_t AsyncClient::getLocalPort() const {
-  if (!_pcb) {
-    return 0;
-  }
-  return _pcb->local_port;
-}
-
-ip4_addr_t AsyncClient::getRemoteAddress4() const {
-#if LWIP_IPV4 && LWIP_IPV6
-  if (_pcb && _pcb->remote_ip.type == IPADDR_TYPE_V4) {
-    return _pcb->remote_ip.u_addr.ip4;
-  }
-#else
-  if (_pcb) {
-    return _pcb->remote_ip;
-  }
-#endif
-  else {
-    ip4_addr_t nulladdr;
-    ip4_addr_set_zero(&nulladdr);
-    return nulladdr;
-  }
-}
-
-ip4_addr_t AsyncClient::getLocalAddress4() const {
-#if LWIP_IPV4 && LWIP_IPV6
-  if (_pcb && _pcb->local_ip.type == IPADDR_TYPE_V4) {
-    return _pcb->local_ip.u_addr.ip4;
-  }
-#else
-  if (_pcb) {
-    return _pcb->local_ip;
-  }
-#endif
-  else {
-    ip4_addr_t nulladdr;
-    ip4_addr_set_zero(&nulladdr);
-    return nulladdr;
-  }
-}
-
-#ifdef ARDUINO
-IPAddress AsyncClient::remoteIP() const {
-#if ESP_IDF_VERSION_MAJOR < 5
-  return IPAddress(getRemoteAddress());
-#else
-  if (!_pcb) {
-    return IPAddress();
-  }
-  IPAddress ip;
-  ip.from_ip_addr_t(&(_pcb->remote_ip));
-  return ip;
-#endif
-}
-
-IPAddress AsyncClient::localIP() const {
-#if ESP_IDF_VERSION_MAJOR < 5
-  return IPAddress(getLocalAddress());
-#else
-  if (!_pcb) {
-    return IPAddress();
-  }
-  IPAddress ip;
-  ip.from_ip_addr_t(&(_pcb->local_ip));
-  return ip;
-#endif
-}
-#endif
-
-uint8_t AsyncClient::state() const {
-  if (!_pcb) {
-    return 0;
-  }
-  return _pcb->state;
-}
-
-bool AsyncClient::connected() const {
-  if (!_pcb) {
-    return false;
-  }
-  return _pcb->state == ESTABLISHED;
-}
-
-bool AsyncClient::connecting() const {
-  if (!_pcb) {
-    return false;
-  }
-  return _pcb->state > CLOSED && _pcb->state < ESTABLISHED;
-}
-
-bool AsyncClient::disconnecting() const {
-  if (!_pcb) {
-    return false;
-  }
-  return _pcb->state > ESTABLISHED && _pcb->state < TIME_WAIT;
-}
-
-bool AsyncClient::disconnected() const {
-  if (!_pcb) {
-    return true;
-  }
-  return _pcb->state == CLOSED || _pcb->state == TIME_WAIT;
-}
-
-bool AsyncClient::freeable() const {
-  if (!_pcb) {
-    return true;
-  }
-  return _pcb->state == CLOSED || _pcb->state > ESTABLISHED;
-}
-
-bool AsyncClient::canSend() const {
-  return space() > 0;
-}
-
-const char *AsyncClient::errorToString(int8_t error) {
-  switch (error) {
-    case ERR_OK:         return "OK";
-    case ERR_MEM:        return "Out of memory error";
-    case ERR_BUF:        return "Buffer error";
-    case ERR_TIMEOUT:    return "Timeout";
-    case ERR_RTE:        return "Routing problem";
-    case ERR_INPROGRESS: return "Operation in progress";
-    case ERR_VAL:        return "Illegal value";
-    case ERR_WOULDBLOCK: return "Operation would block";
-    case ERR_USE:        return "Address in use";
-    case ERR_ALREADY:    return "Already connected";
-    case ERR_CONN:       return "Not connected";
-    case ERR_IF:         return "Low-level netif error";
-    case ERR_ABRT:       return "Connection aborted";
-    case ERR_RST:        return "Connection reset";
-    case ERR_CLSD:       return "Connection closed";
-    case ERR_ARG:        return "Illegal argument";
-    case -55:            return "DNS failed";
-    default:             return "UNKNOWN";
-  }
-}
-
-const char *AsyncClient::stateToString() const {
-  switch (state()) {
-    case 0:  return "Closed";
-    case 1:  return "Listen";
-    case 2:  return "SYN Sent";
-    case 3:  return "SYN Received";
-    case 4:  return "Established";
-    case 5:  return "FIN Wait 1";
-    case 6:  return "FIN Wait 2";
-    case 7:  return "Close Wait";
-    case 8:  return "Closing";
-    case 9:  return "Last ACK";
-    case 10: return "Time Wait";
-    default: return "UNKNOWN";
-  }
-}
-
-/*
-  Async TCP Server
- */
-
-AsyncServer::AsyncServer(ip_addr_t addr, uint16_t port)
-  : _port(port), _addr(addr), _noDelay(false), _pcb(nullptr), _connect_cb(nullptr), _connect_cb_arg(nullptr) {}
-
-#ifdef ARDUINO
-AsyncServer::AsyncServer(IPAddress addr, uint16_t port) : _port(port), _noDelay(false), _pcb(0), _connect_cb(0), _connect_cb_arg(0) {
-#if ESP_IDF_VERSION_MAJOR < 5
-#if LWIP_IPV4 && LWIP_IPV6
-  _addr.type = IPADDR_TYPE_V4;
-  _addr.u_addr.ip4.addr = addr;
-#else
-  _addr.addr = addr;
-#endif
-#else
-  addr.to_ip_addr_t(&_addr);
-#endif
-}
-#if ESP_IDF_VERSION_MAJOR < 5 && __has_include(<IPv6Address.h>) && LWIP_IPV6
-AsyncServer::AsyncServer(IPv6Address addr, uint16_t port) : _port(port), _noDelay(false), _pcb(0), _connect_cb(0), _connect_cb_arg(0) {
-#if LWIP_IPV4 && LWIP_IPV6
-  _addr.type = IPADDR_TYPE_V6;
-#endif
-  auto ipaddr = static_cast<const uint32_t *>(addr);
-  _addr = IPADDR6_INIT(ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
-}
-#endif
-#endif
-
-AsyncServer::AsyncServer(uint16_t port) : _port(port), _noDelay(false), _pcb(0), _connect_cb(0), _connect_cb_arg(0) {
-#if LWIP_IPV4 && LWIP_IPV6
-  _addr.type = IPADDR_TYPE_ANY;
-  _addr.u_addr.ip4.addr = INADDR_ANY;
-#else
-  _addr.addr = INADDR_ANY;
-#endif
-}
-
-AsyncServer::~AsyncServer() {
-  end();
-}
-
-void AsyncServer::onClient(AcConnectHandler cb, void *arg) {
-  _connect_cb = cb;
-  _connect_cb_arg = arg;
-}
-
-void AsyncServer::begin() {
-  if (_pcb) {
-    return;
-  }
-
-  if (!_start_async_task()) {
-    async_tcp_log_e("failed to start task");
-    return;
-  }
-  int8_t err;
-  {
-    tcp_core_guard tcg;
-#if LWIP_IPV4 && LWIP_IPV6
-    _pcb = tcp_new_ip_type(_addr.type);
-#else
-    _pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
-#endif
-  }
-  if (!_pcb) {
-    async_tcp_log_e("_pcb == NULL");
-    return;
-  }
-
-  err = _tcp_bind(&_pcb, &_addr, _port);
-
-  if (err != ERR_OK) {
-    // pcb was closed by _tcp_bind
-    async_tcp_log_e("bind error: %d", err);
-    return;
-  }
-
-  static uint8_t backlog = 5;
-  _pcb = _tcp_listen_with_backlog(_pcb, backlog);
-  if (!_pcb) {
-    async_tcp_log_e("listen_pcb == NULL");
-    return;
-  }
-  tcp_core_guard tcg;
-  tcp_arg(_pcb, (void *)this);
-  tcp_accept(_pcb, &AsyncTCP_detail::tcp_accept);
-}
-
-void AsyncServer::end() {
-  if (_pcb) {
-    tcp_core_guard tcg;
-    tcp_arg(_pcb, NULL);
-    tcp_accept(_pcb, NULL);
-    if (tcp_close(_pcb) != ERR_OK) {
-      tcp_abort(_pcb);
-    }
-    _pcb = NULL;
-  }
-}
-
-// runs on LwIP thread
-int8_t AsyncTCP_detail::tcp_accept(void *arg, tcp_pcb *pcb, int8_t err) {
-  if (!pcb) {
-    async_tcp_log_e("_accept failed: pcb is NULL");
-    return ERR_ABRT;
-  }
-  auto server = reinterpret_cast<AsyncServer *>(arg);
-  if (server->_connect_cb) {
-    AsyncClient *c = new (std::nothrow) AsyncClient(pcb);
-    if (c && c->pcb()) {
-      c->setNoDelay(server->_noDelay);
-
-      lwip_tcp_event_packet_t *e = new (std::nothrow) lwip_tcp_event_packet_t{LWIP_TCP_ACCEPT, c};
-      if (e) {
-        e->accept.server = server;
-
-        queue_mutex_guard guard;
-        _prepend_async_event(e);
-        return ERR_OK;  // success
-      }
-
-      // Couldn't allocate accept event
-      // We can't let the client object call in to close, as we're on the LWIP thread; it could deadlock trying to RPC to itself
-      c->_pcb = nullptr;
-      tcp_abort(pcb);
-      async_tcp_log_e("_accept failed: couldn't accept client");
-      return ERR_ABRT;
-    }
-    if (c) {
-      // Couldn't complete setup
-      // pcb has already been aborted
-      delete c;
-      pcb = nullptr;
-      async_tcp_log_e("_accept failed: couldn't complete setup");
-      return ERR_ABRT;
-    }
-    async_tcp_log_e("_accept failed: couldn't allocate client");
-  } else {
-    async_tcp_log_e("_accept failed: no onConnect callback");
-  }
-  tcp_abort(pcb);
-  return ERR_OK;
-}
-
-int8_t AsyncServer::_accepted(AsyncClient *client) {
-  if (_connect_cb) {
-    _connect_cb(_connect_cb_arg, client);
-  }
-  return ERR_OK;
-}
-
-void AsyncServer::setNoDelay(bool nodelay) {
-  _noDelay = nodelay;
-}
-
-bool AsyncServer::getNoDelay() const {
-  return _noDelay;
-}
-
-uint8_t AsyncServer::status() const {
-  if (!_pcb) {
-    return 0;
-  }
-  return _pcb->state;
-}