Blame | Last modification | View Log | RSS feed
/*Asynchronous TCP library for Espressif MCUsCopyright (c) 2016 Hristo Gochkov. All rights reserved.This file is part of the esp8266 core for Arduino environment.This library is free software; you can redistribute it and/ormodify it under the terms of the GNU Lesser General PublicLicense as published by the Free Software Foundation; eitherversion 2.1 of the License, or (at your option) any later version.This library is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNULesser General Public License for more details.You should have received a copy of the GNU Lesser General PublicLicense along with this library; if not, write to the Free SoftwareFoundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA*//*Changes for July 2019The operator "new ..." was changed to "new (std::nothrow) ...", which willreturn NULL when the heap is out of memory. Without the change "soft WDT"was the result, starting with Arduino ESP8266 Core 2.5.0. (Note, RE:"softWDT" - the error reporting may improve with core 2.6.) With proir coreversions the library appears to work fine.ref: https://github.com/esp8266/Arduino/issues/6269#issue-464978944To support newer lwIP versions and buffer models. All references to 1460were replaced with TCP_MSS. If TCP_MSS is not defined (exp. 1.4v lwIP)1460 is assumed.The ESPAsyncTCP library should build for Arduino ESP8266 Core releases:2.3.0, 2.4.1, 2.4.2, 2.5.1, 2.5.2. It may still build with core versions2.4.0 and 2.5.0. I did not do any regression testing with these, sincethey had too many issues and were quickly superseded.lwIP tcp_err() callback often resulted in crashes. The problem was atcp_err() would come in, while processing a send or receive in theforground. The tcp_err() callback would be passed down to a client'sregistered disconnect CB. A common problem with SyncClient and othermodules as well as some client code was: the freeing of ESPAsyncTCPAsyncClient objects via disconnect CB handlers while the library waswaiting for an operstion to finished. Attempts to access bad pointersfollowed. For SyncClient this commonly occured during a call to delay().On return to SyncClient _client was invalid. Also the problem described byissue #94 also surfacedUse of tcp_abort() required some very special handling and was verychallenging to make work without changing client API. ERR_ABRT can only beused once on a return to lwIP for a given connection and since theAsyncClient structure was sometimes deleted before returning to lwIP, thestate tracking became tricky. While ugly, a global variable for thisseemed to work; however, I abanded it when I saw a possiblereentrancy/concurrency issue. After several approaches I settled theproblem by creating "class ACErrorTracker" to manage the issue.Additional Async Client considerations:The client sketch must always test if the connection is still up at loop()entry and after the return of any function call, that may have done adelay() or yield() or any ESPAsyncTCP library family call. For example,the connection could be lost during a call to _client->write(...). Clientsketches that delete _client as part of their onDisconnect() handler mustbe very careful as _client will become invalid after calls to delay(),yield(), etc.*/#include "Arduino.h"#include "ESPAsyncTCP.h"extern "C"{#include "lwip/opt.h"#include "lwip/tcp.h"#include "lwip/inet.h"#include "lwip/dns.h"#include "lwip/init.h"}#include <tcp_axtls.h>/*Async Client Error Return Tracker*/// Assumption: callbacks are never called with err == ERR_ABRT; however,// they may return ERR_ABRT.ACErrorTracker::ACErrorTracker(AsyncClient *c):_client(c), _close_error(ERR_OK), _errored(EE_OK)#ifdef DEBUG_MORE, _error_event_cb(NULL), _error_event_cb_arg(NULL)#endif{}#ifdef DEBUG_MORE/*** This is not necessary, but a start at gathering some statistics on* errored out connections. Used from AsyncServer.*/void ACErrorTracker::onErrorEvent(AsNotifyHandler cb, void *arg) {_error_event_cb = cb;_error_event_cb_arg = arg;}#endifvoid ACErrorTracker::setCloseError(err_t e) {if (e != ERR_OK)ASYNC_TCP_DEBUG("setCloseError() to: %s(%ld)\n", _client->errorToString(e), e);if(_errored == EE_OK)_close_error = e;}/*** Called mainly by callback routines, called when err is not ERR_OK.* This prevents the possiblity of aborting an already errored out* connection.*/void ACErrorTracker::setErrored(size_t errorEvent){if(EE_OK == _errored)_errored = errorEvent;#ifdef DEBUG_MOREif (_error_event_cb)_error_event_cb(_error_event_cb_arg, errorEvent);#endif}/*** Used by callback functions only. Used for proper ERR_ABRT return value* reporting. ERR_ABRT is only reported/returned once; thereafter ERR_OK* is always returned.*/err_t ACErrorTracker::getCallbackCloseError(void){if (EE_OK != _errored)return ERR_OK;if (ERR_ABRT == _close_error)setErrored(EE_ABORTED);return _close_error;}/*Async TCP Client*/#if DEBUG_ESP_ASYNC_TCPstatic size_t _connectionCount=0;#endif#if ASYNC_TCP_SSL_ENABLEDAsyncClient::AsyncClient(tcp_pcb* pcb, SSL_CTX * ssl_ctx):#elseAsyncClient::AsyncClient(tcp_pcb* pcb):#endif_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), _pcb_busy(false)#if ASYNC_TCP_SSL_ENABLED, _pcb_secure(false), _handshake_done(true)#endif, _pcb_sent_at(0), _close_pcb(false), _ack_pcb(true), _tx_unacked_len(0), _tx_acked_len(0), _rx_ack_len(0), _rx_last_packet(0), _rx_since_timeout(0), _ack_timeout(ASYNC_MAX_ACK_TIME), _connect_port(0), _recv_pbuf_flags(0), _errorTracker(NULL), prev(NULL), next(NULL){_pcb = pcb;if(_pcb){_rx_last_packet = millis();tcp_setprio(_pcb, TCP_PRIO_MIN);tcp_arg(_pcb, this);tcp_recv(_pcb, &_s_recv);tcp_sent(_pcb, &_s_sent);tcp_err(_pcb, &_s_error);tcp_poll(_pcb, &_s_poll, 1);#if ASYNC_TCP_SSL_ENABLEDif(ssl_ctx){if(tcp_ssl_new_server(_pcb, ssl_ctx) < 0){_close();return;}tcp_ssl_arg(_pcb, this);tcp_ssl_data(_pcb, &_s_data);tcp_ssl_handshake(_pcb, &_s_handshake);tcp_ssl_err(_pcb, &_s_ssl_error);_pcb_secure = true;_handshake_done = false;}#endif}_errorTracker = std::make_shared<ACErrorTracker>(this);#if DEBUG_ESP_ASYNC_TCP_errorTracker->setConnectionId(++_connectionCount);#endif}AsyncClient::~AsyncClient(){if(_pcb)_close();_errorTracker->clearClient();}inline void clearTcpCallbacks(tcp_pcb* pcb){tcp_arg(pcb, NULL);tcp_sent(pcb, NULL);tcp_recv(pcb, NULL);tcp_err(pcb, NULL);tcp_poll(pcb, NULL, 0);}#if ASYNC_TCP_SSL_ENABLEDbool AsyncClient::connect(IPAddress ip, uint16_t port, bool secure){#elsebool AsyncClient::connect(IPAddress ip, uint16_t port){#endifif (_pcb) //already connectedreturn false;IPAddress addr;addr = ip;#if LWIP_VERSION_MAJOR == 1netif* interface = ip_route(&addr);if (!interface){ //no route to hostreturn false;}#endiftcp_pcb* pcb = tcp_new();if (!pcb){ //could not allocate pcbreturn false;}tcp_setprio(pcb, TCP_PRIO_MIN);#if ASYNC_TCP_SSL_ENABLED_pcb_secure = secure;_handshake_done = !secure;#endiftcp_arg(pcb, this);tcp_err(pcb, &_s_error);size_t err = tcp_connect(pcb, addr, port,(tcp_connected_fn)&_s_connected);return (ERR_OK == err);}#if ASYNC_TCP_SSL_ENABLEDbool AsyncClient::connect(const char* host, uint16_t port, bool secure){#elsebool AsyncClient::connect(const char* host, uint16_t port){#endifIPAddress addr;err_t err = dns_gethostbyname(host, addr, (dns_found_callback)&_s_dns_found, this);if(err == ERR_OK) {#if ASYNC_TCP_SSL_ENABLEDreturn connect(addr, port, secure);#elsereturn connect(addr, port);#endif} else if(err == ERR_INPROGRESS) {#if ASYNC_TCP_SSL_ENABLED_pcb_secure = secure;_handshake_done = !secure;#endif_connect_port = port;return true;}return false;}AsyncClient& AsyncClient::operator=(const AsyncClient& other){if (_pcb) {ASYNC_TCP_DEBUG("operator=[%u]: Abandoned _pcb(0x%" PRIXPTR ") forced close.\n", getConnectionId(), uintptr_t(_pcb));_close();}_errorTracker = other._errorTracker;// I am confused when "other._pcb" falls out of scope the destructor will// close it? TODO: Look to see where this is used and how it might work._pcb = other._pcb;if (_pcb) {_rx_last_packet = millis();tcp_setprio(_pcb, TCP_PRIO_MIN);tcp_arg(_pcb, this);tcp_recv(_pcb, &_s_recv);tcp_sent(_pcb, &_s_sent);tcp_err(_pcb, &_s_error);tcp_poll(_pcb, &_s_poll, 1);#if ASYNC_TCP_SSL_ENABLEDif(tcp_ssl_has(_pcb)){_pcb_secure = true;_handshake_done = false;tcp_ssl_arg(_pcb, this);tcp_ssl_data(_pcb, &_s_data);tcp_ssl_handshake(_pcb, &_s_handshake);tcp_ssl_err(_pcb, &_s_ssl_error);} else {_pcb_secure = false;_handshake_done = true;}#endif}return *this;}bool AsyncClient::operator==(const AsyncClient &other) {return (_pcb != NULL && other._pcb != NULL && (IPAddress(_pcb->remote_ip) == IPAddress(other._pcb->remote_ip)) && (_pcb->remote_port == other._pcb->remote_port));}void AsyncClient::abort(){// Notes:// 1) _pcb is set to NULL, so we cannot call tcp_abort() more than once.// 2) setCloseError(ERR_ABRT) is only done here!// 3) Using this abort() function guarantees only one tcp_abort() call is// made and only one CB returns with ERR_ABORT.// 4) After abort() is called from _close(), no callbacks with an err// parameter will be called. eg. _recv(), _error(), _connected().// _close() will reset there CB handlers before calling.// 5) A callback to _error(), will set _pcb to NULL, thus avoiding the// of a 2nd call to tcp_abort().// 6) Callbacks to _recv() or _connected() with err set, will result in _pcb// set to NULL. Thus, preventing possible calls later to tcp_abort().if(_pcb) {tcp_abort(_pcb);_pcb = NULL;setCloseError(ERR_ABRT);}return;}void AsyncClient::close(bool now){if(_pcb)tcp_recved(_pcb, _rx_ack_len);if(now) {ASYNC_TCP_DEBUG("close[%u]: AsyncClient 0x%" PRIXPTR "\n", getConnectionId(), uintptr_t(this));_close();} else {_close_pcb = true;}}void AsyncClient::stop() {close(false);}bool AsyncClient::free(){if(!_pcb)return true;if(_pcb->state == 0 || _pcb->state > 4)return true;return false;}size_t AsyncClient::write(const char* data) {if(data == NULL)return 0;return write(data, strlen(data));}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;}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;#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure){int sent = tcp_ssl_write(_pcb, (uint8_t*)data, size);if(sent >= 0){_tx_unacked_len += sent;return sent;}_close();return 0;}#endifsize_t will_send = (room < size) ? room : size;err_t err = tcp_write(_pcb, data, will_send, apiflags);if(err != ERR_OK) {ASYNC_TCP_DEBUG("_add[%u]: tcp_write() returned err: %s(%ld)\n", getConnectionId(), errorToString(err), err);return 0;}_tx_unacked_len += will_send;return will_send;}bool AsyncClient::send(){#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure)return true;#endiferr_t err = tcp_output(_pcb);if(err == ERR_OK){_pcb_busy = true;_pcb_sent_at = millis();return true;}ASYNC_TCP_DEBUG("send[%u]: tcp_output() returned err: %s(%ld)", getConnectionId(), errorToString(err), err);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;}// Private Callbacksvoid AsyncClient::_connected(std::shared_ptr<ACErrorTracker>& errorTracker, void* pcb, err_t err){//(void)err; // LWIP v1.4 appears to always call with ERR_OK// Documentation for 2.1.0 also says:// "err - An unused error code, always ERR_OK currently ;-)"// https://www.nongnu.org/lwip/2_1_x/tcp_8h.html#a939867106bd492caf2d85852fb7f6ae8// Based on that wording and emoji lets just handle it now.// After all, the API does allow for an err != ERR_OK.if(NULL == pcb || ERR_OK != err) {ASYNC_TCP_DEBUG("_connected[%u]:%s err: %s(%ld)\n", errorTracker->getConnectionId(), ((NULL == pcb) ? " NULL == pcb!," : ""), errorToString(err), err);errorTracker->setCloseError(err);errorTracker->setErrored(EE_CONNECTED_CB);_pcb = reinterpret_cast<tcp_pcb*>(pcb);if (_pcb)clearTcpCallbacks(_pcb);_pcb = NULL;_error(err);return;}_pcb = reinterpret_cast<tcp_pcb*>(pcb);if(_pcb){_pcb_busy = false;_rx_last_packet = millis();tcp_setprio(_pcb, TCP_PRIO_MIN);tcp_recv(_pcb, &_s_recv);tcp_sent(_pcb, &_s_sent);tcp_poll(_pcb, &_s_poll, 1);#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure){if(tcp_ssl_new_client(_pcb) < 0){_close();return;}tcp_ssl_arg(_pcb, this);tcp_ssl_data(_pcb, &_s_data);tcp_ssl_handshake(_pcb, &_s_handshake);tcp_ssl_err(_pcb, &_s_ssl_error);}}if(!_pcb_secure && _connect_cb)#else}if(_connect_cb)#endif_connect_cb(_connect_cb_arg, this);return;}void AsyncClient::_close(){if(_pcb) {#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure){tcp_ssl_free(_pcb);}#endifclearTcpCallbacks(_pcb);err_t err = tcp_close(_pcb);if(ERR_OK == err) {setCloseError(err);ASYNC_TCP_DEBUG("_close[%u]: AsyncClient 0x%" PRIXPTR "\n", getConnectionId(), uintptr_t(this));} else {ASYNC_TCP_DEBUG("_close[%u]: abort() called for AsyncClient 0x%" PRIXPTR "\n", getConnectionId(), uintptr_t(this));abort();}_pcb = NULL;if(_discard_cb)_discard_cb(_discard_cb_arg, this);}return;}void AsyncClient::_error(err_t err) {ASYNC_TCP_DEBUG("_error[%u]:%s err: %s(%ld)\n", getConnectionId(), ((NULL == _pcb) ? " NULL == _pcb!," : ""), errorToString(err), err);if(_pcb){#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure){tcp_ssl_free(_pcb);}#endif// At this callback _pcb is possible already freed. Thus, no calls are// made to set to NULL other callbacks._pcb = NULL;}if(_error_cb)_error_cb(_error_cb_arg, this, err);if(_discard_cb)_discard_cb(_discard_cb_arg, this);}#if ASYNC_TCP_SSL_ENABLEDvoid AsyncClient::_ssl_error(int8_t err){if(_error_cb)_error_cb(_error_cb_arg, this, err+64);}#endifvoid AsyncClient::_sent(std::shared_ptr<ACErrorTracker>& errorTracker, tcp_pcb* pcb, uint16_t len) {(void)pcb;#if ASYNC_TCP_SSL_ENABLEDif (_pcb_secure && !_handshake_done)return;#endif_rx_last_packet = millis();_tx_unacked_len -= len;_tx_acked_len += len;ASYNC_TCP_DEBUG("_sent[%u]: %4u, unacked=%4u, acked=%4u, space=%4u\n", errorTracker->getConnectionId(), len, _tx_unacked_len, _tx_acked_len, space());if(_tx_unacked_len == 0){_pcb_busy = false;errorTracker->setCloseError(ERR_OK);if(_sent_cb) {_sent_cb(_sent_cb_arg, this, _tx_acked_len, (millis() - _pcb_sent_at));if(!errorTracker->hasClient())return;}_tx_acked_len = 0;}return;}void AsyncClient::_recv(std::shared_ptr<ACErrorTracker>& errorTracker, tcp_pcb* pcb, pbuf* pb, err_t err) {// While lwIP v1.4 appears to always call with ERR_OK, 2.x lwIP may present// a non-ERR_OK value.// https://www.nongnu.org/lwip/2_1_x/tcp_8h.html#a780cfac08b02c66948ab94ea974202e8if(NULL == pcb || ERR_OK != err){ASYNC_TCP_DEBUG("_recv[%u]:%s err: %s(%ld)\n", errorTracker->getConnectionId(), ((NULL == pcb) ? " NULL == pcb!," : ""), errorToString(err), err);ASYNC_TCP_ASSERT(ERR_ABRT != err);errorTracker->setCloseError(err);errorTracker->setErrored(EE_RECV_CB);_pcb = pcb;if(_pcb)clearTcpCallbacks(_pcb);_pcb = NULL;// I think we are safe from being called from an interrupt context.// Best Hint that calling _error() is safe:// https://www.nongnu.org/lwip/2_1_x/group__lwip__nosys.html// "Feed incoming packets to netif->input(pbuf, netif) function from// mainloop, not from interrupt context. You can allocate a Packet buffers// (PBUF) in interrupt context and put them into a queue which is processed// from mainloop."// And the description of "Mainloop Mode" option 2:// https://www.nongnu.org/lwip/2_1_x/pitfalls.html// "2) Run lwIP in a mainloop. ... lwIP is ONLY called from mainloop// callstacks here. The ethernet IRQ has to put received telegrams into a// queue which is polled in the mainloop. Ensure lwIP is NEVER called from// an interrupt, ...!"// Based on these comments I am thinking tcp_recv_fn() is called// from somebody's mainloop(), which could only have been reached from a// delay like function or the Arduino sketch loop() function has returned.// What I don't want is for the client sketch to delete the AsyncClient// object via _error() while it is in the middle of using it. However,// the client sketch must always test that the connection is still up// at loop() entry and after the return of any function call, that may// have done a delay() or yield()._error(err);return;}if(pb == NULL){ASYNC_TCP_DEBUG("_recv[%u]: pb == NULL! Closing... %ld\n", errorTracker->getConnectionId(), err);_close();return;}_rx_last_packet = millis();errorTracker->setCloseError(ERR_OK);#if ASYNC_TCP_SSL_ENABLEDif(_pcb_secure){ASYNC_TCP_DEBUG("_recv[%u]: %d\n", getConnectionId(), pb->tot_len);int read_bytes = tcp_ssl_read(pcb, pb);if(read_bytes < 0){if (read_bytes != SSL_CLOSE_NOTIFY) {ASYNC_TCP_DEBUG("_recv[%u] err: %d\n", getConnectionId(), read_bytes);_close();}}return;}#endifwhile(pb != NULL){// IF this callback function returns ERR_OK or ERR_ABRT// then it is assummed we freed the pbufs.// https://www.nongnu.org/lwip/2_1_x/group__tcp__raw.html#ga8afd0b316a87a5eeff4726dc95006ed0if(!errorTracker->hasClient()){while(pb != NULL){pbuf *b = pb;pb = b->next;b->next = NULL;pbuf_free(b);}return;}//we should not ack before we assimilate the data_ack_pcb = true;pbuf *b = pb;pb = b->next;b->next = NULL;ASYNC_TCP_DEBUG("_recv[%u]: %d%s\n", errorTracker->getConnectionId(), b->len, (b->flags&PBUF_FLAG_PUSH)?", PBUF_FLAG_PUSH":"");if(_pb_cb){_pb_cb(_pb_cb_arg, this, b);} else {if(_recv_cb){_recv_pbuf_flags = b->flags;_recv_cb(_recv_cb_arg, this, b->payload, b->len);}if(errorTracker->hasClient()){if(!_ack_pcb)_rx_ack_len += b->len;elsetcp_recved(pcb, b->len);}pbuf_free(b);}}return;}void AsyncClient::_poll(std::shared_ptr<ACErrorTracker>& errorTracker, tcp_pcb* pcb){(void)pcb;errorTracker->setCloseError(ERR_OK);// Close requestedif(_close_pcb){ASYNC_TCP_DEBUG("_poll[%u]: Process _close_pcb.\n", errorTracker->getConnectionId() );_close_pcb = false;_close();return;}uint32_t now = millis();// ACK Timeoutif(_pcb_busy && _ack_timeout && (now - _pcb_sent_at) >= _ack_timeout){_pcb_busy = false;if(_timeout_cb)_timeout_cb(_timeout_cb_arg, this, (now - _pcb_sent_at));return;}// RX Timeoutif(_rx_since_timeout && (now - _rx_last_packet) >= (_rx_since_timeout * 1000)){ASYNC_TCP_DEBUG("_poll[%u]: RX Timeout.\n", errorTracker->getConnectionId() );_close();return;}#if ASYNC_TCP_SSL_ENABLED// SSL Handshake Timeoutif(_pcb_secure && !_handshake_done && (now - _rx_last_packet) >= 2000){ASYNC_TCP_DEBUG("_poll[%u]: SSL Handshake Timeout.\n", errorTracker->getConnectionId() );_close();return;}#endif// Everything is fineif(_poll_cb)_poll_cb(_poll_cb_arg, this);return;}#if LWIP_VERSION_MAJOR == 1void AsyncClient::_dns_found(struct ip_addr *ipaddr){#elsevoid AsyncClient::_dns_found(const ip_addr *ipaddr){#endifif(ipaddr){#if ASYNC_TCP_SSL_ENABLEDconnect(ipaddr, _connect_port, _pcb_secure);#elseconnect(ipaddr, _connect_port);#endif} else {if(_error_cb)_error_cb(_error_cb_arg, this, -55);if(_discard_cb)_discard_cb(_discard_cb_arg, this);}}// lwIP Callbacks#if LWIP_VERSION_MAJOR == 1void AsyncClient::_s_dns_found(const char *name, ip_addr_t *ipaddr, void *arg){#elsevoid AsyncClient::_s_dns_found(const char *name, const ip_addr *ipaddr, void *arg){#endif(void)name;reinterpret_cast<AsyncClient*>(arg)->_dns_found(ipaddr);}err_t AsyncClient::_s_poll(void *arg, struct tcp_pcb *tpcb) {AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);std::shared_ptr<ACErrorTracker>errorTracker = c->getACErrorTracker();c->_poll(errorTracker, tpcb);return errorTracker->getCallbackCloseError();}err_t AsyncClient::_s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, err_t err) {AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);auto errorTracker = c->getACErrorTracker();c->_recv(errorTracker, tpcb, pb, err);return errorTracker->getCallbackCloseError();}void AsyncClient::_s_error(void *arg, err_t err) {AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);auto errorTracker = c->getACErrorTracker();errorTracker->setCloseError(err);errorTracker->setErrored(EE_ERROR_CB);c->_error(err);}err_t AsyncClient::_s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len) {AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);auto errorTracker = c->getACErrorTracker();c->_sent(errorTracker, tpcb, len);return errorTracker->getCallbackCloseError();}err_t AsyncClient::_s_connected(void* arg, void* tpcb, err_t err){AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);auto errorTracker = c->getACErrorTracker();c->_connected(errorTracker, tpcb, err);return errorTracker->getCallbackCloseError();}#if ASYNC_TCP_SSL_ENABLEDvoid AsyncClient::_s_data(void *arg, struct tcp_pcb *tcp, uint8_t * data, size_t len){(void)tcp;AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);if(c->_recv_cb)c->_recv_cb(c->_recv_cb_arg, c, data, len);}void AsyncClient::_s_handshake(void *arg, struct tcp_pcb *tcp, SSL *ssl){(void)tcp;(void)ssl;AsyncClient *c = reinterpret_cast<AsyncClient*>(arg);c->_handshake_done = true;if(c->_connect_cb)c->_connect_cb(c->_connect_cb_arg, c);}void AsyncClient::_s_ssl_error(void *arg, struct tcp_pcb *tcp, int8_t err){(void)tcp;#ifdef DEBUG_ESP_ASYNC_TCPAsyncClient *c = reinterpret_cast<AsyncClient*>(arg);auto errorTracker = c->getACErrorTracker();ASYNC_TCP_DEBUG("_ssl_error[%u] err = %d\n", errorTracker->getConnectionId(), err);#endifreinterpret_cast<AsyncClient*>(arg)->_ssl_error(err);}#endif// OperatorsAsyncClient & AsyncClient::operator+=(const AsyncClient &other) {if(next == NULL){next = (AsyncClient*)(&other);next->prev = this;} else {AsyncClient *c = next;while(c->next != NULL) c = c->next;c->next =(AsyncClient*)(&other);c->next->prev = c;}return *this;}void AsyncClient::setRxTimeout(uint32_t timeout){_rx_since_timeout = timeout;}uint32_t AsyncClient::getRxTimeout(){return _rx_since_timeout;}uint32_t AsyncClient::getAckTimeout(){return _ack_timeout;}void AsyncClient::setAckTimeout(uint32_t timeout){_ack_timeout = timeout;}void AsyncClient::setNoDelay(bool nodelay){if(!_pcb)return;if(nodelay)tcp_nagle_disable(_pcb);elsetcp_nagle_enable(_pcb);}bool AsyncClient::getNoDelay(){if(!_pcb)return false;return tcp_nagle_disabled(_pcb);}uint16_t AsyncClient::getMss(){if(_pcb)return tcp_mss(_pcb);return 0;}uint16_t AsyncClient::getRemotePort() {if(!_pcb)return 0;return _pcb->remote_port;}uint16_t AsyncClient::getLocalPort() {if(!_pcb)return 0;return _pcb->local_port;}IPAddress AsyncClient::remoteIP() {if(!_pcb)return IPAddress(0);return _pcb->remote_ip;}uint16_t AsyncClient::remotePort() {return getRemotePort();}IPAddress AsyncClient::localIP() {if(!_pcb)return IPAddress(0);return _pcb->local_ip;}uint16_t AsyncClient::localPort() {return getLocalPort();}#if ASYNC_TCP_SSL_ENABLEDSSL * AsyncClient::getSSL(){if(_pcb && _pcb_secure){return tcp_ssl_get_ssl(_pcb);}return NULL;}#endifuint8_t AsyncClient::state() {if(!_pcb)return 0;return _pcb->state;}bool AsyncClient::connected(){if (!_pcb)return false;#if ASYNC_TCP_SSL_ENABLEDreturn _pcb->state == 4 && _handshake_done;#elsereturn _pcb->state == 4;#endif}bool AsyncClient::connecting(){if (!_pcb)return false;return _pcb->state > 0 && _pcb->state < 4;}bool AsyncClient::disconnecting(){if (!_pcb)return false;return _pcb->state > 4 && _pcb->state < 10;}bool AsyncClient::disconnected(){if (!_pcb)return true;return _pcb->state == 0 || _pcb->state == 10;}bool AsyncClient::freeable(){if (!_pcb)return true;return _pcb->state == 0 || _pcb->state > 4;}bool AsyncClient::canSend(){return !_pcb_busy && (space() > 0);}// Callback Settersvoid 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;}size_t AsyncClient::space(){#if ASYNC_TCP_SSL_ENABLEDif((_pcb != NULL) && (_pcb->state == 4) && _handshake_done){uint16_t s = tcp_sndbuf(_pcb);if(_pcb_secure){#ifdef AXTLS_2_0_0_SNDBUFreturn tcp_ssl_sndbuf(_pcb);#elseif(s >= 128) //safe approachreturn s - 128;return 0;#endif}return s;}#else // ASYNC_TCP_SSL_ENABLEDif((_pcb != NULL) && (_pcb->state == 4)){return tcp_sndbuf(_pcb);}#endif // ASYNC_TCP_SSL_ENABLEDreturn 0;}void AsyncClient::ackPacket(struct pbuf * pb){if(!pb){return;}tcp_recved(_pcb, pb->len);pbuf_free(pb);}const char * AsyncClient::errorToString(err_t error) {switch (error) {case ERR_OK: return "No error, everything 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_ABRT: return "Connection aborted";case ERR_RST: return "Connection reset";case ERR_CLSD: return "Connection closed";case ERR_CONN: return "Not connected";case ERR_ARG: return "Illegal argument";case ERR_USE: return "Address in use";#if defined(LWIP_VERSION_MAJOR) && (LWIP_VERSION_MAJOR > 1)case ERR_ALREADY: return "Already connectioning";#endifcase ERR_IF: return "Low-level netif error";case ERR_ISCONN: return "Connection already established";case -55: return "DNS failed";default: return "Unknown error";}}const char * AsyncClient::stateToString(){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*/struct pending_pcb {tcp_pcb* pcb;pbuf *pb;struct pending_pcb * next;};AsyncServer::AsyncServer(IPAddress addr, uint16_t port): _port(port), _addr(addr), _noDelay(false), _pcb(0), _connect_cb(0), _connect_cb_arg(0)#if ASYNC_TCP_SSL_ENABLED, _pending(NULL), _ssl_ctx(NULL), _file_cb(0), _file_cb_arg(0)#endif{#ifdef DEBUG_MOREfor (size_t i=0; i<EE_MAX; ++i)_event_count[i] = 0;#endif}AsyncServer::AsyncServer(uint16_t port): _port(port), _addr(IP_ANY_TYPE), _noDelay(false), _pcb(0), _connect_cb(0), _connect_cb_arg(0)#if ASYNC_TCP_SSL_ENABLED, _pending(NULL), _ssl_ctx(NULL), _file_cb(0), _file_cb_arg(0)#endif{#ifdef DEBUG_MOREfor (size_t i=0; i<EE_MAX; ++i)_event_count[i] = 0;#endif}AsyncServer::~AsyncServer(){end();}void AsyncServer::onClient(AcConnectHandler cb, void* arg){_connect_cb = cb;_connect_cb_arg = arg;}#if ASYNC_TCP_SSL_ENABLEDvoid AsyncServer::onSslFileRequest(AcSSlFileHandler cb, void* arg){_file_cb = cb;_file_cb_arg = arg;}#endifvoid AsyncServer::begin(){if(_pcb)return;int8_t err;tcp_pcb* pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);if (!pcb){return;}tcp_setprio(pcb, TCP_PRIO_MIN);IPAddress local_addr;local_addr = _addr;err = tcp_bind(pcb, local_addr, _port);// Failures are ERR_ISCONN or ERR_USEif (err != ERR_OK) {tcp_close(pcb);return;}tcp_pcb* listen_pcb = tcp_listen(pcb);if (!listen_pcb) {tcp_close(pcb);return;}_pcb = listen_pcb;tcp_arg(_pcb, (void*) this);tcp_accept(_pcb, &_s_accept);}#if ASYNC_TCP_SSL_ENABLEDvoid AsyncServer::beginSecure(const char *cert, const char *key, const char *password){if(_ssl_ctx){return;}tcp_ssl_file(_s_cert, this);_ssl_ctx = tcp_ssl_new_server_ctx(cert, key, password);if(_ssl_ctx){begin();}}#endifvoid AsyncServer::end(){if(_pcb){//cleanup all connections?tcp_arg(_pcb, NULL);tcp_accept(_pcb, NULL);if(tcp_close(_pcb) != ERR_OK){tcp_abort(_pcb);}_pcb = NULL;}#if ASYNC_TCP_SSL_ENABLEDif(_ssl_ctx){ssl_ctx_free(_ssl_ctx);_ssl_ctx = NULL;if(_pending){struct pending_pcb * p;while(_pending){p = _pending;_pending = _pending->next;if(p->pb){pbuf_free(p->pb);}free(p);}}}#endif}void AsyncServer::setNoDelay(bool nodelay){_noDelay = nodelay;}bool AsyncServer::getNoDelay(){return _noDelay;}uint8_t AsyncServer::status(){if (!_pcb)return 0;return _pcb->state;}err_t AsyncServer::_accept(tcp_pcb* pcb, err_t err){//http://savannah.nongnu.org/bugs/?43739if(NULL == pcb || ERR_OK != err){// https://www.nongnu.org/lwip/2_1_x/tcp_8h.html#a00517abce6856d6c82f0efebdafb734d// An error code if there has been an error accepting. Only return ERR_ABRT// if you have called tcp_abort from within the callback function!// eg. 2.1.0 could call with error on failure to allocate pcb.ASYNC_TCP_DEBUG("_accept:%s err: %ld\n", ((NULL == pcb) ? " NULL == pcb!," : ""), err);ASYNC_TCP_ASSERT(ERR_ABRT != err);#ifdef DEBUG_MOREincEventCount(EE_ACCEPT_CB);#endifreturn ERR_OK;}if(_connect_cb){#if ASYNC_TCP_SSL_ENABLEDif (_noDelay || _ssl_ctx)#elseif (_noDelay)#endiftcp_nagle_disable(pcb);elsetcp_nagle_enable(pcb);#if ASYNC_TCP_SSL_ENABLEDif(_ssl_ctx){if(tcp_ssl_has_client() || _pending){struct pending_pcb * new_item = (struct pending_pcb*)malloc(sizeof(struct pending_pcb));if(!new_item){ASYNC_TCP_DEBUG("### malloc new pending failed!\n");if(tcp_close(pcb) != ERR_OK){tcp_abort(pcb);return ERR_ABRT;}return ERR_OK;}//1 ASYNC_TCP_DEBUG("### put to wait: %d\n", _clients_waiting);new_item->pcb = pcb;new_item->pb = NULL;new_item->next = NULL;tcp_setprio(_pcb, TCP_PRIO_MIN);tcp_arg(pcb, this);tcp_poll(pcb, &_s_poll, 1);tcp_recv(pcb, &_s_recv);if(_pending == NULL){_pending = new_item;} else {struct pending_pcb * p = _pending;while(p->next != NULL)p = p->next;p->next = new_item;}} else {AsyncClient *c = new (std::nothrow) AsyncClient(pcb, _ssl_ctx);if(c){ASYNC_TCP_DEBUG("_accept[%u]: SSL connected\n", c->getConnectionId());c->onConnect([this](void * arg, AsyncClient *c){(void)arg;_connect_cb(_connect_cb_arg, c);}, this);} else {ASYNC_TCP_DEBUG("_accept[_ssl_ctx]: new AsyncClient() failed, connection aborted!\n");if(tcp_close(pcb) != ERR_OK){tcp_abort(pcb);return ERR_ABRT;}}}return ERR_OK;} else {AsyncClient *c = new (std::nothrow) AsyncClient(pcb, NULL);#elseAsyncClient *c = new (std::nothrow) AsyncClient(pcb);#endifif(c){auto errorTracker = c->getACErrorTracker();#ifdef DEBUG_MOREerrorTracker->onErrorEvent([](void *obj, size_t ee){ ((AsyncServer*)(obj))->incEventCount(ee); },this);#endifASYNC_TCP_DEBUG("_accept[%u]: connected\n", errorTracker->getConnectionId());_connect_cb(_connect_cb_arg, c);return errorTracker->getCallbackCloseError();} else {ASYNC_TCP_DEBUG("_accept: new AsyncClient() failed, connection aborted!\n");if(tcp_close(pcb) != ERR_OK){tcp_abort(pcb);return ERR_ABRT;}}#if ASYNC_TCP_SSL_ENABLED}#endif}if(tcp_close(pcb) != ERR_OK){tcp_abort(pcb);return ERR_ABRT;}return ERR_OK;}err_t AsyncServer::_s_accept(void *arg, tcp_pcb* pcb, err_t err){return reinterpret_cast<AsyncServer*>(arg)->_accept(pcb, err);}#if ASYNC_TCP_SSL_ENABLEDerr_t AsyncServer::_poll(tcp_pcb* pcb){err_t err = ERR_OK;if(!tcp_ssl_has_client() && _pending){struct pending_pcb * p = _pending;if(p->pcb == pcb){_pending = _pending->next;} else {while(p->next && p->next->pcb != pcb) p = p->next;if(!p->next) return 0;struct pending_pcb * b = p->next;p->next = b->next;p = b;}//1 ASYNC_TCP_DEBUG("### remove from wait: %d\n", _clients_waiting);AsyncClient *c = new (std::nothrow) AsyncClient(pcb, _ssl_ctx);if(c){c->onConnect([this](void * arg, AsyncClient *c){(void)arg;_connect_cb(_connect_cb_arg, c);}, this);if(p->pb) {auto errorTracker = c->getACErrorTracker();c->_recv(errorTracker, pcb, p->pb, 0);err = errorTracker->getCallbackCloseError();}}// Should there be error handling for when "new AsynClient" fails??free(p);}return err;}err_t AsyncServer::_recv(struct tcp_pcb *pcb, struct pbuf *pb, err_t err){(void)err;if(!_pending)return ERR_OK;struct pending_pcb * p;if(!pb){//1 ASYNC_TCP_DEBUG("### close from wait: %d\n", _clients_waiting);p = _pending;if(p->pcb == pcb){_pending = _pending->next;} else {while(p->next && p->next->pcb != pcb) p = p->next;if(!p->next) return 0;struct pending_pcb * b = p->next;p->next = b->next;p = b;}if(p->pb){pbuf_free(p->pb);}free(p);size_t err = tcp_close(pcb);if (err != ERR_OK) {tcp_abort(pcb);return ERR_ABRT;}} else {//1 ASYNC_TCP_DEBUG("### wait _recv: %u %d\n", pb->tot_len, _clients_waiting);p = _pending;while(p && p->pcb != pcb)p = p->next;if(p){if(p->pb){pbuf_chain(p->pb, pb);} else {p->pb = pb;}}}return ERR_OK;}int AsyncServer::_cert(const char *filename, uint8_t **buf){if(_file_cb){return _file_cb(_file_cb_arg, filename, buf);}*buf = 0;return 0;}int AsyncServer::_s_cert(void *arg, const char *filename, uint8_t **buf){return reinterpret_cast<AsyncServer*>(arg)->_cert(filename, buf);}err_t AsyncServer::_s_poll(void *arg, struct tcp_pcb *pcb){return reinterpret_cast<AsyncServer*>(arg)->_poll(pcb);}err_t AsyncServer::_s_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *pb, err_t err){return reinterpret_cast<AsyncServer*>(arg)->_recv(pcb, pb, err);}#endif