diff --git a/examples/ClientServer/Client/Client.ino b/examples/ClientServer/Client/Client.ino new file mode 100644 index 0000000..b30d791 --- /dev/null +++ b/examples/ClientServer/Client/Client.ino @@ -0,0 +1,62 @@ +#include +#include + +extern "C" { +#include +#include +} + +#include "config.h" + +static os_timer_t intervalTimer; + +static void replyToServer(void* arg) { + AsyncClient* client = reinterpret_cast(arg); + + // send reply + if (client->space() > 32 && client->canSend()) { + char message[32]; + sprintf(message, "this is from %s", WiFi.localIP().toString().c_str()); + client->add(message, strlen(message)); + client->send(); + } +} + +/* event callbacks */ +static void handleData(void* arg, AsyncClient* client, void *data, size_t len) { + Serial.printf("\n data received from %s \n", client->remoteIP().toString().c_str()); + Serial.write((uint8_t*)data, len); + + os_timer_arm(&intervalTimer, 2000, true); // schedule for reply to server at next 2s +} + +void onConnect(void* arg, AsyncClient* client) { + Serial.printf("\n client has been connected to %s on port %d \n", SERVER_HOST_NAME, TCP_PORT); + replyToServer(client); +} + + +void setup() { + Serial.begin(115200); + delay(20); + + // connects to access point + WiFi.mode(WIFI_STA); + WiFi.begin(SSID, PASSWORD); + while (WiFi.status() != WL_CONNECTED) { + Serial.print('.'); + delay(500); + } + + AsyncClient* client = new AsyncClient; + client->onData(&handleData, client); + client->onConnect(&onConnect, client); + client->connect(SERVER_HOST_NAME, TCP_PORT); + + os_timer_disarm(&intervalTimer); + os_timer_setfn(&intervalTimer, &replyToServer, client); +} + +void loop() { + +} diff --git a/examples/ClientServer/Client/config.h b/examples/ClientServer/Client/config.h new file mode 100644 index 0000000..cf51e91 --- /dev/null +++ b/examples/ClientServer/Client/config.h @@ -0,0 +1,23 @@ +#ifndef CONFIG_H +#define CONFIG_H + +/* + * This example demonstrate how to use asynchronous client & server APIs + * in order to establish tcp socket connections in client server manner. + * server is running (on port 7050) on one ESP, acts as AP, and other clients running on + * remaining ESPs acts as STAs. after connection establishment between server and clients + * there is a simple message transfer in every 2s. clients connect to server via it's host name + * (in this case 'esp_server') with help of DNS service running on server side. + * + * Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s. +*/ + +#define SSID "ESP-TEST" +#define PASSWORD "123456789" + +#define SERVER_HOST_NAME "esp_server" + +#define TCP_PORT 7050 +#define DNS_PORT 53 + +#endif // CONFIG_H diff --git a/examples/ClientServer/Server/Server.ino b/examples/ClientServer/Server/Server.ino new file mode 100644 index 0000000..c8c9b7f --- /dev/null +++ b/examples/ClientServer/Server/Server.ino @@ -0,0 +1,73 @@ +#include +#include +#include +#include + +#include "config.h" + +static DNSServer DNS; + +static std::vector clients; // a list to hold all clients + + /* clients events */ +static void handleError(void* arg, AsyncClient* client, int8_t error) { + Serial.printf("\n connection error %s from client %s \n", client->errorToString(error), client->remoteIP().toString().c_str()); +} + +static void handleData(void* arg, AsyncClient* client, void *data, size_t len) { + Serial.printf("\n data received from client %s \n", client->remoteIP().toString().c_str()); + Serial.write((uint8_t*)data, len); + + // reply to client + if (client->space() > 32 && client->canSend()) { + char reply[32]; + sprintf(reply, "this is from %s", SERVER_HOST_NAME); + client->add(reply, strlen(reply)); + client->send(); + } +} + +static void handleDisconnect(void* arg, AsyncClient* client) { + Serial.printf("\n client %s disconnected \n", client->remoteIP().toString().c_str()); +} + +static void handleTimeOut(void* arg, AsyncClient* client, uint32_t time) { + Serial.printf("\n client ACK timeout ip: %s \n", client->remoteIP().toString().c_str()); +} + + +/* server events */ +static void handleNewClient(void* arg, AsyncClient* client) { + Serial.printf("\n new client has been connected to server, ip: %s", client->remoteIP().toString().c_str()); + + // add to list + clients.push_back(client); + + // register events + client->onData(&handleData, NULL); + client->onError(&handleError, NULL); + client->onDisconnect(&handleDisconnect, NULL); + client->onTimeout(&handleTimeOut, NULL); +} + +void setup() { + Serial.begin(115200); + delay(20); + + // create access point + while (!WiFi.softAP(SSID, PASSWORD, 6, false, 15)) { + delay(500); + } + + // start dns server + if (!DNS.start(DNS_PORT, SERVER_HOST_NAME, WiFi.softAPIP())) + Serial.printf("\n failed to start dns service \n"); + + AsyncServer* server = new AsyncServer(TCP_PORT); // start listening on tcp port 7050 + server->onClient(&handleNewClient, server); + server->begin(); +} + +void loop() { + DNS.processNextRequest(); +} diff --git a/examples/ClientServer/Server/config.h b/examples/ClientServer/Server/config.h new file mode 100644 index 0000000..cf51e91 --- /dev/null +++ b/examples/ClientServer/Server/config.h @@ -0,0 +1,23 @@ +#ifndef CONFIG_H +#define CONFIG_H + +/* + * This example demonstrate how to use asynchronous client & server APIs + * in order to establish tcp socket connections in client server manner. + * server is running (on port 7050) on one ESP, acts as AP, and other clients running on + * remaining ESPs acts as STAs. after connection establishment between server and clients + * there is a simple message transfer in every 2s. clients connect to server via it's host name + * (in this case 'esp_server') with help of DNS service running on server side. + * + * Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s. +*/ + +#define SSID "ESP-TEST" +#define PASSWORD "123456789" + +#define SERVER_HOST_NAME "esp_server" + +#define TCP_PORT 7050 +#define DNS_PORT 53 + +#endif // CONFIG_H diff --git a/library.json b/library.json index 76816d0..8f39000 100644 --- a/library.json +++ b/library.json @@ -12,7 +12,7 @@ "type": "git", "url": "https://github.com/me-no-dev/ESPAsyncTCP.git" }, - "version": "1.1.3", + "version": "1.2.0", "license": "LGPL-3.0", "frameworks": "arduino", "platforms": "espressif8266", diff --git a/library.properties b/library.properties index 9330e4d..d8e1f9c 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=ESP AsyncTCP -version=1.1.0 +version=1.2.0 author=Me-No-Dev maintainer=Me-No-Dev sentence=Async TCP Library for ESP8266 and ESP31B diff --git a/src/ESPAsyncTCP.cpp b/src/ESPAsyncTCP.cpp index c3fc6e7..7c3fd97 100644 --- a/src/ESPAsyncTCP.cpp +++ b/src/ESPAsyncTCP.cpp @@ -201,7 +201,8 @@ int8_t AsyncClient::abort(){ } void AsyncClient::close(bool now){ - tcp_recved(_pcb, _rx_ack_len); + if(_pcb) + tcp_recved(_pcb, _rx_ack_len); if(now) _close(); else @@ -366,10 +367,14 @@ void AsyncClient::_ssl_error(int8_t err){ #endif err_t AsyncClient::_sent(tcp_pcb* pcb, uint16_t len) { +#if ASYNC_TCP_SSL_ENABLED + if (_pcb_secure && !_handshake_done) + return ERR_OK; +#endif _rx_last_packet = millis(); - ASYNC_TCP_DEBUG("_sent: %u\n", len); _tx_unacked_len -= len; _tx_acked_len += len; + ASYNC_TCP_DEBUG("_sent: %u (%d %d)\n", len, _tx_unacked_len, _tx_acked_len); if(_tx_unacked_len == 0){ _pcb_busy = false; if(_sent_cb) @@ -395,7 +400,7 @@ err_t AsyncClient::_recv(tcp_pcb* pcb, pbuf* pb, err_t err) { ASYNC_TCP_DEBUG("_recv err: %d\n", read_bytes); _close(); } - return read_bytes; + //return read_bytes; } return ERR_OK; } @@ -743,27 +748,43 @@ void AsyncClient::ackPacket(struct pbuf * pb){ pbuf_free(pb); } -const char * AsyncClient::errorToString(int8_t error){ - switch(error){ - case 0: return "OK"; - case -1: return "Out of memory error"; - case -2: return "Buffer error"; - case -3: return "Timeout"; - case -4: return "Routing problem"; - case -5: return "Operation in progress"; - case -6: return "Illegal value"; - case -7: return "Operation would block"; - case -8: return "Connection aborted"; - case -9: return "Connection reset"; - case -10: return "Connection closed"; - case -11: return "Not connected"; - case -12: return "Illegal argument"; - case -13: return "Address in use"; - case -14: return "Low-level netif error"; - case -15: return "Already connected"; - case -55: return "DNS failed"; - default: return "UNKNOWN"; - } +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_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"; + case ERR_IF: + return "Low-level netif error"; + case ERR_ISCONN: + return "Connection already established"; + default: + return "Unknown error"; + } } const char * AsyncClient::stateToString(){ diff --git a/src/tcp_axtls.c b/src/tcp_axtls.c index 2a7b966..1e2f324 100755 --- a/src/tcp_axtls.c +++ b/src/tcp_axtls.c @@ -406,6 +406,7 @@ int tcp_ssl_read(struct tcp_pcb *tcp, struct pbuf *p) { } while (p->tot_len - fd_data->pbuf_offset > 0); tcp_recved(tcp, p->tot_len); + fd_data->tcp_pbuf = NULL; pbuf_free(p); return total_bytes; diff --git a/src/tcp_axtls.h b/src/tcp_axtls.h index 57a0e52..118e36f 100755 --- a/src/tcp_axtls.h +++ b/src/tcp_axtls.h @@ -40,6 +40,7 @@ extern "C" { #endif +#include #include "include/ssl.h" #define ERR_TCP_SSL_INVALID_SSL -101