[TMP] extending Client apis

Author: andreagilardoni

api/Client.h

@@ -23,6 +23,7 @@
 #include "IPAddress.h"
 
 namespace arduino {
+// TODO define explicit poll method
 
 // The objective of this interface is to split the definition of a Client that
 // works with streams and one that works with discrete sized messages
@@ -40,9 +41,10 @@ class ClientConnect {
 
 class Client : public Stream, ClientConnect {
 public:
-  virtual size_t write(uint8_t) = 0;
-  virtual size_t write(const uint8_t *buf, size_t size) = 0;
-  virtual int read(uint8_t *buf, size_t size) = 0;
+  // Note: already defined in print and Stream
+  // virtual size_t write(uint8_t) = 0;
+  // virtual size_t write(const uint8_t *buf, size_t size) = 0;
+  // virtual int read(uint8_t *buf, size_t size) = 0;
   virtual void stop() = 0;
 protected:
   uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); }; // FIXME this is a utility function

api/Stream.h

@@ -67,7 +67,7 @@ class Stream : public Print
 
   void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
   unsigned long getTimeout(void) { return _timeout; }
-  
+
   bool find(const char *target);   // reads data from the stream until the target string is found
   bool find(const uint8_t *target) { return find ((const char *)target); }
   // returns true if target string is found, false if timed out (see setTimeout)
@@ -94,7 +94,7 @@ class Stream : public Print
   float parseFloat(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
   // float version of parseInt
 
-  size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
+  virtual size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
   size_t readBytes( uint8_t *buffer, size_t length) { return readBytes((char *)buffer, length); }
   // terminates if length characters have been read or timeout (see setTimeout)
   // returns the number of characters placed in the buffer (0 means no valid data found)
@@ -130,4 +130,4 @@ class Stream : public Print
 
 }
 
-using arduino::Stream;
+using arduino::Stream;

api/net/NetworkInterface.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include "../IPAddress.h"
+
+#ifndef MAX_NETIFACES
+#define MAX_NETIFACES 4
+#endif
+
+class NetworkInterfaceManager {
+public:
+    static NetworkInterface* getIface(size_t i) { return netiface[i]; }
+
+    NetworkInterfaceManager& getInstance() {
+        static NetworkInterfaceManager nim;
+        return nim;
+    }
+
+private:
+    NetworkInterfaceManager(): default_netif(nullptr) {
+        memset(&netifaces, 0, sizeof(netifaces));
+    }
+
+    ~NetworkInterfaceManager() = default;
+
+    class NetworkInterface;
+
+    // should this be a std::vector? generally only one net interface will be used
+    NetworkInterface* netifaces[MAX_NETIFACES];
+    NetworkInterface* default_netif;
+
+    void appendIface(NetworkInterface* netif) {
+        for (NetworkInterface* ptr = netifaces;
+                ptr < netifaces + MAX_NETIFACES;
+                ptr++;) {
+            if(ptr == nullptr) {
+                ptr = netif;
+
+                if(default_netif == nullptr) {
+                    default_netif = netif;
+                }
+            }
+        }
+    }
+
+    friend NetworkInterface;
+
+public:
+    void setDefault(size_t i) {
+        if(i < MAX_NETIFACES) {
+            default_netif = netifaces[i];
+        }
+    }
+
+    NetworkInterface* getDefault() {
+        return default_netif;
+    }
+};
+
+// this requires cpp17
+// TODO name?
+inline NetworkInterfaceManager& NetIfaceManager = NetworkInterfaceManager::getInstance();
+
+// TODO there are different kinds of network interfaces, should we define an enum containing the values from
+//      ConnectionHandler?
+//
+// TODO this is the base level for a Network interface, specific implementations with kind specific
+//      methods should also be defined, i.e. Wifi, Wifi sta + Wifi ap, Ethernet, GSM
+//
+// TODO should we append the network interface only when begin happened with success? how do we know that?
+//
+// TODO should a network interface also have a ping method?
+//
+// TODO define explicit poll method
+class NetworkInterface {
+public:
+    NetworkInterface() {
+        NetworkInterfaceManager.getInstance().appendIface(this);
+    }
+    virtual ~NetworkInterface() = default;
+
+    virtual IPAddress localIP() = 0
+    virtual IPAddress subnetMask() = 0;
+    virtual IPAddress gatewayIP() = 0;
+    virtual IPAddress dnsServerIP() = 0;
+
+    // TODO define how a mac address should be represented, 8 bytes/6 bytes
+    virtual void setMACAddress(const uint8_t* mac) = 0;
+    virtual void getMACAddress(const uint8_t* mac) = 0;
+
+    // A concrete network interface may have different settings that can be plugged in the begin call
+    // so there will be overloaded begin calls
+    virtual bool begin() = 0;
+    virtual bool end() = 0;
+protected:
+    // NOTE return autopointer with implementation of a client class?
+};
+

api/net/TCPClient.cpp

@@ -0,0 +1,6 @@
+#include "TCPClient.h"
+
+
+namespace arduino { namespace net {
+
+}} // arduino::net

api/net/TCPClient.h

@@ -0,0 +1,72 @@
+#pragma once
+
+namespace arduino { namespace net {
+
+// In most arduino platforms Client classes are bound to a Network interface by inheritance
+// This because there is no routing mechanism that decouples the client from the lower level.
+// For this reason we need to differentiate from one client to another by allocating and
+// deallocating the concrete client
+
+// TODO what can we do to handle Zephyr/mbedos clients? those are not statically bound to an interface,
+//      wrapping them could mean wasting resources:
+//      - The general use TCPclient could be a typedef?
+
+// TLS client integration into the wrapper:
+//    - PIMPL, which implementation is instantiated only if a method of TLS client is called
+//      - Issue that the Flash is always being consumed since it may be instantiated at runtime (MACRO Exclusion?)
+//      - RAM is not being consumed for TLS structures unless specifically required
+//    - TLS client is not a tcp client 2 classes definition are required
+//      - Flash is being used only if the class is being used
+//      - Client embedding may be of use (TCPClient -> TLSClient -> HttpClient)
+//        + the last layer may be instantiated with default values, but can be still embedded manually
+//    - middleware definition: between TCPclient and the user there are multiple middleware layers
+//      that act as layer 5/6 of iso/osi stack, TLS is one of them (are there any others?)
+//      - sort of client embedding, which may be more flexible
+//        - I always instantiate a TCPClient, but if I need Http, I will add it as middleware to the current instance
+//          + If HttpClient has different specifics from a TCPClient they might be hard to expose
+//    - It could be nice to have an explicit connectSSL in client which enables SSL
+
+class TCPClientConnect: public ClientConnect {
+public:
+
+  // default generic TCPClient associated with default net interface
+  TCPClientConnect()
+  : _factory(TCPClientConnect::_factory) {
+  }
+
+  ~TCPClientConnect();
+
+  int connect(IPAddress ip, uint16_t port) override;
+  int connect(const char *host, uint16_t port) override;
+  void disconnect() override;
+
+  uint8_t connected() override;
+  operator bool() override;
+
+protected:
+  // the factory should provide a way to allocate and deallocate the client
+  // there should be a default factory that uses to use the default network interface
+  static std::function<std::unique_ptr<Client>()> _factory;
+
+  // factories can be changed per instance
+  std::function<std::unique_ptr<Client>()> _factory;
+
+  // the client should be instantiated when calling connect, if it fails the Client is deleted
+  // otherwise it is called when the stop/end call is performed
+  // unique_ptr is being used to propagate the allocation and deallocation methods that a factory may provide
+  std::unique_ptr<Client> client;
+
+  // TODO should a client keep the Network interface reference?
+
+  friend TCPClient;
+};
+
+class TCPClient: public Client, TCPClientConnect {
+public:
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t *buf, size_t size) override;
+  int read(uint8_t *buf, size_t size) override;
+  void stop() override;
+};
+
+}}

api/Tls.h renamed to api/net/Tls.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Client.h"
+#include "../Client.h"
 
 
 namespace arduino {
@@ -13,6 +13,8 @@ enum class CertificateFormat {
     Pem,
 }
 
+// TLS 
+
 class Tls: public ClientConnect {
 public:
     virtual ~Tls() = default;