@alteriom/painlessmesh 2.0.2 → 2.1.0

package/src/arduino/wifi.hpp

@@ -2721,54 +2721,56 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   /**
    * Helper method to send gateway acknowledgment
    */
-  void sendGatewayAck(
-      const gateway::GatewayDataPackage& request, bool success,
-      uint16_t httpStatus, const TSTRING& error,
-      std::shared_ptr<Connection> 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;
-    }
+  /** Hosts that recently failed to resolve; fed on ESP32 only, see the
+   *  GATEWAY_DATA handler. */
+  gateway::NegativeDnsCache negativeDns;
 
-    auto conn = router::findRoute<Connection>((*this), request.originNode);
-    if (!conn && ingressConnection) {
-      // A newly promoted gateway can receive data before its NodeTree has
-      // converged enough for findRoute() to resolve the request origin.  The
-      // ingress connection is nevertheless a valid reverse path: the request
-      // just arrived through it and every intermediate node can continue
-      // routing the addressed acknowledgment toward originNode.
-      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);
+#if defined(ESP32) || defined(ESP8266)
+  /**
+   * The start and the end of the response body (gateway::ResponseExcerpt),
+   * read from the stream for at most GATEWAY_RESPONSE_HEAD_TIMEOUT_MS and
+   * GATEWAY_RESPONSE_SCAN_BYTES. A body that fits whole is read whole. A
+   * chunked body is read through gateway::ChunkedBodyDecoder: the raw stream
+   * carries the framing, which getString() would remove but only by keeping
+   * the whole body.
+   */
+  static TSTRING readResponseExcerpt(HTTPClient& http) {
+    const int size = http.getSize();
+    if (size >= 0 &&
+        static_cast<size_t>(size) <=
+            gateway::GATEWAY_RESPONSE_HEAD_BYTES + gateway::GATEWAY_RESPONSE_TAIL_BYTES) {
+      return http.getString();
+    }
+    gateway::ResponseExcerpt excerpt;
+    WiFiClient* stream = http.getStreamPtr();
+    if (stream == nullptr) return excerpt.text();
+    const bool chunked =
+        size < 0 && gateway::transferEncodingIsChunked(http.header("Transfer-Encoding"));
+    gateway::ChunkedBodyDecoder decoder(excerpt);
+    const uint32_t deadline =
+        millis() + gateway::GATEWAY_RESPONSE_HEAD_TIMEOUT_MS;
+    bool more = true;
+    while (more && static_cast<int32_t>(deadline - millis()) > 0) {
+      int available = stream->available();
+      if (available <= 0) {
+        if (!stream->connected()) break;
+        delay(1);
+        continue;
+      }
+      while (more && available-- > 0) {
+        const int c = stream->read();
+        if (c < 0) break;
+        more = chunked ? decoder.add(static_cast<char>(c))
+                       : excerpt.add(static_cast<char>(c));
+      }
     }
+    return excerpt.text();
   }
+#endif
+
+  // sendGatewayAck() is portable and lives in painlessmesh::Mesh
+  // (mesh.hpp): every node needs it, not only a gateway, to answer a
+  // request it cannot serve.
 
   /**
    * Initialize gateway Internet handler
@@ -2837,8 +2839,13 @@ class Mesh : public painlessmesh::Mesh<Connection> {
           // that genuinely stopped answering NODE_SYNC still gets reaped even
           // under continuous gateway traffic from other peers.
           const auto blockingStartedMs = millis();
+          // `retryable` is the gateway's word to the origin node on whether
+          // the identical request may be sent again: 0 whenever it may have
+          // reached the server, so a retry cannot deliver it twice.
           auto finish = [this, &pkg, ingress, blockingStartedMs](
-                            bool ok, uint16_t code, const TSTRING& err) {
+                            bool ok, uint16_t code, const TSTRING& err,
+                            int8_t retryable, const TSTRING& response = TSTRING(),
+                            uint32_t retryAfterMs = 0) {
             const auto stalledMs = millis() - blockingStartedMs;
             auto refreshed = gateway::refreshPeerWatchdogs(*this, stalledMs);
             if (refreshed > 0) {
@@ -2848,31 +2855,75 @@ class Mesh : public painlessmesh::Mesh<Connection> {
                   static_cast<unsigned>(refreshed),
                   static_cast<unsigned long>(stalledMs));
             }
-            this->sendGatewayAck(pkg, ok, code, err, ingress);
+            this->sendGatewayAck(pkg, ok, code, err, ingress, response, retryable,
+                                 retryAfterMs);
           };
 
           // Check Internet connectivity
           // First check WiFi status for quick fail
           if (WiFi.status() != WL_CONNECTED) {
-            finish(false, 0, "Gateway WiFi not connected");
+            finish(false, 0, "Gateway WiFi not connected", 0);
             return true;  // Consume package - we handled it (with error)
           }
           
           // Then check actual internet access (DNS resolution)
           // This detects when WiFi is connected but router has no internet
           if (!hasActualInternetAccess()) {
-            finish(false, 0, "Router has no internet access - check WAN connection");
+            finish(false, 0, "Router has no internet access - check WAN connection", 0);
             return true;  // Consume package - we handled it (with error)
           }
           
           // Finally, check for captive portal interference
           // This detects when DNS works but HTTP requests are intercepted
           if (!detectCaptivePortal()) {
-            finish(false, 0, "Captive portal detected - requires web authentication. Check router/WiFi settings");
+            finish(false, 0, "Captive portal detected - requires web authentication. Check router/WiFi settings", 0);
             return true;  // Consume package - we handled it (with error)
           }
 
 #if defined(ESP32) || defined(ESP8266)
+#ifdef ESP32
+          // A destination whose name failed to resolve is refused for
+          // GATEWAY_DNS_NEGATIVE_TTL_MS without another lookup (issue #453).
+          // HTTPClient reports a failed lookup as "connection refused" after
+          // the resolver's own patience -- on ESP32 not boundable by this
+          // library -- and it did so on every attempt: the origin node's
+          // retries and, since #451, the bridge's own sends each paid it, and
+          // the scheduler stalled long enough for relayed requests to time
+          // out on their origin nodes. Resolving here, once, names the real
+          // failure and caps the stall to one lookup per TTL per host.
+          // ESP32 only: the ESP8266 core bounds HTTPClient's own lookup by the
+          // HTTP timeout, and a second bounded wait would not fit the
+          // blocking budget.
+          const TSTRING host = gateway::hostFromUrl(pkg.destination);
+          if (host.length() > 0 && !gateway::looksLikeIpLiteral(host)) {
+            uint32_t failedAgoMs = 0;
+            if (negativeDns.isFailing(host, millis(), &failedAgoMs)) {
+              char dnsBuf[160];
+              snprintf(dnsBuf, sizeof(dnsBuf),
+                       "DNS lookup for %s failed %lus ago; not retried for "
+                       "another %lus",
+                       host.c_str(),
+                       static_cast<unsigned long>(failedAgoMs / 1000),
+                       static_cast<unsigned long>(
+                           (gateway::GATEWAY_DNS_NEGATIVE_TTL_MS - failedAgoMs) /
+                           1000));
+              Log(ERROR, "%s\n", dnsBuf);
+              finish(false, 0, TSTRING(dnsBuf), 0);
+              return true;
+            }
+            IPAddress resolved;
+            if (WiFi.hostByName(host.c_str(), resolved) != 1) {
+              negativeDns.remember(host, millis());
+              char dnsBuf[160];
+              snprintf(dnsBuf, sizeof(dnsBuf), "DNS lookup failed for %s",
+                       host.c_str());
+              Log(ERROR, "%s\n", dnsBuf);
+              finish(false, 0, TSTRING(dnsBuf), 0);
+              return true;
+            }
+          }
+#endif  // ESP32
+
           // Make HTTP/HTTPS request
           HTTPClient http;
           http.setTimeout(GATEWAY_HTTP_TIMEOUT_MS);
@@ -2917,6 +2968,17 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 #endif
           }
 
+          // The same id on every attempt at this call. A service that
+          // honours Idempotency-Key treats a retry as the request it already
+          // has; anything recording requests can count the copies.
+          const TSTRING requestId =
+              gateway::requestIdFor(pkg.originNode, pkg.messageId, pkg.requestNonce);
+          http.addHeader("X-Request-Id", requestId.c_str());
+          http.addHeader("Idempotency-Key", requestId.c_str());
+          // Not const: both cores declare collectHeaders(const char* keys[], ...).
+          const char* collected[] = {"Retry-After", "Transfer-Encoding"};
+          http.collectHeaders(collected, 2);
+
           // Make request (GET if no payload, POST if payload)
           if (pkg.payload.length() > 0) {
             http.addHeader("Content-Type", pkg.contentType.c_str());
@@ -2925,67 +2987,82 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             httpCode = http.GET();
           }
 
-          // Only specific 2xx status codes indicate genuine success:
-          // 200 OK, 201 Created, 202 Accepted, 204 No Content.
-          //
-          // Other 2xx codes like 203 (Non-Authoritative Information) often
-          // indicate cached/proxied responses that may not represent actual
-          // delivery to the destination service (e.g., WhatsApp API).
+          // HTTP semantics only: 200/201/202/204 succeed, anything else fails,
+          // and a retry is allowed only when it cannot deliver the request
+          // twice (see gateway::classifyHttpResult). Whether a service's reply
+          // means what the application wanted is the application's decision,
+          // so the start of the body goes back on success as well as failure.
           //
           // 3xx redirects are not automatically followed.
           //
           // The classification lives in painlessmesh::gateway so the desktop
           // test suite can exercise it; this file is ESP-only and never
           // compiled by the Catch2 build.
-          const auto outcome = gateway::classifyHttpResult(httpCode);
+          TSTRING responseHead;
+          if (httpCode > 0) {
+            responseHead =
+                readResponseExcerpt(http);
+          }
+          const auto outcome =
+              gateway::classifyHttpResult(httpCode, responseHead);
           success = outcome.success;
+          const TSTRING responseSummary =
+              httpCode > 0 ? gateway::summarizeResponseBody(responseHead) : TSTRING();
+          uint32_t retryAfterMs = 0;
+          if (outcome.retryable && httpCode > 0) {
+            retryAfterMs = gateway::parseRetryAfterMs(http.header("Retry-After"));
+          }
 
           if (!outcome.transportError) {
+            char errorBuf[320];
+            const char* reason = outcome.reason.c_str();
+            const char* sep = outcome.reason.length() > 0 ? ": " : "";
             if (success) {
               Log(COMMUNICATION, "HTTP request completed: code=%d\n", httpCode);
-            } else if (httpCode >= 200 && httpCode < 300) {
-              // Other 2xx codes - ambiguous success
-              // HTTP 203 is retryable, so log at COMMUNICATION level to reduce noise
-              char errorBuf[128];
-              snprintf(errorBuf, sizeof(errorBuf), 
-                      "Ambiguous response - HTTP %d may indicate cached/proxied response, not actual delivery", 
-                      httpCode);
-              error = TSTRING(errorBuf);
-              Log(COMMUNICATION, "HTTP request ambiguous: code=%d (treated as failure, will retry)\n", httpCode);
-            } else if (httpCode >= 500 && httpCode < 600) {
-              // 5xx server errors are retryable, log at COMMUNICATION level
-              char errorBuf[32];
-              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d", httpCode);
+            } else if (outcome.unverifiedStatus) {
+              // A 2xx outside 200/201/202/204: the server answered, but not
+              // with a status this library can call a delivery. Never
+              // retried. Logged at ERROR, where a sketch on the default
+              // levels sees what the service said.
+              snprintf(errorBuf, sizeof(errorBuf),
+                       "HTTP %d: not a delivery the gateway can confirm%s%s",
+                       httpCode, sep, reason);
               error = TSTRING(errorBuf);
-              Log(COMMUNICATION, "HTTP server error: code=%d (will retry)\n", httpCode);
-            } else if (httpCode == 429) {
-              // HTTP 429 rate limit is retryable, log at COMMUNICATION level
-              char errorBuf[32];
-              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d", httpCode);
+              Log(ERROR, "HTTP response unverified: %s\n", errorBuf);
+            } else if (outcome.retryable) {
+              // 429 or 503: the server says it did not take the request.
+              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d%s%s", httpCode, sep,
+                       reason);
               error = TSTRING(errorBuf);
-              Log(COMMUNICATION, "HTTP rate limit: code=%d (will retry)\n", httpCode);
+              Log(COMMUNICATION, "HTTP %d: the server asked to retry (after %lu ms)\n",
+                  httpCode, static_cast<unsigned long>(retryAfterMs));
             } else {
-              // 1xx, 3xx, 4xx (except 429) - non-retryable, log at ERROR level
-              char errorBuf[32];
-              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d", httpCode);
+              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d%s%s", httpCode, sep,
+                       reason);
               error = TSTRING(errorBuf);
-              Log(ERROR, "HTTP request failed: code=%d\n", httpCode);
+              Log(ERROR, "HTTP request failed: %s\n", errorBuf);
             }
           } else {
-            // Network errors (httpCode <= 0) are retryable but indicate serious issues
-            // Keep at ERROR level as they may indicate gateway connectivity problems
+            // Below HTTP. When the request may already be at the server -- a
+            // read timeout, a connection lost after sending -- it is not
+            // retried, and the error says why, so an application that
+            // resends does so knowing it may duplicate.
             error = http.errorToString(httpCode);
+            if (!outcome.retryable) {
+              error += " (the request may have reached the server; not retried)";
+            }
             Log(ERROR, "HTTP request failed: %s\n", error.c_str());
           }
 
           http.end();
 
-          // Send acknowledgment back. Transport errors carry status 0, the
-          // value handleGatewayAck() treats as a retryable network error.
-          finish(success, outcome.ackStatus, error);
+          // Send acknowledgment back, with the verdict on retrying and the
+          // start of whatever the server said.
+          finish(success, outcome.ackStatus, error, outcome.retryable ? 1 : 0,
+                 responseSummary, retryAfterMs);
 #else
         // Non-ESP platform - send error
-        finish(false, 0, "HTTP client not available on this platform");
+        finish(false, 0, "HTTP client not available on this platform", 0);
 #endif
 
           return true;  // Consume package - we have processed it and sent
@@ -2993,6 +3070,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         });
   }
 
+  /**
+   * The station just got an IP. On a node that runs the Internet health
+   * check -- a bridge or a shared gateway, whose station is the manual router
+   * link -- the last probe most likely ran during association and failed,
+   * and the next is a full interval away (issue #450). Probe again now, from
+   * the scheduler rather than the Wi-Fi event task, so hasLocalInternet()
+   * and the bridge's own sends stop waiting out the interval. A regular
+   * node's mesh station never enables the check and is left alone.
+   */
+  void probeUplinkAfterAssociation() {
+    if (!this->isInternetHealthCheckEnabled() || !stationScan.manual) return;
+    this->addTask([this]() { this->checkInternetNow(); });
+  }
+
   void eventHandleInit() {
     using namespace logger;
     // Where the station scan learns the channel the mesh is rooted on.
@@ -3101,6 +3192,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             this->stationScan.stationAttemptOver();
             this->stationScan.stationUp();
             this->tcpConnect();  // Connect to TCP port
+            this->probeUplinkAfterAssociation();
             this->semaphoreGive();
           }
         },
@@ -3137,6 +3229,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
           this->stationScan.stationAttemptOver();
           this->stationScan.stationUp();
           this->tcpConnect();  // Connect to TCP port
+          this->probeUplinkAfterAssociation();
         });
 #endif  // ESP32
     return;

package/src/painlessMeshSTA.cpp

@@ -628,6 +628,9 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
 #endif
   bool isRooted = layout::isRooted(mesh->asNodeTree());
   if (isRooted) everRooted = true;
+  // The immediate-rescan allowance is per outage, and this is the one place
+  // every scan passes through: a node with a connection has not spent it.
+  if (painlessmesh::layout::liveSubs(*mesh) > 0) rejoinScanned = false;
   if (aps.empty()) {
     // No unknown nodes found
     consecutiveEmptyScans++;
@@ -732,11 +735,42 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
       task.delay(interval);
       if (orphanScanBackoff < 2) orphanScanBackoff++;
     } else {
-      // else scan fast (SCAN_INTERVAL)
-      Log(CONNECTION,
-          "connectToAP(): No unknown nodes found scan rate set to "
-          "fast\n");
+      // Not connected, and this scan turned up nothing to connect to.
+      //
+      // "Fast" here is 0.5 * SCAN_INTERVAL -- fifteen seconds. For a node
+      // that still has a live connection (an AP-side child) that is soon
+      // enough: it is in the mesh and reachable while it looks for more.
+      // For a node with none it is the whole cost of the outage, and it is
+      // paid while the node's neighbours still have it in their routing
+      // tables: they keep sending to it until their own NODE_TIMEOUT, and
+      // those messages are dropped.
+      //
+      // Measured on the Alteriom HIL rig (issue #459): an ESP32-C3 closed
+      // its only uplink on a momentary nodeSync contradiction, logged
+      // "scan rate set to fast" 12 ms later, and did not scan again for
+      // exactly 15 000 ms. It was out of the mesh for 16.2 s and answered
+      // an empty node list throughout; a unicast sent to it in that window
+      // was accepted by the sender and lost. The scan that finally ran
+      // found five mesh APs at -30 to -58 dBm and was associated 1.2 s
+      // later. There was nothing to wait for.
+      //
+      // So a node with no connections left scans at once. Once per outage:
+      // `rejoinScanned` is cleared as soon as it has a connection again,
+      // so a node that is simply alone falls back to the interval instead
+      // of scanning back to back.
       task.setInterval(0.5 * SCAN_INTERVAL);
+      if (painlessmesh::layout::liveSubs(*mesh) == 0 && !rejoinScanned) {
+        rejoinScanned = true;
+        Log(CONNECTION,
+            "connectToAP(): No connections left; scanning again now rather "
+            "than in %d s\n",
+            (int)(0.5 * SCAN_INTERVAL / TASK_SECOND));
+        task.forceNextIteration();
+      } else {
+        Log(CONNECTION,
+            "connectToAP(): No unknown nodes found scan rate set to "
+            "fast\n");
+      }
     }
     mesh->stability += min(1000 - mesh->stability, (size_t)25);
   } else {

package/src/painlessMeshSTA.h

@@ -62,7 +62,14 @@ class StationScan {
   // The station got an address: its link is up. Cleared once the drop
   // callbacks have judged a disconnect, so they can tell a link that was
   // up and went away from an attempt that never got that far.
-  void stationUp() { stationLinkUp = true; }
+  void stationUp() {
+    stationLinkUp = true;
+    // A link again, so the immediate-rescan allowance is restored now
+    // rather than at the next scan. Without this a node that dropped
+    // twice inside one scan interval paid the full fifteen seconds for
+    // the second drop (#459).
+    rejoinScanned = false;
+  }
   void stationDown() { stationLinkUp = false; }
   bool stationLinkUp = false;
   // The station link was closed by this node's own channel move a moment
@@ -147,6 +154,11 @@ class StationScan {
   // channel re-detection runs, and consuming those results here found them
   // already deleted, reported "wifi scan failed", and rescanned at once.
   bool scanRequested = false;
+  // Whether this node has already scanned at once on losing its last
+  // connection. Cleared the moment it has one again, so the immediate
+  // rescan is one per outage and not a scan loop: a node that is out of
+  // the mesh and finds nothing still falls back to the interval below.
+  bool rejoinScanned = false;
   // Set when the next station scan must cover every channel: the empty
   // scans have piled up and the node is looking for the channel the mesh
   // moved to. The re-detection is this task's ordinary asynchronous scan

package/src/painlessmesh/buffer.hpp

@@ -206,12 +206,17 @@ class SentBuffer {
   size_t requestLength(size_t buffer_length) {
     // Use highest priority message available
     auto* msg = getNextMessage();
-    if (!msg)
-      return 0;
-    else
-      // String.toCharArray automatically turns the last character into
-      // a \0, we need the extra space to deal with that annoyance
-      return (std::min)(buffer_length - 1, msg->length() + 1);
+    if (!msg) return 0;
+    // A caller with no room is owed nothing. The subtraction below leaves
+    // space for the terminator toCharArray() always writes; on an unsigned
+    // zero it wraps to SIZE_MAX instead, min() then picks the message, and
+    // the answer comes back *larger* than was asked for -- which the
+    // documented contract above forbids and read() then acts on, writing
+    // length + 1 bytes into a buffer the caller said had none.
+    if (buffer_length == 0) return 0;
+    // String.toCharArray automatically turns the last character into
+    // a \0, we need the extra space to deal with that annoyance
+    return (std::min)(buffer_length - 1, msg->length() + 1);
   }
 
   /**

package/src/painlessmesh/callback.hpp

@@ -76,6 +76,13 @@ class PackageCallbackList {
     return size;
   }
 
+  /** How many callbacks are registered for one package id. */
+  size_t count(int id) {
+    auto generation = clearPending ? pendingCallbackMap : callbackMap;
+    auto it = generation->find(id);
+    return it == generation->end() ? 0 : it->second.size();
+  }
+
   void clear() {
     if (dispatchDepth > 0) {
       clearPending = true;