LwipServer - manage connections as LwipClient so a copy always exists

JAndrassy · JAndrassy · commit af09d061f82e · 2023-12-15T17:29:59.000+01:00
for shared_ptr
diff --git a/libraries/Ethernet/src/EthernetClient.h b/libraries/Ethernet/src/EthernetClient.h
@@ -8,6 +8,7 @@ class EthernetClient : public lwipClient {
    public:
    EthernetClient() {}
    EthernetClient(struct tcp_struct *tcpClient) : lwipClient(tcpClient) {}
+   EthernetClient(lwipClient& client) : lwipClient(client) {}
 };
 
 #endif
diff --git a/libraries/Ethernet/src/EthernetServer.h b/libraries/Ethernet/src/EthernetServer.h
@@ -12,24 +12,8 @@ class EthernetServer : public lwipServer {
    EthernetServer(uint16_t port) : lwipServer(port) {}
 
    EthernetClient available() {
-      accept();
-
-      for (int n = 0; n < MAX_CLIENT; n++) {
-         if (_tcp_client[n] != NULL) {
-            if (_tcp_client[n]->pcb != NULL) {
-               EthernetClient client(_tcp_client[n]);
-               uint8_t s = client.status();
-               if (s == TCP_ACCEPTED) {
-                  if (client.available()) {
-                     return client;
-                  }
-               }
-            }
-         }
-     }
-
-     struct tcp_struct *default_client = NULL;
-     return EthernetClient(default_client);
+     lwipClient client = lwipServer::available();
+     return EthernetClient(client);
    }
 };
 
diff --git a/libraries/WiFi/src/WiFiClient.h b/libraries/WiFi/src/WiFiClient.h
@@ -8,6 +8,7 @@ class WiFiClient : public lwipClient {
    public:
    WiFiClient() {}
    WiFiClient(struct tcp_struct *tcpClient) : lwipClient(tcpClient) {}
+   WiFiClient(lwipClient& client) : lwipClient(client) {}
 };
 
 #endif
diff --git a/libraries/WiFi/src/WiFiServer.h b/libraries/WiFi/src/WiFiServer.h
@@ -11,24 +11,8 @@ class WiFiServer : public lwipServer {
    WiFiServer(uint16_t port) : lwipServer(port) {}
 
    WiFiClient available() {
-      accept();
-
-      for (int n = 0; n < MAX_CLIENT; n++) {
-         if (_tcp_client[n] != NULL) {
-            if (_tcp_client[n]->pcb != NULL) {
-               WiFiClient client(_tcp_client[n]);
-               uint8_t s = client.status();
-               if (s == TCP_ACCEPTED) {
-                  if (client.available()) {
-                     return client;
-                  }
-               }
-            }
-         }
-     }
-
-     struct tcp_struct *default_client = NULL;
-     return WiFiClient(default_client);
+     lwipClient client = lwipServer::available();
+     return WiFiClient(client);
    }
 };
 
diff --git a/libraries/lwIpWrapper/src/lwipClient.cpp b/libraries/lwIpWrapper/src/lwipClient.cpp
@@ -6,9 +6,13 @@ extern "C" {
 
 #include "lwipClient.h"
 
+static void memPoolDeleter(struct tcp_struct* tcpClient)
+{
+    mem_free(tcpClient);
+}
+
 /* -------------------------------------------------------------------------- */
 lwipClient::lwipClient()
-    : _tcp_client(NULL)
 {
 }
 /* -------------------------------------------------------------------------- */
@@ -17,15 +21,14 @@ lwipClient::lwipClient()
 sketches but sock is ignored. */
 /* -------------------------------------------------------------------------- */
 lwipClient::lwipClient(uint8_t sock)
-    : _tcp_client(NULL)
 {
 }
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 lwipClient::lwipClient(struct tcp_struct* tcpClient)
+    : _tcp_client(tcpClient, memPoolDeleter)
 {
-    _tcp_client = tcpClient;
 }
 /* -------------------------------------------------------------------------- */
 
@@ -49,7 +52,7 @@ int lwipClient::connect(IPAddress ip, uint16_t port)
     /* -------------------------------------------------------------------------- */
     if (_tcp_client == NULL) {
         /* Allocates memory for client */
-        _tcp_client = (struct tcp_struct*)mem_malloc(sizeof(struct tcp_struct));
+        _tcp_client.reset((struct tcp_struct*)mem_malloc(sizeof(struct tcp_struct)), memPoolDeleter);
 
         if (_tcp_client == NULL) {
             return 0;
@@ -69,7 +72,7 @@ int lwipClient::connect(IPAddress ip, uint16_t port)
 
     uint32_t startTime = millis();
     ip_addr_t ipaddr;
-    tcp_arg(_tcp_client->pcb, _tcp_client);
+    tcp_arg(_tcp_client->pcb, _tcp_client.get());
     if (ERR_OK != tcp_connect(_tcp_client->pcb, u8_to_ip_addr(rawIPAddress(ip), &ipaddr), port, &tcp_connected_callback)) {
         stop();
         return 0;
@@ -215,7 +218,7 @@ void lwipClient::stop()
 
     // close tcp connection if not closed yet
     if (status() != TCP_CLOSING) {
-        tcp_connection_close(_tcp_client->pcb, _tcp_client);
+        tcp_connection_close(_tcp_client->pcb, _tcp_client.get());
     }
 }
 
@@ -243,7 +246,7 @@ uint8_t lwipClient::status()
 lwipClient::operator bool()
 {
     /* -------------------------------------------------------------------------- */
-    return (_tcp_client && (_tcp_client->state != TCP_CLOSING));
+    return (_tcp_client != nullptr);
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/libraries/lwIpWrapper/src/lwipClient.h b/libraries/lwIpWrapper/src/lwipClient.h
@@ -9,6 +9,7 @@
 #include "lwipMem.h"
 #include "lwipTcp.h"
 #include "lwipTypes.h"
+#include <memory>
 
 class lwipClient : public Client {
 
@@ -66,7 +67,7 @@ class lwipClient : public Client {
     using Print::write;
 
 private:
-    struct tcp_struct* _tcp_client;
+    std::shared_ptr<struct tcp_struct> _tcp_client;
     uint16_t _timeout = 10000;
 };
 
diff --git a/libraries/lwIpWrapper/src/lwipServer.cpp b/libraries/lwIpWrapper/src/lwipServer.cpp
@@ -9,9 +9,6 @@ extern "C" {
 lwipServer::lwipServer(uint16_t port)
 {
     _port = port;
-    for (int i = 0; i < MAX_CLIENT; i++) {
-        _tcp_client[i] = {};
-    }
     _tcp_server = {};
 }
 
@@ -50,12 +47,8 @@ void lwipServer::accept()
 {
     /* Free client if disconnected */
     for (int n = 0; n < MAX_CLIENT; n++) {
-        if (_tcp_client[n] != NULL) {
-            lwipClient client(_tcp_client[n]);
-            if (client.status() == TCP_CLOSING) {
-                mem_free(_tcp_client[n]);
-                _tcp_client[n] = NULL;
-            }
+        if (_tcp_client[n] && !_tcp_client[n].connected()) {
+            _tcp_client[n] = lwipClient();
         }
     }
 }
@@ -65,21 +58,12 @@ lwipClient lwipServer::available()
     accept();
 
     for (int n = 0; n < MAX_CLIENT; n++) {
-        if (_tcp_client[n] != NULL) {
-            if (_tcp_client[n]->pcb != NULL) {
-                lwipClient client(_tcp_client[n]);
-                uint8_t s = client.status();
-                if (s == TCP_ACCEPTED) {
-                    if (client.available()) {
-                        return client;
-                    }
-                }
-            }
+        if (_tcp_client[n].available()) {
+            return _tcp_client[n];
         }
     }
 
-    struct tcp_struct* default_client = NULL;
-    return lwipClient(default_client);
+    return lwipClient();
 }
 
 size_t lwipServer::write(uint8_t b)
@@ -94,14 +78,8 @@ size_t lwipServer::write(const uint8_t* buffer, size_t size)
     accept();
 
     for (int n = 0; n < MAX_CLIENT; n++) {
-        if (_tcp_client[n] != NULL) {
-            if (_tcp_client[n]->pcb != NULL) {
-                lwipClient client(_tcp_client[n]);
-                uint8_t s = client.status();
-                if (s == TCP_ACCEPTED) {
-                    n += client.write(buffer, size);
-                }
-            }
+        if (_tcp_client[n].status() == TCP_ACCEPTED) {
+            n += _tcp_client[n].write(buffer, size);
         }
     }
 
diff --git a/libraries/lwIpWrapper/src/lwipServer.h b/libraries/lwIpWrapper/src/lwipServer.h
@@ -10,7 +10,7 @@ class lwipServer : public Server {
 protected:
     uint16_t _port;
     struct tcp_struct _tcp_server;
-    struct tcp_struct* _tcp_client[MAX_CLIENT];
+    lwipClient _tcp_client[MAX_CLIENT];
 
     void accept(void);
 
diff --git a/libraries/lwIpWrapper/src/lwipTcp.cpp b/libraries/lwIpWrapper/src/lwipTcp.cpp
@@ -1,4 +1,5 @@
 #include "lwipTcp.h"
+#include "lwipClient.h"
 
 #if LWIP_TCP
 static err_t tcp_recv_callback(void* arg, struct tcp_pcb* tpcb, struct pbuf* p, err_t err);
@@ -53,7 +54,7 @@ err_t tcp_accept_callback(void* arg, struct tcp_pcb* newpcb, err_t err)
 {
     err_t ret_err;
     uint8_t accepted;
-    struct tcp_struct** tcpClient = (struct tcp_struct**)arg;
+    lwipClient* tcpClient = (lwipClient*)arg;
 
     /* set priority for the newly accepted tcp connection newpcb */
     tcp_setprio(newpcb, TCP_PRIO_MIN);
@@ -69,8 +70,8 @@ err_t tcp_accept_callback(void* arg, struct tcp_pcb* newpcb, err_t err)
 
             /* Looking for an empty socket */
             for (uint16_t i = 0; i < MAX_CLIENT; i++) {
-                if (tcpClient[i] == NULL) {
-                    tcpClient[i] = client;
+                if (!tcpClient[i]) {
+                    tcpClient[i] = lwipClient(client);
                     accepted = 1;
                     break;
                 }

Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,13 @@ extern "C" {`
`6`	`6`
`7`	`7`	`#include "lwipClient.h"`
`8`	`8`
	`9`	`+static void memPoolDeleter(struct tcp_struct* tcpClient)`
	`10`	`+{`
	`11`	`+ mem_free(tcpClient);`
	`12`	`+}`
	`13`	`+`
`9`	`14`	`/* -------------------------------------------------------------------------- */`
`10`	`15`	`lwipClient::lwipClient()`
`11`		`- : _tcp_client(NULL)`
`12`	`16`	`{`
`13`	`17`	`}`
`14`	`18`	`/* -------------------------------------------------------------------------- */`
`@@ -17,15 +21,14 @@ lwipClient::lwipClient()`
`17`	`21`	`sketches but sock is ignored. */`
`18`	`22`	`/* -------------------------------------------------------------------------- */`
`19`	`23`	`lwipClient::lwipClient(uint8_t sock)`
`20`		`- : _tcp_client(NULL)`
`21`	`24`	`{`
`22`	`25`	`}`
`23`	`26`	`/* -------------------------------------------------------------------------- */`
`24`	`27`
`25`	`28`	`/* -------------------------------------------------------------------------- */`
`26`	`29`	`lwipClient::lwipClient(struct tcp_struct* tcpClient)`
	`30`	`+ : _tcp_client(tcpClient, memPoolDeleter)`
`27`	`31`	`{`
`28`		`- _tcp_client = tcpClient;`
`29`	`32`	`}`
`30`	`33`	`/* -------------------------------------------------------------------------- */`
`31`	`34`
`@@ -49,7 +52,7 @@ int lwipClient::connect(IPAddress ip, uint16_t port)`
`49`	`52`	`/* -------------------------------------------------------------------------- */`
`50`	`53`	`if (_tcp_client == NULL) {`
`51`	`54`	`/* Allocates memory for client */`
`52`		`- _tcp_client = (struct tcp_struct*)mem_malloc(sizeof(struct tcp_struct));`
	`55`	`+ _tcp_client.reset((struct tcp_struct*)mem_malloc(sizeof(struct tcp_struct)), memPoolDeleter);`
`53`	`56`
`54`	`57`	`if (_tcp_client == NULL) {`
`55`	`58`	`return 0;`
`@@ -69,7 +72,7 @@ int lwipClient::connect(IPAddress ip, uint16_t port)`
`69`	`72`
`70`	`73`	`uint32_t startTime = millis();`
`71`	`74`	`ip_addr_t ipaddr;`
`72`		`- tcp_arg(_tcp_client->pcb, _tcp_client);`
	`75`	`+ tcp_arg(_tcp_client->pcb, _tcp_client.get());`
`73`	`76`	`if (ERR_OK != tcp_connect(_tcp_client->pcb, u8_to_ip_addr(rawIPAddress(ip), &ipaddr), port, &tcp_connected_callback)) {`
`74`	`77`	`stop();`
`75`	`78`	`return 0;`
`@@ -215,7 +218,7 @@ void lwipClient::stop()`
`215`	`218`
`216`	`219`	`// close tcp connection if not closed yet`
`217`	`220`	`if (status() != TCP_CLOSING) {`
`218`		`- tcp_connection_close(_tcp_client->pcb, _tcp_client);`
	`221`	`+ tcp_connection_close(_tcp_client->pcb, _tcp_client.get());`
`219`	`222`	`}`
`220`	`223`	`}`
`221`	`224`
`@@ -243,7 +246,7 @@ uint8_t lwipClient::status()`
`243`	`246`	`lwipClient::operator bool()`
`244`	`247`	`{`
`245`	`248`	`/* -------------------------------------------------------------------------- */`
`246`		`- return (_tcp_client && (_tcp_client->state != TCP_CLOSING));`
	`249`	`+ return (_tcp_client != nullptr);`
`247`	`250`	`}`
`248`	`251`
`249`	`252`	`/* -------------------------------------------------------------------------- */`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,6 @@ extern "C" {`
`9`	`9`	`lwipServer::lwipServer(uint16_t port)`
`10`	`10`	`{`
`11`	`11`	`_port = port;`
`12`		`- for (int i = 0; i < MAX_CLIENT; i++) {`
`13`		`- _tcp_client[i] = {};`
`14`		`- }`
`15`	`12`	`_tcp_server = {};`
`16`	`13`	`}`
`17`	`14`
`@@ -50,12 +47,8 @@ void lwipServer::accept()`
`50`	`47`	`{`
`51`	`48`	`/* Free client if disconnected */`
`52`	`49`	`for (int n = 0; n < MAX_CLIENT; n++) {`
`53`		`- if (_tcp_client[n] != NULL) {`
`54`		`- lwipClient client(_tcp_client[n]);`
`55`		`- if (client.status() == TCP_CLOSING) {`
`56`		`- mem_free(_tcp_client[n]);`
`57`		`- _tcp_client[n] = NULL;`
`58`		`- }`
	`50`	`+ if (_tcp_client[n] && !_tcp_client[n].connected()) {`
	`51`	`+ _tcp_client[n] = lwipClient();`
`59`	`52`	`}`
`60`	`53`	`}`
`61`	`54`	`}`
`@@ -65,21 +58,12 @@ lwipClient lwipServer::available()`
`65`	`58`	`accept();`
`66`	`59`
`67`	`60`	`for (int n = 0; n < MAX_CLIENT; n++) {`
`68`		`- if (_tcp_client[n] != NULL) {`
`69`		`- if (_tcp_client[n]->pcb != NULL) {`
`70`		`- lwipClient client(_tcp_client[n]);`
`71`		`- uint8_t s = client.status();`
`72`		`- if (s == TCP_ACCEPTED) {`
`73`		`- if (client.available()) {`
`74`		`- return client;`
`75`		`- }`
`76`		`- }`
`77`		`- }`
	`61`	`+ if (_tcp_client[n].available()) {`
	`62`	`+ return _tcp_client[n];`
`78`	`63`	`}`
`79`	`64`	`}`
`80`	`65`
`81`		`- struct tcp_struct* default_client = NULL;`
`82`		`- return lwipClient(default_client);`
	`66`	`+ return lwipClient();`
`83`	`67`	`}`
`84`	`68`
`85`	`69`	`size_t lwipServer::write(uint8_t b)`
`@@ -94,14 +78,8 @@ size_t lwipServer::write(const uint8_t* buffer, size_t size)`
`94`	`78`	`accept();`
`95`	`79`
`96`	`80`	`for (int n = 0; n < MAX_CLIENT; n++) {`
`97`		`- if (_tcp_client[n] != NULL) {`
`98`		`- if (_tcp_client[n]->pcb != NULL) {`
`99`		`- lwipClient client(_tcp_client[n]);`
`100`		`- uint8_t s = client.status();`
`101`		`- if (s == TCP_ACCEPTED) {`
`102`		`- n += client.write(buffer, size);`
`103`		`- }`
`104`		`- }`
	`81`	`+ if (_tcp_client[n].status() == TCP_ACCEPTED) {`
	`82`	`+ n += _tcp_client[n].write(buffer, size);`
`105`	`83`	`}`
`106`	`84`	`}`
`107`	`85`