Add HTTPClient, ported from the ESP8266 (#784)

Remove the need to have a separate WiFiClient that's destroyed after
the HTTPClient.  Let the object handle its own client, and pass through
any SSL requests.

Also supports the original ::begin methods which need a
WiFiClient(Secure) to be passed in and managed by the app.

docs/httpclient.rst

+HTTPClient Library
+==================
+
+A simple HTTP requestor that can handle both HTTP and HTTP requests is
+included as the ``HTTPClient`` library.
+
+Check the examples for use under HTTP and HTTPS configurations.  In general,
+for HTTP connections (unsecured and very uncommon on the internet today) simply
+passing in a URL and performiung a GET is sufficient to transfer data.
+
+.. code:: cpp
+
+    // Error checking is left as an exercise for the reader...
+    HTTPClient http;
+    if (http.begin("http://my.server/url")) {
+        if (http.GET() > 0) {
+            String data = http.getString();
+        }
+        http.end();
+    }
+
+For HTTPS connections, simply add the appropriate WiFiClientSecure calls
+as needed (i.e. ``setInsecure()``, ``setTrustAnchor``, etc.).  See the
+WiFiClientSecure documentation for more details.
+
+.. code:: cpp
+
+    // Error checking is left as an exercise for the reader...
+    HTTPClient https;
+    https.setInsecure(); // Use certs, but do not check their authenticity
+    if (https.begin("https://my.secure.server/url")) {
+        if (http.GET() > 0) {
+            String data = http.getString();
+        }
+        http.end();
+    }
+
+Unlike the ESP8266 and ESP32 ``HTTPClient`` implementations it is not necessary
+to create a ``WiFiClient`` or ``WiFiClientSecure`` to pass in to the ``HTTPClient``
+object.

docs/index.rst

@@ -50,6 +50,8 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
    WiFiClientSecure (TLS/SSL/HTTPS) <bearssl-client-secure-class>
    WiFiServerSecure (TLS/SSL/HTTPS) <bearssl-server-secure-class>
 
+   HTTP/HTTPS Client <httpclient>
+
    Over-the-Air (OTA) Updates <ota>
 
    Ported/Optimized Libraries <libraries>

keywords.txt

@@ -2,6 +2,8 @@
 # Syntax Coloring Map
 #######################################
 
+Arduino	KEYWORD3		RESERVED_WORD
+
 #######################################
 # Datatypes (KEYWORD1)
 #######################################

libraries/HTTPClient/examples/Authorization/Authorization.ino

+/**
+   Authorization.ino
+
+    Created on: 09.12.2015
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(ssid, pass);
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+
+    HTTPClient http;
+    http.setInsecure();
+
+    Serial.print("[HTTP] begin...\n");
+    // configure traged server and url
+
+
+    http.begin("https://guest:guest@jigsaw.w3.org/HTTP/Basic/");
+
+    /*
+      // or
+      http.begin(client, "http://jigsaw.w3.org/HTTP/Basic/");
+      http.setAuthorization("guest", "guest");
+
+      // or
+      http.begin(client, "http://jigsaw.w3.org/HTTP/Basic/");
+      http.setAuthorization("Z3Vlc3Q6Z3Vlc3Q=");
+    */
+
+
+    Serial.print("[HTTP] GET...\n");
+    // start connection and send HTTP header
+    int httpCode = http.GET();
+
+    // httpCode will be negative on error
+    if (httpCode > 0) {
+      // HTTP header has been send and Server response header has been handled
+      Serial.printf("[HTTP] GET... code: %d\n", httpCode);
+
+      // file found at server
+      if (httpCode == HTTP_CODE_OK) {
+        String payload = http.getString();
+        Serial.println(payload);
+      }
+    } else {
+      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+    }
+
+    http.end();
+  }
+
+  delay(10000);
+}

libraries/HTTPClient/examples/BasicHttpClient/BasicHttpClient.ino

+/**
+   BasicHTTPClient.ino
+
+   Created on: 24.05.2015
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFiMulti.addAP(ssid, pass);
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+
+    HTTPClient http;
+
+    Serial.print("[HTTP] begin...\n");
+    if (http.begin("http://httpbin.org")) {  // HTTP
+
+
+      Serial.print("[HTTP] GET...\n");
+      // start connection and send HTTP header
+      int httpCode = http.GET();
+
+      // httpCode will be negative on error
+      if (httpCode > 0) {
+        // HTTP header has been send and Server response header has been handled
+        Serial.printf("[HTTP] GET... code: %d\n", httpCode);
+
+        // file found at server
+        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
+          String payload = http.getString();
+          Serial.println(payload);
+        }
+      } else {
+        Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+      }
+
+      http.end();
+    } else {
+      Serial.printf("[HTTP} Unable to connect\n");
+    }
+  }
+
+  delay(10000);
+}

libraries/HTTPClient/examples/BasicHttpsClient-Hard/BasicHttpsClient-Hard.ino

+/**
+   BasicHTTPSClient-Hard.ino
+
+   Demonstrates the manual way of making a WiFiClient and passing it in to the HTTPClient
+
+   Created on: 20.08.2018
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(ssid, pass);
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+
+    WiFiClientSecure client;
+    client.setInsecure(); // Not safe against MITM attacks
+
+    HTTPClient https;
+
+    Serial.print("[HTTPS] begin...\n");
+    if (https.begin(client, "https://jigsaw.w3.org/HTTP/connection.html")) {  // HTTPS
+
+      Serial.print("[HTTPS] GET...\n");
+      // start connection and send HTTP header
+      int httpCode = https.GET();
+
+      // httpCode will be negative on error
+      if (httpCode > 0) {
+        // HTTP header has been send and Server response header has been handled
+        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);
+
+        // file found at server
+        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
+          String payload = https.getString();
+          Serial.println(payload);
+        }
+      } else {
+        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
+      }
+
+      https.end();
+    } else {
+      Serial.printf("[HTTPS] Unable to connect\n");
+    }
+  }
+
+  Serial.println("Wait 10s before next round...");
+  delay(10000);
+}

libraries/HTTPClient/examples/BasicHttpsClient/BasicHttpsClient.ino

+/**
+   BasicHTTPSClient.ino
+
+    Created on: 20.08.2018
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(ssid, pass);
+}
+
+const char *jigsaw_cert = R"EOF(
+-----BEGIN CERTIFICATE-----
+MIIFKTCCBM+gAwIBAgIQAbTKhAICxb7iDJbE6qU/NzAKBggqhkjOPQQDAjBKMQsw
+CQYDVQQGEwJVUzEZMBcGA1UEChMQQ2xvdWRmbGFyZSwgSW5jLjEgMB4GA1UEAxMX
+Q2xvdWRmbGFyZSBJbmMgRUNDIENBLTMwHhcNMjIwMzE3MDAwMDAwWhcNMjMwMzE2
+MjM1OTU5WjB1MQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQG
+A1UEBxMNU2FuIEZyYW5jaXNjbzEZMBcGA1UEChMQQ2xvdWRmbGFyZSwgSW5jLjEe
+MBwGA1UEAxMVc25pLmNsb3VkZmxhcmVzc2wuY29tMFkwEwYHKoZIzj0CAQYIKoZI
+zj0DAQcDQgAEYnkGDyrIltjRnxoVdy/xgndo+WGMOASzs2hHeCjbJ1KplKJc/ciK
+XCWq/4+pTzSiVgTFhRmCdLcU1Fa05YFNQaOCA2owggNmMB8GA1UdIwQYMBaAFKXO
+N+rrsHUOlGeItEX62SQQh5YfMB0GA1UdDgQWBBRIzOWGCDBB/PMrMucSrjIKqlgE
+uDAvBgNVHREEKDAmghVzbmkuY2xvdWRmbGFyZXNzbC5jb22CDWppZ3Nhdy53My5v
+cmcwDgYDVR0PAQH/BAQDAgeAMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcD
+AjB7BgNVHR8EdDByMDegNaAzhjFodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vQ2xv
+dWRmbGFyZUluY0VDQ0NBLTMuY3JsMDegNaAzhjFodHRwOi8vY3JsNC5kaWdpY2Vy
+dC5jb20vQ2xvdWRmbGFyZUluY0VDQ0NBLTMuY3JsMD4GA1UdIAQ3MDUwMwYGZ4EM
+AQICMCkwJwYIKwYBBQUHAgEWG2h0dHA6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzB2
+BggrBgEFBQcBAQRqMGgwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0
+LmNvbTBABggrBgEFBQcwAoY0aHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0Ns
+b3VkZmxhcmVJbmNFQ0NDQS0zLmNydDAMBgNVHRMBAf8EAjAAMIIBfwYKKwYBBAHW
+eQIEAgSCAW8EggFrAWkAdQDoPtDaPvUGNTLnVyi8iWvJA9PL0RFr7Otp4Xd9bQa9
+bgAAAX+aFPh6AAAEAwBGMEQCICivjuh2ywUYvVpTKHo65JEheR8dFq8QvBgEiXfw
+m6q6AiAkxAgz77oboGQGetNmab45+peY+nAGOfyW9vi9S1gMaAB3ADXPGRu/sWxX
+vw+tTG1Cy7u2JyAmUeo/4SrvqAPDO9ZMAAABf5oU+GEAAAQDAEgwRgIhANKeTNMy
+GqUsCo7ph7YMWzrhMuDeyP8xPSiCtFzKcn/eAiEAyv5lgCUQ6K14V13zYfL99wZD
+LFcIP/KZ1y7nuPAksTAAdwCzc3cH4YRQ+GOG1gWp3BEJSnktsWcMC4fc8AMOeTal
+mgAAAX+aFPiWAAAEAwBIMEYCIQD6535jWw776D4vjyupP2fBw26CBMpVT5++k4rR
+xqeOXwIhAIbEaEKkEq6JtpWWfVpTyDkMpMfTuiqYVe6REy2XsmEhMAoGCCqGSM49
+BAMCA0gAMEUCIH3r/puXZcX1bfUoBq2njuHe0bxWtvzDaz5k6WLYrazTAiEA+ePL
+N6K5xrmaof185pVCxACPLc/BoKyUwMeC8iXCm00=
+-----END CERTIFICATE-----
+)EOF";
+
+static int cnt = 0;
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+    HTTPClient https;
+    switch (cnt) {
+      case 0:
+        Serial.println("[HTTPS] using insecure SSL, not validating certificate");
+        https.setInsecure(); // Note this is unsafe against MITM attacks
+        cnt++;
+        break;
+      case 1:
+        Serial.println("[HTTPS] using secure SSL, validating certificate");
+        https.setCACert(jigsaw_cert);
+        cnt++;
+        break;
+      default:
+        Serial.println("[HTTPS] not setting any SSL verification settings, will fail");
+        cnt = 0;
+    }
+
+    Serial.print("[HTTPS] begin...\n");
+    if (https.begin("https://jigsaw.w3.org/HTTP/connection.html")) {  // HTTPS
+
+      Serial.print("[HTTPS] GET...\n");
+      // start connection and send HTTP header
+      int httpCode = https.GET();
+
+      // httpCode will be negative on error
+      if (httpCode > 0) {
+        // HTTP header has been send and Server response header has been handled
+        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);
+
+        // file found at server
+        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
+          String payload = https.getString();
+          Serial.println(payload);
+        }
+      } else {
+        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
+      }
+
+      https.end();
+    } else {
+      Serial.printf("[HTTPS] Unable to connect\n");
+    }
+  }
+
+  Serial.println("Wait 10s before next round...");
+  delay(10000);
+}

libraries/HTTPClient/examples/ChunkedClient/ChunkedClient.ino

+/**
+   ChunkedClient.ino
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(ssid, pass);
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+    HTTPClient http;
+
+    Serial.print("[HTTP] begin...\n");
+    if (http.begin("http://anglesharp.azurewebsites.net/Chunked")) {
+
+      Serial.print("[HTTP] GET...\n");
+      // start connection and send HTTP header
+      int httpCode = http.GET();
+
+      // httpCode will be negative on error
+      if (httpCode > 0) {
+        // HTTP header has been send and Server response header has been handled
+        Serial.printf("[HTTP] GET... code: %d\n", httpCode);
+
+        // file found at server
+        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
+          String payload = http.getString();
+          Serial.println(payload);
+        }
+      } else {
+        Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+      }
+
+      http.end();
+    } else {
+      Serial.printf("[HTTP] Unable to connect\n");
+    }
+  }
+
+  Serial.println("Wait forever...");
+  while (1) {
+    continue;
+  }
+}

libraries/HTTPClient/examples/DigestAuthorization/DigestAuthorization.ino

+/*
+    This sketch shows how to handle HTTP Digest Authorization.
+
+    Written by Parham Alvani and Sajjad Rahnama, 2018-01-07.
+
+   This example is released into public domain,
+   or, at your option, CC0 licensed.
+*/
+
+#include <WiFi.h>
+
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "NOBABIES"
+#define STAPSK "ElephantsAreGreat"
+#endif
+
+const char* ssid = STASSID;
+const char* ssidPassword = STAPSK;
+
+const char* username = "admin";
+const char* password = "admin";
+
+const char* server = "http://httpbin.org";
+const char* uri = "/digest-auth/auth/admin/admin/MD5";
+
+String exractParam(String& authReq, const String& param, const char delimit) {
+  int _begin = authReq.indexOf(param);
+  if (_begin == -1) {
+    return "";
+  }
+  return authReq.substring(_begin + param.length(), authReq.indexOf(delimit, _begin + param.length()));
+}
+
+String getCNonce(const int len) {
+  static const char alphanum[] = "0123456789"
+                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                 "abcdefghijklmnopqrstuvwxyz";
+  String s = "";
+
+  for (int i = 0; i < len; ++i) {
+    s += alphanum[rand() % (sizeof(alphanum) - 1)];
+  }
+
+  return s;
+}
+
+String getDigestAuth(String& authReq, const String& username, const String& password, const String& method, const String& uri, unsigned int counter) {
+  // extracting required parameters for RFC 2069 simpler Digest
+  String realm = exractParam(authReq, "realm=\"", '"');
+  String nonce = exractParam(authReq, "nonce=\"", '"');
+  String cNonce = getCNonce(8);
+
+  char nc[9];
+  snprintf(nc, sizeof(nc), "%08x", counter);
+
+  // parameters for the RFC 2617 newer Digest
+  MD5Builder md5;
+  md5.begin();
+  md5.add(username + ":" + realm + ":" + password);  // md5 of the user:realm:user
+  md5.calculate();
+  String h1 = md5.toString();
+
+  md5.begin();
+  md5.add(method + ":" + uri);
+  md5.calculate();
+  String h2 = md5.toString();
+
+  md5.begin();
+  md5.add(h1 + ":" + nonce + ":" + String(nc) + ":" + cNonce + ":" + "auth" + ":" + h2);
+  md5.calculate();
+  String response = md5.toString();
+
+  String authorization = "Digest username=\"" + username + "\", realm=\"" + realm + "\", nonce=\"" + nonce + "\", uri=\"" + uri + "\", algorithm=\"MD5\", qop=auth, nc=" + String(nc) + ", cnonce=\"" + cNonce + "\", response=\"" + response + "\"";
+  Serial.println(authorization);
+
+  return authorization;
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, ssidPassword);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  Serial.println("");
+  Serial.println("WiFi connected");
+  Serial.println("IP address: ");
+  Serial.println(WiFi.localIP());
+
+  srand(rp2040.getCycleCount());
+}
+
+void loop() {
+  HTTPClient http;
+
+  Serial.print("[HTTP] begin...\n");
+
+  // configure target server and url
+  http.begin(String(server) + String(uri));
+
+
+  const char* keys[] = { "WWW-Authenticate" };
+  http.collectHeaders(keys, 1);
+
+  Serial.print("[HTTP] GET...\n");
+  // start connection and send HTTP header
+  int httpCode = http.GET();
+
+  if (httpCode > 0) {
+    String authReq = http.header("WWW-Authenticate");
+    Serial.println(authReq);
+
+    String authorization = getDigestAuth(authReq, String(username), String(password), "GET", String(uri), 1);
+
+    http.end();
+    http.begin(String(server) + String(uri));
+
+    http.addHeader("Authorization", authorization);
+
+    int httpCode = http.GET();
+    if (httpCode > 0) {
+      String payload = http.getString();
+      Serial.println(payload);
+    } else {
+      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+    }
+  } else {
+    Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+  }
+
+  http.end();
+  delay(10000);
+}

libraries/HTTPClient/examples/PostHttpClient/PostHttpClient.ino

+/**
+   PostHTTPClient.ino
+
+    Created on: 21.11.2016
+
+*/
+
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+void setup() {
+
+  Serial.begin(115200);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  WiFi.begin(STASSID, STAPSK);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.print("Connected! IP address: ");
+  Serial.println(WiFi.localIP());
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFi.status() == WL_CONNECTED)) {
+
+    HTTPClient http;
+    http.setInsecure();
+
+    Serial.print("[HTTP] begin...\n");
+    // configure target server and url
+    http.begin("https://httpbin.org/post");
+    http.addHeader("Content-Type", "application/json");
+
+    Serial.print("[HTTP] POST...\n");
+    // start connection and send HTTP header and body
+    int httpCode = http.POST("{\"hello\":\"world\"}");
+
+    // httpCode will be negative on error
+    if (httpCode > 0) {
+      // HTTP header has been send and Server response header has been handled
+      Serial.printf("[HTTP] POST... code: %d\n", httpCode);
+
+      // file found at server
+      if (httpCode == HTTP_CODE_OK) {
+        const String& payload = http.getString();
+        Serial.println("received payload:\n<<");
+        Serial.println(payload);
+        Serial.println(">>");
+      }
+    } else {
+      Serial.printf("[HTTP] POST... failed, error: %s\n", http.errorToString(httpCode).c_str());
+    }
+
+    http.end();
+  }
+
+  delay(10000);
+}

libraries/HTTPClient/examples/ReuseConnectionV2/ReuseConnectionV2.ino

+/**
+   reuseConnectionV2.ino
+
+    Created on: 22.11.2015
+
+   This example reuses the http connection and also restores the connection if the connection is lost
+*/
+
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+WiFiMulti WiFiMulti;
+
+HTTPClient http;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println("Connecting to WiFi...");
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(STASSID, STAPSK);
+
+  // wait for WiFi connection
+  while ((WiFiMulti.run() != WL_CONNECTED)) {
+    Serial.write('.');
+    delay(500);
+  }
+  Serial.println(" connected to WiFi");
+
+  // allow reuse (if server supports it)
+  http.setReuse(true);
+  http.setInsecure();
+
+  http.begin("https://jigsaw.w3.org/HTTP/connection.html");
+  // http.begin(client, "jigsaw.w3.org", 80, "/HTTP/connection.html");
+}
+
+int pass = 0;
+
+void loop() {
+  // First 10 loop()s, retrieve the URL
+  if (pass < 10) {
+    pass++;
+    Serial.printf("Reuse connection example, GET url for the %d time\n", pass);
+    int httpCode = http.GET();
+    if (httpCode > 0) {
+      Serial.printf("[HTTP] GET... code: %d\n", httpCode);
+
+      // file found at server
+      if (httpCode == HTTP_CODE_OK) {
+        http.writeToStream(&Serial);
+      }
+    } else {
+      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
+      // Something went wrong with the connection, try to reconnect
+      http.end();
+      http.begin("https://jigsaw.w3.org/HTTP/connection.html");
+      // http.begin(client, "jigsaw.w3.org", 80, "/HTTP/connection.html");
+    }
+
+    if (pass == 10) {
+      http.end();
+      Serial.println("Done testing");
+    } else {
+      Serial.println("\n\n\nWait 5 second...\n");
+      delay(5000);
+    }
+  }
+}

libraries/HTTPClient/examples/StreamHttpsClient/StreamHttpsClient.ino

+/**
+   StreamHTTPClient.ino
+
+    Created on: 24.05.2015
+
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <HTTPClient.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char *ssid = STASSID;
+const char *pass = STAPSK;
+
+WiFiMulti WiFiMulti;
+
+void setup() {
+
+  Serial.begin(115200);
+  // Serial.setDebugOutput(true);
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.printf("[SETUP] WAIT %d...\n", t);
+    Serial.flush();
+    delay(1000);
+  }
+
+  WiFi.mode(WIFI_STA);
+  WiFiMulti.addAP(ssid, pass);
+}
+
+void loop() {
+  // wait for WiFi connection
+  if ((WiFiMulti.run() == WL_CONNECTED)) {
+
+    Serial.print("[HTTPS] begin...\n");
+
+    // configure server and url
+    const char *fp = "41:FA:FD:B6:96:5F:33:09:F4:ED:09:28:BF:66:4D:5B:A2:88:03:65";
+
+    HTTPClient https;
+    https.setFingerprint(fp);
+
+    if (https.begin("https://www.trustedfirmware.org/projects/mbed-tls")) {
+
+      Serial.print("[HTTPS] GET...\n");
+      // start connection and send HTTP header
+      int httpCode = https.GET();
+      if (httpCode > 0) {
+        // HTTP header has been send and Server response header has been handled
+        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);
+
+        // file found at server
+        if (httpCode == HTTP_CODE_OK) {
+
+          // get length of document (is -1 when Server sends no Content-Length header)
+          int len = https.getSize();
+
+          // create buffer for read
+          static uint8_t buff[128] = { 0 };
+
+          // read all data from server
+          while (https.connected() && (len > 0 || len == -1)) {
+            // get available data size
+            size_t size = https.getStreamPtr()->available();
+
+            if (size) {
+              // read up to 128 byte
+              int c = https.getStreamPtr()->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));
+
+              // write it to Serial
+              Serial.write(buff, c);
+
+              if (len > 0) {
+                len -= c;
+              }
+            }
+            delay(1);
+          }
+
+          Serial.println();
+          Serial.print("[HTTPS] connection closed or file end.\n");
+        }
+      } else {
+        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
+      }
+
+      https.end();
+    } else {
+      Serial.printf("Unable to connect\n");
+    }
+  }
+
+  Serial.println("Wait 10s before the next round...");
+  delay(10000);
+}

libraries/HTTPClient/keywords.txt

+#######################################
+# Syntax Coloring Map For HTTPClient
+#######################################
+
+#######################################
+# Library (KEYWORD3)
+#######################################
+
+HTTPClient	KEYWORD3		RESERVED_WORD
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+t_http_codes	KEYWORD1		DATA_TYPE
+transferEncoding_t	KEYWORD1		DATA_TYPE
+TransportTraits	KEYWORD1		DATA_TYPE
+TransportTraitsPtr	KEYWORD1		DATA_TYPE
+StreamString	KEYWORD1		DATA_TYPE
+HTTPClient	KEYWORD1		DATA_TYPE
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+end	KEYWORD2
+connected	KEYWORD2
+setReuse	KEYWORD2
+setUserAgent	KEYWORD2
+setAuthorization	KEYWORD2
+setTimeout	KEYWORD2
+useHTTP10	KEYWORD2
+GET	KEYWORD2
+POST	KEYWORD2
+PUT	KEYWORD2
+PATCH	KEYWORD2
+sendRequest	KEYWORD2
+addHeader	KEYWORD2
+collectHeaders	KEYWORD2
+header	KEYWORD2
+headerName	KEYWORD2
+headers	KEYWORD2
+hasHeader	KEYWORD2
+getSize	KEYWORD2
+getStream	KEYWORD2
+getStreamPtr	KEYWORD2
+writeToStream	KEYWORD2
+getString	KEYWORD2
+errorToString	KEYWORD2
+
+setSession	KEYWORD2
+setInsecure	KEYWORD2
+setKnownKey	KEYWORD2
+setFingerprint	KEYWORD2
+allowSelfSignedCerts	KEYWORD2
+setTrustAnchors	KEYWORD2
+setX509Time	KEYWORD2
+setClientRSACert	KEYWORD2
+setClientECCert	KEYWORD2
+setBufferSizes	KEYWORD2
+setCertStore	KEYWORD2
+setCiphers	KEYWORD2
+setCiphersLessSecure	KEYWORD2
+setSSLVersion	KEYWORD2
+setCACert	KEYWORD2
+setCertificate	KEYWORD2
+setPrivateKey	KEYWORD2
+loadCACert	KEYWORD2
+loadCertificate	KEYWORD2
+loadPrivateKey	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+HTTPCLIENT_DEFAULT_TCP_TIMEOUT	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_CONNECTION_REFUSED	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_SEND_HEADER_FAILED	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_SEND_PAYLOAD_FAILED	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_NOT_CONNECTED	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_CONNECTION_LOST	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_NO_STREAM	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_NO_HTTP_SERVER	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_TOO_LESS_RAM	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_ENCODING	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_STREAM_WRITE	LITERAL1		RESERVED_WORD_2
+HTTPC_ERROR_READ_TIMEOUT	LITERAL1		RESERVED_WORD_2
+HTTP_TCP_BUFFER_SIZE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_CONTINUE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_SWITCHING_PROTOCOLS	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PROCESSING	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_OK	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_CREATED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_ACCEPTED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NON_AUTHORITATIVE_INFORMATION	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NO_CONTENT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_RESET_CONTENT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PARTIAL_CONTENT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_MULTI_STATUS	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_ALREADY_REPORTED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_IM_USED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_MULTIPLE_CHOICES	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_MOVED_PERMANENTLY	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_FOUND	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_SEE_OTHER	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NOT_MODIFIED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_USE_PROXY	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_TEMPORARY_REDIRECT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PERMANENT_REDIRECT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_BAD_REQUEST	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_UNAUTHORIZED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PAYMENT_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_FORBIDDEN	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NOT_FOUND	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_METHOD_NOT_ALLOWED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NOT_ACCEPTABLE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PROXY_AUTHENTICATION_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_REQUEST_TIMEOUT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_CONFLICT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_GONE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_LENGTH_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PRECONDITION_FAILED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PAYLOAD_TOO_LARGE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_URI_TOO_LONG	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_UNSUPPORTED_MEDIA_TYPE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_RANGE_NOT_SATISFIABLE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_EXPECTATION_FAILED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_MISDIRECTED_REQUEST	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_UNPROCESSABLE_ENTITY	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_LOCKED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_FAILED_DEPENDENCY	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_UPGRADE_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_PRECONDITION_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_TOO_MANY_REQUESTS	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_REQUEST_HEADER_FIELDS_TOO_LARGE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_INTERNAL_SERVER_ERROR	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NOT_IMPLEMENTED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_BAD_GATEWAY	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_SERVICE_UNAVAILABLE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_GATEWAY_TIMEOUT	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_HTTP_VERSION_NOT_SUPPORTED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_VARIANT_ALSO_NEGOTIATES	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_INSUFFICIENT_STORAGE	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_LOOP_DETECTED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NOT_EXTENDED	LITERAL1		RESERVED_WORD_2
+HTTP_CODE_NETWORK_AUTHENTICATION_REQUIRED	LITERAL1		RESERVED_WORD_2
+HTTPC_TE_IDENTITY	LITERAL1		RESERVED_WORD_2
+HTTPC_TE_CHUNKED	LITERAL1		RESERVED_WORD_2

libraries/HTTPClient/library.properties

+name=HTTPClient
+version=1.2
+author=Markus Sattler
+maintainer=Earle F. Philhower, III <earlephilhower@yahoo.com>
+sentence=http Client for ESP8266, portes to the Pico
+paragraph=
+category=Communication
+url=https://github.com/earlephilhower/arduino-pico/blob/master/libraries/HTTPClient
+architectures=rp2040
+dot_a_linkage=true

libraries/HTTPClient/src/base64.cpp

+/**
+    base64.cpp
+
+    Created on: 09.12.2015
+
+    Copyright (c) 2015 Markus Sattler. All rights reserved.
+    This file is part of the ESP8266 core for Arduino.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#include "Arduino.h"
+extern "C" {
+#include "libb64/cencode.h"
+}
+#include "base64.h"
+
+/**
+    convert input data to base64
+    @param data const uint8_t
+    @param length size_t
+    @return String
+*/
+String base64::encode(const uint8_t * data, size_t length, bool doNewLines) {
+    String base64;
+
+    // base64 needs more size then the source data, use cencode.h macros
+    size_t size = ((doNewLines ? base64_encode_expected_len(length)
+                    : base64_encode_expected_len_nonewlines(length)) + 1);
+
+    if (base64.reserve(size)) {
+
+        base64_encodestate _state;
+        if (doNewLines) {
+            base64_init_encodestate(&_state);
+        } else {
+            base64_init_encodestate_nonewlines(&_state);
+        }
+
+        constexpr size_t BUFSIZE = 48;
+        char buf[BUFSIZE + 1 /* newline */ + 1 /* NUL */];
+        for (size_t len = 0; len < length; len += BUFSIZE * 3 / 4) {
+            size_t blocklen = base64_encode_block((const char*) data + len,
+                                                  std::min(BUFSIZE * 3 / 4, length - len), buf, &_state);
+            buf[blocklen] = '\0';
+            base64 += buf;
+        }
+        if (base64_encode_blockend(buf, &_state)) {
+            base64 += buf;
+        }
+    } else {
+        base64 = F("-FAIL-");
+    }
+
+    return base64;
+}

libraries/HTTPClient/src/base64.h

+/**
+    base64.h
+
+    Created on: 09.12.2015
+
+    Copyright (c) 2015 Markus Sattler. All rights reserved.
+    This file is part of the ESP8266 core for Arduino.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#pragma once
+
+#include <api/String.h>
+
+class base64 {
+public:
+    // NOTE: The default behaviour of backend (lib64)
+    // is to add a newline every 72 (encoded) characters output.
+    // This may 'break' longer uris and json variables
+    static String encode(const uint8_t * data, size_t length, bool doNewLines);
+    static inline String encode(const String& text, bool doNewLines) {
+        return encode((const uint8_t *) text.c_str(), text.length(), doNewLines);
+    }
+
+    // esp32 compat:
+
+    static inline String encode(const uint8_t * data, size_t length) {
+        return encode(data, length, false);
+    }
+
+    static inline String encode(const String& text) {
+        return encode(text, false);
+    }
+};

libraries/HTTPClient/src/libb64/AUTHORS

+libb64: Base64 Encoding/Decoding Routines
+======================================
+
+Authors:
+-------
+
+Chris Venter	chris.venter@gmail.com	http://rocketpod.blogspot.com

libraries/HTTPClient/src/libb64/LICENSE

+Copyright-Only Dedication (based on United States law) 
+or Public Domain Certification
+
+The person or persons who have associated work with this document (the
+"Dedicator" or "Certifier") hereby either (a) certifies that, to the best of
+his knowledge, the work of authorship identified is in the public domain of the
+country from which the work is published, or (b) hereby dedicates whatever
+copyright the dedicators holds in the work of authorship identified below (the
+"Work") to the public domain. A certifier, moreover, dedicates any copyright
+interest he may have in the associated work, and for these purposes, is
+described as a "dedicator" below.
+
+A certifier has taken reasonable steps to verify the copyright status of this
+work. Certifier recognizes that his good faith efforts may not shield him from
+liability if in fact the work certified is not in the public domain.
+
+Dedicator makes this dedication for the benefit of the public at large and to
+the detriment of the Dedicator's heirs and successors. Dedicator intends this
+dedication to be an overt act of relinquishment in perpetuity of all present
+and future rights under copyright law, whether vested or contingent, in the
+Work. Dedicator understands that such relinquishment of all rights includes
+the relinquishment of all rights to enforce (by lawsuit or otherwise) those
+copyrights in the Work.
+
+Dedicator recognizes that, once placed in the public domain, the Work may be
+freely reproduced, distributed, transmitted, used, modified, built upon, or
+otherwise exploited by anyone for any purpose, commercial or non-commercial,
+and in any way, including by methods that have not yet been invented or
+conceived.
\ No newline at end of file

libraries/HTTPClient/src/libb64/cdecode.cpp

+/*
+    cdecoder.c - c source to a base64 decoding algorithm implementation
+
+    This is part of the libb64 project, and has been placed in the public domain.
+    For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include <pgmspace.h>
+#include <stdint.h>
+#include "cdecode.h"
+
+extern "C" {
+
+    static int base64_decode_value_signed(int8_t value_in) {
+        static const int8_t decoding[] PROGMEM  = {62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
+        static const int8_t decoding_size = sizeof(decoding);
+        value_in -= 43;
+        if (value_in < 0 || value_in > decoding_size) {
+            return -1;
+        }
+        return pgm_read_byte(&decoding[(int)value_in]);
+    }
+
+    void base64_init_decodestate(base64_decodestate* state_in) {
+        state_in->step = step_a;
+        state_in->plainchar = 0;
+    }
+
+    static int base64_decode_block_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out, base64_decodestate* state_in) {
+        const int8_t* codechar = code_in;
+        int8_t* plainchar = plaintext_out;
+        int8_t fragment;
+
+        *plainchar = state_in->plainchar;
+
+        switch (state_in->step) {
+            while (1) {
+            case step_a:
+                do {
+                    if (codechar == code_in + length_in) {
+                        state_in->step = step_a;
+                        state_in->plainchar = *plainchar;
+                        return plainchar - plaintext_out;
+                    }
+                    fragment = (int8_t)base64_decode_value_signed(*codechar++);
+                } while (fragment < 0);
+                *plainchar    = (fragment & 0x03f) << 2;
+            // falls through
+            case step_b:
+                do {
+                    if (codechar == code_in + length_in) {
+                        state_in->step = step_b;
+                        state_in->plainchar = *plainchar;
+                        return plainchar - plaintext_out;
+                    }
+                    fragment = (int8_t)base64_decode_value_signed(*codechar++);
+                } while (fragment < 0);
+                *plainchar++ |= (fragment & 0x030) >> 4;
+                *plainchar    = (fragment & 0x00f) << 4;
+            // falls through
+            case step_c:
+                do {
+                    if (codechar == code_in + length_in) {
+                        state_in->step = step_c;
+                        state_in->plainchar = *plainchar;
+                        return plainchar - plaintext_out;
+                    }
+                    fragment = (int8_t)base64_decode_value_signed(*codechar++);
+                } while (fragment < 0);
+                *plainchar++ |= (fragment & 0x03c) >> 2;
+                *plainchar    = (fragment & 0x003) << 6;
+            // falls through
+            case step_d:
+                do {
+                    if (codechar == code_in + length_in) {
+                        state_in->step = step_d;
+                        state_in->plainchar = *plainchar;
+                        return plainchar - plaintext_out;
+                    }
+                    fragment = (int8_t)base64_decode_value_signed(*codechar++);
+                } while (fragment < 0);
+                *plainchar++   |= (fragment & 0x03f);
+            }
+        }
+        /* control should not reach here */
+        return plainchar - plaintext_out;
+    }
+
+    static int base64_decode_chars_signed(const int8_t* code_in, const int length_in, int8_t* plaintext_out) {
+        base64_decodestate _state;
+        base64_init_decodestate(&_state);
+        int len = base64_decode_block_signed(code_in, length_in, plaintext_out, &_state);
+        if (len > 0) {
+            plaintext_out[len] = 0;
+        }
+        return len;
+    }
+
+    int base64_decode_value(char value_in) {
+        return base64_decode_value_signed(*((int8_t *) &value_in));
+    }
+
+    int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in) {
+        return base64_decode_block_signed((int8_t *) code_in, length_in, (int8_t *) plaintext_out, state_in);
+    }
+
+    int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out) {
+        return base64_decode_chars_signed((int8_t *) code_in, length_in, (int8_t *) plaintext_out);
+    }
+
+};

libraries/HTTPClient/src/libb64/cdecode.h

+/*
+    cdecode.h - c header for a base64 decoding algorithm
+
+    This is part of the libb64 project, and has been placed in the public domain.
+    For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CDECODE_H
+#define BASE64_CDECODE_H
+
+#define base64_decode_expected_len(n) ((n * 3) / 4)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    step_a, step_b, step_c, step_d
+} base64_decodestep;
+
+typedef struct {
+    base64_decodestep step;
+    char plainchar;
+} base64_decodestate;
+
+void base64_init_decodestate(base64_decodestate* state_in);
+
+int base64_decode_value(char value_in);
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
+
+int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* BASE64_CDECODE_H */

libraries/HTTPClient/src/libb64/cencode.cpp

+/*
+    cencoder.c - c source to a base64 encoding algorithm implementation
+
+    This is part of the libb64 project, and has been placed in the public domain.
+    For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "cencode.h"
+
+extern "C" {
+
+    void base64_init_encodestate(base64_encodestate* state_in) {
+        state_in->step = step_A;
+        state_in->result = 0;
+        state_in->stepcount = 0;
+        state_in->stepsnewline = BASE64_CHARS_PER_LINE;
+    }
+
+
+    void base64_init_encodestate_nonewlines(base64_encodestate* state_in) {
+        base64_init_encodestate(state_in);
+        state_in->stepsnewline = -1;
+    }
+
+    char base64_encode_value(const char n) {
+        char r;
+
+        if (n < 26) {
+            r = n + 'A';
+        } else if (n < 26 + 26) {
+            r = n - 26 + 'a';
+        } else if (n < 26 + 26 + 10) {
+            r = n - 26 - 26 + '0';
+        } else if (n == 62) {
+            r = '+';
+        } else {
+            r = '/';
+        }
+        return r;
+    }
+
+    int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in) {
+        const char* plainchar = plaintext_in;
+        const char* const plaintextend = plaintext_in + length_in;
+        char* codechar = code_out;
+        char result;
+        char fragment;
+
+        result = state_in->result;
+
+        switch (state_in->step) {
+            while (1) {
+            case step_A:
+                if (plainchar == plaintextend) {
+                    state_in->result = result;
+                    state_in->step = step_A;
+                    return codechar - code_out;
+                }
+                fragment = *plainchar++;
+                result = (fragment & 0x0fc) >> 2;
+                *codechar++ = base64_encode_value(result);
+                result = (fragment & 0x003) << 4;
+            // falls through
+            case step_B:
+                if (plainchar == plaintextend) {
+                    state_in->result = result;
+                    state_in->step = step_B;
+                    return codechar - code_out;
+                }
+                fragment = *plainchar++;
+                result |= (fragment & 0x0f0) >> 4;
+                *codechar++ = base64_encode_value(result);
+                result = (fragment & 0x00f) << 2;
+            // falls through
+            case step_C:
+                if (plainchar == plaintextend) {
+                    state_in->result = result;
+                    state_in->step = step_C;
+                    return codechar - code_out;
+                }
+                fragment = *plainchar++;
+                result |= (fragment & 0x0c0) >> 6;
+                *codechar++ = base64_encode_value(result);
+                result  = (fragment & 0x03f) >> 0;
+                *codechar++ = base64_encode_value(result);
+
+                ++(state_in->stepcount);
+                if ((state_in->stepcount == BASE64_CHARS_PER_LINE / 4) && (state_in->stepsnewline > 0)) {
+                    *codechar++ = '\n';
+                    state_in->stepcount = 0;
+                }
+            }
+        }
+        /* control should not reach here */
+        return codechar - code_out;
+    }
+
+    int base64_encode_blockend(char* code_out, base64_encodestate* state_in) {
+        char* codechar = code_out;
+
+        switch (state_in->step) {
+        case step_B:
+            *codechar++ = base64_encode_value(state_in->result);
+            *codechar++ = '=';
+            *codechar++ = '=';
+            break;
+        case step_C:
+            *codechar++ = base64_encode_value(state_in->result);
+            *codechar++ = '=';
+            break;
+        case step_A:
+            break;
+        }
+        *codechar = 0x00;
+
+        return codechar - code_out;
+    }
+
+    int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out) {
+        base64_encodestate _state;
+        base64_init_encodestate(&_state);
+        int len = base64_encode_block(plaintext_in, length_in, code_out, &_state);
+        return len + base64_encode_blockend((code_out + len), &_state);
+    }
+
+};

libraries/HTTPClient/src/libb64/cencode.h

+/*
+    cencode.h - c header for a base64 encoding algorithm
+
+    This is part of the libb64 project, and has been placed in the public domain.
+    For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CENCODE_H
+#define BASE64_CENCODE_H
+
+#define BASE64_CHARS_PER_LINE 72
+
+#define base64_encode_expected_len_nonewlines(n) ((((4 * (n)) / 3) + 3) & ~3)
+#define base64_encode_expected_len(n) \
+       (base64_encode_expected_len_nonewlines(n) + ((n / ((BASE64_CHARS_PER_LINE * 3) / 4)) + 1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    step_A, step_B, step_C
+} base64_encodestep;
+
+typedef struct {
+    base64_encodestep step;
+    char result;
+    int stepcount;
+    int stepsnewline;
+} base64_encodestate;
+
+void base64_init_encodestate(base64_encodestate* state_in);
+void base64_init_encodestate_nonewlines(base64_encodestate* state_in);
+
+char base64_encode_value(char value_in);
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
+
+int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* BASE64_CENCODE_H */

libraries/WiFi/keywords.txt

@@ -63,6 +63,26 @@ beginMulticast	KEYWORD2
 setTimeout	KEYWORD2
 waitSet	KEYWORD2
 
+setSession	KEYWORD2
+setInsecure	KEYWORD2
+setKnownKey	KEYWORD2
+setFingerprint	KEYWORD2
+allowSelfSignedCerts	KEYWORD2
+setTrustAnchors	KEYWORD2
+setX509Time	KEYWORD2
+setClientRSACert	KEYWORD2
+setClientECCert	KEYWORD2
+setBufferSizes	KEYWORD2
+setCertStore	KEYWORD2
+setCiphers	KEYWORD2
+setCiphersLessSecure	KEYWORD2
+setSSLVersion	KEYWORD2
+setCACert	KEYWORD2
+setCertificate	KEYWORD2
+setPrivateKey	KEYWORD2
+loadCACert	KEYWORD2
+loadCertificate	KEYWORD2
+loadPrivateKey	KEYWORD2
 
 #######################################
 # Constants (LITERAL1)

libraries/WiFi/src/WiFiMulti.cpp

@@ -53,6 +53,7 @@ bool WiFiMulti::addAP(const char *ssid, const char *pass) {
     } else {
         ap.pass = nullptr;
     }
+    DEBUGV("[WIFIMULTI] Adding: '%s' %s' to list\n", ap.ssid, ap.pass);
     _list.push_front(ap);
     return true;
 }
@@ -77,6 +78,7 @@ uint8_t WiFiMulti::run(uint32_t to) {
     for (int i = 0; i < cnt; i++) {
         if (WiFi.RSSI(i) > maxRSSID) {
             for (auto j = _list.begin(); j != _list.end(); j++) {
+                DEBUGV("[WIFIMULTI] Checking for '%s' at %d\n", WiFi.SSID(i), WiFi.RSSI(i));
                 if (!strcmp(j->ssid, WiFi.SSID(i))) {
                     hit = j;
                     maxRSSID = WiFi.RSSI(i);
@@ -90,6 +92,7 @@ uint8_t WiFiMulti::run(uint32_t to) {
     }
 
     // Connect!
+    DEBUGV("[WIFIMULTI] Connecting to '%s' and '%s'\n", hit->ssid, hit->pass);
     uint32_t start = millis();
     if (hit->pass) {
         WiFi.begin(hit->ssid, hit->pass);

libraries/WiFi/src/WiFiMulti.h

@@ -32,7 +32,7 @@ public:
 
     bool addAP(const char *ssid, const char *pass = NULL);
 
-    uint8_t run(uint32_t to = 5000);
+    uint8_t run(uint32_t to = 10000);
 
 private:
     struct _AP {

tests/restyle.sh

@@ -7,7 +7,7 @@ for dir in ./cores/rp2040 ./libraries/EEPROM ./libraries/I2S \
            ./libraries/WiFi ./libraries/lwIP_Ethernet ./libraries/lwIP_CYW43 \
            ./libraries/FreeRTOS/src ./libraries/LEAmDNS ./libraries/MD5Builder \
            ./libraries/PicoOTA ./libraries/SDFS ./libraries/ArduinoOTA \
-           ./libraries/Updater; do
+           ./libraries/Updater ./libraries/HTTPClient; do
     find $dir -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" \) -a  \! -path '*api*' -exec astyle --suffix=none --options=./tests/astyle_core.conf \{\} \;
     find $dir -type f -name "*.ino" -exec astyle --suffix=none --options=./tests/astyle_examples.conf \{\} \;
 done

tools/build.py

@@ -65,9 +65,7 @@ def compile(tmp_dir, sketch, cache, tools_dir, hardware_dir, ide_path, f, args):
                'dbgport={dbgport},' \
                'dbglvl={dbglvl},' \
                'usbstack={usbstack}'.format(**vars(args))
-    if "/WiFi" in sketch:
-        fqbn = fqbn.replace("rpipico", "rpipicow")
-    if "/ArduinoOTA" in sketch:
+    if ("/WiFi" in sketch) or ("/ArduinoOTA" in sketch) or ("/HTTPClient" in sketch):
         fqbn = fqbn.replace("rpipico", "rpipicow")
     cmd += [fqbn]
     cmd += ['-built-in-libraries', ide_path + '/libraries']