introduce wall time

Author: d-a-v

libraries/ESP8266HTTPClient/examples/BasicHttpsClient/BasicHttpsClient.ino

@@ -60,8 +60,8 @@ void loop() {
 #endif
 
     HTTPClient https;
-    https.setTimeout(4000);  // or: client->setTimeout(4000);
-    client->setHandshakeTimeout(10000);
+    https.setWalTime(10000);     // do not exceed 10s while getting data
+    client->setWallTime(20000);  // do not exceed 20s during handshake
 
     // Try to reduce RAM footprint when SSL server allows it
     constexpr int sslbufsize = 1024;

libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp

@@ -86,9 +86,6 @@ bool HTTPClient::begin(WiFiClient &client, const String& url) {
 
     _port = (protocol == "https" ? 443 : 80);
     _client = client.clone();
-    if (_deferredTimeout) {
-        _client->setTimeout(_deferredTimeout);
-    }
 
     return beginInternal(url, protocol.c_str());
 }
@@ -112,9 +109,6 @@ bool HTTPClient::begin(WiFiClient &client, const String& host, uint16_t port, co
     }
 
     _client = client.clone();
-    if (_deferredTimeout) {
-        _client->setTimeout(_deferredTimeout);
-    }
 
     clear();
 
@@ -309,17 +303,12 @@ void HTTPClient::setAuthorization(String auth)
 }
 
 /**
- * set the timeout for the TCP connection
+ * set the wall time for operations
  * @param timeout unsigned int
  */
-void HTTPClient::setTimeout(uint16_t timeout)
+void HTTPClient::setWallTime(unsigned long wallTime)
 {
-    if(connected()) {
-        _client->setTimeout(timeout);
-    }
-    else {
-        _deferredTimeout = timeout;
-    }
+    _wallTime.reset(wallTime?: esp8266::polledTimeout::oneShotMs::neverExpires);
 }
 
 /**
@@ -885,7 +874,6 @@ bool HTTPClient::sendHeader(const char * type)
  */
 int HTTPClient::handleHeaderResponse()
 {
-
     if(!connected()) {
         return HTTPC_ERROR_NOT_CONNECTED;
     }
@@ -897,16 +885,14 @@ int HTTPClient::handleHeaderResponse()
     String transferEncoding;
 
     _transferEncoding = HTTPC_TE_IDENTITY;
-    unsigned long lastDataTime = millis();
+    _wallTime.reset();
 
     while(connected()) {
         size_t len = _client->available();
         if(len > 0) {
             int headerSeparator = -1;
             String headerLine = _client->readStringUntil('\n');
 
-            lastDataTime = millis();
-
             DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] RX: '%s'\n", headerLine.c_str());
 
             if (headerLine.startsWith(F("HTTP/1."))) {
@@ -984,7 +970,7 @@ int HTTPClient::handleHeaderResponse()
             }
 
         } else {
-            if((millis() - lastDataTime) > _client.get()->getTimeout()) {
+            if(_wallTime) {
                 return HTTPC_ERROR_READ_TIMEOUT;
             }
             esp_yield();

libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.h

@@ -29,6 +29,7 @@
 #include <Arduino.h>
 #include <StreamString.h>
 #include <WiFiClient.h>
+#include <PolledTimeout.h>
 
 #include <memory>
 
@@ -42,6 +43,8 @@
 #define DEBUG_HTTPCLIENT(...) do { (void)0; } while (0)
 #endif
 
+#define HTTPCLIENT_DEFAULT_TCP_TIMEOUT (5000)
+
 /// HTTP client errors
 #define HTTPC_ERROR_CONNECTION_FAILED   (-1)
 #define HTTPC_ERROR_SEND_HEADER_FAILED  (-2)
@@ -150,7 +153,7 @@ typedef std::unique_ptr<TransportTraits> TransportTraitsPtr;
 class HTTPClient
 {
 public:
-    HTTPClient() = default;
+    HTTPClient(): _wallTime(HTTPCLIENT_DEFAULT_TCP_TIMEOUT) {};
     ~HTTPClient() = default;
     HTTPClient(HTTPClient&&) = default;
     HTTPClient& operator=(HTTPClient&&) = default;
@@ -175,7 +178,8 @@ class HTTPClient
     void setAuthorization(const char * user, const char * password);
     void setAuthorization(const char * auth);
     void setAuthorization(String auth);
-    void setTimeout(uint16_t timeout);
+    void setWallTime(unsigned long wallTime);
+    [[deprecated("use setWallTime() instead")]] void setTimeout(unsigned long wallTime) { setWallTime(wallTime); }
 
     // Redirections
     void setFollowRedirects(followRedirects_t follow);
@@ -254,7 +258,7 @@ class HTTPClient
     String _host;
     uint16_t _port = 0;
     bool _reuse = true;
-    uint16_t _deferredTimeout = 0;
+    esp8266::polledTimeout::oneShotMs _wallTime;
     bool _useHTTP10 = false;
 
     String _uri;
@@ -312,6 +316,7 @@ int HTTPClient::writeToStream(S * output)
         }
     } else if(_transferEncoding == HTTPC_TE_CHUNKED) {
         int size = 0;
+        _wallTime.reset();
         while(1) {
             if(!connected()) {
                 return returnError(HTTPC_ERROR_CONNECTION_LOST);
@@ -358,6 +363,10 @@ int HTTPClient::writeToStream(S * output)
                 return returnError(HTTPC_ERROR_READ_TIMEOUT);
             }
 
+            if (_wallTime) {
+                return returnError(HTTPC_ERROR_READ_TIMEOUT);
+            }
+
             esp_yield();
         }
     } else {

libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp

@@ -31,7 +31,6 @@ extern "C" {
 }
 #include "debug.h"
 #include "ESP8266WiFi.h"
-#include "PolledTimeout.h"
 #include "WiFiClient.h"
 #include "WiFiClientSecureBearSSL.h"
 #include "StackThunk.h"
@@ -68,6 +67,8 @@ extern "C" {
 
 namespace BearSSL {
 
+constexpr auto defaultWallTime = 10000UL;
+
 void WiFiClientSecureCtx::_clear() {
   _sc = nullptr;
   _sc_svr = nullptr;
@@ -80,7 +81,7 @@ void WiFiClientSecureCtx::_clear() {
   _now = 0; // You can override or ensure time() is correct w/configTime
   _ta = nullptr;
   setBufferSizes(16384, 512); // Minimum safe
-  _set_handshake_done(false); // refreshes _timeout
+  _handshake_done = false;
   _recvapp_buf = nullptr;
   _recvapp_len = 0;
   _oom_err = false;
@@ -100,7 +101,7 @@ void WiFiClientSecureCtx::_clearAuthenticationSettings() {
 }
 
 
-WiFiClientSecureCtx::WiFiClientSecureCtx() : WiFiClient() {
+WiFiClientSecureCtx::WiFiClientSecureCtx() : WiFiClient(), _wallTime(defaultWallTime) {
   _clear();
   _clearAuthenticationSettings();
   _certStore = nullptr; // Don't want to remove cert store on a clear, should be long lived
@@ -121,7 +122,7 @@ WiFiClientSecureCtx::~WiFiClientSecureCtx() {
 WiFiClientSecureCtx::WiFiClientSecureCtx(ClientContext* client,
                                      const X509List *chain, const PrivateKey *sk,
                                      int iobuf_in_size, int iobuf_out_size, ServerSessions *cache,
-                                     const X509List *client_CA_ta, int tls_min, int tls_max) {
+                                     const X509List *client_CA_ta, int tls_min, int tls_max): _wallTime(defaultWallTime) {
   _clear();
   _clearAuthenticationSettings();
   stack_thunk_add_ref();
@@ -142,7 +143,7 @@ WiFiClientSecureCtx::WiFiClientSecureCtx(ClientContext *client,
                                      const X509List *chain,
                                      unsigned cert_issuer_key_type, const PrivateKey *sk,
                                      int iobuf_in_size, int iobuf_out_size, ServerSessions *cache,
-                                     const X509List *client_CA_ta, int tls_min, int tls_max) {
+                                     const X509List *client_CA_ta, int tls_min, int tls_max): _wallTime(defaultWallTime) {
   _clear();
   _clearAuthenticationSettings();
   stack_thunk_add_ref();
@@ -201,13 +202,10 @@ bool WiFiClientSecureCtx::stop(unsigned int maxWaitMs) {
 }
 
 bool WiFiClientSecureCtx::flush(unsigned int maxWaitMs) {
-  auto savedRuntime = _runtimeTimeout;
-  auto savedHandshake = _handshakeTimeout;
-  _runtimeTimeout = maxWaitMs;
-  _handshakeTimeout = maxWaitMs;
+  auto savedTimeout = _timeout;
+  _timeout = std::max(1U, maxWaitMs);
   (void) _run_until(BR_SSL_SENDAPP);
-  _runtimeTimeout = savedRuntime;
-  _handshakeTimeout = savedHandshake;
+  _timeout = savedTimeout;
   return WiFiClient::flush(maxWaitMs);
 }
 
@@ -248,7 +246,7 @@ void WiFiClientSecureCtx::_freeSSL() {
   _recvapp_buf = nullptr;
   _recvapp_len = 0;
   // This connection is toast
-  _set_handshake_done(false); // refreshes _timeout
+  _handshake_done = false;
 }
 
 bool WiFiClientSecureCtx::_clientConnected() {
@@ -463,7 +461,6 @@ size_t WiFiClientSecureCtx::peekBytes(uint8_t *buffer, size_t length) {
     return 0;
   }
 
-  _updateStreamTimeout();
   _startMillis = millis();
   while ((_pollRecvBuffer() < (int)length) && ((millis() - _startMillis) < _timeout)) {
     yield();
@@ -486,10 +483,7 @@ int WiFiClientSecureCtx::_run_until(unsigned target, bool blocking) {
     return -1;
   }
 
-  // _run_until() is called prior to inherited read/write methods
-  // -> refreshing _timeout here, which is also used by ancestors
-  DEBUG_BSSL("_run_until starts, timeout=%lu\n", _updateStreamTimeout());
-  esp8266::polledTimeout::oneShotMs loopTimeout(_updateStreamTimeout());
+  esp8266::polledTimeout::oneShotMs loopTimeout(_timeout);
 
   for (int no_work = 0; blocking || no_work < 2;) {
     optimistic_yield(100);
@@ -617,15 +611,20 @@ bool WiFiClientSecureCtx::_wait_for_handshake() {
   }
 #endif
 
-  _set_handshake_done(false); // refreshes _timeout
+  _wallTime.reset();
+  _handshake_done = false;
   while (!_handshake_done && _clientConnected()) {
     int ret = _run_until(BR_SSL_SENDAPP);
     if (ret < 0) {
       DEBUG_BSSL("_wait_for_handshake: failed\n");
       break;
     }
     if (br_ssl_engine_current_state(_eng) & BR_SSL_SENDAPP) {
-      _set_handshake_done(true); // refreshes _timeout
+      _handshake_done = true;
+    }
+    if (_wallTime) {
+      DEBUG_BSSL("handshake too long\n");
+      break;
     }
     optimistic_yield(1000);
   }
@@ -1221,8 +1220,6 @@ bool WiFiClientSecureCtx::_connectSSL(const char* hostName) {
   _x509_insecure = nullptr;
   _x509_knownkey = nullptr;
 
-  // _timeout has been refreshed to normal operation as _handshake_done turned to true
-
   return ret;
 }
 
@@ -1691,7 +1688,7 @@ void WiFiClientSecure::setTimeout (unsigned long timeout)
 {
   WiFiClient::setTimeout(timeout);
   if (_ctx)
-    _ctx->setRuntimeTimeout(timeout);
+    _ctx->setTimeout(timeout);
 }
 
 };  // namespace BearSSL

libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.h

@@ -28,6 +28,7 @@
 #include <bearssl/bearssl.h>
 #include "BearSSLHelpers.h"
 #include "CertStoreBearSSL.h"
+#include "PolledTimeout.h"
 
 namespace BearSSL {
 
@@ -147,9 +148,8 @@ class WiFiClientSecureCtx : public WiFiClient {
     // consume bytes after use (see peekBuffer)
     virtual void peekConsume (size_t consume) override;
 
-    void setRuntimeTimeout (unsigned long timeout) { _runtimeTimeout = timeout; }
-    void setHandshakeTimeout (unsigned long timeout) { _handshakeTimeout = timeout; }
-    unsigned long getHandshakeTimeout () const { return _handshakeTimeout; }
+    // install a wall-time used during handshake
+    void setWallTime (unsigned long wallTime) { _wallTime.reset(wallTime?: esp8266::polledTimeout::oneShotMs::neverExpires); }
 
   protected:
     bool _connectSSL(const char *hostName); // Do initial SSL handshake
@@ -240,13 +240,7 @@ class WiFiClientSecureCtx : public WiFiClient {
 
     uint8_t *_streamLoad(Stream& stream, size_t size);
 
-    // timeout management
-
-    unsigned long _updateStreamTimeout () { setTimeout(_handshake_done? _runtimeTimeout: _handshakeTimeout); return getTimeout(); }
-    void _set_handshake_done (bool handshake_done) { _handshake_done = handshake_done; _updateStreamTimeout(); }
-
-    unsigned long _runtimeTimeout = 5000, _handshakeTimeout = 15000;
-
+    esp8266::polledTimeout::oneShotMs _wallTime;
 }; // class WiFiClientSecureCtx
 
 
@@ -373,9 +367,8 @@ class WiFiClientSecure : public WiFiClient {
     // override setTimeout and forward to context
     virtual void setTimeout (unsigned long timeout) override;
 
-    // allowing user to set timeout used during handshake
-    void setHandshakeTimeout (unsigned long timeout) { _ctx->setHandshakeTimeout(timeout); }
-    unsigned long getHandshakeTimeout () const { return _ctx->getHandshakeTimeout(); }
+    // install a wall-time used during handshake
+    void setWallTime (unsigned long wallTime) { _ctx->setWallTime(wallTime); }
 
   private:
     std::shared_ptr<WiFiClientSecureCtx> _ctx;