Merge remote-tracking branch 'riz/ssl_fix_pr' into debug_ide2

Former-commit-id: edb13f7

Author: facchinm

libraries/WiFiS3/examples/WiFiWebClientSSL/WiFiWebClientSSL.ino

@@ -0,0 +1,128 @@
+/*
+  TLS WiFi Web client
+
+  Remeber to update the CA certificates using CertificateUploader sketch
+  before using this sketch.
+
+*/
+
+#include "WiFiS3.h"
+#include "WiFiSSLClient.h"
+#include "IPAddress.h"
+
+#include "arduino_secrets.h" 
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+char ssid[] = SECRET_SSID;        // your network SSID (name)
+char pass[] = SECRET_PASS;        // your network password (use for WPA, or use as key for WEP)
+
+int status = WL_IDLE_STATUS;
+// if you don't want to use DNS (and reduce your sketch size)
+// use the numeric IP instead of the name for the server:
+//IPAddress server(74,125,232,128);  // numeric IP for Google (no DNS)
+char server[] = "www.google.com";    // name address for Google (using DNS)
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server
+// that you want to connect to (port 80 is default for HTTP):
+WiFiSSLClient client;
+
+/* -------------------------------------------------------------------------- */
+void setup() {
+/* -------------------------------------------------------------------------- */  
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+  
+  // check for the WiFi module:
+  if (WiFi.status() == WL_NO_MODULE) {
+    Serial.println("Communication with WiFi module failed!");
+    // don't continue
+    while (true);
+  }
+  
+  String fv = WiFi.firmwareVersion();
+  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
+    Serial.println("Please upgrade the firmware");
+  }
+  
+  // attempt to connect to WiFi network:
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network.
+    status = WiFi.begin(ssid, pass);
+     
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+  
+  printWifiStatus();
+ 
+  Serial.println("\nStarting connection to server...");
+  // if you get a connection, report back via serial:
+  
+  if (client.connect(server, 443)) {
+    Serial.println("connected to server");
+    // Make a HTTP request:
+    client.println("GET / HTTP/1.1");
+    client.println("Host: www.google.com");
+    client.println("Connection: close");
+    client.println();
+  }
+}
+
+/* just wrap the received data up to 80 columns in the serial print*/
+/* -------------------------------------------------------------------------- */
+void read_response() {
+/* -------------------------------------------------------------------------- */  
+  uint32_t received_data_num = 0;
+  while (client.available()) {
+    /* actual data reception */
+    char c = client.read();
+    /* print data to serial port */
+    Serial.print(c);
+    /* wrap data to 80 columns*/
+    received_data_num++;
+    if(received_data_num % 80 == 0) { 
+      Serial.println();
+    }
+  }  
+}
+
+/* -------------------------------------------------------------------------- */
+void loop() {
+/* -------------------------------------------------------------------------- */  
+  read_response();
+
+  // if the server's disconnected, stop the client:
+  if (!client.connected()) {
+    Serial.println();
+    Serial.println("disconnecting from server.");
+    client.stop();
+
+    // do nothing forevermore:
+    while (true);
+  }
+}
+
+/* -------------------------------------------------------------------------- */
+void printWifiStatus() {
+/* -------------------------------------------------------------------------- */  
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your board's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}

libraries/WiFiS3/examples/WiFiWebClientSSL/arduino_secrets.h

@@ -0,0 +1,2 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""

libraries/WiFiS3/src/WiFiClient.cpp

@@ -88,7 +88,7 @@ size_t WiFiClient::write(const uint8_t *buf, size_t size){
 }
 
 /* -------------------------------------------------------------------------- */
-int WiFiClient::available(){
+int WiFiClient::available() {
 /* -------------------------------------------------------------------------- */   
    int rv = 0;
    if(_sock >= 0 && rx_buffer != nullptr) {
@@ -100,8 +100,10 @@ int WiFiClient::available(){
          modem.begin();
          if(modem.write(string(PROMPT(_AVAILABLE)),res, "%s%d\r\n" , CMD_WRITE(_AVAILABLE), _sock)) {
             rv = atoi(res.c_str());
-            
-         }  
+            if (rv < 0) {
+               return 0;
+            }
+         }
       }
    }
    return rv;
@@ -252,4 +254,4 @@ uint16_t WiFiClient::remotePort(){
       }  
    }
    return rv; 
-}
+}

libraries/WiFiS3/src/WiFiClient.h

@@ -72,7 +72,6 @@ class WiFiClient : public Client {
   bool destroy_at_distructor;
 
 
-  
 };
 
 #endif

libraries/WiFiS3/src/WiFiSSLClient.cpp

@@ -3,7 +3,13 @@
 using namespace std;
 
 /* -------------------------------------------------------------------------- */
-WiFiSSLClient::WiFiSSLClient() : _sock(-1){
+WiFiSSLClient::WiFiSSLClient() : _sock(-1) {
+/* -------------------------------------------------------------------------- */
+   rx_buffer = std::shared_ptr<FifoBuffer<uint8_t,RX_BUFFER_DIM>>(new FifoBuffer<uint8_t,RX_BUFFER_DIM>());
+}
+
+/* -------------------------------------------------------------------------- */
+WiFiSSLClient::~WiFiSSLClient() {
 /* -------------------------------------------------------------------------- */
 
 }
@@ -24,6 +30,7 @@ void WiFiSSLClient::getSocket() {
 int WiFiSSLClient::connect(IPAddress ip, uint16_t port) {
 /* -------------------------------------------------------------------------- */
    getSocket();
+
    string res = "";
    if(modem.write(string(PROMPT(_SSLCLIENTCONNECTIP)),res, "%s%d,%s,%d\r\n" , CMD_WRITE(_SSLCLIENTCONNECTIP), _sock, ip.toString(), port)) {
       return 1;
@@ -35,6 +42,9 @@ int WiFiSSLClient::connect(IPAddress ip, uint16_t port) {
 int WiFiSSLClient::connect(const char* host, uint16_t port) {
 /* -------------------------------------------------------------------------- */
    getSocket();
+   if (!_custom_root) {
+      setCACert();
+   }
    string res = "";
    if(modem.write(string(PROMPT(_SSLCLIENTCONNECTNAME)),res, "%s%d,%s,%d\r\n" , CMD_WRITE(_SSLCLIENTCONNECTNAME), _sock, host, port)) {
       return 1;
@@ -47,27 +57,16 @@ void WiFiSSLClient::setCACert(const char* root_ca, size_t size) {
 /* -------------------------------------------------------------------------- */
    getSocket();
    string res = "";
-   Serial.print("size ");
-   Serial.println(size);
    if(size > 0) {
       modem.write_nowait(string(PROMPT(_SETCAROOT)),res, "%s%d,%d\r\n" , CMD_WRITE(_SETCAROOT), _sock, size);
       if(modem.passthrough((uint8_t *)root_ca, size)) {
-         return;
+         _custom_root = true;
       }
    } else {
       modem.write(string(PROMPT(_SETCAROOT)),res, "%s%d\r\n" , CMD_WRITE(_SETCAROOT), _sock);
    }
 }
 
-/* -------------------------------------------------------------------------- */
-void WiFiSSLClient::setInsecure() {
-/* -------------------------------------------------------------------------- */
-   getSocket();
-   string res = "";
-   modem.write(string(PROMPT(_SSLSETINSERCURE)),res, "%s%d\r\n" , CMD_WRITE(_SSLSETINSERCURE), _sock);
-
-}
-
 /* -------------------------------------------------------------------------- */
 size_t WiFiSSLClient::write(uint8_t b){
 /* -------------------------------------------------------------------------- */   
@@ -94,15 +93,18 @@ size_t WiFiSSLClient::write(const uint8_t *buf, size_t size){
 int WiFiSSLClient::available(){
 /* -------------------------------------------------------------------------- */   
    int rv = 0;
-   if(_sock >= 0) {
-      if(rx_buffer.available() > 0) {
-         return rx_buffer.available();
+   if(_sock >= 0 && rx_buffer != nullptr) {
+      if(rx_buffer->available() > 0) {
+         return rx_buffer->available();
       }
       else {
          string res = "";
          modem.begin();
          if(modem.write(string(PROMPT(_SSLAVAILABLE)),res, "%s%d\r\n" , CMD_WRITE(_SSLAVAILABLE), _sock)) {
             rv = atoi(res.c_str());
+            if (rv < 0) {
+               return 0;
+            }
          }  
       }
    }
@@ -115,15 +117,15 @@ int WiFiSSLClient::_read() {
    int rv = -1;
    if(_sock >= 0) {
       string res = "";
-      uint32_t size = rx_buffer.freePositions() - 1;
+      uint32_t size = rx_buffer->freePositions() - 1;
       modem.begin();
 
       /* important - it works one shot */
       modem.avoid_trim_results();
       modem.read_using_size();
       if(modem.write(string(PROMPT(_SSLCLIENTRECEIVE)),res, "%s%d,%d\r\n" , CMD_WRITE(_SSLCLIENTRECEIVE), _sock, size)) {
          for(int i = 0, rv = 0; i < size && i < res.size(); i++) {
-            rx_buffer.store((uint8_t)res[i]);
+            rx_buffer->store((uint8_t)res[i]);
             rv++;
          }
       }
@@ -134,7 +136,7 @@ int WiFiSSLClient::_read() {
 /* -------------------------------------------------------------------------- */
 bool WiFiSSLClient::read_needed(size_t s) {
 /* -------------------------------------------------------------------------- */   
-   if((size_t)rx_buffer.available() < s) {
+   if((size_t)rx_buffer->available() < s) {
       _read();
    }
 }
@@ -157,7 +159,7 @@ int WiFiSSLClient::read(uint8_t *buf, size_t size) {
    bool go_on = true;
    for(int i = 0; i < size && go_on; i++) {
       bool is_read = false;
-      *(buf+i) = rx_buffer.read(&is_read);
+      *(buf+i) = rx_buffer->read(&is_read);
       if(is_read) {
          rv++;
       }

libraries/WiFiS3/src/WiFiSSLClient.h

@@ -30,37 +30,36 @@ class WiFiSSLClient : public WiFiClient {
 
 public:
    WiFiSSLClient();
-
+   ~WiFiSSLClient();
    virtual int connect(IPAddress ip, uint16_t port);
    virtual int connect(const char* host, uint16_t port);
    void setCACert(const char* root_ca = NULL, size_t size = 0); 
-   void setInsecure();
-  virtual size_t write(uint8_t);
-  virtual size_t write(const uint8_t *buf, size_t size);
-  virtual int available();
-  virtual int read();
-  virtual int read(uint8_t *buf, size_t size);
-  virtual int peek();
-  virtual void flush();
-  virtual void stop();
-  virtual uint8_t connected();
-  virtual operator bool() {
-    return _sock != -1;
-  }
+   virtual size_t write(uint8_t);
+   virtual size_t write(const uint8_t *buf, size_t size);
+   virtual int available();
+   virtual int read();
+   virtual int read(uint8_t *buf, size_t size);
+   virtual int peek();
+   virtual void flush();
+   virtual void stop();
+   virtual uint8_t connected();
+   virtual operator bool() {
+     return _sock != -1;
+   }
+
+   virtual IPAddress remoteIP();
+   virtual uint16_t remotePort();
 
-  virtual IPAddress remoteIP();
-  virtual uint16_t remotePort();
+   friend class WiFiServer;
 
-  friend class WiFiServer;
-  
-  using Print::write;
+   using Print::write;
 
-protected:
-  int _sock;
-  void getSocket();
-  FifoBuffer<uint8_t,RX_BUFFER_DIM> rx_buffer;
-  int _read();
-  bool read_needed(size_t s);
+private:
+   int _sock;
+   bool _custom_root = false;
+   void getSocket();
+   int _read();
+   bool read_needed(size_t s);
 
 private:
    void upload_default_Cert();