mod: various TBT

Author: eigen-value

src/tcp_client.h

@@ -15,6 +15,7 @@
 #define BRIDGE_TCP_CLIENT_H
 
 #define TCP_CONNECT_METHOD          "tcp/connect"
+#define TCP_CONNECT_SSL_METHOD      "tcp/connectSSL"
 #define TCP_CLOSE_METHOD            "tcp/close"
 #define TCP_WRITE_METHOD            "tcp/write"
 #define TCP_READ_METHOD             "tcp/read"
@@ -27,7 +28,7 @@
 
 
 template<size_t BufferSize=DEFAULT_TCP_CLIENT_BUF_SIZE>
-class BridgeTCPClient final: public Client {
+class BridgeTCPClient : public Client {
 
     BridgeClass* bridge;
     uint32_t connection_id{};
@@ -52,13 +53,13 @@ class BridgeTCPClient final: public Client {
 
     int connect(const char *host, uint16_t port) override {
 
-        String send_buffer = host;
-        send_buffer += ":";
-        send_buffer += String(port);
+        if (_connected) return 0;
+
+        String hostname = host;
 
         k_mutex_lock(&client_mutex, K_FOREVER);
 
-        const bool resp = bridge->call(TCP_CONNECT_METHOD, connection_id, send_buffer);
+        const bool resp = bridge->call(TCP_CONNECT_METHOD, connection_id, hostname, port);
 
         if (!resp) {
             _connected = false;
@@ -72,19 +73,44 @@ class BridgeTCPClient final: public Client {
         return 0;
     }
 
+    int connectSSL(const char *host, uint16_t port, const char *ca_cert) {
+
+        if (_connected) return 0;
+
+        String hostname = host;
+        String ca_cert_str = ca_cert;
+
+        k_mutex_lock(&client_mutex, K_FOREVER);
+
+        const bool resp = bridge->call(TCP_CONNECT_SSL_METHOD, connection_id, hostname, port, ca_cert_str);
+
+        if (!resp) {
+            _connected = false;
+            k_mutex_unlock(&client_mutex);
+            return -1;
+        }
+        _connected = true;
+
+        k_mutex_unlock(&client_mutex);
+        return 0;
+    }
+
     size_t write(uint8_t c) override {
         return write(&c, 1);
     }
 
     size_t write(const uint8_t *buf, size_t size) override {
-        String send_buffer;
+
+        if (!_connected) return 0;
+
+        MsgPack::arr_t<uint8_t> payload;
 
         for (size_t i = 0; i < size; ++i) {
-            send_buffer += static_cast<char>(buf[i]);
+            payload.push_back(buf[i]);
         }
 
         size_t written;
-        const bool ret = bridge->call(TCP_WRITE_METHOD, written, send_buffer);
+        const bool ret = bridge->call(TCP_WRITE_METHOD, written, connection_id, payload);
         if (ret) {
             return written;
         }
@@ -131,6 +157,10 @@ class BridgeTCPClient final: public Client {
         // No-op: flush is implemented for Client subclasses using an output buffer
     }
 
+    void close() {
+        stop();
+    }
+
     void stop() override {
         k_mutex_lock(&client_mutex, K_FOREVER);
         String msg;

src/tcp_server.h

@@ -31,52 +31,44 @@ class BridgeTCPServer final: public Server {
     IPAddress _addr{};
     uint16_t _port;
     bool _listening = false;
-    uint32_t listener_id;
+    uint32_t listener_id = 0;
+    uint32_t connection_id = 0;
     struct k_mutex server_mutex{};
 
 public:
     explicit BridgeTCPServer(BridgeClass& bridge, const IPAddress& addr, uint16_t port): bridge(&bridge), _addr(addr), _port(port) {}
 
-    explicit BridgeTCPServer(BridgeClass& bridge, uint16_t port): bridge(&bridge), _addr(IP_ANY_TYPE), _port(port) {}
+    // explicit BridgeTCPServer(BridgeClass& bridge, uint16_t port): bridge(&bridge), _addr(INADDR_NONE), _port(port) {}
 
-    bool begin() {
+    void begin() override {
         k_mutex_init(&server_mutex);
+
         if (!(*bridge)) {
-            if (!bridge->begin()) {
-                return false;
-            }
+            while (!bridge->begin());
         }
 
         k_mutex_lock(&server_mutex, K_FOREVER);
 
-        String conn_str = addr.toString() + String(_port);
-        const bool ret = bridge->call(TCP_LISTEN_METHOD, listener_id, conn_str);
-        // TODO is listener_id one per server obj?
-
-        if (ret) {
-            _listening = true;
-        }
+        String hostname = _addr.toString();
+        _listening = bridge->call(TCP_LISTEN_METHOD, listener_id, hostname, _port);
 
         k_mutex_unlock(&server_mutex);
 
-        return ret;
     }
 
-    void begin(uint16_t port) {
-        _port = port;
-        begin();
-    }
+    BridgeTCPClient<BufferSize> accept() {
 
+        if (connection_id != 0) {
+            return BridgeTCPClient<BufferSize>(*bridge, connection_id);
+        }
 
-    BridgeTCPClient<BufferSize> accept() {
         k_mutex_lock(&server_mutex, K_FOREVER);
 
-        uint32_t connection_id = 0;
         const bool ret = bridge->call(TCP_ACCEPT_METHOD, connection_id, listener_id);
 
         k_mutex_unlock(&server_mutex);
 
-        if (ret && connection_id != 0) {    // TODO is connection_id 0 acceptable???
+        if (ret && connection_id != 0) {    // connection_id 0 marks an invalid connection
             return BridgeTCPClient<BufferSize>(*bridge, connection_id);
         }
 
@@ -89,12 +81,29 @@ class BridgeTCPServer final: public Server {
     }
 
     size_t write(const uint8_t *buf, size_t size) override {
-        // Broadcasting to all clients would require tracking them
-        // For now, this is not implemented
-        // TODO a logic to resolve which port-socket is the target of the write
+
+        BridgeTCPClient<BufferSize> client = accept();
+
+        if (client) {
+            return client.write(buf, size);
+        }
+
         return 0;
     }
 
+    void close() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+
+        String msg;
+        const bool ret = bridge->call(TCP_CLOSE_METHOD, msg, listener_id);
+
+        if (ret) {
+            _listening = false;
+        }
+
+        k_mutex_unlock(&server_mutex);
+    }
+
     bool is_listening() const {
         return _listening;
     }