-Werror stream deprecations & inconsistent overloads

drop write(Stream&) implementations
don't add virtual w/ override, distinguish from class virtuals
fixup u8 vs. char, prefer u8 in all methods and entries

Author: mcspr

libraries/ESP8266WiFi/src/WiFiClient.cpp

@@ -220,29 +220,6 @@ size_t WiFiClient::write(const uint8_t *buf, size_t size)
     return _client->write((const char*)buf, size);
 }
 
-size_t WiFiClient::write(Stream& stream)
-{
-    // (this method is deprecated)
-
-    if (!_client || !stream.available())
-    {
-        return 0;
-    }
-    // core up to 2.7.4 was equivalent to this
-    return stream.sendAll(this);
-}
-
-size_t WiFiClient::write_P(PGM_P buf, size_t size)
-{
-    if (!_client || !size)
-    {
-        return 0;
-    }
-    _client->setTimeout(_timeout);
-    StreamConstPtr nopeek(buf, size);
-    return nopeek.sendAll(this);
-}
-
 int WiFiClient::available()
 {
     if (!_client)
@@ -439,14 +416,9 @@ uint8_t WiFiClient::getKeepAliveCount () const
     return _client->getKeepAliveCount();
 }
 
-bool WiFiClient::hasPeekBufferAPI () const
-{
-    return true;
-}
-
 // return a pointer to available data buffer (size = peekAvailable())
 // semantic forbids any kind of read() before calling peekConsume()
-const char* WiFiClient::peekBuffer ()
+const void* WiFiClient::peekBuffer ()
 {
     return _client? _client->peekBuffer(): nullptr;
 }

libraries/ESP8266WiFi/src/WiFiClient.h

@@ -27,17 +27,7 @@
 #include "Client.h"
 #include "IPAddress.h"
 #include "include/slist.h"
-
-#ifndef TCP_MSS
-#define TCP_MSS 1460 // lwip1.4
-#endif
-
-#define WIFICLIENT_MAX_PACKET_SIZE TCP_MSS
-#define WIFICLIENT_MAX_FLUSH_WAIT_MS 300
-
-#define TCP_DEFAULT_KEEPALIVE_IDLE_SEC          7200 // 2 hours
-#define TCP_DEFAULT_KEEPALIVE_INTERVAL_SEC      75   // 75 sec
-#define TCP_DEFAULT_KEEPALIVE_COUNT             9    // fault after 9 failures
+#include "include/internal.h"
 
 class ClientContext;
 class WiFiServer;
@@ -65,31 +55,30 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   virtual std::unique_ptr<WiFiClient> clone() const;
 
   virtual uint8_t status();
-  virtual int connect(IPAddress ip, uint16_t port) override;
-  virtual int connect(const char *host, uint16_t port) override;
+  int connect(IPAddress ip, uint16_t port) override;
+  int connect(const char *host, uint16_t port) override;
   virtual int connect(const String& host, uint16_t port);
-  virtual size_t write(uint8_t) override;
-  virtual size_t write(const uint8_t *buf, size_t size) override;
-  virtual size_t write_P(PGM_P buf, size_t size);
-  [[ deprecated("use stream.sendHow(client...)") ]]
-  size_t write(Stream& stream);
-
-  virtual int available() override;
-  virtual int read() override;
-  virtual int read(uint8_t* buf, size_t size) override;
+
+  using Print::write;
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t *buf, size_t size) override;
+
+  int available() override;
+  int read() override;
+  int read(uint8_t* buf, size_t size) override;
   int read(char* buf, size_t size);
 
-  virtual int peek() override;
+  int peek() override;
   virtual size_t peekBytes(uint8_t *buffer, size_t length);
   size_t peekBytes(char *buffer, size_t length) {
     return peekBytes((uint8_t *) buffer, length);
   }
-  virtual void flush() override { (void)flush(0); } // wait for all outgoing characters to be sent, output buffer should be empty after this call
-  virtual void stop() override { (void)stop(0); }
+  void flush() override { (void)flush(0); } // wait for all outgoing characters to be sent, output buffer should be empty after this call
+  void stop() override { (void)stop(0); }
   bool flush(unsigned int maxWaitMs);
   bool stop(unsigned int maxWaitMs);
-  virtual uint8_t connected() override;
-  virtual operator bool() override;
+  uint8_t connected() override;
+  operator bool() override;
 
   virtual IPAddress remoteIP();
   virtual uint16_t  remotePort();
@@ -102,8 +91,6 @@ class WiFiClient : public Client, public SList<WiFiClient> {
 
   friend class WiFiServer;
 
-  using Print::write;
-  
   static void stopAll();
   static void stopAllExcept(WiFiClient * c);
 
@@ -133,27 +120,26 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   void setSync(bool sync);
 
   // peek buffer API is present
-  virtual bool hasPeekBufferAPI () const override;
+  bool hasPeekBufferAPI () const override { return true; }
 
   // return number of byte accessible by peekBuffer()
-  virtual size_t peekAvailable () override;
+  size_t peekAvailable () override;
 
   // return a pointer to available data buffer (size = peekAvailable())
   // semantic forbids any kind of read() before calling peekConsume()
-  virtual const char* peekBuffer () override;
+  const void* peekBuffer () override;
 
   // consume bytes after use (see peekBuffer)
-  virtual void peekConsume (size_t consume) override;
+  void peekConsume (size_t consume) override;
 
-  virtual bool outputCanTimeout () override { return connected(); }
-  virtual bool inputCanTimeout () override { return connected(); }
+  bool outputCanTimeout () override { return connected(); }
+  bool inputCanTimeout () override { return connected(); }
 
   // Immediately stops this client instance.
   // Unlike stop(), does not wait to gracefuly shutdown the connection.
   void abort();
 
 protected:
-
   static int8_t _s_connected(void* arg, void* tpcb, int8_t err);
   static void _s_err(void* arg, int8_t err);
 

libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp

@@ -294,7 +294,7 @@ int WiFiClientSecureCtx::availableForWrite () {
   return 0;
 }
 
-size_t WiFiClientSecureCtx::_write(const uint8_t *buf, size_t size, bool pmem) {
+size_t WiFiClientSecureCtx::_write(const uint8_t *buf, size_t size) {
   size_t sent_bytes = 0;
 
   if (!size || !_engineConnected()) {
@@ -316,11 +316,7 @@ size_t WiFiClientSecureCtx::_write(const uint8_t *buf, size_t size, bool pmem) {
       size_t sendapp_len;
       unsigned char *sendapp_buf = br_ssl_engine_sendapp_buf(_eng, &sendapp_len);
       int to_send = size > sendapp_len ? sendapp_len : size;
-      if (pmem) {
-        memcpy_P(sendapp_buf, buf, to_send);
-      } else {
-        memcpy(sendapp_buf, buf, to_send);
-      }
+      memcpy(sendapp_buf, buf, to_send);
       br_ssl_engine_sendapp_ack(_eng, to_send);
       br_ssl_engine_flush(_eng, 0);
       flush();
@@ -336,20 +332,11 @@ size_t WiFiClientSecureCtx::_write(const uint8_t *buf, size_t size, bool pmem) {
 }
 
 size_t WiFiClientSecureCtx::write(const uint8_t *buf, size_t size) {
-  return _write(buf, size, false);
-}
-
-size_t WiFiClientSecureCtx::write_P(PGM_P buf, size_t size) {
-  return _write((const uint8_t *)buf, size, true);
+  return _write(buf, size);
 }
 
-size_t WiFiClientSecureCtx::write(Stream& stream) {
-  if (!_engineConnected()) {
-    DEBUG_BSSL("write: no br_ssl engine to work with\n");
-    return 0;
-  }
-
-  return stream.sendAll(this);
+size_t WiFiClientSecureCtx::write(uint8_t c) {
+  return _write(&c, 1);
 }
 
 int WiFiClientSecureCtx::read(uint8_t *buf, size_t size) {
@@ -395,9 +382,9 @@ int WiFiClientSecureCtx::read(uint8_t *buf, size_t size) {
 
 // return a pointer to available data buffer (size = peekAvailable())
 // semantic forbids any kind of read() before calling peekConsume()
-const char* WiFiClientSecureCtx::peekBuffer ()
+const void* WiFiClientSecureCtx::peekBuffer ()
 {
-    return (const char*)_recvapp_buf;
+    return _recvapp_buf;
 }
 
 // consume bytes after use (see peekBuffer)

libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.h

@@ -51,9 +51,11 @@ class WiFiClientSecureCtx : public WiFiClient {
     int connect(const char* name, uint16_t port) override;
 
     uint8_t connected() override;
+
+    using Print::write;
+    size_t write(uint8_t) override;
     size_t write(const uint8_t *buf, size_t size) override;
-    size_t write_P(PGM_P buf, size_t size) override;
-    size_t write(Stream& stream); // Note this is not virtual
+
     int read(uint8_t *buf, size_t size) override;
     int read(char *buf, size_t size) { return read((uint8_t*)buf, size); }
     int available() override;
@@ -135,17 +137,17 @@ class WiFiClientSecureCtx : public WiFiClient {
     bool setSSLVersion(uint32_t min = BR_TLS10, uint32_t max = BR_TLS12);
 
     // peek buffer API is present
-    virtual bool hasPeekBufferAPI () const override { return true; }
+    bool hasPeekBufferAPI () const override { return true; }
 
     // return number of byte accessible by peekBuffer()
-    virtual size_t peekAvailable () override { return WiFiClientSecureCtx::available(); }
+    size_t peekAvailable () override { return WiFiClientSecureCtx::available(); }
 
     // return a pointer to available data buffer (size = peekAvailable())
     // semantic forbids any kind of read() before calling peekConsume()
-    virtual const char* peekBuffer () override;
+    const void* peekBuffer () override;
 
     // consume bytes after use (see peekBuffer)
-    virtual void peekConsume (size_t consume) override;
+    void peekConsume (size_t consume) override;
 
   protected:
     bool _connectSSL(const char *hostName); // Do initial SSL handshake
@@ -205,7 +207,7 @@ class WiFiClientSecureCtx : public WiFiClient {
     std::shared_ptr<unsigned char> _alloc_iobuf(size_t sz);
     void _freeSSL();
     int _run_until(unsigned target, bool blocking = true);
-    size_t _write(const uint8_t *buf, size_t size, bool pmem);
+    size_t _write(const uint8_t *buf, size_t size);
     bool _wait_for_handshake(); // Sets and return the _handshake_done after connecting
 
     // Optional client certificate
@@ -268,11 +270,11 @@ class WiFiClientSecure : public WiFiClient {
     int connect(const char* name, uint16_t port) override { return _ctx->connect(name, port); }
 
     uint8_t connected() override { return _ctx->connected(); }
+
+    using Print::write;
+    size_t write(uint8_t c) override { return _ctx->write(c); }
     size_t write(const uint8_t *buf, size_t size) override { return _ctx->write(buf, size); }
-    size_t write_P(PGM_P buf, size_t size) override { return _ctx->write_P(buf, size); }
-    size_t write(const char *buf) { return write((const uint8_t*)buf, strlen(buf)); }
-    size_t write_P(const char *buf) { return write_P((PGM_P)buf, strlen_P(buf)); }
-    size_t write(Stream& stream) /* Note this is not virtual */ { return _ctx->write(stream); }
+
     int read(uint8_t *buf, size_t size) override { return _ctx->read(buf, size); }
     int available() override { return _ctx->available(); }
     int availableForWrite() override { return _ctx->availableForWrite(); }
@@ -346,17 +348,17 @@ class WiFiClientSecure : public WiFiClient {
     static bool probeMaxFragmentLength(const String& host, uint16_t port, uint16_t len);
 
     // peek buffer API is present
-    virtual bool hasPeekBufferAPI () const override { return true; }
+    bool hasPeekBufferAPI () const override { return true; }
 
     // return number of byte accessible by peekBuffer()
-    virtual size_t peekAvailable () override { return _ctx->available(); }
+    size_t peekAvailable () override { return _ctx->available(); }
 
     // return a pointer to available data buffer (size = peekAvailable())
     // semantic forbids any kind of read() before calling peekConsume()
-    virtual const char* peekBuffer () override { return _ctx->peekBuffer(); }
+    const void* peekBuffer () override { return _ctx->peekBuffer(); }
 
     // consume bytes after use (see peekBuffer)
-    virtual void peekConsume (size_t consume) override { return _ctx->peekConsume(consume); }
+    void peekConsume (size_t consume) override { return _ctx->peekConsume(consume); }
 
     void keepAlive(uint16_t idle_sec = TCP_DEFAULT_KEEPALIVE_IDLE_SEC, uint16_t intv_sec = TCP_DEFAULT_KEEPALIVE_INTERVAL_SEC, uint8_t count = TCP_DEFAULT_KEEPALIVE_COUNT) override
     {

libraries/ESP8266WiFi/src/include/ClientContext.h

@@ -26,10 +26,16 @@ class WiFiClient;
 
 typedef void (*discard_cb_t)(void*, ClientContext*);
 
+#include <debug.h>
 #include <assert.h>
 #include <esp_priv.h>
 #include <coredecls.h>
 
+#include <lwip/init.h>
+#include <lwip/tcp.h>
+
+#include "internal.h"
+
 bool getDefaultPrivateGlobalSyncValue ();
 
 class ClientContext
@@ -313,7 +319,7 @@ class ClientContext
         _rx_buf_offset = 0;
     }
 
-    bool wait_until_acked(int max_wait_ms = WIFICLIENT_MAX_FLUSH_WAIT_MS)
+    bool wait_until_acked(int max_wait_ms)
     {
         // https://github.com/esp8266/Arduino/pull/3967#pullrequestreview-83451496
         // option 1 done
@@ -422,11 +428,11 @@ class ClientContext
 
     // return a pointer to available data buffer (size = peekAvailable())
     // semantic forbids any kind of read() before calling peekConsume()
-    const char* peekBuffer ()
+    const void* peekBuffer ()
     {
         if (!_rx_buf)
             return nullptr;
-        return (const char*)_rx_buf->payload + _rx_buf_offset;
+        return (const uint8_t*)_rx_buf->payload + _rx_buf_offset;
     }
 
     // return number of byte accessible by peekBuffer()
@@ -460,7 +466,7 @@ class ClientContext
         }
     }
 
-    size_t _write_from_source(const char* ds, const size_t dl)
+    size_t _write_from_source(const char* ds, size_t dl)
     {
         assert(_datasource == nullptr);
         assert(!_send_waiting);
@@ -489,7 +495,7 @@ class ClientContext
         } while(true);
 
         if (_sync)
-            wait_until_acked();
+            wait_until_acked(_timeout_ms);
 
         return _written;
     }