@alteriom/painlessmesh 1.9.20 → 2.0.0

package/src/painlessmesh/tcp.hpp

@@ -30,6 +30,84 @@ static const uint32_t TCP_EXHAUSTION_RECONNECT_DELAY_MS = 10000; // 10 seconds b
 // This prevents repeatedly trying to connect to nodes with unresponsive TCP servers
 static const uint32_t TCP_FAILURE_BLOCK_DURATION_MS = 60000;
 
+// Safe operating bounds applied by clampTcpRetryConfig().
+// Each retry allocates a new AsyncClient and schedules a task, so an unbounded
+// maxRetries is a heap and recursion-depth hazard on ESP8266. A zero retry
+// delay would schedule retry tasks with no spacing, i.e. a hot loop allocating
+// an AsyncClient per scheduler tick.
+static const uint8_t TCP_RETRY_MAX_RETRIES_LIMIT = 10;
+static const uint32_t TCP_RETRY_MIN_DELAY_MS = 50;
+static const uint32_t TCP_RETRY_MAX_DELAY_MS = 60000;
+
+/**
+ * User-tunable TCP connection retry parameters
+ *
+ * One instance is stored per mesh (painlessmesh::Mesh), configured through
+ * Mesh::setTcpRetryConfig(). The member defaults are spelled as the legacy
+ * constants above rather than as literals, so the "defaults match the previous
+ * hardcoded behaviour exactly" guarantee is enforced by the compiler and cannot
+ * silently drift.
+ *
+ * NOTE: this deliberately lives on the mesh instance rather than at namespace
+ * scope. A mutable namespace-scope instance in this header would give every
+ * translation unit its own private copy, so a sketch that configured the mesh
+ * in one TU and connected from another would silently fall back to defaults
+ * with no diagnostic.
+ */
+struct TcpRetryConfig {
+  /// Max TCP connect retry attempts before falling back to a WiFi reconnect
+  uint8_t maxRetries = TCP_CONNECT_MAX_RETRIES;
+  /// Base delay between retry attempts (ms), scaled by exponential backoff
+  uint32_t retryDelayMs = TCP_CONNECT_RETRY_DELAY_MS;
+  /// Delay after IP acquisition before the TCP connect is attempted (ms)
+  uint32_t stabilizationDelayMs = TCP_CONNECT_STABILIZATION_DELAY_MS;
+  /// Delay before the WiFi reconnect that follows retry exhaustion (ms)
+  uint32_t exhaustionReconnectDelayMs = TCP_EXHAUSTION_RECONNECT_DELAY_MS;
+  /// Duration a node is blocklisted after retry exhaustion (ms, 0 = never)
+  uint32_t failureBlockDurationMs = TCP_FAILURE_BLOCK_DURATION_MS;
+};
+
+/**
+ * Delay before retry attempt number `retryCount`
+ *
+ * Exponential backoff with the multiplier capped at 8, giving the default
+ * sequence 1s, 2s, 4s, 8s, 8s. Capping prevents excessive delays and keeps the
+ * product clear of uint32_t overflow.
+ *
+ * @param cfg Active retry configuration
+ * @param retryCount Zero-based retry attempt number
+ * @return Delay in milliseconds
+ */
+inline uint32_t retryBackoffDelay(const TcpRetryConfig &cfg,
+                                  uint8_t retryCount) {
+  uint8_t backoffMultiplier = (retryCount < 3) ? (1U << retryCount) : 8;
+  return cfg.retryDelayMs * backoffMultiplier;
+}
+
+/**
+ * Coerce a retry configuration into safe operating bounds
+ *
+ * Only the two values that can render a node unusable are clamped:
+ * maxRetries (heap/recursion pressure) and retryDelayMs (hot-loop floor and
+ * overflow ceiling). maxRetries == 0 is explicitly allowed - it means "fall
+ * back to a WiFi reconnect on the first TCP error", which is the whole point
+ * of the low-latency profile. stabilizationDelayMs, exhaustionReconnectDelayMs
+ * and failureBlockDurationMs are left alone because 0 is meaningful for each
+ * (skip stabilization / reconnect immediately / never blocklist).
+ *
+ * @param cfg Configuration to clamp (taken by value, returned clamped)
+ * @return The clamped configuration
+ */
+inline TcpRetryConfig clampTcpRetryConfig(TcpRetryConfig cfg) {
+  if (cfg.maxRetries > TCP_RETRY_MAX_RETRIES_LIMIT)
+    cfg.maxRetries = TCP_RETRY_MAX_RETRIES_LIMIT;
+  if (cfg.retryDelayMs < TCP_RETRY_MIN_DELAY_MS)
+    cfg.retryDelayMs = TCP_RETRY_MIN_DELAY_MS;
+  if (cfg.retryDelayMs > TCP_RETRY_MAX_DELAY_MS)
+    cfg.retryDelayMs = TCP_RETRY_MAX_DELAY_MS;
+  return cfg;
+}
+
 inline uint32_t encodeNodeId(const uint8_t *hwaddr) {
   using namespace painlessmesh::logger;
   Log(GENERAL, "encodeNodeId():\n");
@@ -82,7 +160,17 @@ void initServer(AsyncServer &server, M &mesh) {
           conn->initTasks();
           mesh.subs.push_back(conn);
           mesh.semaphoreGive();
+          return;
         }
+        // The mesh was busy for the whole second the semaphore allows. The
+        // stack has accepted the client already; left like this it is
+        // neither the mesh's nor closed, and the peer waits on a link that
+        // will never carry a node sync. Say so, and close it, so the peer
+        // tries again at once rather than after its own timeout.
+        Log(ERROR,
+            "New AP connection refused: mesh busy, closing it so the peer "
+            "retries\n");
+        client->close(true);
       },
       NULL);
   server.begin();
@@ -93,8 +181,9 @@ void initServer(AsyncServer &server, M &mesh) {
  * 
  * This function attempts to connect to the mesh network via TCP.
  * If the connection fails (error -14 ERR_CONN or other errors), it will
- * retry up to TCP_CONNECT_MAX_RETRIES times before triggering a full
- * WiFi reconnection cycle.
+ * retry up to the configured maxRetries times before triggering a full
+ * WiFi reconnection cycle. See Mesh::setTcpRetryConfig() to tune the retry
+ * envelope; the defaults reproduce the historic hardcoded behaviour.
  * 
  * The retry mechanism helps handle timing issues where:
  * - The TCP server may not be immediately ready after AP initialization
@@ -117,16 +206,49 @@ template <class T, class M>
 void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh, 
              uint8_t retryCount = 0) {
   using namespace logger;
-  
+
+  // Snapshot the retry configuration once, before any lambda is built. The
+  // onError lambda outlives this stack frame, so it captures this snapshot by
+  // value rather than reading mesh's member later: a user callback could
+  // otherwise mutate the config between the connect attempt and the error,
+  // tearing the backoff schedule mid-sequence. Each retry re-enters connect()
+  // and re-snapshots, so a config change still takes effect on the next
+  // attempt.
+  const TcpRetryConfig cfg = mesh.getTcpRetryConfig();
+
   Log(CONNECTION, "tcp::connect(): Attempting connection to port %d (attempt %d/%d)\n",
-      port, retryCount + 1, TCP_CONNECT_MAX_RETRIES + 1);
+      port, retryCount + 1, cfg.maxRetries + 1);
+
+  // Guard shared between onError and onConnect: under normal conditions a
+  // TCP connection attempt leads to only ONE of the two outcomes. But if
+  // WiFi drops right as the TCP handshake completes, AsyncTCP can queue
+  // BOTH events (connection succeeded at the TCP level + abort due to the
+  // WiFi link being lost) for the same AsyncClient, and both callbacks end
+  // up firing for the SAME object. Without this guard, the client would be
+  // "handed over" twice: once to a BufferedConnection (via onConnect, which
+  // becomes its owner and will delete it via its own destructor) and once
+  // to the retry path (via onError, which schedules it again for deletion)
+  // - two scheduleAsyncClientDeletion() calls on the same pointer, and
+  // therefore a double deferred deletion on the same object once both
+  // tasks fire.
+  auto claimed = std::make_shared<bool>(false);
   
   // Store retry count and connection parameters for the error handler
   // We need to capture these by value since they're used in the lambda
-  client.onError([&mesh, ip, port, retryCount](void *, AsyncClient *client, int8_t err) {
+  client.onError([&mesh, ip, port, retryCount, claimed, cfg](void *, AsyncClient *client, int8_t err) {
+    if (*claimed) {
+      // onConnect has already claimed this client (the connection actually
+      // succeeded, and it's already been wrapped in a BufferedConnection
+      // that owns it): don't touch the same object again.
+      Log(CONNECTION,
+          "tcp_err(): onError fired after onConnect had already claimed "
+          "the client - ignored to avoid double handling\n");
+      return;
+    }
+    *claimed = true;
     if (mesh.semaphoreTake()) {
-      Log(CONNECTION, "tcp_err(): error trying to connect %d (attempt %d/%d)\n", 
-          err, retryCount + 1, TCP_CONNECT_MAX_RETRIES + 1);
+      Log(CONNECTION, "tcp_err(): error trying to connect %d (attempt %d/%d)\n",
+          err, retryCount + 1, cfg.maxRetries + 1);
       
       // Check if we have retries left - retry logic only works on real hardware
       // In test environment (PAINLESSMESH_BOOST), fall through to dropped connection
@@ -134,27 +256,21 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
       (void)ip;
       (void)port;
 #if !defined(PAINLESSMESH_BOOST) && (defined(ESP32) || defined(ESP8266))
-      if (retryCount < TCP_CONNECT_MAX_RETRIES) {
-        // Calculate delay with exponential backoff: base_delay * 2^retryCount
-        // This gives increasing time between retries as failures accumulate:
-        // - retryCount=0: 1000ms * 1 = 1s
-        // - retryCount=1: 1000ms * 2 = 2s
-        // - retryCount=2: 1000ms * 4 = 4s
-        // - retryCount=3: 1000ms * 8 = 8s (capped at 8)
-        // - retryCount=4: 1000ms * 8 = 8s (capped at 8)
-        // Cap multiplier at 8 to prevent excessive delays
-        uint8_t backoffMultiplier = (retryCount < 3) ? (1U << retryCount) : 8;
-        uint32_t retryDelay = TCP_CONNECT_RETRY_DELAY_MS * backoffMultiplier;
-        
-        Log(CONNECTION, "tcp_err(): Scheduling retry in %u ms (backoff x%d)\n", 
-            retryDelay, backoffMultiplier);
+      if (retryCount < cfg.maxRetries) {
+        // Delay grows with exponential backoff, multiplier capped at 8.
+        // With the default 1000ms base that is: 1s, 2s, 4s, 8s, 8s.
+        uint32_t retryDelay = retryBackoffDelay(cfg, retryCount);
+
+        Log(CONNECTION, "tcp_err(): Scheduling retry in %u ms\n", retryDelay);
         
         // Schedule a retry after a delay using the mesh's task scheduler
         // Note: &mesh is captured by reference because:
         // 1. Mesh is a singleton that lives for the program's lifetime
         // 2. The task scheduler belongs to the mesh, so mesh is always valid when task runs
         // 3. Copying the mesh object is not possible/allowed
-        // Recursion depth is strictly bounded by TCP_CONNECT_MAX_RETRIES (default: 5)
+        // Recursion depth is strictly bounded by cfg.maxRetries (default 5),
+        // which clampTcpRetryConfig() never lets exceed
+        // TCP_RETRY_MAX_RETRIES_LIMIT (10).
         mesh.addTask([&mesh, ip, port, retryCount]() {
           Log(CONNECTION, "tcp_err(): Retrying TCP connection...\n");
           
@@ -178,7 +294,7 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
       // 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 for IP %s\n",
-          TCP_CONNECT_MAX_RETRIES + 1, ip.toString().c_str());
+          cfg.maxRetries + 1, ip.toString().c_str());
       
       // Block this node temporarily to prevent immediate reconnection to the same unresponsive node
       // This helps when the bridge's TCP server is down but WiFi AP is still running
@@ -186,15 +302,19 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
       #if !defined(PAINLESSMESH_BOOST)
       // Try to decode nodeId from IP and block it
       // Only works for mesh IPs (format: 10.x.x.1)
+      // A failureBlockDurationMs of 0 is an explicit "never blocklist" opt-out.
+      // Passing it through would set blockUntil = millis() + 0, which
+      // isNodeBlocked() reads as already expired - so the entry would do
+      // nothing except linger in the blocklist until cleanup sweeps it.
       uint32_t failedNodeId = decodeNodeIdFromIP(ip);
-      if (failedNodeId != 0) {
+      if (failedNodeId != 0 && cfg.failureBlockDurationMs > 0) {
         // Note: This requires M to be wifi::Mesh which has blockNodeAfterTCPFailure
-        mesh.blockNodeAfterTCPFailure(ip, TCP_FAILURE_BLOCK_DURATION_MS);
+        mesh.blockNodeAfterTCPFailure(ip, cfg.failureBlockDurationMs);
       }
       #endif
-      
+
       Log(CONNECTION, "tcp_err(): Scheduling WiFi reconnection in %u ms\n",
-          TCP_EXHAUSTION_RECONNECT_DELAY_MS);
+          cfg.exhaustionReconnectDelayMs);
       
       // Defer deletion of the failed AsyncClient to prevent heap corruption
       // Use the centralized deletion scheduler to ensure proper spacing between deletions
@@ -208,13 +328,32 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
       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);
+      }, cfg.exhaustionReconnectDelayMs);
       mesh.semaphoreGive();
     }
   });
 
   client.onConnect(
-      [&mesh](void *, AsyncClient *client) {
+      [&mesh, claimed](void *, AsyncClient *client) {
+        if (*claimed) {
+          // onError has already fired for this client (e.g. an abort
+          // caused by losing WiFi right while the TCP handshake was
+          // completing): the client is already scheduled for deletion by
+          // the retry path. Wrapping it in a new BufferedConnection now
+          // would give it two owners at once. This connection did however
+          // genuinely succeed at the TCP level (that's why onConnect
+          // fired): close it explicitly here, so that when the deferred
+          // deletion already scheduled by onError fires, it finds a
+          // properly closed client instead of one still "connected" -
+          // otherwise we'd fall right back into the bug we're fixing.
+          Log(CONNECTION,
+              "tcp::connect(): onConnect fired after onError had already "
+              "claimed the client - closing the connection and discarding "
+              "it\n");
+          client->close();
+          return;
+        }
+        *claimed = true;
         if (mesh.semaphoreTake()) {
           Log(CONNECTION, "New STA connection incoming\n");
           auto conn = std::make_shared<T>(client, &mesh, true);

package/src/painlessmesh/message_tracker.hpp

@@ -1,311 +0,0 @@
-#ifndef _PAINLESS_MESH_MESSAGE_TRACKER_HPP_
-#define _PAINLESS_MESH_MESSAGE_TRACKER_HPP_
-
-#include <map>
-#include <algorithm>
-#include "painlessmesh/configuration.hpp"
-#include "painlessmesh/logger.hpp"
-
-// External logger instance
-extern painlessmesh::logger::LogClass Log;
-
-namespace painlessmesh {
-
-/**
- * Key for tracking messages by their unique combination of ID and origin node
- */
-struct MessageKey {
-  uint32_t messageId;
-  uint32_t originNode;
-  
-  bool operator<(const MessageKey& other) const {
-    if (messageId != other.messageId) {
-      return messageId < other.messageId;
-    }
-    return originNode < other.originNode;
-  }
-  
-  bool operator==(const MessageKey& other) const {
-    return messageId == other.messageId && originNode == other.originNode;
-  }
-};
-
-/**
- * Tracked message entry with timestamp and acknowledgment status
- */
-struct TrackedMessage {
-  uint32_t timestamp;     // When the message was first processed (millis)
-  bool acknowledged;      // Whether the message has been acknowledged
-  
-  TrackedMessage() : timestamp(0), acknowledged(false) {}
-  TrackedMessage(uint32_t ts) : timestamp(ts), acknowledged(false) {}
-};
-
-/**
- * MessageTracker - Prevents duplicate message processing and tracks acknowledgments
- * 
- * This class provides efficient tracking of processed messages to prevent
- * duplicate processing in mesh networks. It supports:
- * - Configurable maximum tracked messages (memory-efficient for ESP8266)
- * - Automatic cleanup of expired entries
- * - Acknowledgment tracking for reliable delivery
- * - Thread-safe consideration for ESP32
- * 
- * Example usage:
- * \code
- * MessageTracker tracker(500, 60000);  // Max 500 messages, 60s timeout
- * 
- * uint32_t msgId = 12345;
- * uint32_t originNode = 67890;
- * 
- * // Check if message was already processed
- * if (!tracker.isProcessed(msgId, originNode)) {
- *     // Process the message
- *     processMessage(msg);
- *     
- *     // Mark as processed
- *     tracker.markProcessed(msgId, originNode);
- * }
- * 
- * // Later, mark as acknowledged
- * tracker.markAcknowledged(msgId, originNode);
- * 
- * // Periodically cleanup old entries
- * tracker.cleanup();
- * \endcode
- */
-class MessageTracker {
-public:
-  /**
-   * Constructor
-   * @param maxMessages Maximum number of messages to track (default: 500)
-   * @param timeoutMs Timeout in milliseconds for automatic cleanup (default: 60000)
-   */
-  MessageTracker(uint16_t maxMessages = 500, uint32_t timeoutMs = 60000)
-    : maxTrackedMessages(maxMessages), messageTimeoutMs(timeoutMs) {}
-  
-  /**
-   * Check if a message has already been processed
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   * @return true if the message was already processed, false otherwise
-   */
-  bool isProcessed(uint32_t messageId, uint32_t originNode) {
-    MessageKey key = {messageId, originNode};
-    auto it = trackedMessages.find(key);
-    return it != trackedMessages.end();
-  }
-  
-  /**
-   * Mark a message as processed
-   * If the tracker is at capacity, oldest entries will be removed first.
-   * Note: If maxMessages is 0, this method does nothing and returns false.
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   * @return true if message was tracked, false if capacity is 0
-   */
-  bool markProcessed(uint32_t messageId, uint32_t originNode) {
-    MessageKey key = {messageId, originNode};
-    uint32_t currentTime = millis();
-    
-    // Check if already exists
-    auto it = trackedMessages.find(key);
-    if (it != trackedMessages.end()) {
-      // Update timestamp but preserve acknowledged status
-      it->second.timestamp = currentTime;
-      Log(logger::GENERAL, "MessageTracker: Updated message %u from node %u\n",
-          messageId, originNode);
-      return true;
-    }
-    
-    // Handle capacity 0 case - don't add new entries
-    if (maxTrackedMessages == 0) {
-      Log(logger::GENERAL, "MessageTracker: Cannot track message %u (capacity=0)\n",
-          messageId);
-      return false;
-    }
-    
-    // Enforce memory limits before adding new entry
-    if (trackedMessages.size() >= maxTrackedMessages) {
-      enforceMemoryLimit();
-    }
-    
-    // Add new entry
-    trackedMessages[key] = TrackedMessage(currentTime);
-    Log(logger::GENERAL, "MessageTracker: Tracked message %u from node %u (size=%zu)\n",
-        messageId, originNode, trackedMessages.size());
-    return true;
-  }
-  
-  /**
-   * Mark a message as acknowledged
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   * @return true if the message was found and marked, false otherwise
-   */
-  bool markAcknowledged(uint32_t messageId, uint32_t originNode) {
-    MessageKey key = {messageId, originNode};
-    auto it = trackedMessages.find(key);
-    
-    if (it != trackedMessages.end()) {
-      it->second.acknowledged = true;
-      Log(logger::GENERAL, "MessageTracker: Acknowledged message %u from node %u\n",
-          messageId, originNode);
-      return true;
-    }
-    
-    Log(logger::GENERAL, "MessageTracker: Message %u from node %u not found for acknowledgment\n",
-        messageId, originNode);
-    return false;
-  }
-  
-  /**
-   * Check if a message has been acknowledged
-   * @param messageId The unique message identifier
-   * @param originNode The node that originated the message
-   * @return true if acknowledged, false if not found or not acknowledged
-   */
-  bool isAcknowledged(uint32_t messageId, uint32_t originNode) {
-    MessageKey key = {messageId, originNode};
-    auto it = trackedMessages.find(key);
-    
-    if (it != trackedMessages.end()) {
-      return it->second.acknowledged;
-    }
-    
-    return false;
-  }
-  
-  /**
-   * Cleanup expired entries based on the configured timeout
-   * @return Number of entries removed
-   */
-  uint32_t cleanup() {
-    uint32_t currentTime = millis();
-    uint32_t removedCount = 0;
-    
-    auto it = trackedMessages.begin();
-    while (it != trackedMessages.end()) {
-      // Handle millis() overflow - if currentTime < timestamp, assume overflow
-      uint32_t age;
-      if (currentTime >= it->second.timestamp) {
-        age = currentTime - it->second.timestamp;
-      } else {
-        // Overflow occurred
-        age = (0xFFFFFFFF - it->second.timestamp) + currentTime + 1;
-      }
-      
-      if (age > messageTimeoutMs) {
-        it = trackedMessages.erase(it);
-        removedCount++;
-      } else {
-        ++it;
-      }
-    }
-    
-    if (removedCount > 0) {
-      Log(logger::GENERAL, "MessageTracker: Cleaned up %u expired entries (size=%zu)\n",
-          removedCount, trackedMessages.size());
-    }
-    
-    return removedCount;
-  }
-  
-  /**
-   * Get the current number of tracked messages
-   * @return Number of entries in the tracker
-   */
-  size_t size() const {
-    return trackedMessages.size();
-  }
-  
-  /**
-   * Check if the tracker is empty
-   * @return true if no messages are being tracked
-   */
-  bool empty() const {
-    return trackedMessages.empty();
-  }
-  
-  /**
-   * Clear all tracked messages
-   */
-  void clear() {
-    trackedMessages.clear();
-    Log(logger::GENERAL, "MessageTracker: Cleared all entries\n");
-  }
-  
-  /**
-   * Get the maximum number of tracked messages
-   * @return Configured maximum
-   */
-  uint16_t getMaxMessages() const {
-    return maxTrackedMessages;
-  }
-  
-  /**
-   * Get the timeout value in milliseconds
-   * @return Configured timeout
-   */
-  uint32_t getTimeoutMs() const {
-    return messageTimeoutMs;
-  }
-  
-  /**
-   * Set a new maximum for tracked messages
-   * If current size exceeds new max, oldest entries will be removed
-   * @param maxMessages New maximum
-   */
-  void setMaxMessages(uint16_t maxMessages) {
-    maxTrackedMessages = maxMessages;
-    
-    // Enforce new limit if needed
-    while (trackedMessages.size() > maxTrackedMessages) {
-      enforceMemoryLimit();
-    }
-  }
-  
-  /**
-   * Set a new timeout value
-   * @param timeoutMs New timeout in milliseconds
-   */
-  void setTimeoutMs(uint32_t timeoutMs) {
-    messageTimeoutMs = timeoutMs;
-  }
-
-private:
-  std::map<MessageKey, TrackedMessage> trackedMessages;
-  uint16_t maxTrackedMessages;
-  uint32_t messageTimeoutMs;
-  
-  /**
-   * Enforce memory limit by removing the oldest entry
-   * @return true if an entry was removed, false if tracker was empty
-   */
-  bool enforceMemoryLimit() {
-    if (trackedMessages.empty()) {
-      return false;
-    }
-    
-    // Find the oldest entry
-    auto oldest = trackedMessages.begin();
-    uint32_t oldestTimestamp = oldest->second.timestamp;
-    
-    for (auto it = trackedMessages.begin(); it != trackedMessages.end(); ++it) {
-      if (it->second.timestamp < oldestTimestamp) {
-        oldest = it;
-        oldestTimestamp = it->second.timestamp;
-      }
-    }
-    
-    Log(logger::GENERAL, "MessageTracker: Evicting oldest entry (msg=%u, node=%u) to enforce limit\n",
-        oldest->first.messageId, oldest->first.originNode);
-    
-    trackedMessages.erase(oldest);
-    return true;
-  }
-};
-
-}  // namespace painlessmesh
-
-#endif  // _PAINLESS_MESH_MESSAGE_TRACKER_HPP_