impr: protecting tcp_server flags, initialization, write and getters

fix: monitor.peek unsafe

Author: eigen-value

src/monitor.h

@@ -95,8 +95,9 @@ class BridgeMonitor: public Stream {
     int peek() override {
         k_mutex_lock(&monitor_mutex, K_FOREVER);
         if (temp_buffer.available()) {
+            int c = temp_buffer.peek();
             k_mutex_unlock(&monitor_mutex);
-            return temp_buffer.peek();
+            return c;
         }
         k_mutex_unlock(&monitor_mutex);
         return -1;

src/tcp_server.h

@@ -50,39 +50,35 @@ class BridgeTCPServer final: public Server {
         }
 
         k_mutex_lock(&server_mutex, K_FOREVER);
-
-        String hostname = _addr.toString();
-        _listening = bridge->call(TCP_LISTEN_METHOD, hostname, _port).result(listener_id);
-
+        if (!_listening){
+            String hostname = _addr.toString();
+            _listening = bridge->call(TCP_LISTEN_METHOD, hostname, _port).result(listener_id);
+        }
         k_mutex_unlock(&server_mutex);
 
     }
 
     BridgeTCPClient<BufferSize> accept() {
 
-        if (!_listening) {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+
+        if (!_listening) {  // Not listening -> return disconnected (invalid) client
+            k_mutex_unlock(&server_mutex);
             return BridgeTCPClient<BufferSize>(*bridge, 0, false);
         }
 
-        if (_connected) {
+        if (_connected) {   // Connection already established return a client copy
+            k_mutex_unlock(&server_mutex);
             return BridgeTCPClient<BufferSize>(*bridge, connection_id);
         }
 
-        k_mutex_lock(&server_mutex, K_FOREVER);
-
+        // Accept a connection
         const bool ret = bridge->call(TCP_ACCEPT_METHOD, listener_id).result(connection_id);
+        _connected = ret;
 
         k_mutex_unlock(&server_mutex);
-
-        if (ret) {    // connection_id 0 marks an invalid connection
-            _connected = true;
-            return BridgeTCPClient<BufferSize>(*bridge, connection_id);
-        } else {
-            _connected = false;
-            // Return invalid client
-            return BridgeTCPClient<BufferSize>(*bridge, 0, false);
-        }
-
+        // If no connection established return a disconnected (invalid) client
+        return ret? BridgeTCPClient<BufferSize>(*bridge, connection_id) : BridgeTCPClient<BufferSize>(*bridge, 0, false);
     }
 
     size_t write(uint8_t c) override {
@@ -92,24 +88,25 @@ class BridgeTCPServer final: public Server {
     size_t write(const uint8_t *buf, size_t size) override {
 
         BridgeTCPClient<BufferSize> client = accept();
+        if (!client) return 0;
 
-        if (client && _connected) {
-            return client.write(buf, size);
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        if (_connected) {
+            size_t written = client.write(buf, size);
+            k_mutex_unlock(&server_mutex);
+            return written;
         }
-
+        k_mutex_unlock(&server_mutex);
         return 0;
     }
 
     void close() {
         k_mutex_lock(&server_mutex, K_FOREVER);
-
         String msg;
-        const bool ret = bridge->call(TCP_CLOSE_LISTENER_METHOD, listener_id).result(msg);
-
-        if (ret) {
-            _listening = false;
+        if (_listening){
+            _listening = !bridge->call(TCP_CLOSE_LISTENER_METHOD, listener_id).result(msg);
+            // Debug msg?
         }
-
         k_mutex_unlock(&server_mutex);
     }
 
@@ -120,16 +117,36 @@ class BridgeTCPServer final: public Server {
         k_mutex_unlock(&server_mutex);
     }
 
-    bool is_listening() const {
-        return _listening;
+    bool is_listening() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        bool out = _listening;
+        k_mutex_unlock(&server_mutex);
+        return out;
     }
 
-    uint16_t getPort() const {
-        return _port;
+    bool is_connected() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        bool out = _connected;
+        k_mutex_unlock(&server_mutex);
+        return out;
+    }
+
+    uint16_t getPort() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        uint16_t port = _port;
+        k_mutex_unlock(&server_mutex);
+        return port;
+    }
+
+    String getAddr() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        String hostname = _addr.toString();
+        k_mutex_unlock(&server_mutex);
+        return hostname;
     }
 
     operator bool() const {
-        return _listening;
+        return is_listening();
     }
 
     using Print::write;