initial commitHEADmain

5 files changed, 1756 insertions, 0 deletions

diff --git a/libraries/AsyncTCP/LICENSE b/libraries/AsyncTCP/LICENSE
new file mode 100644
index 0000000..65c5ca8
--- /dev/null
+++ b/libraries/AsyncTCP/LICENSE
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/libraries/AsyncTCP/README.md b/libraries/AsyncTCP/README.md
new file mode 100644
index 0000000..cde5f14
--- /dev/null
+++ b/libraries/AsyncTCP/README.md
@@ -0,0 +1,8 @@
+### Async TCP Library for ESP32 Arduino
+
+This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
+
+This library is the base for [ESPAsyncWebServer](https://github.com/dvarrel/ESPAsyncWebServer)
+
+## AsyncClient and AsyncServer
+The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
diff --git a/libraries/AsyncTCP/library.properties b/libraries/AsyncTCP/library.properties
new file mode 100644
index 0000000..2c6ff0a
--- /dev/null
+++ b/libraries/AsyncTCP/library.properties
@@ -0,0 +1,9 @@
+name=AsyncTCP
+version=1.1.4
+author=dvarrel
+maintainer=dvarrel
+sentence=Async TCP Library for ESP32. Forked from https://github.com/me-no-dev/AsyncTCP
+paragraph=to build a WebServer, with files saved in flash
+category=Communication
+url=https://github.com/dvarrel/AsyncTCP
+architectures=esp32
diff --git a/libraries/AsyncTCP/src/AsyncTCP.cpp b/libraries/AsyncTCP/src/AsyncTCP.cpp
new file mode 100644
index 0000000..89ff6ee
--- /dev/null
+++ b/libraries/AsyncTCP/src/AsyncTCP.cpp
@@ -0,0 +1,1357 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (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/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 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 of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "Arduino.h"
+
+#include "AsyncTCP.h"
+extern "C"{
+#include "lwip/opt.h"
+#include "lwip/tcp.h"
+#include "lwip/inet.h"
+#include "lwip/dns.h"
+#include "lwip/err.h"
+}
+#include "esp_task_wdt.h"
+
+/*
+ * TCP/IP Event Task
+ * */
+
+typedef enum {
+    LWIP_TCP_SENT, LWIP_TCP_RECV, LWIP_TCP_FIN, LWIP_TCP_ERROR, LWIP_TCP_POLL, LWIP_TCP_CLEAR, LWIP_TCP_ACCEPT, LWIP_TCP_CONNECTED, LWIP_TCP_DNS
+} lwip_event_t;
+
+typedef struct {
+        lwip_event_t event;
+        void *arg;
+        union {
+                struct {
+                        void * 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 {
+                        AsyncClient * client;
+                } accept;
+                struct {
+                        const char * name;
+                        ip_addr_t addr;
+                } dns;
+        };
+} lwip_event_packet_t;
+
+static xQueueHandle _async_queue;
+static TaskHandle_t _async_service_task_handle = NULL;
+
+
+SemaphoreHandle_t _slots_lock;
+const int _number_of_closed_slots = CONFIG_LWIP_MAX_ACTIVE_TCP;
+static uint32_t _closed_slots[_number_of_closed_slots];
+static uint32_t _closed_index = []() {
+    _slots_lock = xSemaphoreCreateBinary();
+    xSemaphoreGive(_slots_lock);
+    for (int i = 0; i < _number_of_closed_slots; ++ i) {
+        _closed_slots[i] = 1;
+    }
+    return 1;
+}();
+
+
+static inline bool _init_async_event_queue(){
+    if(!_async_queue){
+        _async_queue = xQueueCreate(32, sizeof(lwip_event_packet_t *));
+        if(!_async_queue){
+            return false;
+        }
+    }
+    return true;
+}
+
+static inline bool _send_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueSend(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static inline bool _prepend_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueSendToFront(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static inline bool _get_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueReceive(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static bool _remove_events_with_arg(void * arg){
+    lwip_event_packet_t * first_packet = NULL;
+    lwip_event_packet_t * packet = NULL;
+
+    if(!_async_queue){
+        return false;
+    }
+    //figure out which is the first packet so we can keep the order
+    while(!first_packet){
+        if(xQueueReceive(_async_queue, &first_packet, 0) != pdPASS){
+            return false;
+        }
+        //discard packet if matching
+        if((int)first_packet->arg == (int)arg){
+            free(first_packet);
+            first_packet = NULL;
+        //return first packet to the back of the queue
+        } else if(xQueueSend(_async_queue, &first_packet, portMAX_DELAY) != pdPASS){
+            return false;
+        }
+    }
+
+    while(xQueuePeek(_async_queue, &packet, 0) == pdPASS && packet != first_packet){
+        if(xQueueReceive(_async_queue, &packet, 0) != pdPASS){
+            return false;
+        }
+        if((int)packet->arg == (int)arg){
+            free(packet);
+            packet = NULL;
+        } else if(xQueueSend(_async_queue, &packet, portMAX_DELAY) != pdPASS){
+            return false;
+        }
+    }
+    return true;
+}
+
+static void _handle_async_event(lwip_event_packet_t * e){
+    if(e->arg == NULL){
+        // do nothing when arg is NULL
+        //ets_printf("event arg == NULL: 0x%08x\n", e->recv.pcb);
+    } else if(e->event == LWIP_TCP_CLEAR){
+        _remove_events_with_arg(e->arg);
+    } else if(e->event == LWIP_TCP_RECV){
+        //ets_printf("-R: 0x%08x\n", e->recv.pcb);
+        AsyncClient::_s_recv(e->arg, e->recv.pcb, e->recv.pb, e->recv.err);
+    } else if(e->event == LWIP_TCP_FIN){
+        //ets_printf("-F: 0x%08x\n", e->fin.pcb);
+        AsyncClient::_s_fin(e->arg, e->fin.pcb, e->fin.err);
+    } else if(e->event == LWIP_TCP_SENT){
+        //ets_printf("-S: 0x%08x\n", e->sent.pcb);
+        AsyncClient::_s_sent(e->arg, e->sent.pcb, e->sent.len);
+    } else if(e->event == LWIP_TCP_POLL){
+        //ets_printf("-P: 0x%08x\n", e->poll.pcb);
+        AsyncClient::_s_poll(e->arg, e->poll.pcb);
+    } else if(e->event == LWIP_TCP_ERROR){
+        //ets_printf("-E: 0x%08x %d\n", e->arg, e->error.err);
+        AsyncClient::_s_error(e->arg, e->error.err);
+    } else if(e->event == LWIP_TCP_CONNECTED){
+        //ets_printf("C: 0x%08x 0x%08x %d\n", e->arg, e->connected.pcb, e->connected.err);
+        AsyncClient::_s_connected(e->arg, e->connected.pcb, e->connected.err);
+    } else if(e->event == LWIP_TCP_ACCEPT){
+        //ets_printf("A: 0x%08x 0x%08x\n", e->arg, e->accept.client);
+        AsyncServer::_s_accepted(e->arg, e->accept.client);
+    } else if(e->event == LWIP_TCP_DNS){
+        //ets_printf("D: 0x%08x %s = %s\n", e->arg, e->dns.name, ipaddr_ntoa(&e->dns.addr));
+        AsyncClient::_s_dns_found(e->dns.name, &e->dns.addr, e->arg);
+    }
+    free((void*)(e));
+}
+
+static void _async_service_task(void *pvParameters){
+    lwip_event_packet_t * packet = NULL;
+    for (;;) {
+        if(_get_async_event(&packet)){
+#if CONFIG_ASYNC_TCP_USE_WDT
+            if(esp_task_wdt_add(NULL) != ESP_OK){
+                log_e("Failed to add async task to WDT");
+            }
+#endif
+            _handle_async_event(packet);
+#if CONFIG_ASYNC_TCP_USE_WDT
+            if(esp_task_wdt_delete(NULL) != ESP_OK){
+                log_e("Failed to remove loop task from WDT");
+            }
+#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 _start_async_task(){
+    if(!_init_async_event_queue()){
+        return false;
+    }
+    if(!_async_service_task_handle){
+        xTaskCreateUniversal(_async_service_task, "async_tcp", 8192 * 2, NULL, 3, &_async_service_task_handle, CONFIG_ASYNC_TCP_RUNNING_CORE);
+        if(!_async_service_task_handle){
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+ * LwIP Callbacks
+ * */
+
+static int8_t _tcp_clear_events(void * arg) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_CLEAR;
+    e->arg = arg;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_connected(void * arg, tcp_pcb * pcb, int8_t err) {
+    //ets_printf("+C: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_CONNECTED;
+    e->arg = arg;
+    e->connected.pcb = pcb;
+    e->connected.err = err;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_poll(void * arg, struct tcp_pcb * pcb) {
+    //ets_printf("+P: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_POLL;
+    e->arg = arg;
+    e->poll.pcb = pcb;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->arg = arg;
+    if(pb){
+        //ets_printf("+R: 0x%08x\n", pcb);
+        e->event = LWIP_TCP_RECV;
+        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
+        AsyncClient::_s_lwip_fin(e->arg, e->fin.pcb, e->fin.err);
+    }
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) {
+    //ets_printf("+S: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_SENT;
+    e->arg = arg;
+    e->sent.pcb = pcb;
+    e->sent.len = len;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static void _tcp_error(void * arg, int8_t err) {
+    //ets_printf("+E: 0x%08x\n", arg);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_ERROR;
+    e->arg = arg;
+    e->error.err = err;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+}
+
+static void _tcp_dns_found(const char * name, struct ip_addr * ipaddr, void * arg) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    //ets_printf("+DNS: name=%s ipaddr=0x%08x arg=%x\n", name, ipaddr, arg);
+    e->event = LWIP_TCP_DNS;
+    e->arg = arg;
+    e->dns.name = name;
+    if (ipaddr) {
+        memcpy(&e->dns.addr, ipaddr, sizeof(struct ip_addr));
+    } else {
+        memset(&e->dns.addr, 0, sizeof(e->dns.addr));
+    }
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+}
+
+//Used to switch out from LwIP thread
+static int8_t _tcp_accept(void * arg, AsyncClient * client) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_ACCEPT;
+    e->arg = arg;
+    e->accept.client = client;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+/*
+ * TCP/IP API Calls
+ * */
+
+#include "lwip/priv/tcpip_priv.h"
+
+typedef struct {
+    struct tcpip_api_call_data call;
+    tcp_pcb * pcb;
+    int8_t closed_slot;
+    int8_t err;
+    union {
+            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->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = tcp_output(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_output(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        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, int8_t closed_slot, const char* data, size_t size, uint8_t apiflags) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = 0;
+        tcp_recved(msg->pcb, msg->received);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_recved(tcp_pcb * pcb, int8_t closed_slot, size_t len) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = tcp_close(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_close(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        tcp_abort(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_abort(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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, int8_t closed_slot, ip_addr_t * addr, uint16_t port, tcp_connected_fn cb) {
+    if(!pcb){
+        return ESP_FAIL;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    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;
+    msg->err = tcp_bind(msg->pcb, msg->bind.addr, msg->bind.port);
+    return msg->err;
+}
+
+static esp_err_t _tcp_bind(tcp_pcb * pcb, ip_addr_t * addr, uint16_t port) {
+    if(!pcb){
+        return ESP_FAIL;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = -1;
+    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.closed_slot = -1;
+    msg.backlog = backlog?backlog:0xFF;
+    tcpip_api_call(_tcp_listen_api, (struct tcpip_api_call_data*)&msg);
+    return msg.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)
+, _pcb_busy(false)
+, _pcb_sent_at(0)
+, _ack_pcb(true)
+, _rx_last_packet(0)
+, _rx_since_timeout(0)
+, _ack_timeout(ASYNC_MAX_ACK_TIME)
+, _connect_port(0)
+, prev(NULL)
+, next(NULL)
+{
+    _pcb = pcb;
+    _closed_slot = -1;
+    if(_pcb){
+        _allocate_closed_slot();
+        _rx_last_packet = millis();
+        tcp_arg(_pcb, this);
+        tcp_recv(_pcb, &_tcp_recv);
+        tcp_sent(_pcb, &_tcp_sent);
+        tcp_err(_pcb, &_tcp_error);
+        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+}
+
+AsyncClient::~AsyncClient(){
+    if(_pcb) {
+        _close();
+    }
+    _free_closed_slot();
+}
+
+/*
+ * Operators
+ * */
+
+AsyncClient& AsyncClient::operator=(const AsyncClient& other){
+    if (_pcb) {
+        _close();
+    }
+
+    _pcb = other._pcb;
+    _closed_slot = other._closed_slot;
+    if (_pcb) {
+        _rx_last_packet = millis();
+        tcp_arg(_pcb, this);
+        tcp_recv(_pcb, &_tcp_recv);
+        tcp_sent(_pcb, &_tcp_sent);
+        tcp_err(_pcb, &_tcp_error);
+        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+    return *this;
+}
+
+bool AsyncClient::operator==(const AsyncClient &other) {
+    return _pcb == other._pcb;
+}
+
+AsyncClient & 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;
+}
+
+/*
+ * 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(IPAddress ip, uint16_t port){
+    if (_pcb){
+        log_w("already connected, state %d", _pcb->state);
+        return false;
+    }
+    if(!_start_async_task()){
+        log_e("failed to start task");
+        return false;
+    }
+
+    ip_addr_t addr;
+    addr.type = IPADDR_TYPE_V4;
+    addr.u_addr.ip4.addr = ip;
+
+    tcp_pcb* pcb = tcp_new_ip_type(IPADDR_TYPE_V4);
+    if (!pcb){
+        log_e("pcb == NULL");
+        return false;
+    }
+
+    tcp_arg(pcb, this);
+    tcp_err(pcb, &_tcp_error);
+    tcp_recv(pcb, &_tcp_recv);
+    tcp_sent(pcb, &_tcp_sent);
+    tcp_poll(pcb, &_tcp_poll, 1);
+    //_tcp_connect(pcb, &addr, port,(tcp_connected_fn)&_s_connected);
+    _tcp_connect(pcb, _closed_slot, &addr, port,(tcp_connected_fn)&_tcp_connected);
+    return true;
+}
+
+bool AsyncClient::connect(const char* host, uint16_t port){
+    ip_addr_t addr;
+    
+    if(!_start_async_task()){
+      log_e("failed to start task");
+      return false;
+    }
+    
+    err_t err = dns_gethostbyname(host, &addr, (dns_found_callback)&_tcp_dns_found, this);
+    if(err == ERR_OK) {
+        return connect(IPAddress(addr.u_addr.ip4.addr), port);
+    } else if(err == ERR_INPROGRESS) {
+        _connect_port = port;
+        return true;
+    }
+    log_e("error: %d", err);
+    return false;
+}
+
+void AsyncClient::close(bool now){
+    if(_pcb){
+        _tcp_recved(_pcb, _closed_slot, _rx_ack_len);
+    }
+    _close();
+}
+
+int8_t AsyncClient::abort(){
+    if(_pcb) {
+        _tcp_abort(_pcb, _closed_slot );
+        _pcb = NULL;
+    }
+    return ERR_ABRT;
+}
+
+size_t AsyncClient::space(){
+    if((_pcb != NULL) && (_pcb->state == 4)){
+        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, _closed_slot, data, will_send, apiflags);
+    if(err != ERR_OK) {
+        return 0;
+    }
+    return will_send;
+}
+
+bool AsyncClient::send(){
+    int8_t err = ERR_OK;
+    err = _tcp_output(_pcb, _closed_slot);
+    if(err == ERR_OK){
+        _pcb_busy = true;
+        _pcb_sent_at = millis();
+        return true;
+    }
+    return false;
+}
+
+size_t AsyncClient::ack(size_t len){
+    if(len > _rx_ack_len)
+        len = _rx_ack_len;
+    if(len){
+        _tcp_recved(_pcb, _closed_slot, len);
+    }
+    _rx_ack_len -= len;
+    return len;
+}
+
+void AsyncClient::ackPacket(struct pbuf * pb){
+  if(!pb){
+    return;
+  }
+  _tcp_recved(_pcb, _closed_slot, pb->len);
+  pbuf_free(pb);
+}
+
+/*
+ * Main Private Methods
+ * */
+
+int8_t AsyncClient::_close(){
+    //ets_printf("X: 0x%08x\n", (uint32_t)this);
+    int8_t err = ERR_OK;
+    if(_pcb) {
+        //log_i("");
+        tcp_arg(_pcb, NULL);
+        tcp_sent(_pcb, NULL);
+        tcp_recv(_pcb, NULL);
+        tcp_err(_pcb, NULL);
+        tcp_poll(_pcb, NULL, 0);
+        _tcp_clear_events(this);
+        err = _tcp_close(_pcb, _closed_slot);
+        if(err != ERR_OK) {
+            err = abort();
+        }
+        _pcb = NULL;
+        if(_discard_cb) {
+            _discard_cb(_discard_cb_arg, this);
+        }
+    }
+    return err;
+}
+
+void AsyncClient::_allocate_closed_slot(){
+    xSemaphoreTake(_slots_lock, portMAX_DELAY);
+    uint32_t closed_slot_min_index = 0;
+    for (int i = 0; i < _number_of_closed_slots; ++ i) {
+        if ((_closed_slot == -1 || _closed_slots[i] <= closed_slot_min_index) && _closed_slots[i] != 0) {
+            closed_slot_min_index = _closed_slots[i];
+            _closed_slot = i;
+        }
+    }
+    if (_closed_slot != -1) {
+        _closed_slots[_closed_slot] = 0;
+    }
+    xSemaphoreGive(_slots_lock);
+}
+
+void AsyncClient::_free_closed_slot(){
+    if (_closed_slot != -1) {
+        _closed_slots[_closed_slot] = _closed_index;
+        _closed_slot = -1;
+        ++ _closed_index;
+    }
+}
+
+/*
+ * Private Callbacks
+ * */
+
+int8_t AsyncClient::_connected(void* pcb, int8_t err){
+    _pcb = reinterpret_cast<tcp_pcb*>(pcb);
+    if(_pcb){
+        _rx_last_packet = millis();
+        _pcb_busy = false;
+//        tcp_recv(_pcb, &_tcp_recv);
+//        tcp_sent(_pcb, &_tcp_sent);
+//        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+    if(_connect_cb) {
+        _connect_cb(_connect_cb_arg, this);
+    }
+    return ERR_OK;
+}
+
+void AsyncClient::_error(int8_t err) {
+    if(_pcb){
+        tcp_arg(_pcb, NULL);
+        if(_pcb->state == LISTEN) {
+            tcp_sent(_pcb, NULL);
+            tcp_recv(_pcb, NULL);
+            tcp_err(_pcb, NULL);
+            tcp_poll(_pcb, NULL, 0);
+        }
+        _pcb = NULL;
+    }
+    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){
+        log_e("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
+        return ERR_OK;
+    }
+    tcp_arg(_pcb, NULL);
+    if(_pcb->state == LISTEN) {
+        tcp_sent(_pcb, NULL);
+        tcp_recv(_pcb, NULL);
+        tcp_err(_pcb, NULL);
+        tcp_poll(_pcb, NULL, 0);
+    }
+    if(tcp_close(_pcb) != ERR_OK) {
+        tcp_abort(_pcb);
+    }
+    _free_closed_slot();
+    _pcb = NULL;
+    return ERR_OK;
+}
+
+//In Async Thread
+int8_t AsyncClient::_fin(tcp_pcb* pcb, int8_t err) {
+    _tcp_clear_events(this);
+    if(_discard_cb) {
+        _discard_cb(_discard_cb_arg, this);
+    }
+    return ERR_OK;
+}
+
+int8_t AsyncClient::_sent(tcp_pcb* pcb, uint16_t len) {
+    _rx_last_packet = millis();
+    //log_i("%u", len);
+    _pcb_busy = false;
+    if(_sent_cb) {
+        _sent_cb(_sent_cb_arg, this, len, (millis() - _pcb_sent_at));
+    }
+    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, _closed_slot, b->len);
+            }
+            pbuf_free(b);
+        }
+    }
+    return ERR_OK;
+}
+
+int8_t AsyncClient::_poll(tcp_pcb* pcb){
+    if(!_pcb){
+        log_w("pcb is NULL");
+        return ERR_OK;
+    }
+    if(pcb != _pcb){
+        log_e("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
+        return ERR_OK;
+    }
+
+    uint32_t now = millis();
+
+    // ACK Timeout
+    if(_pcb_busy && _ack_timeout && (now - _pcb_sent_at) >= _ack_timeout){
+        _pcb_busy = false;
+        log_w("ack timeout %d", pcb->state);
+        if(_timeout_cb)
+            _timeout_cb(_timeout_cb_arg, this, (now - _pcb_sent_at));
+        return ERR_OK;
+    }
+    // RX Timeout
+    if(_rx_since_timeout && (now - _rx_last_packet) >= (_rx_since_timeout * 1000)){
+        log_w("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(struct ip_addr *ipaddr){
+    if(ipaddr && ipaddr->u_addr.ip4.addr){
+        connect(IPAddress(ipaddr->u_addr.ip4.addr), _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
+ * */
+
+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;
+}
+
+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);
+    } else {
+        tcp_nagle_enable(_pcb);
+    }
+}
+
+bool AsyncClient::getNoDelay(){
+    if(!_pcb) {
+        return false;
+    }
+    return tcp_nagle_disabled(_pcb);
+}
+
+uint16_t AsyncClient::getMss(){
+    if(!_pcb) {
+        return 0;
+    }
+    return tcp_mss(_pcb);
+}
+
+uint32_t AsyncClient::getRemoteAddress() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->remote_ip.u_addr.ip4.addr;
+}
+
+uint16_t AsyncClient::getRemotePort() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->remote_port;
+}
+
+uint32_t AsyncClient::getLocalAddress() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->local_ip.u_addr.ip4.addr;
+}
+
+uint16_t AsyncClient::getLocalPort() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->local_port;
+}
+
+IPAddress AsyncClient::remoteIP() {
+    return IPAddress(getRemoteAddress());
+}
+
+uint16_t AsyncClient::remotePort() {
+    return getRemotePort();
+}
+
+IPAddress AsyncClient::localIP() {
+    return IPAddress(getLocalAddress());
+}
+
+uint16_t AsyncClient::localPort() {
+    return getLocalPort();
+}
+
+uint8_t AsyncClient::state() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->state;
+}
+
+bool AsyncClient::connected(){
+    if (!_pcb) {
+        return false;
+    }
+    return _pcb->state == 4;
+}
+
+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 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(){
+    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";
+    }
+}
+
+/*
+ * Static Callbacks (LwIP C2C++ interconnect)
+ * */
+
+void AsyncClient::_s_dns_found(const char * name, struct ip_addr * ipaddr, void * arg){
+    reinterpret_cast<AsyncClient*>(arg)->_dns_found(ipaddr);
+}
+
+int8_t AsyncClient::_s_poll(void * arg, struct tcp_pcb * pcb) {
+    return reinterpret_cast<AsyncClient*>(arg)->_poll(pcb);
+}
+
+int8_t AsyncClient::_s_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_recv(pcb, pb, err);
+}
+
+int8_t AsyncClient::_s_fin(void * arg, struct tcp_pcb * pcb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_fin(pcb, err);
+}
+
+int8_t AsyncClient::_s_lwip_fin(void * arg, struct tcp_pcb * pcb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_lwip_fin(pcb, err);
+}
+
+int8_t AsyncClient::_s_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) {
+    return reinterpret_cast<AsyncClient*>(arg)->_sent(pcb, len);
+}
+
+void AsyncClient::_s_error(void * arg, int8_t err) {
+    reinterpret_cast<AsyncClient*>(arg)->_error(err);
+}
+
+int8_t AsyncClient::_s_connected(void * arg, void * pcb, int8_t err){
+    return reinterpret_cast<AsyncClient*>(arg)->_connected(pcb, err);
+}
+
+/*
+  Async TCP Server
+ */
+
+AsyncServer::AsyncServer(IPAddress addr, uint16_t port)
+: _port(port)
+, _addr(addr)
+, _noDelay(false)
+, _pcb(0)
+, _connect_cb(0)
+, _connect_cb_arg(0)
+{}
+
+AsyncServer::AsyncServer(uint16_t port)
+: _port(port)
+, _addr((uint32_t) IPADDR_ANY)
+, _noDelay(false)
+, _pcb(0)
+, _connect_cb(0)
+, _connect_cb_arg(0)
+{}
+
+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()){
+        log_e("failed to start task");
+        return;
+    }
+    int8_t err;
+    _pcb = tcp_new_ip_type(IPADDR_TYPE_V4);
+    if (!_pcb){
+        log_e("_pcb == NULL");
+        return;
+    }
+
+    ip_addr_t local_addr;
+    local_addr.type = IPADDR_TYPE_V4;
+    local_addr.u_addr.ip4.addr = (uint32_t) _addr;
+    err = _tcp_bind(_pcb, &local_addr, _port);
+
+    if (err != ERR_OK) {
+        _tcp_close(_pcb, -1);
+        log_e("bind error: %d", err);
+        return;
+    }
+
+    static uint8_t backlog = 5;
+    _pcb = _tcp_listen_with_backlog(_pcb, backlog);
+    if (!_pcb) {
+        log_e("listen_pcb == NULL");
+        return;
+    }
+    tcp_arg(_pcb, (void*) this);
+    tcp_accept(_pcb, &_s_accept);
+}
+
+void AsyncServer::end(){
+    if(_pcb){
+        tcp_arg(_pcb, NULL);
+        tcp_accept(_pcb, NULL);
+        if(tcp_close(_pcb) != ERR_OK){
+            _tcp_abort(_pcb, -1);
+        }
+        _pcb = NULL;
+    }
+}
+
+//runs on LwIP thread
+int8_t AsyncServer::_accept(tcp_pcb* pcb, int8_t err){
+    //ets_printf("+A: 0x%08x\n", pcb);
+    if(_connect_cb){
+        AsyncClient *c = new AsyncClient(pcb);
+        if(c){
+            c->setNoDelay(_noDelay);
+            return _tcp_accept(this, c);
+        }
+    }
+    if(tcp_close(pcb) != ERR_OK){
+        tcp_abort(pcb);
+    }
+    log_e("FAIL");
+    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(){
+    return _noDelay;
+}
+
+uint8_t AsyncServer::status(){
+    if (!_pcb) {
+        return 0;
+    }
+    return _pcb->state;
+}
+
+int8_t AsyncServer::_s_accept(void * arg, tcp_pcb * pcb, int8_t err){
+    return reinterpret_cast<AsyncServer*>(arg)->_accept(pcb, err);
+}
+
+int8_t AsyncServer::_s_accepted(void *arg, AsyncClient* client){
+    return reinterpret_cast<AsyncServer*>(arg)->_accepted(client);
+}
diff --git a/libraries/AsyncTCP/src/AsyncTCP.h b/libraries/AsyncTCP/src/AsyncTCP.h
new file mode 100644
index 0000000..ac87ded
--- /dev/null
+++ b/libraries/AsyncTCP/src/AsyncTCP.h
@@ -0,0 +1,217 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (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/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 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 of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef ASYNCTCP_H_
+#define ASYNCTCP_H_
+
+#include "IPAddress.h"
+#include "sdkconfig.h"
+#include <functional>
+extern "C" {
+    #include "freertos/semphr.h"
+    #include "lwip/pbuf.h"
+}
+
+//If core is not defined, then we are running in Arduino or PIO
+#ifndef CONFIG_ASYNC_TCP_RUNNING_CORE
+#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
+#define CONFIG_ASYNC_TCP_USE_WDT 1 //if enabled, adds between 33us and 200us per event
+#endif
+
+class AsyncClient;
+
+#define ASYNC_MAX_ACK_TIME 5000
+#define ASYNC_WRITE_FLAG_COPY 0x01 //will allocate new buffer to hold the data while sending (else will hold reference to the data given)
+#define ASYNC_WRITE_FLAG_MORE 0x02 //will not send PSH flag, meaning that there should be more data to be sent before the application should react.
+
+typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
+typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)> AcAckHandler;
+typedef std::function<void(void*, AsyncClient*, int8_t error)> AcErrorHandler;
+typedef std::function<void(void*, AsyncClient*, void *data, size_t len)> AcDataHandler;
+typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandler;
+typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
+
+struct tcp_pcb;
+struct ip_addr;
+
+class AsyncClient {
+  public:
+    AsyncClient(tcp_pcb* pcb = 0);
+    ~AsyncClient();
+
+    AsyncClient & operator=(const AsyncClient &other);
+    AsyncClient & operator+=(const AsyncClient &other);
+
+    bool operator==(const AsyncClient &other);
+
+    bool operator!=(const AsyncClient &other) {
+      return !(*this == other);
+    }
+    bool connect(IPAddress ip, uint16_t port);
+    bool connect(const char* host, uint16_t port);
+    void close(bool now = false);
+    void stop();
+    int8_t abort();
+    bool free();
+
+    bool canSend();//ack is not pending
+    size_t space();//space available in the TCP window
+    size_t add(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY);//add for sending
+    bool send();//send all data added with the method above
+
+    //write equals add()+send()
+    size_t write(const char* data);
+    size_t write(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY); //only when canSend() == true
+
+    uint8_t state();
+    bool connecting();
+    bool connected();
+    bool disconnecting();
+    bool disconnected();
+    bool freeable();//disconnected or disconnecting
+
+    uint16_t getMss();
+
+    uint32_t getRxTimeout();
+    void setRxTimeout(uint32_t timeout);//no RX data timeout for the connection in seconds
+
+    uint32_t getAckTimeout();
+    void setAckTimeout(uint32_t timeout);//no ACK timeout for the last sent packet in milliseconds
+
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+
+    uint32_t getRemoteAddress();
+    uint16_t getRemotePort();
+    uint32_t getLocalAddress();
+    uint16_t getLocalPort();
+
+    //compatibility
+    IPAddress remoteIP();
+    uint16_t  remotePort();
+    IPAddress localIP();
+    uint16_t  localPort();
+
+    void onConnect(AcConnectHandler cb, void* arg = 0);     //on successful connect
+    void onDisconnect(AcConnectHandler cb, void* arg = 0);  //disconnected
+    void onAck(AcAckHandler cb, void* arg = 0);             //ack received
+    void onError(AcErrorHandler cb, void* arg = 0);         //unsuccessful connect or error
+    void onData(AcDataHandler cb, void* arg = 0);           //data received (called if onPacket is not used)
+    void onPacket(AcPacketHandler cb, void* arg = 0);       //data received
+    void onTimeout(AcTimeoutHandler cb, void* arg = 0);     //ack timeout
+    void onPoll(AcConnectHandler cb, void* arg = 0);        //every 125ms when connected
+
+    void ackPacket(struct pbuf * pb);//ack pbuf from onPacket
+    size_t ack(size_t len); //ack data that you have not acked using the method below
+    void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
+
+    const char * errorToString(int8_t error);
+    const char * stateToString();
+
+    //Do not use any of the functions below!
+    static int8_t _s_poll(void *arg, struct tcp_pcb *tpcb);
+    static int8_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, int8_t err);
+    static int8_t _s_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static int8_t _s_lwip_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static void _s_error(void *arg, int8_t err);
+    static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
+    static int8_t _s_connected(void* arg, void* tpcb, int8_t err);
+    static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
+
+    int8_t _recv(tcp_pcb* pcb, pbuf* pb, int8_t err);
+    tcp_pcb * pcb(){ return _pcb; }
+
+  protected:
+    tcp_pcb* _pcb;
+    int8_t  _closed_slot;
+
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+    AcConnectHandler _discard_cb;
+    void* _discard_cb_arg;
+    AcAckHandler _sent_cb;
+    void* _sent_cb_arg;
+    AcErrorHandler _error_cb;
+    void* _error_cb_arg;
+    AcDataHandler _recv_cb;
+    void* _recv_cb_arg;
+    AcPacketHandler _pb_cb;
+    void* _pb_cb_arg;
+    AcTimeoutHandler _timeout_cb;
+    void* _timeout_cb_arg;
+    AcConnectHandler _poll_cb;
+    void* _poll_cb_arg;
+
+    bool _pcb_busy;
+    uint32_t _pcb_sent_at;
+    bool _ack_pcb;
+    uint32_t _rx_ack_len;
+    uint32_t _rx_last_packet;
+    uint32_t _rx_since_timeout;
+    uint32_t _ack_timeout;
+    uint16_t _connect_port;
+
+    int8_t _close();
+    void _free_closed_slot();
+    void _allocate_closed_slot();
+    int8_t _connected(void* pcb, int8_t err);
+    void _error(int8_t err);
+    int8_t _poll(tcp_pcb* pcb);
+    int8_t _sent(tcp_pcb* pcb, uint16_t len);
+    int8_t _fin(tcp_pcb* pcb, int8_t err);
+    int8_t _lwip_fin(tcp_pcb* pcb, int8_t err);
+    void _dns_found(struct ip_addr *ipaddr);
+
+  public:
+    AsyncClient* prev;
+    AsyncClient* next;
+};
+
+class AsyncServer {
+  public:
+    AsyncServer(IPAddress addr, uint16_t port);
+    AsyncServer(uint16_t port);
+    ~AsyncServer();
+    void onClient(AcConnectHandler cb, void* arg);
+    void begin();
+    void end();
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+    uint8_t status();
+
+    //Do not use any of the functions below!
+    static int8_t _s_accept(void *arg, tcp_pcb* newpcb, int8_t err);
+    static int8_t _s_accepted(void *arg, AsyncClient* client);
+
+  protected:
+    uint16_t _port;
+    IPAddress _addr;
+    bool _noDelay;
+    tcp_pcb* _pcb;
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+
+    int8_t _accept(tcp_pcb* newpcb, int8_t err);
+    int8_t _accepted(AsyncClient* client);
+};
+
+
+#endif /* ASYNCTCP_H_ */