@alteriom/painlessmesh 2.0.1 → 2.0.3

package/src/painlessmesh/mesh.hpp

@@ -98,6 +98,9 @@ struct PendingInternetRequest {
   TSTRING destination = "";        ///< Internet destination URL
   TSTRING payload = "";            ///< Request payload
   internetResultCallback_t callback;  ///< User callback for result
+  /// Why the last attempt failed, when retries were spent waiting for a
+  /// gateway; the final callback reports it instead of a bare retry count.
+  TSTRING lastError = "";
 
   /**
    * Check if this request has timed out
@@ -243,6 +246,37 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     painlessmesh::ntp::addPackageCallback(this->callbackList, (*this));
     painlessmesh::router::addPackageCallback(this->callbackList, (*this));
 
+    // Every node answers a gateway request it cannot serve. A bridge that
+    // reboots, crashes or is reflashed as a regular node announces nothing
+    // -- only a bridge stepping down in-process sends `leaving` -- so its
+    // peers keep it in knownBridges until its last status ages out
+    // (bridgeTimeoutMs, 60 s) and may route every Internet request to it.
+    // A regular node had no GATEWAY_DATA handler and dropped them without a
+    // word; the origin waited out its request timeout, 30 s, each time.
+    // Found on the HIL rig while validating 2.0.3.
+    //
+    // Registered first, so a gateway's own handler (initGatewayInternetHandler
+    // in wifi.hpp, or a test's stand-in) is always the second: this one
+    // stays silent whenever any other GATEWAY_DATA handler exists.
+    this->callbackList.onPackage(
+        protocol::GATEWAY_DATA,
+        [this](protocol::Variant& variant, std::shared_ptr<T> ingress,
+               uint32_t) {
+          if (this->callbackList.count(protocol::GATEWAY_DATA) > 1) {
+            return false;  // this node is a gateway; its handler answers
+          }
+          auto pkg = variant.to<gateway::GatewayDataPackage>();
+          char errorBuf[96];
+          snprintf(errorBuf, sizeof(errorBuf), "Node %u %s",
+                   static_cast<unsigned>(this->nodeId),
+                   gateway::GATEWAY_NOT_A_GATEWAY_PHRASE);
+          Log(logger::ERROR,
+              "GATEWAY_DATA from node %u answered: %s\n",
+              static_cast<unsigned>(pkg.originNode), errorBuf);
+          this->sendGatewayAck(pkg, false, 0, TSTRING(errorBuf), ingress);
+          return true;
+        });
+
     // Seed delivery-confirmation ids with a random value so they do not
     // restart at 1 after a reboot — a delayed ACK for a pre-reboot
     // message could otherwise match a fresh message's id and report a
@@ -1349,7 +1383,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     
     size_t removed = sizeBefore - knownBridges.size();
     if (removed > 0) {
-      Log(GENERAL, "cleanupExpiredBridges(): Removed %u expired bridges\n", removed);
+      Log(GENERAL, "cleanupExpiredBridges(): Removed %lu expired bridges\n",
+          static_cast<unsigned long>(removed));
     }
   }
 
@@ -1432,6 +1467,31 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     return internetHealthChecker.hasLocalInternet();
   }
 
+  /**
+   * Can this node serve a gateway request on its own uplink right now?
+   *
+   * hasLocalInternet() is the last periodic probe's answer. On a bridge the
+   * first probe runs while the station is still associating and fails, and
+   * the next is a full interval (30 s) away, so for that whole window a send
+   * fell through to the mesh path and was refused for want of a peer (issue
+   * #450). When the flag says no and the health check is running, spend the
+   * one on-demand probe the checker allows per period: a send made after the
+   * uplink came up is then served locally, and a node whose uplink really is
+   * down pays one probe per interval, not one per call.
+   *
+   * @return true if the request should go to this node's own gateway handler
+   */
+  bool uplinkServesLocally() {
+    if (hasLocalInternet()) return true;
+    if (!isInternetHealthCheckEnabled()) return false;
+    if (internetHealthChecker.checkOnDemand()) {
+      Log(logger::COMMUNICATION,
+          "uplinkServesLocally(): on-demand probe found the uplink up\n");
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Register callback for local Internet connectivity changes
    * 
@@ -1546,8 +1606,17 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   void enableInternetHealthCheck() {
     using namespace logger;
     if (internetHealthCheckTask != nullptr) {
-      Log(GENERAL, "enableInternetHealthCheck(): Already enabled\n");
-      return;
+      if (internetHealthCheckTask->isEnabled()) {
+        Log(GENERAL, "enableInternetHealthCheck(): Already enabled\n");
+        return;
+      }
+      // A stop()/re-init cycle -- what bridge promotion does before calling
+      // initAsBridge() again -- disables every task and drops it from the
+      // reusable pool, but this member still points at it. Refusing here
+      // would leave a re-initialised node with no health check at all, and
+      // so with hasLocalInternet() stuck false (issue #445). Re-arm instead,
+      // releasing the spent task so the pool can reclaim it.
+      internetHealthCheckTask = nullptr;
     }
     
     Log(GENERAL, "enableInternetHealthCheck(): Starting health check task (interval: %u ms)\n",
@@ -1663,7 +1732,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     // A shared gateway can execute its own gateway package locally. Keep the
     // same package handler, pending-request tracking and callback semantics,
     // but do not require a mesh peer merely to reach this node's own uplink.
-    if (hasLocalInternet()) {
+    if (uplinkServesLocally()) {
       PendingInternetRequest request;
       request.messageId = messageId;
       request.timestamp = millis();
@@ -1678,20 +1747,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       request.callback = callback;
       pendingInternetRequests[messageId] = request;
 
-      gateway::GatewayDataPackage pkg;
-      pkg.from = this->nodeId;
-      pkg.dest = this->nodeId;
-      pkg.messageId = messageId;
-      pkg.originNode = this->nodeId;
-      pkg.timestamp = this->getNodeTime();
-      pkg.priority = priority;
-      pkg.destination = destination;
-      pkg.payload = payload;
-      pkg.contentType = "application/json";
-      pkg.retryCount = 0;
-      pkg.requiresAck = true;
-      protocol::Variant variant(&pkg);
-      this->callbackList.execute(protocol::GATEWAY_DATA, variant, nullptr, 0);
+      dispatchInternetRequestLocally(messageId, priority, 0, destination,
+                                     payload);
       return messageId;
     }
 
@@ -1938,6 +1995,65 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   /**
    * Handle incoming gateway acknowledgment package
    */
+ public:
+  // Public: the gateway handler in wifi.hpp, a derived class, answers with it.
+  /**
+   * Answer a gateway request: send its GATEWAY_ACK back to the origin node.
+   *
+   * A request this node originated completes locally, without a mesh hop.
+   * Otherwise the ack is routed to the origin; when the NodeTree has not yet
+   * converged enough for findRoute() to resolve it -- a freshly promoted
+   * gateway can receive data before that -- the connection the request
+   * arrived on is a valid reverse path, since every intermediate node routes
+   * the addressed ack onward toward the origin.
+   *
+   * Used by the gateway's own handler (wifi.hpp) and by the fallback every
+   * node registers for requests it cannot serve.
+   */
+  void sendGatewayAck(const gateway::GatewayDataPackage& request, bool success,
+                      uint16_t httpStatus, const TSTRING& error,
+                      std::shared_ptr<T> ingressConnection = nullptr) {
+    using namespace logger;
+
+    gateway::GatewayAckPackage ack;
+    ack.from = this->nodeId;
+    ack.dest = request.originNode;
+    ack.messageId = request.messageId;
+    ack.originNode = request.originNode;
+    ack.success = success;
+    ack.httpStatus = httpStatus;
+    ack.error = error;
+    ack.timestamp = this->getNodeTime();
+
+    if (request.originNode == this->nodeId) {
+      protocol::Variant variant(&ack);
+      this->callbackList.execute(protocol::GATEWAY_ACK, variant, nullptr, 0);
+      Log(COMMUNICATION,
+          "Completed local GATEWAY_ACK (success=%d, http=%d)\n", success,
+          httpStatus);
+      return;
+    }
+
+    auto conn = router::findRoute<T>((*this), request.originNode);
+    if (!conn && ingressConnection) {
+      conn = ingressConnection;
+      Log(COMMUNICATION,
+          "Routing GATEWAY_ACK to node %u through request ingress while "
+          "topology converges\n",
+          request.originNode);
+    }
+    if (conn) {
+      protocol::Variant variant(&ack);
+      router::send(std::move(variant), conn);
+      Log(COMMUNICATION, "Sent GATEWAY_ACK to node %u (success=%d, http=%d)\n",
+          request.originNode, success, httpStatus);
+    } else {
+      Log(ERROR, "Failed to send GATEWAY_ACK: no route to node %u\n",
+          request.originNode);
+    }
+  }
+
+ private:
   void handleGatewayAck(const gateway::GatewayAckPackage& ack) {
     using namespace logger;
     Log(COMMUNICATION, "handleGatewayAck(): msgId=%u success=%d http=%u\n",
@@ -1961,6 +2077,46 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       return;
     }
 
+    // The node this request went to is not a gateway (issue found on the
+    // HIL rig while validating 2.0.3): it rebooted or was reflashed as a
+    // regular node without announcing it, and its last bridge status is
+    // still inside bridgeTimeoutMs. Forget it and send again through the
+    // next gateway at once. The retry budget is not spent: nothing was
+    // attempted against the Internet, and every such answer removes one
+    // entry from knownBridges, so this cannot loop.
+    if (gateway::responseContains(ack.error,
+                                  gateway::GATEWAY_NOT_A_GATEWAY_PHRASE)) {
+      const uint32_t staleGateway = request.gatewayNodeId;
+      bool forgot = this->forgetBridge(staleGateway);
+      if (ack.from != staleGateway) forgot = this->forgetBridge(ack.from) || forgot;
+      Log(ERROR, "handleGatewayAck(): %s; forgot it as a gateway for msgId=%u\n",
+          ack.error.c_str(), ack.messageId);
+
+      if (!forgot) {
+        // Nothing to forget, so a redispatch would reach the same node.
+        // Fall through to the ordinary failure path below.
+      } else if (this->getPrimaryBridge() == nullptr &&
+                 !this->uplinkServesLocally()) {
+        // No gateway left right now. On the rig the live bridge's first
+        // status arrived half a second after the ex-bridge answered, so an
+        // accepted request rides the ordinary retry backoff rather than
+        // failing on the spot; retryInternetRequest() reschedules while no
+        // gateway is known, and the final callback carries this reason.
+        char errorBuf[160];
+        snprintf(errorBuf, sizeof(errorBuf),
+                 "No Internet gateway available: %s", ack.error.c_str());
+        request.lastError = TSTRING(errorBuf);
+        scheduleInternetRetry(ack.messageId);
+        return;
+      } else {
+        const uint32_t messageId = ack.messageId;
+        this->addTask([this, messageId]() {
+          this->retryInternetRequest(messageId);
+        });
+        return;
+      }
+    }
+
     // Failure response - determine if retryable
     bool isRetryable = false;
     
@@ -2041,6 +2197,37 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     }
   }
 
+  /**
+   * Run a gateway request against this node's own uplink
+   *
+   * The package goes to this node's own GATEWAY_DATA handler, so the
+   * acknowledgment, pending-request tracking and callback semantics stay
+   * identical to a request served by a peer gateway.
+   *
+   * The handler runs synchronously and its acknowledgment can erase the
+   * pending entry, so callers must not hold a reference into
+   * pendingInternetRequests across this call -- pass copies.
+   */
+  void dispatchInternetRequestLocally(uint32_t messageId, uint8_t priority,
+                                      uint8_t retryCount,
+                                      const TSTRING& destination,
+                                      const TSTRING& payload) {
+    gateway::GatewayDataPackage pkg;
+    pkg.from = this->nodeId;
+    pkg.dest = this->nodeId;
+    pkg.messageId = messageId;
+    pkg.originNode = this->nodeId;
+    pkg.timestamp = this->getNodeTime();
+    pkg.priority = priority;
+    pkg.destination = destination;
+    pkg.payload = payload;
+    pkg.contentType = "application/json";
+    pkg.retryCount = retryCount;
+    pkg.requiresAck = true;
+    protocol::Variant variant(&pkg);
+    this->callbackList.execute(protocol::GATEWAY_DATA, variant, nullptr, 0);
+  }
+
   /**
    * Schedule retry for a failed Internet request
    */
@@ -2053,11 +2240,14 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     PendingInternetRequest& request = it->second;
 
     if (request.retryCount >= request.maxRetries) {
-      // Max retries reached - fail the request
+      // Max retries reached - fail the request, with the reason the retries
+      // were spent on when there is one
       Log(logger::ERROR, "scheduleInternetRetry(): Max retries reached for msgId=%u\n",
           messageId);
       if (request.callback) {
-        request.callback(false, 0, "Max retries exceeded");
+        request.callback(false, 0,
+                         request.lastError.length() > 0 ? request.lastError
+                                                        : TSTRING("Max retries exceeded"));
       }
       pendingInternetRequests.erase(it);
       return;
@@ -2087,6 +2277,28 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
     PendingInternetRequest& request = it->second;
 
+    // A request this node is serving from its own uplink never had a mesh
+    // hop to repeat. The routing path below needs an active peer and a
+    // discovered bridge, so a lone gateway would burn every retry without
+    // issuing a single HTTP request and then report "Max retries exceeded"
+    // in place of the transport error that actually occurred -- the same
+    // dishonest failure issue #446 was about.
+    //
+    // Copy what the redispatch needs first: the local handler runs
+    // synchronously and can erase this entry, leaving `request` dangling.
+    if (request.gatewayNodeId == this->nodeId && uplinkServesLocally()) {
+      const uint8_t priority = request.priority;
+      const uint8_t retryCount = request.retryCount;
+      const TSTRING destination = request.destination;
+      const TSTRING payload = request.payload;
+      Log(logger::COMMUNICATION,
+          "retryInternetRequest(): Retrying msgId=%u on the local uplink\n",
+          messageId);
+      dispatchInternetRequestLocally(messageId, priority, retryCount,
+                                     destination, payload);
+      return;
+    }
+
     // Check mesh connectivity before attempting retry
     // During bridge failover, connection may be temporarily lost
     if (!hasActiveMeshConnections()) {

package/src/painlessmesh/router.hpp

@@ -204,9 +204,14 @@ void routePackage(const layout::Layout<T>& layout,
 #if ARDUINOJSON_VERSION_MAJOR == 7
   protocol::Variant variant(pkg);
   if (variant.error) {
+    // The error is a DeserializationError object, not an integer: passing it
+    // through varargs is undefined behaviour. size_t is unsigned long on the
+    // 64-bit desktop build and unsigned int on ESP32/ESP8266, so it is cast
+    // to one type and printed with the matching specifier.
     Log(ERROR,
-        "routePackage(): parsing failed. err=%u, total_length=%d, data=%s<--\n",
-        variant.error, pkg.length(), pkg.c_str());
+        "routePackage(): parsing failed. err=%s, total_length=%lu, data=%s<--\n",
+        variant.error.c_str(), static_cast<unsigned long>(pkg.length()),
+        pkg.c_str());
     return;
   }
 
@@ -248,15 +253,20 @@ void routePackage(const layout::Layout<T>& layout,
   auto variant = std::make_shared<protocol::Variant>(pkg, capacity);
   
   if (variant->error) {
+    // Same two defects as the ArduinoJson 7 branch above (CodeQL
+    // cpp/wrong-type-format-argument, alerts #6-#9).
     if (variant->error == DeserializationError::NoMemory) {
       Log(ERROR,
-          "routePackage(): Message too large. length=%d, calculated_capacity=%u, "
-          "nesting_depth=%u. Consider increasing MAX_MESSAGE_CAPACITY if needed.\n",
-          pkg.length(), calculatedCapacity, nestingDepth);
+          "routePackage(): Message too large. length=%lu, calculated_capacity=%lu, "
+          "nesting_depth=%lu. Consider increasing MAX_MESSAGE_CAPACITY if needed.\n",
+          static_cast<unsigned long>(pkg.length()),
+          static_cast<unsigned long>(calculatedCapacity),
+          static_cast<unsigned long>(nestingDepth));
     } else {
       Log(ERROR,
-          "routePackage(): parsing failed. err=%u, length=%d, data=%s<--\n",
-          variant->error, pkg.length(), pkg.c_str());
+          "routePackage(): parsing failed. err=%s, length=%lu, data=%s<--\n",
+          variant->error.c_str(), static_cast<unsigned long>(pkg.length()),
+          pkg.c_str());
     }
     return;
   }