From a512fe15a6feb4714afd3eb99473825047870c97 Mon Sep 17 00:00:00 2001
From: Mathieu Carbou <mathieu.carbou@gmail.com>
Date: Sat, 26 Oct 2024 11:51:20 +0200
Subject: [PATCH] Fix #27: Required to lock TCPIP core functionality Ref: -
 https://github.com/mathieucarbou/AsyncTCP/issues/27 -
 https://github.com/espressif/arduino-esp32/issues/10526

---
 src/AsyncTCP.cpp | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/src/AsyncTCP.cpp b/src/AsyncTCP.cpp
index 8b4bc16..323fff5 100644
--- a/src/AsyncTCP.cpp
+++ b/src/AsyncTCP.cpp
@@ -39,6 +39,26 @@ extern "C"{
 #include <NetworkInterface.h>
 #endif
 
+#define TAG "AsyncTCP"
+
+// https://github.com/espressif/arduino-esp32/issues/10526
+#ifdef CONFIG_LWIP_TCPIP_CORE_LOCKING
+#define TCP_MUTEX_LOCK()                                \
+  if (!sys_thread_tcpip(LWIP_CORE_LOCK_QUERY_HOLDER)) { \
+    ESP_LOGE(TAG, "LOCK_TCPIP_CORE @ %s:%d", __FILE__, __LINE__); \
+    LOCK_TCPIP_CORE();                                  \
+  }
+
+#define TCP_MUTEX_UNLOCK()                             \
+  if (sys_thread_tcpip(LWIP_CORE_LOCK_QUERY_HOLDER)) { \
+    ESP_LOGE(TAG, "UNLOCK_TCPIP_CORE @ %s:%d", __FILE__, __LINE__); \
+    UNLOCK_TCPIP_CORE();                               \
+  }
+#else  // CONFIG_LWIP_TCPIP_CORE_LOCKING
+#define TCP_MUTEX_LOCK()
+#define TCP_MUTEX_UNLOCK()
+#endif  // CONFIG_LWIP_TCPIP_CORE_LOCKING
+
 #define INVALID_CLOSED_SLOT -1
 
 /*
@@ -600,7 +620,9 @@ AsyncClient::AsyncClient(tcp_pcb* pcb)
     _closed_slot = INVALID_CLOSED_SLOT;
     if(_pcb){
         _rx_last_packet = millis();
+        TCP_MUTEX_LOCK();
         tcp_arg(_pcb, this);
+        TCP_MUTEX_UNLOCK();
         tcp_recv(_pcb, &_tcp_recv);
         tcp_sent(_pcb, &_tcp_sent);
         tcp_err(_pcb, &_tcp_error);
@@ -631,7 +653,9 @@ AsyncClient& AsyncClient::operator=(const AsyncClient& other){
     _closed_slot = other._closed_slot;
     if (_pcb) {
         _rx_last_packet = millis();
+        TCP_MUTEX_LOCK();
         tcp_arg(_pcb, this);
+        TCP_MUTEX_UNLOCK();
         tcp_recv(_pcb, &_tcp_recv);
         tcp_sent(_pcb, &_tcp_sent);
         tcp_err(_pcb, &_tcp_error);
@@ -722,17 +746,22 @@ bool AsyncClient::_connect(ip_addr_t addr, uint16_t port){
         return false;
     }
 
+    TCP_MUTEX_LOCK();
     tcp_pcb* pcb = tcp_new_ip_type(addr.type);
+    TCP_MUTEX_UNLOCK();
     if (!pcb){
         log_e("pcb == NULL");
         return false;
     }
 
+    TCP_MUTEX_LOCK();
     tcp_arg(pcb, this);
     tcp_err(pcb, &_tcp_error);
     tcp_recv(pcb, &_tcp_recv);
     tcp_sent(pcb, &_tcp_sent);
     tcp_poll(pcb, &_tcp_poll, 1);
+    TCP_MUTEX_UNLOCK();
+
     esp_err_t err =_tcp_connect(pcb, _closed_slot, &addr, port,(tcp_connected_fn)&_tcp_connected);
     return err == ESP_OK;
 }
@@ -928,7 +957,9 @@ int8_t AsyncClient::_connected(tcp_pcb* pcb, int8_t err){
 
 void AsyncClient::_error(int8_t err) {
     if(_pcb){
+        TCP_MUTEX_LOCK();
         tcp_arg(_pcb, NULL);
+        TCP_MUTEX_UNLOCK();
         if(_pcb->state == LISTEN) {
             tcp_sent(_pcb, NULL);
             tcp_recv(_pcb, NULL);
@@ -952,7 +983,9 @@ int8_t AsyncClient::_lwip_fin(tcp_pcb* pcb, int8_t err) {
         log_d("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
         return ERR_OK;
     }
+    TCP_MUTEX_LOCK();
     tcp_arg(_pcb, NULL);
+    TCP_MUTEX_UNLOCK();
     if(_pcb->state == LISTEN) {
         tcp_sent(_pcb, NULL);
         tcp_recv(_pcb, NULL);
@@ -1461,7 +1494,9 @@ void AsyncServer::begin(){
         return;
     }
     int8_t err;
+    TCP_MUTEX_LOCK();
     _pcb = tcp_new_ip_type(_bind4 && _bind6 ? IPADDR_TYPE_ANY : (_bind6 ? IPADDR_TYPE_V6 : IPADDR_TYPE_V4));
+    TCP_MUTEX_UNLOCK();
     if (!_pcb){
         log_e("_pcb == NULL");
         return;
@@ -1493,14 +1528,24 @@ void AsyncServer::begin(){
         log_e("listen_pcb == NULL");
         return;
     }
+    TCP_MUTEX_LOCK();
     tcp_arg(_pcb, (void*) this);
+    TCP_MUTEX_UNLOCK();
+
+    TCP_MUTEX_LOCK();
     tcp_accept(_pcb, &_s_accept);
+    TCP_MUTEX_UNLOCK();
 }
 
 void AsyncServer::end(){
     if(_pcb){
+        TCP_MUTEX_LOCK();
         tcp_arg(_pcb, NULL);
+        TCP_MUTEX_UNLOCK();
+
+        TCP_MUTEX_LOCK();
         tcp_accept(_pcb, NULL);
+        TCP_MUTEX_UNLOCK();
         if(tcp_close(_pcb) != ERR_OK){
             _tcp_abort(_pcb, -1);
         }