fixing lwip server

Author: andreagilardoni

libraries/Ethernet/src/EthernetClient.h

@@ -9,8 +9,9 @@ class EthernetClient : public lwipClient {
     EthernetClient(struct tcp_pcb *pcb, lwipServer *server)
     : lwipClient(pcb, server) {
     }
-    EthernetClient(lwipClient c)
+    EthernetClient(const lwipClient &c)
     : lwipClient(c) {
+        this->bindCNetIf(Ethernet);
     }
 
     int connect(IPAddress ip, uint16_t port) {

libraries/Ethernet/src/EthernetServer.h

@@ -12,6 +12,7 @@ class EthernetServer: public lwipServer {
     }
 
     EthernetClient available() {
-        return EthernetClient(lwipServer::available());
+        lwipClient* res = available_ptr();
+        return res != nullptr ? EthernetClient(*res) : EthernetClient(CLIENT_NONE);
     }
 };

libraries/WiFi/src/WiFiClient.h

@@ -9,8 +9,9 @@ class WiFiClient: public lwipClient {
     WiFiClient(struct tcp_pcb *pcb, lwipServer *server)
     : lwipClient(pcb, server) {
     }
-    WiFiClient(lwipClient c)
+    WiFiClient(const lwipClient &c)
     : lwipClient(c) {
+        this->bindCNetIf(WiFiStation);
     }
 
     int connect(IPAddress ip, uint16_t port) {

libraries/WiFi/src/WiFiServer.h

@@ -12,6 +12,7 @@ class WiFiServer: public lwipServer {
     }
 
     WiFiClient available() {
-        return WiFiClient(lwipServer::available());
+        lwipClient* res = available_ptr();
+        return res != nullptr ? WiFiClient(*res) : WiFiClient(CLIENT_NONE);
     }
 };

libraries/lwIpWrapper/src/lwipClient.cpp

@@ -80,7 +80,9 @@ lwipClient& lwipClient::operator=(lwipClient&& rhs) {
 }
 
 lwipClient::~lwipClient() {
-    this->stop();
+    if(this->tcp_info->state != TCP_CLOSING) {
+        this->stop();
+    }
 }
 
 int lwipClient::connect(const char* host, uint16_t port) {
@@ -231,7 +233,7 @@ err_t lwipClient::recv_callback(struct tcp_pcb* tpcb, struct pbuf* p, err_t err)
         return ERR_OK;
     }
     arduino::lock();
-    if(this->tcp_info->state == TCP_CONNECTED) {
+    if(this->tcp_info->state == TCP_CONNECTED || this->tcp_info->state == TCP_ACCEPTED) {
         if (this->tcp_info->pbuf_head == nullptr) {
             // no need to increment the references of the pbuf,
             // since it is already 1 and lwip shifts the control to this code
@@ -273,16 +275,11 @@ size_t lwipClient::write(const uint8_t* buffer, size_t size) {
         } else if(res == ERR_MEM) {
             // FIXME handle this: we get into this case only if the sent data cannot be put in the send queue
         }
-
-        // TODO understand if the tcp_write will send data if the buffer is not full
-        // force send only if we filled the send buffer
-        // if (ERR_OK != tcp_output(this->tcp_info->pcb)) {
-        //     // return 0;
-        //     break;
-        // }
     } while(buffer_cursor < buffer + size);
-    arduino::unlock();
 
+    tcp_output(this->tcp_info->pcb);
+
+    arduino::unlock();
     return buffer - buffer_cursor;
 }
 
@@ -342,13 +339,13 @@ void lwipClient::flush() {
 }
 
 void lwipClient::stop() {
-    tcp_recv(this->tcp_info->pcb, nullptr);
-    tcp_sent(this->tcp_info->pcb, nullptr);
-    tcp_poll(this->tcp_info->pcb, nullptr, 0);
-    tcp_err(this->tcp_info->pcb, nullptr);
-    tcp_accept(this->tcp_info->pcb, nullptr);
-
     if(this->tcp_info->pcb != nullptr) {
+        tcp_recv(this->tcp_info->pcb, nullptr);
+        tcp_sent(this->tcp_info->pcb, nullptr);
+        tcp_poll(this->tcp_info->pcb, nullptr, 0);
+        tcp_err(this->tcp_info->pcb, nullptr);
+        tcp_accept(this->tcp_info->pcb, nullptr);
+
         err_t err = tcp_close(this->tcp_info->pcb);
         this->tcp_info->state = TCP_CLOSING;
 
@@ -362,6 +359,12 @@ void lwipClient::stop() {
     // if(tcp->p != nullptr) {
     //     pbuf_free(tcp->p); // FIXME it happens that a pbuf, with ref == 0 is added for some reason
     // }
+    if(this->tcp_info->server != nullptr) {
+        // need to first make the server point to nullptr, then remove the client, can cause infinite recursion
+        auto server = this->tcp_info->server;
+        this->tcp_info->server = nullptr;
+        server->remove(this);
+    }
 }
 
 uint8_t lwipClient::connected() {

libraries/lwIpWrapper/src/lwipServer.cpp

@@ -5,6 +5,7 @@ extern "C" {
 #include "CNetIf.h"
 #include "lwipClient.h"
 #include "lwipServer.h"
+#include "utils.h"
 
 err_t tcp_accept_callback(void* arg, struct tcp_pcb* newpcb, err_t err);
 
@@ -74,9 +75,12 @@ void lwipServer::begin(uint16_t port)
 // }
 
 void lwipServer::remove(lwipClient* client) {
+    arduino::lock();
+
     bool found = false;
     for (int i=0; i < size; i++) {
         if(found) {
+            // we move the client to delete to the end of the array, then we remove it
             clients[i-1] = clients[i];
         } else if(*client == *clients[i]) {
             found = true;
@@ -85,25 +89,41 @@ void lwipServer::remove(lwipClient* client) {
 
     delete clients[--size];
     clients[size] = nullptr;
+
+    arduino::unlock();
 }
 
-void lwipServer::accept(struct tcp_pcb* new_client) {
+bool lwipServer::accept(struct tcp_pcb* new_client) {
+    bool res = false;
     // this->clean();
-
+    arduino::lock();
     if(size < MAX_CLIENT-1) {
         clients[size] = new lwipClient(new_client, this);
         size++;
         clients_available++;
+        res = true;
     }
+    arduino::unlock();
+
+    return res;
 }
 
 lwipClient lwipServer::available()
 {
+    lwipClient* res = available_ptr();
+    return res != nullptr ? *res : CLIENT_NONE;
+}
+
+lwipClient* lwipServer::available_ptr()
+{
+    lwipClient* res=nullptr;
+    arduino::lock();
     if(size > 0 && clients_available>0) {
-        return *clients[size-clients_available--]; // TODO verify index
-    } else {
-        return CLIENT_NONE;
+        res = clients[size-clients_available--]; // TODO verify index
     }
+    arduino::unlock();
+
+    return res;
 }
 
 size_t lwipServer::write(uint8_t b)
@@ -112,28 +132,30 @@ size_t lwipServer::write(uint8_t b)
 }
 
 size_t lwipServer::write(const uint8_t* buffer, size_t size) {
+    arduino::lock();
     size_t written=0;
     // this->clean();
 
     for (int i = 0; i < MAX_CLIENT; i++) {
         written += clients[i]->write(buffer, size);
     }
+    arduino::unlock();
 
     return written;
 }
 
 err_t tcp_accept_callback(void* arg, struct tcp_pcb* newpcb, err_t err) {
+    arduino::lock();
     lwipServer* server = (lwipServer*) arg;
-    err_t ret_err;
+    err_t ret_err = ERR_OK;
 
     /* set priority for the newly accepted tcp connection newpcb */
     tcp_setprio(newpcb, TCP_PRIO_MIN);
 
-    if ((arg != NULL) && (ERR_OK == err)) {
-        server->accept(newpcb);
-    } else {
+    if ((arg == NULL) || (ERR_OK != err) || !server->accept(newpcb)) {
         tcp_close(newpcb);
         ret_err = ERR_ARG;
     }
+    arduino::unlock();
     return ret_err;
 }

libraries/lwIpWrapper/src/lwipServer.h

@@ -31,10 +31,12 @@ class lwipServer: public Server {
      * - when a client connection is closed (by calling stop on it or delete on the client)
      *   the server is notified and the remove() method is called thus the client is removed from the server list.
      */
-    void accept(struct tcp_pcb* new_client);
+    bool accept(struct tcp_pcb* new_client);
     // void clean();
     void remove(lwipClient* client);
 
+    lwipClient* available_ptr();
+
     uint16_t _port;
     const IPAddress &listen_address;
     tcp_pcb* server_pcb;