Merge pull request #2 from me-no-dev/master

Syncing with me-no-dev repo

Author: mhightower83

examples/ClientServer/Client/Client.ino

@@ -0,0 +1,62 @@
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+
+extern "C" {
+#include <osapi.h>
+#include <os_type.h>
+}
+
+#include "config.h"
+
+static os_timer_t intervalTimer;
+
+static void replyToServer(void* arg) {
+	AsyncClient* client = reinterpret_cast<AsyncClient*>(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() {
+
+}

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

examples/ClientServer/Server/Server.ino

@@ -0,0 +1,73 @@
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#include <DNSServer.h>
+#include <vector>
+
+#include "config.h"
+
+static DNSServer DNS;
+
+static std::vector<AsyncClient*> 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();
+}

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

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",

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

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(){

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;

src/tcp_axtls.h

@@ -40,6 +40,7 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
 #include "include/ssl.h"
 
 #define ERR_TCP_SSL_INVALID_SSL           -101