@alteriom/painlessmesh 1.9.6 → 1.9.8

package/src/painlessMesh.h

@@ -5,8 +5,8 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.8.13
- * @date 2025-11-20
+ * @version 1.9.7
+ * @date 2025-12-13
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with 
  * ESP8266 and ESP32 devices. This Alteriom fork includes additional packages 

package/src/painlessMeshSTA.cpp

@@ -233,10 +233,19 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
           Log(CONNECTION,
               "connectToAP(): Restarting AP from channel %d to channel %d\n",
               oldChannel, detectedChannel);
-          WiFi.softAPdisconnect(false);
-          delay(100);
+          
+          // Disconnect AP and allow WiFi stack to fully reset
+          // Using true parameter ensures DHCP server is properly stopped
+          WiFi.softAPdisconnect(true);
+          delay(200);  // Increased delay to ensure complete WiFi stack reset
+          
           // Call apInit via friend class access (StationScan is friend of wifi::Mesh)
           mesh->apInit(mesh->getNodeId());
+          
+          // Additional stabilization delay after AP restart
+          // This ensures DHCP server is fully initialized before clients connect
+          delay(100);
+          
           Log(CONNECTION, "connectToAP(): AP restarted on channel %d\n", detectedChannel);
         }
         // Reset counter only when mesh is found on a new channel

package/src/painlessmesh/mesh.hpp

@@ -622,10 +622,10 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * 
    * Use hasLocalInternet() to check if THIS specific node has direct Internet access.
    * 
-   * When connected to mesh, requires recent bridge status (within timeout).
-   * When disconnected from mesh, returns true if any bridge previously
-   * reported Internet connectivity - allowing operations to be queued for
-   * when mesh connectivity is restored.
+   * This method now ALWAYS requires healthy (recent) bridge status to prevent
+   * false positives when mesh connectivity is lost. Without active mesh connections,
+   * stale bridge data cannot be relied upon, as the bridge may have lost Internet
+   * connectivity or become unreachable.
    * 
    * \code
    * if (mesh.hasInternetConnection()) {
@@ -644,16 +644,10 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * @see initAsSharedGateway() to give all nodes direct Internet access (requires router credentials)
    */
   bool hasInternetConnection() {
-    bool hasConnections = hasActiveMeshConnections();
-    
+    // Always require healthy bridge status to prevent false positives
+    // when mesh is disconnected. Stale bridge data is unreliable.
     for (const auto& bridge : knownBridges) {
-      // When connected: require fresh status
-      // When disconnected: use last known state
-      bool isUsable = hasConnections 
-          ? (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected)
-          : bridge.internetConnected;
-      
-      if (isUsable) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) {
         return true;
       }
     }
@@ -698,14 +692,17 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * Get the primary (best) bridge node
    * 
    * Primary bridge is selected based on:
-   * 1. Must be healthy (seen within timeout) - unless node is disconnected
+   * 1. Must be healthy (seen within timeout)
    * 2. Must have Internet connection
    * 3. Best WiFi RSSI to router
    * 
-   * When this node is disconnected from the mesh (no active connections),
-   * returns the last known bridge even if lastSeen is stale. This allows
-   * nodes to attempt routing through the last known bridge once mesh
-   * connectivity is restored.
+   * This method now ALWAYS requires healthy (recent) bridge status to prevent
+   * routing messages to unreachable or outdated bridges when mesh connectivity
+   * is lost. Without active mesh connections and fresh status, we cannot reliably
+   * route messages to any bridge.
+   * 
+   * If you need access to the last known bridge regardless of health status,
+   * use getLastKnownBridge() instead.
    * 
    * @return pointer to BridgeInfo of primary bridge, or nullptr if no suitable bridge
    */
@@ -713,17 +710,9 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     BridgeInfo* primary = nullptr;
     int8_t bestRSSI = -127;  // Worst possible RSSI
     
-    // Check if we have active mesh connections
-    bool hasConnections = hasActiveMeshConnections();
-    
+    // Always require healthy bridge status to prevent routing to stale/unreachable bridges
     for (auto& bridge : knownBridges) {
-      // When connected to mesh: require healthy (recent) bridge status
-      // When disconnected: use any bridge that reported Internet (stale info is better than none)
-      bool isUsable = hasConnections 
-          ? (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected)
-          : bridge.internetConnected;
-      
-      if (isUsable) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) {
         if (bridge.routerRSSI > bestRSSI) {
           bestRSSI = bridge.routerRSSI;
           primary = &bridge;
@@ -1290,6 +1279,18 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       Log(COMMUNICATION, "sendToInternet(): Local Internet available, using gateway protocol for consistency\n");
     }
 
+    // Validate mesh connectivity before attempting to send
+    if (!hasActiveMeshConnections()) {
+      Log(ERROR, "sendToInternet(): No active mesh connections\n");
+      if (callback) {
+        // Schedule callback to avoid blocking
+        this->addTask([callback]() {
+          callback(false, 0, "No mesh connections - cannot route to gateway");
+        });
+      }
+      return 0;
+    }
+
     // Find the best gateway to route through
     BridgeInfo* gateway = getPrimaryBridge();
     if (gateway == nullptr) {
@@ -3134,7 +3135,11 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     using namespace logger;
     Log(CONNECTION, "eraseClosedConnections():\n");
     this->subs.remove_if(
-        [](const std::shared_ptr<T> &conn) { return !conn->connected(); });
+        [](const std::shared_ptr<T> &conn) { 
+          // Null check for safety - should never happen but prevents crashes
+          if (!conn) return true;
+          return !conn->connected(); 
+        });
   }
 
  public:  // Windows MSVC: TCP lambdas need access to droppedConnectionCallbacks

package/src/painlessmesh/tcp.hpp

@@ -20,6 +20,10 @@ namespace tcp {
 static const uint8_t TCP_CONNECT_MAX_RETRIES = 5;       // Max retry attempts before giving up
 static const uint32_t TCP_CONNECT_RETRY_DELAY_MS = 1000; // Delay between retry attempts (1 second)
 static const uint32_t TCP_CONNECT_STABILIZATION_DELAY_MS = 500; // Delay after IP acquisition (500ms)
+// Delay before WiFi reconnection after all TCP retries are exhausted
+// This prevents rapid reconnection loops when TCP server is persistently unavailable
+// Gives the TCP server more time to recover and reduces network congestion
+static const uint32_t TCP_EXHAUSTION_RECONNECT_DELAY_MS = 10000; // 10 seconds before reconnection
 
 inline uint32_t encodeNodeId(const uint8_t *hwaddr) {
   using namespace painlessmesh::logger;
@@ -129,20 +133,42 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
           connect<T, M>((*pRetryConn), ip, port, mesh, retryCount + 1);
         }, retryDelay);
         
-        // Delete the current failed client to prevent memory leak
-        // The AsyncClient is no longer needed after connection failure
-        delete client;
+        // Defer deletion of the failed AsyncClient to prevent heap corruption
+        // Deleting from within the error callback can cause use-after-free issues
+        // as the AsyncTCP library may still be referencing the object
+        // Note: client is captured by value (pointer copy) and we are the sole owner
+        mesh.addTask([client]() {
+          Log(CONNECTION, "tcp_err(): Cleaning up failed AsyncClient (retry path)\n");
+          delete client;
+        }, 0);
         
         mesh.semaphoreGive();
         return;
       }
       
-      // All retries exhausted - clean up the failed client and trigger full reconnection
-      Log(CONNECTION, "tcp_err(): All %d retries exhausted, triggering WiFi reconnection\n",
-          TCP_CONNECT_MAX_RETRIES + 1);
-      delete client;
+      // All retries exhausted - schedule delayed reconnection
+      // Adding a significant delay before reconnection prevents rapid reconnection loops
+      // when the TCP server is persistently unavailable or overloaded
+      Log(CONNECTION, "tcp_err(): All %d retries exhausted, scheduling WiFi reconnection in %u ms\n",
+          TCP_CONNECT_MAX_RETRIES + 1, TCP_EXHAUSTION_RECONNECT_DELAY_MS);
+      
+      // Defer deletion of the failed AsyncClient to prevent heap corruption
+      // Deleting from within the error callback can cause use-after-free issues
+      // as the AsyncTCP library may still be referencing the object
+      // Note: client is captured by value (pointer copy) and we are the sole owner
+      mesh.addTask([client]() {
+        Log(CONNECTION, "tcp_err(): Cleaning up failed AsyncClient (exhaustion path)\n");
+        delete client;
+      }, 0);
 #endif
-      mesh.droppedConnectionCallbacks.execute(0, true);
+      // Defer callback execution to avoid crashes in error handler context
+      // Execute callbacks after semaphore is released and error handler completes
+      // The delay helps prevent endless rapid reconnection loops by giving the TCP server
+      // more time to recover and reducing network congestion from multiple retrying nodes
+      mesh.addTask([&mesh]() {
+        Log(CONNECTION, "tcp_err(): Executing delayed WiFi reconnection after retry exhaustion\n");
+        mesh.droppedConnectionCallbacks.execute(0, true);
+      }, TCP_EXHAUSTION_RECONNECT_DELAY_MS);
       mesh.semaphoreGive();
     }
   });