fix(modem): Added support for inflatable buffer

As a configurable option, if disabled we report an error.

Closes https://github.com/espressif/esp-protocols/issues/272

components/esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -79,6 +79,13 @@ public:
      */
     void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f);
 
+    /**
+     * @brief Sets read callback for manual command processing
+     * Note that this API also locks the command API, which can only be used
+     * after you remove the callback by dte->on_read(nullptr)
+     *
+     * @param on_data Function to be called when a command response is available
+     */
     void on_read(got_line_cb on_data) override;
 
     /**
@@ -122,7 +129,6 @@ protected:
     }
     friend class Scoped<DTE>;                               /*!< Declaring "Scoped<DTE> lock(dte)" locks this instance */
 private:
-    static const size_t GOT_LINE = SignalGroup::bit0;       /*!< Bit indicating response available */
 
     [[nodiscard]] bool setup_cmux();                        /*!< Internal setup of CMUX mode */
     [[nodiscard]] bool exit_cmux();                         /*!< Exit of CMUX mode and cleanup  */
@@ -134,9 +140,73 @@ private:
     std::shared_ptr<Terminal> primary_term;                 /*!< Reference to the primary terminal (mostly for sending commands) */
     std::shared_ptr<Terminal> secondary_term;               /*!< Secondary terminal for this DTE */
     modem_mode mode;                                        /*!< DTE operation mode */
-    SignalGroup signal;                                     /*!< Event group used to signal request-response operations */
-    command_result result;                                  /*!< Command result of the currently exectuted command */
     std::function<bool(uint8_t *data, size_t len)> on_data; /*!< on data callback for current terminal */
+
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+    /**
+     * @brief Implements an extra buffer that is used to capture partial reads from underlying terminals
+     * when we run out of the standard buffer
+     */
+    struct extra_buffer {
+        extra_buffer(): buffer(nullptr) {}
+        ~extra_buffer()
+        {
+            delete buffer;
+        }
+        std::vector<uint8_t> *buffer;
+        size_t consumed{0};
+        void grow(size_t need_size);
+        void deflate()
+        {
+            grow(0);
+            consumed = 0;
+        }
+        [[nodiscard]] uint8_t *begin() const
+        {
+            return &buffer->at(0);
+        }
+        [[nodiscard]] uint8_t *current() const
+        {
+            return &buffer->at(0) + consumed;
+        }
+    } inflatable;
+#endif // CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+
+    /**
+     * @brief Set internal command callbacks to the underlying terminal.
+     * Here we capture command replies to be processed by supplied command callbacks in  struct command_cb.
+     */
+    void set_command_callbacks();
+
+    /**
+     * @brief This abstracts command callback processing and implements its locking, signaling of completion and timeouts.
+     */
+    struct command_cb {
+        static const size_t GOT_LINE = SignalGroup::bit0;       /*!< Bit indicating response available */
+        got_line_cb got_line;                                   /*!< Supplied command callback */
+        Lock line_lock{};                                       /*!< Command callback locking mechanism */
+        char separator{};                                       /*!< Command reply separator (end of line/processing unit) */
+        command_result result{};                                /*!< Command return code */
+        SignalGroup signal;                                     /*!< Event group used to signal request-response operations */
+        bool process_line(uint8_t *data, size_t consumed, size_t len);  /*!< Lets the processing callback handle one line (processing unit) */
+        bool wait_for_line(uint32_t time_ms);                   /*!< Waiting for command processing */
+        void set(got_line_cb l, char s = '\n')                  /*!< Sets the command callback atomically */
+        {
+            Scoped<Lock> lock(line_lock);
+            if (l) {
+                // if we set the line callback, we have to reset the signal and the result
+                signal.clear(GOT_LINE);
+                result = command_result::TIMEOUT;
+            }
+            got_line = std::move(l);
+            separator = s;
+        }
+        void give_up()                                          /*!< Reports other than timeout error when processing replies (out of buffer) */
+        {
+            result = command_result::FAIL;
+            signal.set(GOT_LINE);
+        }
+    } command_cb;                                               /*!< Command callback utility class */
 };
 
 /**