@alteriom/painlessmesh 1.9.18 → 1.9.20

package/src/painlessmesh/mesh.hpp

@@ -352,6 +352,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
     if (!isExternalScheduler) {
       delete mScheduler;
+      mScheduler = nullptr;
     }
   }
 
@@ -876,7 +877,11 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * @return Number of available gateways
    */
   size_t getGatewayCount() {
-    return getNodesWithInternet().size();
+    size_t count = 0;
+    for (const auto& bridge : knownBridges) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) count++;
+    }
+    return count;
   }
 
   /**
@@ -1005,6 +1010,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     using namespace logger;
     if (bridgeCleanupTask != nullptr) {
       bridgeCleanupTask->disable();
+      // Task remains in scheduler (disabled) — negligible overhead.
+      // The scheduler will skip it on each cycle.
       bridgeCleanupTask = nullptr;
       Log(GENERAL, "disableBridgeCleanup(): Cleanup task disabled\n");
     }
@@ -1405,10 +1412,13 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   bool cancelInternetRequest(uint32_t messageId) {
     auto it = pendingInternetRequests.find(messageId);
     if (it != pendingInternetRequests.end()) {
-      if (it->second.callback) {
-        it->second.callback(false, 0, "Request cancelled");
-      }
+      auto callback = it->second.callback;
       pendingInternetRequests.erase(it);
+      if (callback) {
+        this->addTask([callback]() {
+          callback(false, 0, "Request cancelled");
+        });
+      }
       Log(logger::GENERAL, "cancelInternetRequest(): Cancelled msgId=%u\n", messageId);
       return true;
     }
@@ -1532,10 +1542,41 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       isRetryable = true;
       Log(COMMUNICATION, "handleGatewayAck(): HTTP 429 rate limit, marking as retryable\n");
     }
-    // Network errors (httpStatus == 0) are retryable
+    // Network errors (httpStatus == 0) EXCEPT gateway connectivity errors
+    // Gateway connectivity errors are infrastructure issues (not transient)
     else if (ack.httpStatus == 0) {
-      isRetryable = true;
-      Log(COMMUNICATION, "handleGatewayAck(): Network error, marking as retryable\n");
+      // Check if this is a gateway-level connectivity error (non-retryable)
+      bool isGatewayConnectivityError = false;
+      
+      // These errors indicate infrastructure issues that won't be fixed by retrying:
+      // - "Router has no internet access" - WAN connection down
+      // - "Gateway WiFi not connected" - ESP not associated with WiFi
+      // - "Captive portal detected" - Router requires web authentication
+      // Use find() for std::string (test env) or indexOf() for Arduino String
+      bool routerError = false, wifiError = false, captivePortalError = false;
+      #if defined(PAINLESSMESH_BOOST)
+        // Test environment: TSTRING is std::string, use find()
+        routerError = (ack.error.find("Router has no internet") != std::string::npos);
+        wifiError = (ack.error.find("Gateway WiFi not connected") != std::string::npos);
+        captivePortalError = (ack.error.find("Captive portal detected") != std::string::npos);
+      #else
+        // Arduino environment: TSTRING is String, use indexOf()
+        routerError = (ack.error.indexOf("Router has no internet") >= 0);
+        wifiError = (ack.error.indexOf("Gateway WiFi not connected") >= 0);
+        captivePortalError = (ack.error.indexOf("Captive portal detected") >= 0);
+      #endif
+      
+      if (routerError || wifiError || captivePortalError) {
+        isGatewayConnectivityError = true;
+        Log(COMMUNICATION, "handleGatewayAck(): Gateway connectivity error detected (non-retryable): %s\n", 
+            ack.error.c_str());
+      }
+      
+      // Only mark as retryable if it's NOT a gateway connectivity error
+      if (!isGatewayConnectivityError) {
+        isRetryable = true;
+        Log(COMMUNICATION, "handleGatewayAck(): Network error, marking as retryable\n");
+      }
     }
     // HTTP 4xx client errors (except 429) are NOT retryable
     // HTTP 3xx redirects are NOT retryable (should be followed by HTTPClient)
@@ -1923,8 +1964,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         return rtcTime;
       }
     }
-    // Fallback to mesh time (microseconds)
-    return this->getNodeTime();
+    // Fallback to mesh time (microseconds), converted to seconds for consistency
+    return getNodeTime() / 1000000;
   }
 
   /**
@@ -2295,7 +2336,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     auto tree = this->asNodeTree();
     
     // BFS to find hop count
-    std::queue<std::pair<uint32_t, uint8_t>> queue;  // (nodeId, hops)
+    std::queue<std::pair<uint32_t, uint16_t>> queue;  // (nodeId, hops)
     std::set<uint32_t> visited;
     
     // Start from this node
@@ -2307,7 +2348,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       queue.pop();
       
       uint32_t currentNode = current.first;
-      uint8_t hops = current.second;
+      uint16_t hops = current.second;
       
       // Found the target
       if (currentNode == nodeId) {
@@ -2321,7 +2362,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         for (auto neighbor : neighbors) {
           if (visited.find(neighbor) == visited.end()) {
             visited.insert(neighbor);
-            queue.push({neighbor, static_cast<uint8_t>(hops + 1)});
+            queue.push({neighbor, static_cast<uint16_t>(hops + 1)});
           }
         }
       }
@@ -2450,7 +2491,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     // Reconstruct path from parent map
     if (found) {
       uint32_t current = nodeId;
-      while (current != 0) {
+      size_t maxIter = parent.size() + 1;
+      while (current != 0 && maxIter-- > 0) {
         path.insert(path.begin(), current);
         current = parent[current];
       }
@@ -2495,7 +2537,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     uint32_t totalMessagesDropped = 0;
     uint32_t totalLatency = 0;
     uint32_t latencySampleCount = 0;
-    int8_t sumRSSI = 0;
+    int32_t sumRSSI = 0;
     int8_t minRSSI = 0;
     int8_t maxRSSI = -127;
     uint32_t rssiCount = 0;
@@ -2792,76 +2834,6 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     return lastBridgeChange;
   }
 
-  /**
-   * Get Internet path to specific node
-   * 
-   * Returns the routing path from the specified node to the Internet bridge.
-   * Path includes all intermediate nodes from source to bridge.
-   * 
-   * \code
-   * auto path = mesh.getInternetPath(targetNodeId);
-   * Serial.print("Path to Internet: ");
-   * for (auto nodeId : path) {
-   *   Serial.printf("%u -> ", nodeId);
-   * }
-   * Serial.println("Internet");
-   * \endcode
-   * 
-   * @param nodeId Node to find path from
-   * @return Vector of node IDs representing the path (empty if no path)
-   */
-  std::vector<uint32_t> getInternetPath(uint32_t nodeId) {
-    std::vector<uint32_t> path;
-    
-    // Get primary bridge
-    auto primaryBridge = this->getPrimaryBridge();
-    if (primaryBridge == nullptr) {
-      Log(logger::GENERAL, "getInternetPath(): No bridge available\n");
-      return path;
-    }
-    
-    // If requesting path for the bridge itself
-    if (nodeId == primaryBridge->nodeId) {
-      path.push_back(nodeId);
-      return path;
-    }
-    
-    // Start with the target node
-    path.push_back(nodeId);
-    
-    // For now, simplified routing: if direct connection, add bridge
-    // TODO: Implement proper multi-hop path discovery
-    if (this->isConnected(primaryBridge->nodeId)) {
-      path.push_back(primaryBridge->nodeId);
-    }
-    
-    return path;
-  }
-
-  /**
-   * Get bridge node ID for specific node
-   * 
-   * Returns the bridge node ID that the specified node should use to reach Internet.
-   * For most cases, this is the primary bridge.
-   * 
-   * \code
-   * uint32_t bridgeId = mesh.getBridgeForNodeId(targetNodeId);
-   * if (bridgeId != 0) {
-   *   Serial.printf("Node %u uses bridge %u\n", targetNodeId, bridgeId);
-   * }
-   * \endcode
-   * 
-   * @param nodeId Node to find bridge for
-   * @return Bridge node ID, or 0 if no bridge available
-   */
-  uint32_t getBridgeForNodeId(uint32_t nodeId) {
-    auto primaryBridge = this->getPrimaryBridge();
-    if (primaryBridge != nullptr) {
-      return primaryBridge->nodeId;
-    }
-    return 0;
-  }
-
   /**
    * Export topology as DOT format (Graphviz)
    * 
@@ -3222,7 +3194,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   bool isExternalScheduler = false;
 
   /// Is the node a root node
-  bool shouldContainRoot;
+  bool shouldContainRoot = false;
 
   Scheduler *mScheduler;
 
@@ -3237,7 +3209,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    */
   bool semaphoreTake() {
 #ifdef ESP32
-    return xSemaphoreTake(xSemaphore, (TickType_t)100) == pdTRUE;  // Was 10
+    return xSemaphoreTake(xSemaphore, (TickType_t)1000) == pdTRUE;
 #else
     return true;
 #endif

package/src/painlessmesh/message_queue.hpp

@@ -104,9 +104,8 @@ public:
    * Constructor
    * @param maxSize Maximum number of messages in queue
    */
-  explicit MessageQueue(uint32_t maxSize = 1000) 
+  explicit MessageQueue(uint32_t maxSize = 1000)
     : maxQueueSize(maxSize), nextMessageId(1) {
-    messages.reserve(maxSize);
   }
   
   /**

package/src/painlessmesh/metrics.hpp

@@ -33,8 +33,7 @@ class Timer {
 
   uint32_t elapsed_us() const {
 #ifdef ESP32
-    return static_cast<uint32_t>((esp_timer_get_time() - start_time_us_) /
-                                 1000);
+    return static_cast<uint32_t>(esp_timer_get_time() - start_time_us_);
 #else
     return elapsed_ms() * 1000;  // Fallback to millisecond precision
 #endif
@@ -58,266 +57,7 @@ class Timer {
 #endif
 };
 
-/**
- * Message statistics tracking
- */
-struct MessageStats {
-  uint32_t messages_sent = 0;
-  uint32_t messages_received = 0;
-  uint32_t messages_dropped = 0;
-  uint32_t messages_retransmitted = 0;
-  uint32_t bytes_sent = 0;
-  uint32_t bytes_received = 0;
-  uint32_t parse_errors = 0;
-  uint32_t validation_errors = 0;
-
-  // Latency tracking
-  uint32_t min_latency_ms = UINT32_MAX;
-  uint32_t max_latency_ms = 0;
-  uint32_t total_latency_ms = 0;
-  uint32_t latency_samples = 0;
-
-  void record_sent_message(size_t bytes) {
-    messages_sent++;
-    bytes_sent += bytes;
-  }
-
-  void record_received_message(size_t bytes) {
-    messages_received++;
-    bytes_received += bytes;
-  }
-
-  void record_dropped_message() { messages_dropped++; }
-
-  void record_retransmission() { messages_retransmitted++; }
-
-  void record_parse_error() { parse_errors++; }
-
-  void record_validation_error() { validation_errors++; }
-
-  void record_latency(uint32_t latency_ms) {
-    min_latency_ms = std::min(min_latency_ms, latency_ms);
-    max_latency_ms = std::max(max_latency_ms, latency_ms);
-    total_latency_ms += latency_ms;
-    latency_samples++;
-  }
-
-  uint32_t average_latency_ms() const {
-    return latency_samples > 0 ? total_latency_ms / latency_samples : 0;
-  }
-
-  double throughput_bps() const {
-#ifdef ARDUINO
-    uint32_t uptime_s = millis() / 1000;
-#else
-    // For non-Arduino builds, use a simpler approach or disable this feature
-    uint32_t uptime_s = 1;  // Avoid division by zero
-#endif
-    return uptime_s > 0 ? (bytes_sent + bytes_received) * 8.0 / uptime_s : 0.0;
-  }
-
-  double packet_loss_rate() const {
-    uint32_t total_attempted = messages_sent + messages_dropped;
-    return total_attempted > 0
-               ? static_cast<double>(messages_dropped) / total_attempted
-               : 0.0;
-  }
-
-  void reset() { *this = MessageStats{}; }
-};
-
-/**
- * Memory usage tracking
- */
-struct MemoryStats {
-  uint32_t heap_free = 0;
-  uint32_t heap_max_alloc = 0;
-  uint32_t heap_min_free = UINT32_MAX;
-  uint32_t psram_free = 0;
-  uint32_t stack_high_water = 0;
-
-  void update() {
-#ifdef ESP32
-    heap_free = ESP.getFreeHeap();
-    heap_max_alloc = ESP.getMaxAllocHeap();
-    heap_min_free = std::min(heap_min_free, heap_free);
-
-#ifdef BOARD_HAS_PSRAM
-    psram_free = ESP.getFreePsram();
-#endif
-
-    stack_high_water = uxTaskGetStackHighWaterMark(NULL);
-#elif defined(ESP8266)
-    heap_free = ESP.getFreeHeap();
-    heap_max_alloc = ESP.getMaxFreeBlockSize();
-    heap_min_free = std::min(heap_min_free, heap_free);
-#endif
-  }
-
-  bool is_memory_critical() const {
-    return heap_free < 10000;  // Less than 10KB free is critical
-  }
-
-  bool is_memory_low() const {
-    return heap_free < 20000;  // Less than 20KB free is low
-  }
-};
-
-/**
- * Network topology metrics
- */
-struct TopologyStats {
-  uint32_t node_count = 0;
-  uint32_t connection_count = 0;
-  uint32_t max_hops = 0;
-  uint32_t connection_changes = 0;
-  uint32_t failed_connections = 0;
-
-  void record_topology_change(uint32_t nodes, uint32_t connections,
-                              uint32_t hops) {
-    node_count = nodes;
-    connection_count = connections;
-    max_hops = hops;
-    connection_changes++;
-  }
-
-  void record_failed_connection() { failed_connections++; }
-
-  double connection_stability() const {
-    return connection_changes > 0
-               ? 1.0 - static_cast<double>(failed_connections) /
-                           connection_changes
-               : 1.0;
-  }
-};
-
-/**
- * Comprehensive metrics collector
- */
-class MetricsCollector {
- public:
-  MetricsCollector() : start_time_(get_current_time()) {}
-
-  MessageStats& message_stats() { return message_stats_; }
-  MemoryStats& memory_stats() { return memory_stats_; }
-  TopologyStats& topology_stats() { return topology_stats_; }
-
-  const MessageStats& message_stats() const { return message_stats_; }
-  const MemoryStats& memory_stats() const { return memory_stats_; }
-  const TopologyStats& topology_stats() const { return topology_stats_; }
-
-  /**
-   * Update all metrics (call periodically)
-   */
-  void update() {
-    memory_stats_.update();
-    last_update_ = get_current_time();
-  }
-
-  /**
-   * Get uptime in seconds
-   */
-  uint32_t uptime_seconds() const {
-    return (get_current_time() - start_time_) / 1000;
-  }
-
-  /**
-   * Generate JSON status report
-   */
-  TSTRING generate_status_json() const {
-    TSTRING json = "{";
-    json += "\"uptime\":";
-    json += std::to_string(uptime_seconds());
-    json += ",";
-    json += "\"messages\":{";
-    json += "\"sent\":";
-    json += std::to_string(message_stats_.messages_sent);
-    json += ",";
-    json += "\"received\":";
-    json += std::to_string(message_stats_.messages_received);
-    json += ",";
-    json += "\"dropped\":";
-    json += std::to_string(message_stats_.messages_dropped);
-    json += ",";
-    json += "\"avg_latency\":";
-    json += std::to_string(message_stats_.average_latency_ms());
-    json += ",";
-    json += "\"throughput\":";
-    json += std::to_string(message_stats_.throughput_bps());
-    json += ",";
-    json += "\"packet_loss\":";
-    json += std::to_string(message_stats_.packet_loss_rate());
-    json += "},";
-    json += "\"memory\":{";
-    json += "\"heap_free\":";
-    json += std::to_string(memory_stats_.heap_free);
-    json += ",";
-    json += "\"heap_min\":";
-    json += std::to_string(memory_stats_.heap_min_free);
-    json += ",";
-    json += "\"critical\":";
-    json += (memory_stats_.is_memory_critical() ? "true" : "false");
-    json += "},";
-    json += "\"topology\":{";
-    json += "\"nodes\":";
-    json += std::to_string(topology_stats_.node_count);
-    json += ",";
-    json += "\"connections\":";
-    json += std::to_string(topology_stats_.connection_count);
-    json += ",";
-    json += "\"max_hops\":";
-    json += std::to_string(topology_stats_.max_hops);
-    json += ",";
-    json += "\"stability\":";
-    json += std::to_string(topology_stats_.connection_stability());
-    json += "}";
-    json += "}";
-    return json;
-  }
-
-  /**
-   * Reset all metrics
-   */
-  void reset() {
-    message_stats_.reset();
-    topology_stats_ = TopologyStats{};
-    start_time_ = get_current_time();
-  }
-
-  /**
-   * Check if metrics indicate performance issues
-   */
-  bool has_performance_issues() const {
-    return memory_stats_.is_memory_critical() ||
-           message_stats_.packet_loss_rate() > 0.1 ||     // > 10% packet loss
-           topology_stats_.connection_stability() < 0.8;  // < 80% stability
-  }
-
- private:
-  uint32_t get_current_time() const {
-#ifdef ARDUINO
-    return millis();
-#else
-    auto now = std::chrono::steady_clock::now();
-    auto duration = now.time_since_epoch();
-    return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-        .count();
-#endif
-  }
-
-  MessageStats message_stats_;
-  MemoryStats memory_stats_;
-  TopologyStats topology_stats_;
-  uint32_t start_time_;
-  uint32_t last_update_ = 0;
-};
-
-// Global metrics instance (optional, can be disabled)
-#ifdef PAINLESS_MESH_ENABLE_METRICS
-extern MetricsCollector global_metrics;
-#endif
-
 }  // namespace metrics
 }  // namespace painlessmesh
 
-#endif  // _PAINLESS_MESH_METRICS_HPP_
+#endif  // _PAINLESS_MESH_METRICS_HPP_

package/src/painlessmesh/validation.hpp

@@ -8,12 +8,9 @@
  * security and robustness of the mesh network.
  */
 
-#include <list>
-#include <map>
 #ifndef ARDUINO
 #include <chrono>
 #endif
-#include "ArduinoJson.h"
 #include "painlessmesh/configuration.hpp"
 
 namespace painlessmesh {
@@ -45,146 +42,6 @@ struct ValidationConfig {
   bool strict_type_checking = true;   // Enable strict type validation
 };
 
-/**
- * Rate limiting for preventing message spam
- */
-class RateLimiter {
- public:
-  RateLimiter(size_t max_messages_per_second = 10, size_t window_size_ms = 1000)
-      : max_messages_(max_messages_per_second), window_size_(window_size_ms) {}
-
-  bool allow_message(uint32_t node_id) {
-    uint32_t current_time = get_current_time();
-    auto& history = node_history_[node_id];
-
-    // Remove old entries outside the window
-    while (!history.empty() &&
-           (current_time - history.front()) > window_size_) {
-      history.pop_front();
-    }
-
-    // Check if limit is exceeded
-    if (history.size() >= max_messages_) {
-      return false;
-    }
-
-    // Record this message
-    history.push_back(current_time);
-    return true;
-  }
-
-  void clear_node_history(uint32_t node_id) { node_history_.erase(node_id); }
-
-  void clear_all_history() { node_history_.clear(); }
-
- private:
-  uint32_t get_current_time() const {
-#ifdef ARDUINO
-    return millis();
-#else
-    auto now = std::chrono::steady_clock::now();
-    auto duration = now.time_since_epoch();
-    return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-        .count();
-#endif
-  }
-
-  size_t max_messages_;
-  size_t window_size_;
-  std::map<uint32_t, std::list<uint32_t>> node_history_;
-};
-
-/**
- * JSON message validator
- */
-class MessageValidator {
- public:
-  explicit MessageValidator(const ValidationConfig& config = ValidationConfig{})
-      : config_(config) {}
-
-  /**
-   * Validate a JSON message for basic structure and security
-   */
-  ValidationResult validate_message(const JsonObject& obj,
-                                    size_t message_size = 0) const {
-    // Check message size
-    if (message_size > config_.max_message_size) {
-      return ValidationResult::MESSAGE_TOO_LARGE;
-    }
-
-    // Check required fields based on message type
-    if (!obj["type"].is<int>()) {
-      return ValidationResult::MISSING_REQUIRED_FIELD;
-    }
-
-    // Validate node IDs if present
-    if (obj["from"].is<uint32_t>()) {
-      uint32_t from_id = obj["from"].as<uint32_t>();
-      if (!is_valid_node_id(from_id)) {
-        return ValidationResult::INVALID_NODE_ID;
-      }
-    }
-
-    if (obj["dest"].is<uint32_t>()) {
-      uint32_t dest_id = obj["dest"].as<uint32_t>();
-      if (dest_id != 0 && !is_valid_node_id(dest_id)) {  // 0 is broadcast
-        return ValidationResult::INVALID_NODE_ID;
-      }
-    }
-
-    // Validate string fields
-    for (JsonPair pair : obj) {
-      if (pair.value().is<const char*>()) {
-        const char* str_value = pair.value().as<const char*>();
-        if (strlen(str_value) > config_.max_string_length) {
-          return ValidationResult::INVALID_FIELD_VALUE;
-        }
-      }
-    }
-
-    return ValidationResult::VALID;
-  }
-
-  /**
-   * Validate node ID range
-   */
-  bool is_valid_node_id(uint32_t node_id) const {
-    return node_id >= config_.min_node_id && node_id <= config_.max_node_id;
-  }
-
-  /**
-   * Get validation error message
-   */
-  const char* get_error_message(ValidationResult result) const {
-    switch (result) {
-      case ValidationResult::VALID:
-        return "Valid";
-      case ValidationResult::INVALID_JSON:
-        return "Invalid JSON format";
-      case ValidationResult::MISSING_REQUIRED_FIELD:
-        return "Missing required field";
-      case ValidationResult::INVALID_FIELD_TYPE:
-        return "Invalid field type";
-      case ValidationResult::INVALID_FIELD_VALUE:
-        return "Invalid field value";
-      case ValidationResult::MESSAGE_TOO_LARGE:
-        return "Message too large";
-      case ValidationResult::INVALID_NODE_ID:
-        return "Invalid node ID";
-      case ValidationResult::RATE_LIMIT_EXCEEDED:
-        return "Rate limit exceeded";
-      default:
-        return "Unknown error";
-    }
-  }
-
-  const ValidationConfig& get_config() const { return config_; }
-  void set_config(const ValidationConfig& config) { config_ = config; }
-
- private:
-  ValidationConfig config_;
-};
-
 /**
  * Secure random number generation for mesh operations
  */