some sending optimizations

Author: Me No Dev

src/ESPAsyncTCP.cpp

@@ -216,38 +216,14 @@ size_t AsyncClient::write(const char* data) {
   return write(data, strlen(data));
 }
 
-size_t AsyncClient::write(const char* data, size_t size) {
-  if(!_pcb || size == 0 || data == NULL)
-    return 0;
-  if(!canSend())
+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;
-#if ASYNC_TCP_SSL_ENABLED
-  if(_pcb_secure){
-    int sent = tcp_ssl_write(_pcb, (uint8_t*)data, size);
-    if(sent >= 0)
-      return sent;
-    _close();
-    return 0;
-  }
-#endif
-  size_t room = space();
-  size_t will_send = (room < size) ? room : size;
-  int8_t err = tcp_write(_pcb, data, will_send, 0);
-  if(err != ERR_OK)
-    return 0;
-  err = tcp_output(_pcb);
-  if(err != ERR_OK)
-    return 0;
-  _pcb_sent_at = millis();
-  _pcb_busy = true;
-  if(will_send < size){
-    size_t left = size - will_send;
-    return will_send + write(data+will_send, left);
-  }
-  return size;
+  return will_send;
 }
 
-size_t AsyncClient::add(const char* data, size_t size) {
+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();
@@ -263,7 +239,7 @@ size_t AsyncClient::add(const char* data, size_t size) {
   }
 #endif
   size_t will_send = (room < size) ? room : size;
-  int8_t err = tcp_write(_pcb, data, will_send, 0);
+  int8_t err = tcp_write(_pcb, data, will_send, apiflags);
   if(err != ERR_OK)
     return 0;
   return will_send;
@@ -274,8 +250,6 @@ bool AsyncClient::send(){
   if(_pcb_secure)
     return true;
 #endif
-  if(!canSend())
-    return false;
   if(tcp_output(_pcb) == ERR_OK){
     _pcb_busy = true;
     _pcb_sent_at = millis();
@@ -375,26 +349,27 @@ void AsyncClient::_ssl_error(int8_t err){
 
 int8_t AsyncClient::_sent(tcp_pcb* pcb, uint16_t len) {
   _rx_last_packet = millis();
-  //ets_printf("ack: %u\n", len);
+  ASYNC_TCP_DEBUG("_sent: %u\n", 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) {
-  if(pb == 0){
-    //ets_printf("_pb null! %d\n", err);
+  if(pb == NULL){
+    ASYNC_TCP_DEBUG("_recv: pb == NULL! Closing... %d\n", err);
     return _close();
-  } //else ets_printf("_recv: %d\n", pb->tot_len);
+  }
 
   _rx_last_packet = millis();
 #if ASYNC_TCP_SSL_ENABLED
   if(_pcb_secure){
+    ASYNC_TCP_DEBUG("_recv: %d\n", pb->tot_len);
     int read_bytes = tcp_ssl_read(pcb, pb);
     if(read_bytes < 0){
       if (read_bytes != SSL_CLOSE_NOTIFY) {
-        ets_printf("_recv err: %d\n", read_bytes);
+        ASYNC_TCP_DEBUG("_recv err: %d\n", read_bytes);
         _close();
       }
       return read_bytes;
@@ -406,13 +381,13 @@ int8_t AsyncClient::_recv(tcp_pcb* pcb, pbuf* pb, int8_t err) {
     //we should not ack before we assimilate the data
     _ack_pcb = true;
     pbuf *b = pb;
+    ASYNC_TCP_DEBUG("_recv: %d\n", b->len);
     if(_recv_cb)
       _recv_cb(_recv_cb_arg, this, b->payload, b->len);
     if(!_ack_pcb)
       _rx_ack_len += b->len;
     else
       tcp_recved(pcb, b->len);
-    //pb = pbuf_dechain(b);
     pb = b->next;
     b->next = NULL;
     pbuf_free(b);
@@ -697,7 +672,7 @@ size_t AsyncClient::space(){
   if((_pcb != NULL) && (_pcb->state == 4) && _handshake_done){
     uint16_t s = tcp_sndbuf(_pcb);
     if(_pcb_secure){
-#if AXTLS_2_0_0_SNDBUF
+#ifdef AXTLS_2_0_0_SNDBUF
       return tcp_ssl_sndbuf(_pcb);
 #else
       if(s >= 128) //safe approach
@@ -910,13 +885,13 @@ int8_t AsyncServer::_accept(tcp_pcb* pcb, int8_t err){
       if(tcp_ssl_has_client() || _pending){
         struct pending_pcb * new_item = (struct pending_pcb*)malloc(sizeof(struct pending_pcb));
         if(!new_item){
-          //ets_printf("### malloc new pending failed!\n");
+          ASYNC_TCP_DEBUG("### malloc new pending failed!\n");
           if(tcp_close(pcb) != ERR_OK){
             tcp_abort(pcb);
           }
           return ERR_OK;
         }
-        //ets_printf("### put to wait: %d\n", _clients_waiting);
+        ASYNC_TCP_DEBUG("### put to wait: %d\n", _clients_waiting);
         new_item->pcb = pcb;
         new_item->pb = NULL;
         new_item->next = NULL;
@@ -978,7 +953,7 @@ int8_t AsyncServer::_poll(tcp_pcb* pcb){
       p->next = b->next;
       p = b;
     }
-    //ets_printf("### remove from wait: %d\n", _clients_waiting);
+    ASYNC_TCP_DEBUG("### remove from wait: %d\n", _clients_waiting);
     AsyncClient *c = new AsyncClient(pcb, _ssl_ctx);
     if(c){
       c->onConnect([this](void * arg, AsyncClient *c){
@@ -999,7 +974,7 @@ int8_t AsyncServer::_recv(struct tcp_pcb *pcb, struct pbuf *pb, int8_t err){
   struct pending_pcb * p;
 
   if(!pb){
-    //ets_printf("### close from wait: %d\n", _clients_waiting);
+    ASYNC_TCP_DEBUG("### close from wait: %d\n", _clients_waiting);
     p = _pending;
     if(p->pcb == pcb){
       _pending = _pending->next;
@@ -1017,7 +992,7 @@ int8_t AsyncServer::_recv(struct tcp_pcb *pcb, struct pbuf *pb, int8_t err){
     tcp_close(pcb);
     tcp_abort(pcb);
   } else {
-    //ets_printf("### wait _recv: %u %d\n", pb->tot_len, _clients_waiting);
+    ASYNC_TCP_DEBUG("### wait _recv: %u %d\n", pb->tot_len, _clients_waiting);
     p = _pending;
     while(p && p->pcb != pcb)
       p = p->next;

src/ESPAsyncTCP.h

@@ -29,6 +29,8 @@
 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;
@@ -132,7 +134,7 @@ class AsyncClient {
 
     bool canSend();//ack is not pending
     size_t space();
-    size_t add(const char* data, size_t size);//add for sending
+    size_t add(const char* data, size_t size, uint8_t apiflags=0);//add for sending
     bool send();//send all data added with the method above
     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
@@ -142,7 +144,7 @@ class AsyncClient {
 #endif
 
     size_t write(const char* data);
-    size_t write(const char* data, size_t size); //only when canSend() == true
+    size_t write(const char* data, size_t size, uint8_t apiflags=0); //only when canSend() == true
 
     uint8_t state();
     bool connecting();

src/async_config.h

@@ -2,7 +2,7 @@
 #define LIBRARIES_ESPASYNCTCP_SRC_ASYNC_CONFIG_H_
 
 #define ASYNC_TCP_SSL_ENABLED 0
-
-
+#define ASYNC_TCP_DEBUG(...) //ets_printf(__VA_ARGS__)
+#define TCP_SSL_DEBUG(...) //ets_printf(__VA_ARGS__)
 
 #endif /* LIBRARIES_ESPASYNCTCP_SRC_ASYNC_CONFIG_H_ */

src/tcp_axtls.c

@@ -270,7 +270,7 @@ int tcp_ssl_free(struct tcp_pcb *tcp) {
   return 0;
 }
 
-#if AXTLS_2_0_0_SNDBUF
+#ifdef AXTLS_2_0_0_SNDBUF
 int tcp_ssl_sndbuf(struct tcp_pcb *tcp){
   int expected;
   int available;
@@ -314,7 +314,7 @@ int tcp_ssl_write(struct tcp_pcb *tcp, uint8_t *data, size_t len) {
   }
   tcp_ssl->last_wr = 0;
 
-#if AXTLS_2_0_0_SNDBUF
+#ifdef AXTLS_2_0_0_SNDBUF
   int expected_len = ssl_calculate_write_length(tcp_ssl->ssl, len);
   int available_len = tcp_sndbuf(tcp);
   if(expected_len < 0 || expected_len > available_len){

src/tcp_axtls.h

@@ -42,10 +42,6 @@ extern "C" {
 
 #include "include/ssl.h"
 
-#ifndef AXTLS_2_0_0_SNDBUF
-#define AXTLS_2_0_0_SNDBUF 0
-#endif
-
 #define ERR_TCP_SSL_INVALID_SSL           -101
 #define ERR_TCP_SSL_INVALID_TCP           -102
 #define ERR_TCP_SSL_INVALID_CLIENTFD      -103
@@ -58,10 +54,6 @@ extern "C" {
 #define tcp_ssl_ssl_write(A, B, C) tcp_ssl_write(A, B, C)
 #define tcp_ssl_ssl_read(A, B) tcp_ssl_read(A, B)
 
-#ifndef TCP_SSL_DEBUG
-  #define TCP_SSL_DEBUG(...) //ets_printf(__VA_ARGS__)
-#endif
-
 typedef void (* tcp_ssl_data_cb_t)(void *arg, struct tcp_pcb *tcp, uint8_t * data, size_t len);
 typedef void (* tcp_ssl_handshake_cb_t)(void *arg, struct tcp_pcb *tcp, SSL *ssl);
 typedef void (* tcp_ssl_error_cb_t)(void *arg, struct tcp_pcb *tcp, int8_t error);
@@ -78,7 +70,7 @@ int tcp_ssl_is_server(struct tcp_pcb *tcp);
 int tcp_ssl_free(struct tcp_pcb *tcp);
 int tcp_ssl_read(struct tcp_pcb *tcp, struct pbuf *p);
 
-#if AXTLS_2_0_0_SNDBUF
+#ifdef AXTLS_2_0_0_SNDBUF
 int tcp_ssl_sndbuf(struct tcp_pcb *tcp);
 #endif