@alteriom/painlessmesh 1.9.19 → 1.10.0

package/src/connection.cpp

@@ -0,0 +1,10 @@
+#include "painlessmesh/connection.hpp"
+
+namespace painlessmesh {
+namespace tcp {
+
+uint32_t lastScheduledDeletionTime = 0;
+painlessmesh::buffer::temp_buffer_t shared_buffer;
+
+}  // namespace tcp
+}  // namespace painlessmesh

package/src/painlessMesh.h

@@ -5,8 +5,8 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.9.19
- * @date 2025-12-21
+ * @version 1.10.0
+ * @date 2026-08-12
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with 
  * ESP8266 and ESP32 devices. This Alteriom fork includes additional packages 
@@ -44,19 +44,6 @@
 #include "painlessmesh/ota.hpp"
 #endif
 
-// Include improvement modules when enabled
-#ifdef PAINLESSMESH_ENABLE_VALIDATION
-#include "painlessmesh/validation.hpp"
-#endif
-
-#ifdef PAINLESSMESH_ENABLE_METRICS
-#include "painlessmesh/metrics.hpp"
-#endif
-
-#ifdef PAINLESSMESH_ENABLE_MEMORY_OPTIMIZATION
-#include "painlessmesh/memory.hpp"
-#endif
-
 #include "painlessmesh/buffer.hpp"
 #include "painlessmesh/layout.hpp"
 #include "painlessmesh/logger.hpp"

package/src/painlessTaskOptions.h

@@ -2,6 +2,15 @@
 #define _TASK_PRIORITY      // Support for layered scheduling priority
 #define _TASK_STD_FUNCTION  // Support for std::function (ESP8266 and ESP32)
                             // Required for painlessMesh lambda callbacks
+#define _TASK_SELF_DESTRUCT // Scheduler-managed deletion of heap-allocated
+                            // one-shot tasks. The Scheduler deletes the Task
+                            // in execute(), after disable() has returned, so
+                            // a task never has to delete itself from inside
+                            // its own onDisable callback (which is a
+                            // use-after-free: Task::disable() writes to the
+                            // task object after onDisable returns). Used by
+                            // scheduleAsyncClientDeletion() in
+                            // connection.hpp. See issue #373.
 
 // NOTE: _TASK_THREAD_SAFE is currently DISABLED due to incompatibility
 // with _TASK_STD_FUNCTION in TaskScheduler v4.0.x

package/src/painlessmesh/buffer.hpp

@@ -37,7 +37,10 @@ class ReceiveBuffer {
     do {
       auto len = strnlen(data_ptr, length);
       do {
-        auto read_len = (std::min)(len, buf.length);
+        // Reserve one byte for the '\0' terminator below: read_len may be at
+        // most buf.length - 1, otherwise buf.buffer[read_len] writes one
+        // byte past the end of the buffer (caught by the ASan CI job).
+        auto read_len = (std::min)(len, buf.length - 1);
         memcpy(buf.buffer, data_ptr, read_len);
         buf.buffer[read_len] = '\0';
         auto newBuffer = T(buf.buffer);

package/src/painlessmesh/configuration.hpp

@@ -26,10 +26,21 @@
 // Enable OTA support
 #define PAINLESSMESH_ENABLE_OTA
 
-// Minimum free memory, besides here all packets in queue are discarded.
+// NOTE: `MIN_FREE_MEMORY` and `MAX_MESSAGE_QUEUE` are kept as deprecated
+// no-op compatibility macros. The library does not read either macro:
+// the auto-flushing message queue they were meant to tune never landed
+// (see #385, PR #383 review). `MessageQueue`
+// (`painlessmesh/message_queue.hpp`) is a manual priority buffer with
+// its own per-instance `maxSize` argument. Their historical default
+// values are preserved so downstream code that referenced them keeps
+// its prior behavior.
+#ifndef MIN_FREE_MEMORY
 #define MIN_FREE_MEMORY 4000
-// MAX number of unsent messages in queue. Newer messages are discarded
+#endif
+
+#ifndef MAX_MESSAGE_QUEUE
 #define MAX_MESSAGE_QUEUE 50
+#endif
 
 #define NODE_TIMEOUT 10 * TASK_SECOND
 #define SCAN_INTERVAL 30 * TASK_SECOND  // AP scan period in ms

package/src/painlessmesh/connection.hpp

@@ -42,10 +42,10 @@ static const uint32_t TCP_CLIENT_DELETION_SPACING_MS = 1000; // 1000ms spacing b
 // - The scheduler never runs tasks concurrently within the same mesh instance
 // - All mesh operations (including deletion callbacks) execute in the same thread
 // - Even when multiple tasks are ready, they execute one-at-a-time via scheduler->execute()
-static uint32_t lastScheduledDeletionTime = 0; // Timestamp of last deletion scheduled/executed (milliseconds)
+extern uint32_t lastScheduledDeletionTime; // Timestamp of last deletion scheduled/executed (milliseconds)
 
 // Shared buffer for reading/writing to the buffer
-static painlessmesh::buffer::temp_buffer_t shared_buffer;
+extern painlessmesh::buffer::temp_buffer_t shared_buffer;
 
 /**
  * Schedule deletion of an AsyncClient with proper spacing to prevent concurrent cleanups
@@ -116,25 +116,25 @@ inline void scheduleAsyncClientDeletion(Scheduler* scheduler, AsyncClient* clien
   Log(CONNECTION, "%s: Scheduling AsyncClient deletion in %u ms (spaced from previous deletions)\n", 
       logPrefix, actualDelay);
   
-  // Schedule the deletion task
-  // Note: Task object is intentionally leaked to keep implementation simple
-  // This is acceptable because:
-  // 1. Connections are long-lived, destructor calls are infrequent
-  // 2. Task object is small (~32-64 bytes) vs preventing critical heap corruption
-  // 3. In typical deployments, memory impact is negligible (few KB over months)
-  // 4. Alternative cleanup patterns would add significant complexity
+  // Schedule the deletion task with self-cleanup
   Task* cleanupTask = new Task(actualDelay * TASK_MILLISECOND, TASK_ONCE, [client, logPrefix]() {
     using namespace logger;
     Log(CONNECTION, "%s: Deferred cleanup of AsyncClient executing now\n", logPrefix);
-    
-    // Note: lastScheduledDeletionTime is updated at scheduling time (before this task runs), not here
-    // This ensures consistent spacing based on when deletions were scheduled, preventing
-    // the race condition where execution-time updates could "rewind" the timestamp
-    // and cause subsequent deletions to be scheduled too close together
-    
     delete client;
   });
-  
+
+  // Task cleanup (issue #373): the task must NOT delete itself from inside
+  // its own onDisable callback. TaskScheduler's Task::disable() keeps
+  // writing to the task object (iScheduler->iCurrent) after onDisable
+  // returns, so a self-delete there is a guaranteed use-after-free — this
+  // was crashing nodes on every connection teardown.
+  // Instead we mark the task self-destructing (_TASK_SELF_DESTRUCT, enabled
+  // in painlessTaskOptions.h): after the single iteration completes, the
+  // Scheduler itself disables the task, unlinks it from its chain, and
+  // deletes it — all from within Scheduler::execute(), safely outside the
+  // disable() call stack.
+  cleanupTask->setSelfDestruct(true);
+
   scheduler->addTask(*cleanupTask);
   cleanupTask->enableDelayed();
 }
@@ -165,13 +165,28 @@ class BufferedConnection
     using namespace logger;
     Log.remote("~BufferedConnection");
     this->close();
-    if (!client->freeable()) {
-      client->close(true);
-    }
+    // Always call client->close() here, unconditionally - do NOT guard this
+    // behind client->freeable(). freeable() can return true while _pcb is
+    // still a valid, non-null pointer (e.g. pcb->state == CLOSED but not yet
+    // reclaimed by lwIP). If we skip close() in that case, _pcb stays
+    // non-null for the entire TCP_CLIENT_CLEANUP_DELAY_MS+ deferred-deletion
+    // window below - during which lwIP's own internal timers (e.g. TIME_WAIT
+    // expiry) can silently free/recycle that pcb without ever notifying
+    // AsyncClient (the tcp_err callback only fires on abnormal termination,
+    // not on routine timer-driven pcb reclamation). The deferred delete then
+    // finds a stale-but-non-null _pcb and tries to close/free it a second
+    // time, corrupting the heap (observed as heap_caps_free/memp_free
+    // assertion failures and wild-pointer crashes inside tcp_arg(), all
+    // several seconds after the connection actually died).
+    // close() internally handles "nothing to do" safely (AsyncTCP checks
+    // _pcb/*pcb before touching lwIP state), and reliably nulls _pcb via its
+    // synchronous tcpip_api_call round-trip - so calling it unconditionally
+    // here, right at destruction time, closes this exposure window entirely.
+    client->close();
     // Note: client->abort() removed - calling it before deferred deletion
     // can leave the client in an inconsistent state where AsyncTCP is still
-    // trying to clean up the aborted connection. The close() and close(true)
-    // calls above are sufficient for connection termination.
+    // trying to clean up the aborted connection. The close() call above is
+    // sufficient for connection termination.
     // See: AsyncTCP best practices - abort() should only be called immediately
     // before delete, not before a deferred deletion.