CMUX: Experimental implementation

esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -10,7 +10,7 @@
 #include "esp_err.h"
 #include "terminal_objects.hpp"
 #include "ppp_netif.hpp"
-
+#include <array>
 
 enum class terminal_error {
     BUFFER_OVERFLOW,
@@ -18,10 +18,10 @@ enum class terminal_error {
     UNEXPECTED_CONTROL_FLOW,
 };
 
-class terminal {
+class Terminal {
 public:
-    virtual ~terminal() = default;
-    void set_data_cb(std::function<void(size_t len)> f) { on_data = std::move(f); }
+    virtual ~Terminal() = default;
+    virtual void set_data_cb(std::function<bool(size_t len)> f) { on_data = std::move(f); }
     void set_error_cb(std::function<void(terminal_error)> f) { on_error = std::move(f); }
     virtual int write(uint8_t *data, size_t len) = 0;
     virtual int read(uint8_t *data, size_t len) = 0;
@@ -29,26 +29,36 @@ public:
     virtual void stop() = 0;
 
 protected:
-    std::function<void(size_t len)> on_data;
+    std::function<bool(size_t len)> on_data;
     std::function<void(terminal_error)> on_error;
 };
 
-class dte_adapter: public terminal {
+class CMUXedTerminal: public Terminal {
 public:
-    dte_adapter(std::unique_ptr<terminal> terminal):
-            original_dte(std::move(terminal)) {}
-    ~dte_adapter() override = default;
-    int write(uint8_t *data, size_t len) override { return original_dte->write(data, len); }
-    int read(uint8_t *data, size_t len)  override { return original_dte->read(data, len); }
+    explicit CMUXedTerminal(std::unique_ptr<Terminal> t, std::shared_ptr<uint8_t[]> b):
+            term(std::move(t)), buffer(std::move(b)) {}
+    ~CMUXedTerminal() override = default;
+    void setup_cmux() {
+
+    }
+    void set_data_cb(std::function<bool(size_t len)> f) override {}
+    int write(uint8_t *data, size_t len) override { return term->write(data, len); }
+    int read(uint8_t *data, size_t len)  override { return term->read(data, len); }
+    void start() override;
+    void stop() override {}
 private:
-    std::unique_ptr<terminal> original_dte;
+    static bool process_cmux_recv(size_t len);
+    void send_sabm(size_t i);
+    std::unique_ptr<Terminal> term;
+    std::shared_ptr<uint8_t[]> buffer;
 };
 
 
 enum class dte_mode {
     UNDEF,
     COMMAND_MODE,
-    DATA_MODE
+    DATA_MODE,
+    CMUX_MODE
 };
 
 enum class command_result {
@@ -60,12 +70,27 @@ enum class command_result {
 const int DTE_BUFFER_SIZE = 1024;
 
 
+struct CMUXHelper {
+    void send_sabm(size_t dlci);
+};
+
+enum class cmux_state {
+    INIT,
+    HEADER,
+    PAYLOAD,
+    FOOTER,
+
+};
+
 typedef std::function<command_result(uint8_t *data, size_t len)> got_line_cb;
 
 class DTE {
 public:
- explicit DTE(std::unique_ptr<terminal> t);
+ explicit DTE(std::unique_ptr<Terminal> t);
   ~DTE() = default;
+
+//    std::unique_ptr<Terminal> detach() { return std::move(term); }
+//    void attach(std::unique_ptr<Terminal> t) { term = std::move(t); }
 //  void set_line_cb(got_line f) { on_line_cb = std::move(f); }
     int write(uint8_t *data, size_t len)  { return term->write(data, len); }
     int read(uint8_t **d, size_t len)   {
@@ -75,28 +100,51 @@ public:
         *d = data;
         return actual_len;
     }
-    void set_data_cb(std::function<void(size_t len)> f) { on_data = std::move(f); }
+    void set_data_cb(std::function<bool(size_t len)> f)
+    {
+//        on_data = std::move(f);
+        term->set_data_cb(std::move(f));
 
+    }
+//    std::shared_ptr<uint8_t[]> get_buffer() { return buffer;}
     void start() { term->start(); }
     void data_mode_closed() { term->stop(); }
   void set_mode(dte_mode m) {
         term->start(); mode = m;
         if (m == dte_mode::DATA_MODE) {
             term->set_data_cb(on_data);
+        } else if (m == dte_mode::CMUX_MODE) {
+            setup_cmux();
         }
     }
     command_result command(const std::string& command, got_line_cb got_line, uint32_t time_ms);
+//    std::shared_ptr<uint8_t[]> buffer;
 
+    void send_cmux_command(uint8_t i, const std::string& command);
 private:
-    const size_t GOT_LINE = BIT0;
+
+    void setup_cmux();
+    void send_sabm(size_t dlci);
+//    CMUXHelper cmux;
+    static const size_t GOT_LINE = BIT0;
     size_t buffer_size;
     size_t consumed;
+//    std::shared_ptr<std::vector<uint8_t>> buffer;
     std::unique_ptr<uint8_t[]> buffer;
-    std::unique_ptr<terminal> term;
+    std::unique_ptr<Terminal> term;
     got_line_cb on_line;
     dte_mode mode;
     signal_group signal;
-    std::function<void(size_t len)> on_data;
+    std::function<bool(size_t len)> on_data;
+
+    bool on_cmux(size_t len);
+    static bool s_on_cmux(size_t len);
+    cmux_state state;
+    uint8_t dlci;
+    uint8_t type;
+    size_t payload_len;
+    uint8_t frame_header[6];
+    size_t frame_header_offset;
 };