@alteriom/painlessmesh 2.0.1 → 2.0.3

package/src/arduino/wifi.hpp

@@ -492,6 +492,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Step 6: Setup gateway Internet handler
     initGatewayInternetHandler();
 
+    // Step 7: Start the health checker that drives hasLocalInternet().
+    // Without it that flag stays false for the life of the node, so the
+    // local short-circuit in sendToInternet() never fires and a bridge
+    // asking its own uplink fell through to the mesh-routing path -- which
+    // fails with "No active mesh connections" whenever the bridge has no
+    // peer yet, even though the router link is up (issue #445).
+    // initAsSharedGateway() has always done this; initAsBridge() did not.
+    //
+    // No configureInternetHealthCheck() call here: a bridge has no
+    // SharedGatewayConfig, the checker's own defaults (8.8.8.8:53, 30 s,
+    // 5 s) already match that struct's, and configuring would clobber any
+    // setInternetCheckTarget() the sketch made before init.
+    enableInternetHealthCheck();
+
     Log(STARTUP, "=== Bridge Mode Active ===\n");
     Log(STARTUP, "  Mesh SSID: %s\n", meshSSID.c_str());
     Log(STARTUP, "  Mesh Channel: %d%s\n", detectedChannel, 
@@ -2707,54 +2721,53 @@ 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)
+  /**
+   * Read the start of an HTTP response body, bounded in bytes and in time
+   *
+   * The gateway used to discard the body, so a service that answers a refusal
+   * with a 2xx (CallMeBot, issue #450) was reported as delivered, and a
+   * failure reached the origin node as a bare status. When the length is
+   * known and small the whole body is taken; otherwise up to maxBytes are
+   * read from the stream, waiting at most GATEWAY_RESPONSE_HEAD_TIMEOUT_MS,
+   * which keeps a large or chunked page from eating the heap or the
+   * cooperative scheduler.
+   */
+  static TSTRING readResponseHead(HTTPClient& http, size_t maxBytes) {
+    const int size = http.getSize();
+    if (size >= 0 && static_cast<size_t>(size) <= maxBytes) {
+      return http.getString();
+    }
+    TSTRING head;
+    WiFiClient* stream = http.getStreamPtr();
+    if (stream == nullptr) return head;
+    const uint32_t deadline =
+        millis() + gateway::GATEWAY_RESPONSE_HEAD_TIMEOUT_MS;
+    while (head.length() < maxBytes &&
+           static_cast<int32_t>(deadline - millis()) > 0) {
+      int available = stream->available();
+      if (available <= 0) {
+        if (!stream->connected()) break;
+        delay(1);
+        continue;
+      }
+      while (available-- > 0 && head.length() < maxBytes) {
+        const int c = stream->read();
+        if (c < 0) break;
+        head += static_cast<char>(c);
+      }
     }
+    return head;
   }
+#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
@@ -2859,12 +2872,63 @@ class Mesh : public painlessmesh::Mesh<Connection> {
           }
 
 #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));
+              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));
+              return true;
+            }
+          }
+#endif  // ESP32
+
           // Make HTTP/HTTPS request
           HTTPClient http;
           http.setTimeout(GATEWAY_HTTP_TIMEOUT_MS);
 
           bool success = false;
-          uint16_t httpCode = 0;
+          // HTTPClient returns an int: a positive value is an HTTP status
+          // code, a negative one is its own transport error (HTTPC_ERROR_*,
+          // -1 for a refused connection, -11 for a read timeout, ...). This
+          // was a uint16_t, which wrapped -1 to 65535 -- a value that passes
+          // `httpCode > 0`, so every transport failure was reported to the
+          // origin node as "HTTP 65535" (issue #446), the errorToString()
+          // branch below was unreachable, and handleGatewayAck() classified a
+          // transient network failure as a non-retryable HTTP status.
+          int httpCode = 0;
           TSTRING error = "";
 
 #ifdef ESP8266
@@ -2903,50 +2967,70 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             httpCode = http.GET();
           }
 
+          // A 2xx is the origin's acceptance, except 203 (a proxy transformed
+          // the response) and except when the body says the service refused
+          // the request: CallMeBot answers "Too many requests" under 201 and
+          // 203 (issue #450). The body is therefore read -- bounded -- before
+          // classifying, and it is what the origin node is told on 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.
+          TSTRING responseHead;
           if (httpCode > 0) {
-            // Only specific 2xx status codes indicate genuine success
-            // 200 OK: Standard successful response
-            // 201 Created: Resource successfully created
-            // 202 Accepted: Request accepted for processing
-            // 204 No Content: Successful with no response body
-            //
-            // 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).
-            //
-            // 3xx redirects are not automatically followed
-            success = (httpCode == 200 || httpCode == 201 || 
-                      httpCode == 202 || httpCode == 204);
-            
+            responseHead =
+                readResponseHead(http, gateway::GATEWAY_RESPONSE_HEAD_BYTES);
+          }
+          const auto outcome =
+              gateway::classifyHttpResult(httpCode, responseHead);
+          success = outcome.success;
+
+          if (!outcome.transportError) {
+            char errorBuf[192];
+            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);
+            } else if (outcome.refusedByBody) {
+              // Success-class status, refusing body. Not retryable: the
+              // service answered, and the origin node gets its words.
+              snprintf(errorBuf, sizeof(errorBuf),
+                       "HTTP %d: service refused the request%s%s", httpCode,
+                       sep, reason);
               error = TSTRING(errorBuf);
-              Log(COMMUNICATION, "HTTP request ambiguous: code=%d (treated as failure, will retry)\n", httpCode);
+              Log(ERROR, "HTTP request refused by the service: %s\n", errorBuf);
+            } else if (outcome.unverifiedStatus) {
+              // A 2xx outside 200/201/202/204. CallMeBot answers 208 to a
+              // message that never arrives (issue #452), so this is a
+              // failure, and the body -- the only place the service says
+              // what it did -- goes to the origin node and to the log at
+              // ERROR level, where a sketch running the default levels
+              // sees it. 203 stays retryable; the rest are final.
+              snprintf(errorBuf, sizeof(errorBuf),
+                       "HTTP %d: not a delivery the gateway can confirm%s%s",
+                       httpCode, sep, reason);
+              error = TSTRING(errorBuf);
+              Log(ERROR, "HTTP response unverified: %s\n", errorBuf);
             } 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);
+              snprintf(errorBuf, sizeof(errorBuf), "HTTP %d%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);
+              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);
             } 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
@@ -2957,8 +3041,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 
           http.end();
 
-          // Send acknowledgment back
-          finish(success, httpCode, error);
+          // Send acknowledgment back. Transport errors carry status 0, the
+          // value handleGatewayAck() treats as a retryable network error.
+          finish(success, outcome.ackStatus, error);
 #else
         // Non-ESP platform - send error
         finish(false, 0, "HTTP client not available on this platform");
@@ -2969,6 +3054,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.
@@ -3077,6 +3176,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             this->stationScan.stationAttemptOver();
             this->stationScan.stationUp();
             this->tcpConnect();  // Connect to TCP port
+            this->probeUplinkAfterAssociation();
             this->semaphoreGive();
           }
         },
@@ -3113,6 +3213,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/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;