gateway.hpp

Go to the documentation of this file.

#ifndef _PAINLESS_MESH_GATEWAY_HPP_
#define _PAINLESS_MESH_GATEWAY_HPP_
 
#include "Arduino.h"
#include "painlessmesh/configuration.hpp"
#include "painlessmesh/logger.hpp"
 
#if defined(ESP32) || defined(ESP8266)
#include <WiFiClient.h>
#endif
#include "painlessmesh/plugin.hpp"
#include "painlessmesh/protocol.hpp"
#include "painlessmesh/validation.hpp"
 
#include <functional>
#include <map>
#include <vector>
 
namespace painlessmesh {
namespace gateway {
 
constexpr bool isValidMeshChannel(uint8_t channel) {
  return channel >= 1 && channel <= 13;
}
 
constexpr bool shouldFollowBridgeChannel(uint32_t localNodeId,
                                         uint32_t electedBridgeId,
                                         uint8_t currentChannel,
                                         uint8_t announcedChannel) {
  return electedBridgeId != localNodeId &&
         isValidMeshChannel(announcedChannel) &&
         announcedChannel != currentChannel;
}
 
struct MeshChannelCandidate {
  uint8_t channel = 0;
  int32_t rssi = 0;
  // `push_back({channel, rssi})` needs a constructor under gnu++11 (the
  // ESP32 Arduino 2.x core), where a struct with default member
  // initializers is not an aggregate.
  MeshChannelCandidate() {}
  MeshChannelCandidate(uint8_t channel_, int32_t rssi_) : channel(channel_), rssi(rssi_) {}
};
 
inline uint8_t pickMeshChannel(const std::vector<MeshChannelCandidate>& candidates,
                               uint8_t avoidChannel, uint8_t routerChannel = 0) {
  const MeshChannelCandidate* elsewhere = nullptr;
  const MeshChannelCandidate* here = nullptr;
  for (const auto& c : candidates) {
    if (!isValidMeshChannel(c.channel)) continue;
    if (c.channel == routerChannel) return c.channel;
    const MeshChannelCandidate*& slot = (c.channel == avoidChannel) ? here : elsewhere;
    if (slot == nullptr || c.rssi > slot->rssi) slot = &c;
  }
  if (elsewhere != nullptr) return elsewhere->channel;
  if (here != nullptr) return here->channel;
  return 0;
}
 
struct ValidationResult {
  bool valid = true;
  TSTRING errorMessage = "";
 
  ValidationResult() = default;
  ValidationResult(bool v, const TSTRING& msg) : valid(v), errorMessage(msg) {}
 
  explicit operator bool() const { return valid; }
};
 
struct SharedGatewayConfig {
  // ============================================
  // Core Configuration
  // ============================================
 
  bool enabled = false;
 
  TSTRING routerSSID = "";
 
  TSTRING routerPassword = "";
 
  // ============================================
  // Internet Connectivity Checking
  // ============================================
 
  uint32_t internetCheckInterval = 30000;
 
  TSTRING internetCheckHost = "8.8.8.8";
 
  uint16_t internetCheckPort = 53;
 
  uint32_t internetCheckTimeout = 5000;
 
  // ============================================
  // Message Handling
  // ============================================
 
  uint8_t messageRetryCount = 3;
 
  uint32_t retryInterval = 1000;
 
  uint32_t duplicateTrackingTimeout = 60000;
 
  uint16_t maxTrackedMessages = 500;
 
  // ============================================
  // Gateway Coordination
  // ============================================
 
  uint32_t gatewayHeartbeatInterval = 15000;
 
  uint32_t gatewayFailureTimeout = 45000;
 
  bool participateInElection = true;
 
  // ============================================
  // Advanced Configuration
  // ============================================
 
  uint8_t relayedMessagePriority = 0;
 
  bool maintainPermanentConnection = true;
 
  // ============================================
  // Validation Methods
  // ============================================
 
  ValidationResult validate() const {
    // If not enabled, configuration is valid (nothing to validate)
    if (!enabled) {
      return ValidationResult(true, "");
    }
 
    // Router SSID is required when enabled
    if (routerSSID.length() == 0) {
      return ValidationResult(false, "routerSSID is required when enabled");
    }
 
    // SSID length validation (max 32 characters per WiFi spec)
    if (routerSSID.length() > 32) {
      return ValidationResult(false,
                              "routerSSID exceeds maximum length of 32 characters");
    }
 
    // Password length validation (WPA2 max is 63 characters)
    if (routerPassword.length() > 63) {
      return ValidationResult(
          false, "routerPassword exceeds maximum length of 63 characters");
    }
 
    // Internet check host validation
    if (internetCheckHost.length() == 0) {
      return ValidationResult(false, "internetCheckHost cannot be empty");
    }
 
    // Interval validations (minimum sensible values)
    if (internetCheckInterval < 1000) {
      return ValidationResult(
          false, "internetCheckInterval must be at least 1000ms");
    }
 
    if (internetCheckTimeout < 100) {
      return ValidationResult(false,
                              "internetCheckTimeout must be at least 100ms");
    }
 
    if (internetCheckTimeout >= internetCheckInterval) {
      return ValidationResult(
          false,
          "internetCheckTimeout must be less than internetCheckInterval");
    }
 
    if (gatewayHeartbeatInterval < 1000) {
      return ValidationResult(
          false, "gatewayHeartbeatInterval must be at least 1000ms");
    }
 
    if (gatewayFailureTimeout < gatewayHeartbeatInterval * 2) {
      return ValidationResult(
          false,
          "gatewayFailureTimeout should be at least 2x gatewayHeartbeatInterval");
    }
 
    if (duplicateTrackingTimeout < 1000) {
      return ValidationResult(
          false, "duplicateTrackingTimeout must be at least 1000ms");
    }
 
    if (maxTrackedMessages < 10) {
      return ValidationResult(false, "maxTrackedMessages must be at least 10");
    }
 
    if (retryInterval < 100) {
      return ValidationResult(false, "retryInterval must be at least 100ms");
    }
 
    return ValidationResult(true, "");
  }
 
  bool canParticipateInElection() const {
    return participateInElection && routerSSID.length() > 0;
  }
 
  bool hasRouterCredentials() const { return routerSSID.length() > 0; }
 
};
 
struct InternetStatus {
  bool available = false;          
  uint32_t lastCheckTime = 0;      
  uint32_t lastSuccessTime = 0;    
  uint32_t checkCount = 0;         
  uint32_t successCount = 0;       
  uint32_t failureCount = 0;       
  uint32_t lastLatencyMs = 0;      
  TSTRING lastError = "";          
  TSTRING checkHost = "";          
  uint16_t checkPort = 0;          
 
  uint8_t getUptimePercent() const {
    if (checkCount == 0) return 0;
    return static_cast<uint8_t>((successCount * 100) / checkCount);
  }
 
  uint32_t getTimeSinceLastSuccess() const {
    if (lastSuccessTime == 0) return UINT32_MAX;
    return millis() - lastSuccessTime;
  }
 
  bool isStale(uint32_t maxAgeMs = 60000) const {
    if (lastCheckTime == 0) return true;
    return (millis() - lastCheckTime) > maxAgeMs;
  }
};
 
typedef std::function<void(bool available)> InternetChangedCallback_t;
 
class InternetHealthChecker {
 public:
  InternetHealthChecker() = default;
 
  void setConfig(const SharedGatewayConfig& config) {
    checkHost_ = config.internetCheckHost;
    checkPort_ = config.internetCheckPort;
    checkInterval_ = config.internetCheckInterval;
    checkTimeout_ = config.internetCheckTimeout;
    status_.checkHost = checkHost_;
    status_.checkPort = checkPort_;
  }
 
  void setCheckTarget(const TSTRING& host, uint16_t port = 53) {
    checkHost_ = host;
    checkPort_ = port;
    status_.checkHost = checkHost_;
    status_.checkPort = checkPort_;
  }
 
  void setCheckInterval(uint32_t intervalMs) {
    checkInterval_ = intervalMs;
  }
 
  void setCheckTimeout(uint32_t timeoutMs) {
    checkTimeout_ = timeoutMs;
  }
 
  void onConnectivityChanged(InternetChangedCallback_t callback) {
    connectivityChangedCallback_ = callback;
  }
 
  bool hasLocalInternet() const {
    return status_.available;
  }
 
  InternetStatus getStatus() const {
    return status_;
  }
 
  bool checkNow() {
    // A full probe answers the question the on-demand budget exists for.
    onDemandSpent_ = false;
    status_.checkCount++;
    status_.lastCheckTime = millis();
 
    bool connected = performTcpCheck();
 
    if (connected) {
      status_.successCount++;
      status_.lastSuccessTime = millis();
      status_.lastError = "";
    } else {
      status_.failureCount++;
    }
 
    // Detect status change and fire callback
    if (connected != status_.available) {
      status_.available = connected;
      if (connectivityChangedCallback_) {
        connectivityChangedCallback_(connected);
      }
    }
 
    return connected;
  }
 
  bool checkOnDemand() {
    if (status_.available) return true;
    if (onDemandSpent_) return false;
    const bool connected = checkNow();
    onDemandSpent_ = true;
    return connected;
  }
 
  uint32_t getCheckInterval() const {
    return checkInterval_;
  }
 
  uint32_t getCheckTimeout() const {
    return checkTimeout_;
  }
 
  TSTRING getCheckHost() const {
    return checkHost_;
  }
 
  uint16_t getCheckPort() const {
    return checkPort_;
  }
 
  void resetStats() {
    status_.checkCount = 0;
    status_.successCount = 0;
    status_.failureCount = 0;
    status_.lastCheckTime = 0;
    status_.lastSuccessTime = 0;
    status_.lastLatencyMs = 0;
    status_.lastError = "";
  }
 
#ifdef PAINLESSMESH_BOOST
  void setMockConnected(bool connected) {
    mockConnected_ = connected;
  }
#endif
 
 private:
  bool performTcpCheck() {
#ifdef PAINLESSMESH_BOOST
    // Test environment - use mock value
    if (mockConnected_) {
      status_.lastLatencyMs = 10;  // Simulated latency
      return true;
    }
    status_.lastError = "Mock: No Internet in test environment";
    return false;
#elif defined(ESP32) || defined(ESP8266)
    // No station, no uplink: answer at once instead of spending the connect
    // timeout on a link that does not exist. This is what keeps the
    // on-demand probe cheap on a bridge whose router is down.
    if (WiFi.status() != WL_CONNECTED) {
      status_.lastError = "Station not connected";
      return false;
    }
    WiFiClient client;
    uint32_t started = millis();
#ifdef ESP32
    bool connected = client.connect(checkHost_.c_str(), checkPort_, checkTimeout_);
#else
    // ESP8266's WiFiClient lacks ESP32's per-connect timeout overload, so the
    // timeout is set on the client instead. It is milliseconds, not seconds:
    // WiFiClient inherits Stream::setTimeout ("maximum milliseconds to wait")
    // and connect() hands _timeout straight to WiFi.hostByName(), whose
    // parameter is named timeout_ms. Dividing by 1000 here gave DNS five
    // milliseconds to resolve, so the check failed every time and an ESP8266
    // shared gateway never reported local Internet.
    client.setTimeout(checkTimeout_);
    bool connected = client.connect(checkHost_.c_str(), checkPort_);
#endif
    status_.lastLatencyMs = millis() - started;
    if (!connected) {
      status_.lastError = "TCP connectivity check failed";
      return false;
    }
    client.stop();
    return true;
#else
    status_.lastError = "Internet health checks are unsupported on this platform";
    return false;
#endif
  }
 
  // Configuration
  TSTRING checkHost_ = "8.8.8.8";
  uint16_t checkPort_ = 53;
  uint32_t checkInterval_ = 30000;
  uint32_t checkTimeout_ = 5000;
 
  // State
  InternetStatus status_;
  InternetChangedCallback_t connectivityChangedCallback_;
  bool onDemandSpent_ = false;
 
#ifdef PAINLESSMESH_BOOST
  bool mockConnected_ = false;
#endif
};
 
enum class GatewayPriority : uint8_t {
  PRIORITY_CRITICAL = 0,  
  PRIORITY_HIGH = 1,      
  PRIORITY_NORMAL = 2,    
  PRIORITY_LOW = 3        
};
 
class GatewayDataPackage : public plugin::SinglePackage {
 public:
  uint32_t messageId = 0;
 
  uint32_t originNode = 0;
 
  uint32_t timestamp = 0;
 
  uint8_t priority = static_cast<uint8_t>(GatewayPriority::PRIORITY_NORMAL);
 
  TSTRING destination = "";
 
  TSTRING payload = "";
 
  TSTRING contentType = "application/json";
 
  uint8_t retryCount = 0;
 
  bool requiresAck = false;
 
  uint32_t requestNonce = 0;
 
  static constexpr int numPackageFields = 10;
 
  GatewayDataPackage() : SinglePackage(protocol::GATEWAY_DATA) {}
 
  GatewayDataPackage(JsonObject jsonObj) : SinglePackage(jsonObj) {
    messageId = jsonObj["msgId"];
    originNode = jsonObj["origin"];
    timestamp = jsonObj["ts"];
    priority = jsonObj["prio"];
    retryCount = jsonObj["retry"];
    requiresAck = jsonObj["ack"] | false;
    requestNonce = jsonObj["nonce"] | 0UL;
 
#if ARDUINOJSON_VERSION_MAJOR < 7
    if (jsonObj.containsKey("dest_url"))
      destination = jsonObj["dest_url"].as<TSTRING>();
    if (jsonObj.containsKey("payload"))
      payload = jsonObj["payload"].as<TSTRING>();
    if (jsonObj.containsKey("content"))
      contentType = jsonObj["content"].as<TSTRING>();
#else
    if (jsonObj["dest_url"].is<TSTRING>())
      destination = jsonObj["dest_url"].as<TSTRING>();
    if (jsonObj["payload"].is<TSTRING>())
      payload = jsonObj["payload"].as<TSTRING>();
    if (jsonObj["content"].is<TSTRING>())
      contentType = jsonObj["content"].as<TSTRING>();
#endif
  }
 
  JsonObject addTo(JsonObject&& jsonObj) const {
    jsonObj = SinglePackage::addTo(std::move(jsonObj));
    jsonObj["msgId"] = messageId;
    jsonObj["origin"] = originNode;
    jsonObj["ts"] = timestamp;
    jsonObj["prio"] = priority;
    jsonObj["dest_url"] = destination;
    jsonObj["payload"] = payload;
    jsonObj["content"] = contentType;
    jsonObj["retry"] = retryCount;
    jsonObj["ack"] = requiresAck;
    if (requestNonce != 0) jsonObj["nonce"] = requestNonce;
    return jsonObj;
  }
 
#if ARDUINOJSON_VERSION_MAJOR < 7
  size_t jsonObjectSize() const {
    // noJsonFields (from base class) + numPackageFields (our fields)
    return JSON_OBJECT_SIZE(noJsonFields + numPackageFields) + destination.length() +
           payload.length() + contentType.length();
  }
#endif
 
  static uint32_t generateMessageId(uint32_t nodeId) {
    // The counter starts at a random point each boot. Starting at zero, the
    // first request after every reboot carried the same id as the first
    // request of the boot before -- and so the same X-Request-Id and
    // Idempotency-Key, which a service that remembers keys drops as a repeat.
    static uint16_t counter =
        static_cast<uint16_t>(validation::SecureRandom::generate());
    ++counter;
    if (counter == 0) ++counter;
    // Combine node ID (upper 16 bits) with counter (lower 16 bits)
    return ((nodeId & 0xFFFF) << 16) | counter;
  }
 
};
 
enum HttpTransportError : int {
  HTTP_TRANSPORT_CONNECTION_REFUSED = -1,  
  HTTP_TRANSPORT_SEND_HEADER_FAILED = -2,  
  HTTP_TRANSPORT_SEND_PAYLOAD_FAILED = -3, 
  HTTP_TRANSPORT_NOT_CONNECTED = -4,       
  HTTP_TRANSPORT_CONNECTION_LOST = -5,     
  HTTP_TRANSPORT_NO_STREAM = -6,           
  HTTP_TRANSPORT_NO_HTTP_SERVER = -7,      
  HTTP_TRANSPORT_TOO_LESS_RAM = -8,        
  HTTP_TRANSPORT_ENCODING = -9,            
  HTTP_TRANSPORT_STREAM_WRITE = -10,       
  HTTP_TRANSPORT_READ_TIMEOUT = -11,       
};
 
inline bool transportErrorMayHaveReachedServer(int rawCode) {
  switch (rawCode) {
    case HTTP_TRANSPORT_CONNECTION_REFUSED:
    case HTTP_TRANSPORT_SEND_HEADER_FAILED:
    case HTTP_TRANSPORT_SEND_PAYLOAD_FAILED:
      return false;
    default:
      return true;
  }
}
 
struct HttpRequestOutcome {
  bool success = false;
 
  uint16_t ackStatus = 0;
 
  bool transportError = false;
 
  bool unverifiedStatus = false;
 
  bool retryable = false;
 
  TSTRING reason;
};
 
static const size_t GATEWAY_RESPONSE_REASON_MAX = 240;
 
static const size_t GATEWAY_RESPONSE_HEAD_BYTES = 512;
static const size_t GATEWAY_RESPONSE_TAIL_BYTES = 256;
 
static const size_t GATEWAY_RESPONSE_SCAN_BYTES = 8192;
 
static const uint32_t GATEWAY_RESPONSE_HEAD_TIMEOUT_MS = 250;
 
static const uint32_t GATEWAY_RETRY_AFTER_MAX_MS = 60000;
 
inline bool responseContains(const TSTRING& haystack, const char* needle) {
#if defined(PAINLESSMESH_BOOST)
  return haystack.find(needle) != std::string::npos;
#else
  return haystack.indexOf(needle) >= 0;
#endif
}
 
inline TSTRING summarizeResponseBody(
    const TSTRING& body, size_t maxLen = GATEWAY_RESPONSE_REASON_MAX) {
  TSTRING text;
  bool inTag = false;
  bool pendingSpace = false;
  for (size_t i = 0; i < body.length(); ++i) {
    const char c = body[i];
    if (c == '<') {
      inTag = true;
      continue;
    }
    if (c == '>') {
      inTag = false;
      pendingSpace = true;
      continue;
    }
    if (inTag) continue;
    if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
      pendingSpace = true;
      continue;
    }
    if (pendingSpace && text.length() > 0) text += ' ';
    pendingSpace = false;
    text += c;
  }
  if (text.length() <= maxLen) return text;
 
  static const char JOIN[] = " ... ";
  const size_t joinLength = sizeof(JOIN) - 1;
  const size_t room = maxLen > joinLength ? maxLen - joinLength : 0;
  const size_t head = room / 2;
  const size_t tail = room - head;
  TSTRING out;
  for (size_t i = 0; i < head; ++i) out += text[i];
  out += JOIN;
  for (size_t i = text.length() - tail; i < text.length(); ++i) out += text[i];
  return out;
}
 
class ResponseExcerpt {
 public:
  bool add(char c) {
    ++seen_;
    if (head_.length() < GATEWAY_RESPONSE_HEAD_BYTES) {
      head_ += c;
    } else {
      tail_[(tailStart_ + tailLength_) % GATEWAY_RESPONSE_TAIL_BYTES] = c;
      if (tailLength_ < GATEWAY_RESPONSE_TAIL_BYTES) {
        ++tailLength_;
      } else {
        tailStart_ = (tailStart_ + 1) % GATEWAY_RESPONSE_TAIL_BYTES;
      }
    }
    return seen_ < GATEWAY_RESPONSE_SCAN_BYTES;
  }
 
  void add(const TSTRING& text) {
    for (size_t i = 0; i < text.length(); ++i) {
      if (!add(text[i])) return;
    }
  }
 
  TSTRING text() const {
    TSTRING out = head_;
    if (seen_ > head_.length() + tailLength_) out += " ... ";
    for (size_t i = 0; i < tailLength_; ++i) {
      out += tail_[(tailStart_ + i) % GATEWAY_RESPONSE_TAIL_BYTES];
    }
    return out;
  }
 
 private:
  TSTRING head_;
  char tail_[GATEWAY_RESPONSE_TAIL_BYTES] = {};
  size_t tailStart_ = 0;
  size_t tailLength_ = 0;
  size_t seen_ = 0;
};
 
class ChunkedBodyDecoder {
 public:
  explicit ChunkedBodyDecoder(ResponseExcerpt& excerpt) : excerpt_(excerpt) {}
 
  bool add(char c) {
    switch (state_) {
      case State::Size:
        if (c == '\r') {
          state_ = State::SizeLf;
        } else if (c == ';') {
          state_ = State::Extension;
        } else if (c == ' ' || c == '\t') {
          // Tolerated around the size, as many servers emit it.
        } else {
          const int digit = hexValue(c);
          if (digit < 0 || sizeDigits_ >= 8) return stop();
          remaining_ = (remaining_ << 4) | static_cast<uint32_t>(digit);
          ++sizeDigits_;
        }
        return true;
      case State::Extension:
        if (c == '\r') state_ = State::SizeLf;
        return true;
      case State::SizeLf:
        if (c != '\n' || sizeDigits_ == 0) return stop();
        sizeDigits_ = 0;
        if (remaining_ == 0) {
          state_ = State::Done;
          return false;
        }
        state_ = State::Data;
        return true;
      case State::Data:
        --remaining_;
        if (remaining_ == 0) state_ = State::DataCr;
        if (!excerpt_.add(c)) {
          state_ = State::Done;
          return false;
        }
        return true;
      case State::DataCr:
        if (c != '\r') return stop();
        state_ = State::DataLf;
        return true;
      case State::DataLf:
        if (c != '\n') return stop();
        state_ = State::Size;
        return true;
      case State::Done:
        return false;
    }
    return false;
  }
 
  void add(const TSTRING& raw) {
    for (size_t i = 0; i < raw.length(); ++i) {
      if (!add(raw[i])) return;
    }
  }
 
  bool complete() const { return state_ == State::Done && !malformed_; }
 
 private:
  enum class State { Size, Extension, SizeLf, Data, DataCr, DataLf, Done };
 
  static int hexValue(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return -1;
  }
 
  bool stop() {
    malformed_ = true;
    state_ = State::Done;
    return false;
  }
 
  ResponseExcerpt& excerpt_;
  State state_ = State::Size;
  uint32_t remaining_ = 0;
  uint8_t sizeDigits_ = 0;
  bool malformed_ = false;
};
 
inline bool transferEncodingIsChunked(const TSTRING& value) {
  TSTRING lower;
  for (size_t i = 0; i < value.length(); ++i) {
    const char c = value[i];
    lower += (c >= 'A' && c <= 'Z') ? static_cast<char>(c - 'A' + 'a') : c;
  }
  return responseContains(lower, "chunked");
}
 
inline uint32_t parseRetryAfterMs(const TSTRING& value) {
  uint64_t seconds = 0;
  size_t digits = 0;
  for (size_t i = 0; i < value.length(); ++i) {
    const char c = value[i];
    if (c == ' ' || c == '\t') {
      if (digits == 0) continue;
      break;
    }
    if (c < '0' || c > '9') return 0;
    seconds = seconds * 10 + static_cast<uint64_t>(c - '0');
    if (seconds > 0xFFFFFFFFULL / 1000ULL) return 0xFFFFFFFFUL;
    ++digits;
  }
  return digits == 0 ? 0 : static_cast<uint32_t>(seconds * 1000ULL);
}
 
inline TSTRING requestIdFor(uint32_t originNode, uint32_t messageId,
                            uint32_t requestNonce = 0) {
  char buffer[40];
  if (requestNonce == 0) {
    snprintf(buffer, sizeof(buffer), "pm-%08x-%08x",
             static_cast<unsigned>(originNode), static_cast<unsigned>(messageId));
  } else {
    snprintf(buffer, sizeof(buffer), "pm-%08x-%08x-%08x",
             static_cast<unsigned>(originNode), static_cast<unsigned>(messageId),
             static_cast<unsigned>(requestNonce));
  }
  return TSTRING(buffer);
}
 
inline uint32_t newRequestNonce() {
  uint32_t nonce = validation::SecureRandom::generate();
  return nonce != 0 ? nonce : 1;
}
 
inline HttpRequestOutcome classifyHttpResult(int rawCode,
                                             const TSTRING& body = TSTRING()) {
  HttpRequestOutcome outcome;
  if (rawCode <= 0) {
    outcome.transportError = true;
    outcome.retryable = !transportErrorMayHaveReachedServer(rawCode);
    return outcome;
  }
  outcome.ackStatus =
      static_cast<uint16_t>(rawCode > 0xFFFF ? 0xFFFF : rawCode);
  outcome.success =
      rawCode == 200 || rawCode == 201 || rawCode == 202 || rawCode == 204;
  outcome.unverifiedStatus = !outcome.success && rawCode >= 200 && rawCode < 300;
  outcome.retryable = rawCode == 429 || rawCode == 503;
  if (!outcome.success) outcome.reason = summarizeResponseBody(body);
  return outcome;
}
 
static const char GATEWAY_NOT_A_GATEWAY_PHRASE[] = "is not an Internet gateway";
 
static const uint32_t GATEWAY_DNS_NEGATIVE_TTL_MS = 60000;
 
inline TSTRING hostFromUrl(const TSTRING& url) {
  const char* s = url.c_str();
  const size_t n = url.length();
  size_t i = 0;
  for (size_t k = 0; k + 2 < n; ++k) {
    if (s[k] == ':' && s[k + 1] == '/' && s[k + 2] == '/') {
      i = k + 3;
      break;
    }
  }
  size_t j = i;
  while (j < n && s[j] != '/' && s[j] != '?' && s[j] != '#' && s[j] != ':') ++j;
  TSTRING host;
  for (size_t k = i; k < j; ++k) host += s[k];
  return host;
}
 
inline bool looksLikeIpLiteral(const TSTRING& host) {
  if (host.length() == 0) return false;
  for (size_t i = 0; i < host.length(); ++i) {
    const char c = host[i];
    if (!(c >= '0' && c <= '9') && c != '.') return false;
  }
  return true;
}
 
class NegativeDnsCache {
 public:
  // An enum, not a static const member: the test suite passes it to Catch2 by
  // reference, which needs a definition C++14 cannot give an in-class
  // constant without an out-of-line one.
  enum : size_t { SLOTS = 4 };
 
  void remember(const TSTRING& host, uint32_t nowMs,
                uint32_t ttlMs = GATEWAY_DNS_NEGATIVE_TTL_MS) {
    Entry* slot = find(host);
    if (slot == nullptr) {
      slot = &entries_[0];
      for (size_t i = 0; i < SLOTS; ++i) {
        if (!entries_[i].used) {
          slot = &entries_[i];
          break;
        }
        if (static_cast<int32_t>(entries_[i].at - slot->at) < 0) slot = &entries_[i];
      }
    }
    slot->used = true;
    slot->host = host;
    slot->at = nowMs;
    slot->ttl = ttlMs;
  }
 
  bool isFailing(const TSTRING& host, uint32_t nowMs, uint32_t* ageMs = nullptr) {
    Entry* slot = find(host);
    if (slot == nullptr) return false;
    const uint32_t age = nowMs - slot->at;
    if (age >= slot->ttl) {
      slot->used = false;
      return false;
    }
    if (ageMs != nullptr) *ageMs = age;
    return true;
  }
 
  void forget(const TSTRING& host) {
    Entry* slot = find(host);
    if (slot != nullptr) slot->used = false;
  }
 
  size_t size() const {
    size_t n = 0;
    for (size_t i = 0; i < SLOTS; ++i) n += entries_[i].used ? 1 : 0;
    return n;
  }
 
 private:
  struct Entry {
    TSTRING host;
    uint32_t at = 0;
    uint32_t ttl = 0;
    bool used = false;
  };
 
  Entry* find(const TSTRING& host) {
    for (size_t i = 0; i < SLOTS; ++i) {
      if (entries_[i].used && entries_[i].host == host) return &entries_[i];
    }
    return nullptr;
  }
 
  Entry entries_[SLOTS];
};
 
class GatewayAckPackage : public plugin::SinglePackage {
 public:
  uint32_t messageId = 0;
 
  uint32_t originNode = 0;
 
  bool success = false;
 
  uint16_t httpStatus = 0;
 
  TSTRING error = "";
 
  uint32_t timestamp = 0;
 
  TSTRING response = "";
 
  int8_t retryable = -1;
 
  uint32_t retryAfterMs = 0;
 
  static constexpr int numPackageFields = 9;
 
  GatewayAckPackage() : SinglePackage(protocol::GATEWAY_ACK) {}
 
  GatewayAckPackage(JsonObject jsonObj) : SinglePackage(jsonObj) {
    messageId = jsonObj["msgId"];
    originNode = jsonObj["origin"];
    success = jsonObj["success"] | false;
    httpStatus = jsonObj["http"];
    timestamp = jsonObj["ts"];
 
#if ARDUINOJSON_VERSION_MAJOR < 7
    if (jsonObj.containsKey("err"))
      error = jsonObj["err"].as<TSTRING>();
    if (jsonObj.containsKey("resp"))
      response = jsonObj["resp"].as<TSTRING>();
    if (jsonObj.containsKey("retry"))
      retryable = jsonObj["retry"].as<bool>() ? 1 : 0;
#else
    if (jsonObj["err"].is<TSTRING>())
      error = jsonObj["err"].as<TSTRING>();
    if (jsonObj["resp"].is<TSTRING>())
      response = jsonObj["resp"].as<TSTRING>();
    if (jsonObj["retry"].is<bool>())
      retryable = jsonObj["retry"].as<bool>() ? 1 : 0;
#endif
    retryAfterMs = jsonObj["retryAfter"] | 0UL;
  }
 
  JsonObject addTo(JsonObject&& jsonObj) const {
    jsonObj = SinglePackage::addTo(std::move(jsonObj));
    jsonObj["msgId"] = messageId;
    jsonObj["origin"] = originNode;
    jsonObj["success"] = success;
    jsonObj["http"] = httpStatus;
    jsonObj["err"] = error;
    jsonObj["ts"] = timestamp;
    // Added in 2.1.0 and omitted when they say nothing, so an ack to a node
    // that predates them is the ack it always was.
    if (response.length() > 0) jsonObj["resp"] = response;
    if (retryable >= 0) jsonObj["retry"] = retryable == 1;
    if (retryAfterMs > 0) jsonObj["retryAfter"] = retryAfterMs;
    return jsonObj;
  }
 
#if ARDUINOJSON_VERSION_MAJOR < 7
  size_t jsonObjectSize() const {
    // noJsonFields (from base class) + numPackageFields (our fields)
    return JSON_OBJECT_SIZE(noJsonFields + numPackageFields) + error.length() +
           response.length();
  }
#endif
 
};
 
// ===========================================================================
// Scheduler-stall protection for blocking gateway requests
// ===========================================================================
 
// The socket timeouts below are derived from NODE_TIMEOUT rather than written
// as absolute numbers, so a gateway request cannot outlast the mesh watchdog in
// *any* build. That is not hypothetical tidiness: the host test environment
// overrides NODE_TIMEOUT to 5s (test/catch/Arduino.h shadows configuration.hpp
// wholesale via its include guard), so hardcoded defaults sized for the 10s
// production watchdog would blow the assertion below there.
//
// They live in this header, not in configuration.hpp, for the same reason --
// gateway.hpp is reached through both configurations, configuration.hpp is not.
//
// At the production NODE_TIMEOUT of 10s this gives 5000ms for the request and
// 2000ms for the captive-portal probe. Dividing by TASK_MILLISECOND first
// normalises out the scheduler resolution, so the result is milliseconds under
// _TASK_MICRO_RES too.
 
#ifndef GATEWAY_HTTP_TIMEOUT_MS
#define GATEWAY_HTTP_TIMEOUT_MS ((NODE_TIMEOUT) / TASK_MILLISECOND / 5)
#endif
 
#ifndef GATEWAY_CAPTIVE_PORTAL_TIMEOUT_MS
#define GATEWAY_CAPTIVE_PORTAL_TIMEOUT_MS ((NODE_TIMEOUT) / TASK_MILLISECOND / 10)
#endif
 
#ifndef GATEWAY_DNS_TIMEOUT_MS
#define GATEWAY_DNS_TIMEOUT_MS ((NODE_TIMEOUT) / TASK_MILLISECOND / 10)
#endif
 
#ifndef GATEWAY_CONNECTIVITY_CACHE_MS
#define GATEWAY_CONNECTIVITY_CACHE_MS 60000UL
#endif
 
constexpr unsigned long gatewayBlockingBudgetMs() {
  return 2UL * static_cast<unsigned long>(GATEWAY_HTTP_TIMEOUT_MS) +
         2UL * static_cast<unsigned long>(GATEWAY_CAPTIVE_PORTAL_TIMEOUT_MS) +
         static_cast<unsigned long>(GATEWAY_DNS_TIMEOUT_MS);
}
 
// A gateway that can block longer than the mesh watchdog partitions the mesh
// around itself (issues #318, #332). Catch what is expressible at compile time
// -- both socket waits of each HTTP call plus the DNS probe; see the ESP32
// resolver caveat above for the one wait this cannot cover. TASK_ constants
// are scaled by the scheduler's resolution, so the comparison is written in
// scheduler units to stay correct under _TASK_MICRO_RES too.
static_assert(gatewayBlockingBudgetMs() * TASK_MILLISECOND < NODE_TIMEOUT,
              "Gateway blocking budget (2x GATEWAY_HTTP_TIMEOUT_MS + 2x "
              "GATEWAY_CAPTIVE_PORTAL_TIMEOUT_MS + GATEWAY_DNS_TIMEOUT_MS) "
              "must stay below NODE_TIMEOUT, or a gateway request stalls the "
              "scheduler for longer than its peers are willing to wait and "
              "the mesh partitions around the gateway. Raise NODE_TIMEOUT if "
              "you need a longer HTTP timeout.");
 
template <typename T>
bool reserveGatewayBlockingBudget(T& connection) {
  if (!connection.timeOutTask.isEnabled()) return false;
  connection.timeOutTask.adjust(static_cast<long>(
      gatewayBlockingBudgetMs() * TASK_MILLISECOND));
  return true;
}
 
template <typename T>
size_t refreshPeerWatchdogs(T& mesh, unsigned long stalledMs) {
  if (stalledMs == 0) return 0;  // nothing blocked, nothing to give back
  size_t refreshed = 0;
  for (auto&& connection : mesh.subs) {
    if (!connection) continue;
    if (!connection->timeOutTask.isEnabled()) continue;
    connection->timeOutTask.adjust(
        static_cast<long>(stalledMs * TASK_MILLISECOND));
    ++refreshed;
  }
  return refreshed;
}
 
}  // namespace gateway
}  // namespace painlessmesh
 
#endif  // _PAINLESS_MESH_GATEWAY_HPP_