feat(core-clp): Add BoundedReader to prevent out-of-bound reads in segmented input streams.

components/core/CMakeLists.txt

@@ -353,6 +353,8 @@ set(SOURCE_FILES_unitTest
         src/clp/clp/run.hpp
         src/clp/clp/utils.cpp
         src/clp/clp/utils.hpp
+        src/clp/CheckpointReader.cpp
+        src/clp/CheckpointReader.hpp
         src/clp/CurlDownloadHandler.cpp
         src/clp/CurlDownloadHandler.hpp
         src/clp/CurlEasyHandle.hpp
@@ -549,6 +551,7 @@ set(SOURCE_FILES_unitTest
         tests/LogSuppressor.hpp
         tests/test-Array.cpp
         tests/test-BufferedFileReader.cpp
+        tests/test-CheckpointReader.cpp
         tests/test-clp_s-end_to_end.cpp
         tests/test-EncodedVariableInterpreter.cpp
         tests/test-encoding_methods.cpp

components/core/src/clp/CheckpointReader.cpp

@@ -0,0 +1,37 @@
+#include "CheckpointReader.hpp"
+
+namespace clp {
+auto CheckpointReader::try_seek_from_begin(size_t pos) -> ErrorCode {
+    m_cur_pos = pos > m_checkpoint ? m_checkpoint : pos;
+    auto rc = m_reader->try_seek_from_begin(m_cur_pos);
+    if (ErrorCode_Success != rc) {
+        return rc;
+    }
+    if (m_cur_pos >= m_checkpoint) {
+        return ErrorCode_EndOfFile;
+    }
+    return ErrorCode_Success;
+}
+
+auto CheckpointReader::try_read(char* buf, size_t num_bytes_to_read, size_t& num_bytes_read)
+        -> ErrorCode {
+    if ((m_cur_pos + num_bytes_to_read) > m_checkpoint) {
+        num_bytes_to_read = m_checkpoint - m_cur_pos;
+    }
+
+    if (m_cur_pos == m_checkpoint) {
+        return ErrorCode_EndOfFile;
+    }
+
+    auto rc = m_reader->try_read(buf, num_bytes_to_read, num_bytes_read);
+    m_cur_pos += num_bytes_read;
+    if (ErrorCode_EndOfFile == rc) {
+        if (0 == num_bytes_read) {
+            return ErrorCode_EndOfFile;
+        }
+    } else if (ErrorCode_Success != rc) {
+        return rc;
+    }
+    return ErrorCode_Success;
+}
+}  // namespace clp

components/core/src/clp/CheckpointReader.hpp

@@ -0,0 +1,77 @@
+#ifndef CLP_CHECKPOINTREADER_HPP
+#define CLP_CHECKPOINTREADER_HPP
+
+#include "ReaderInterface.hpp"
+
+namespace clp {
+/**
+ * CheckpointReader is a ReaderInterface designed to wrap other ReaderInterfaces and prevent users
+ * from reading or seeking beyond a certain point in the underlying input stream.
+ *
+ * This is useful when the underlying input stream is divided into several logical segments and we
+ * want to prevent a reader for an earlier segment consuming any bytes from a later segment. In
+ * particular, reading part of a later segment may force the reader for that later segment to seek
+ * backwards, which can be either inefficient or impossible for certain kinds of input streams.
+ */
+class CheckpointReader : public ReaderInterface {
+public:
+    // Constructor
+    explicit CheckpointReader(ReaderInterface* reader, size_t checkpoint)
+            : m_reader(reader),
+              m_checkpoint(checkpoint) {
+        if (nullptr != m_reader) {
+            m_cur_pos = m_reader->get_pos();
+        }
+        if (m_cur_pos > m_checkpoint) {
+            throw ReaderInterface::OperationFailed(ErrorCode_BadParam, __FILE__, __LINE__);
+        }
+    }
+
+    // Methods implementing the ReaderInterface
+    /**
+     * Tries to get the current position of the read head in the underlying reader.
+     * @param pos Position of the read head in the underlying reader
+     * @return ErrorCode_Success on success
+     * @return ErrorCode_errno on failure
+     */
+    auto try_get_pos(size_t& pos) -> ErrorCode override { return m_reader->try_get_pos(pos); }
+
+    /**
+     * Tries to seek to the given position, limited by the checkpoint. If pos is past the checkpoint
+     * then this reader seeks up to the checkpoint in the underlying stream, then returns
+     * ErrorCode_EndOfFile on success or ErrorCode_errno otherwise.
+     * @param pos
+     * @return ErrorCode_Success on success
+     * @return ErrorCode_EndOfFile on EOF or if trying to seek beyond the checkpoint
+     * @return ErrorCode_errno on failure
+     */
+    auto try_seek_from_begin(size_t pos) -> ErrorCode override;
+
+    /**
+     * Tries to read up to a given number of bytes from the file, limited by the checkpoint. If the
+     * requested read would advance the read head beyond the checkpoint then the read size is
+     * adjusted such that the read head is advanced to the checkpoint. If a read is attempted when
+     * the read head is at the checkpoint then ErrorCode_EndOfFile is returned.
+     * @param buf
+     * @param num_bytes_to_read The number of bytes to try and read
+     * @param num_bytes_read The actual number of bytes read
+     * @return ErrorCode_errno on error
+     * @return ErrorCode_EndOfFile on EOF or trying to read after hitting checkpoint
+     * @return ErrorCode_Success on success
+     */
+    auto
+    try_read(char* buf, size_t num_bytes_to_read, size_t& num_bytes_read) -> ErrorCode override;
+
+    auto try_read_to_delimiter(char delim, bool keep_delimiter, bool append, std::string& str)
+            -> ErrorCode override {
+        return ErrorCode_Unsupported;
+    }
+
+private:
+    ReaderInterface* m_reader{nullptr};
+    size_t m_checkpoint{};
+    size_t m_cur_pos{};
+};
+}  // namespace clp
+
+#endif  // CLP_CHECKPOINTREADER_HPP

components/core/src/clp/StringReader.cpp

@@ -41,6 +41,10 @@ ErrorCode StringReader::try_read(char* buf, size_t num_bytes_to_read, size_t& nu
 }
 
 ErrorCode StringReader::try_seek_from_begin(size_t pos) {
+    if (pos > input_string.size()) {
+        this->pos = input_string.size();
+        return ErrorCode_EndOfFile;
+    }
     this->pos = pos;
     return ErrorCode_Success;
 }

components/core/tests/test-CheckpointReader.cpp

@@ -0,0 +1,94 @@
+#include <string>
+
+#include <Catch2/single_include/catch2/catch.hpp>
+
+#include "../src/clp/CheckpointReader.hpp"
+#include "../src/clp/ErrorCode.hpp"
+#include "../src/clp/StringReader.hpp"
+
+TEST_CASE("Test Checkpoint Reader", "[CheckpointReader]") {
+    constexpr char cTestString[]{"0123456789"};
+    constexpr size_t cTestStringLen{std::char_traits<char>::length(cTestString)};
+
+    SECTION("CheckpointReader does not support try_read_to_delimiter") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, cTestStringLen};
+        std::string tmp;
+        REQUIRE(clp::ErrorCode_Unsupported
+                == checkpoint_reader.try_read_to_delimiter('0', false, false, tmp));
+    }
+
+    SECTION("CheckpointReader does not allow reads beyond end of underlying stream.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, cTestStringLen + 1};
+        char buf[cTestStringLen + 1];
+        size_t num_bytes_read{};
+        auto rc = checkpoint_reader.try_read(buf, cTestStringLen + 1, num_bytes_read);
+        REQUIRE(clp::ErrorCode_Success == rc);
+        REQUIRE(num_bytes_read == cTestStringLen);
+        REQUIRE(cTestStringLen == string_reader.get_pos());
+        REQUIRE(cTestStringLen == checkpoint_reader.get_pos());
+    }
+
+    SECTION("CheckpointReader does not allow reads beyond checkpoint.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, 1};
+        char buf[cTestStringLen];
+        size_t num_bytes_read{};
+        auto rc = checkpoint_reader.try_read(buf, cTestStringLen, num_bytes_read);
+        REQUIRE(clp::ErrorCode_Success == rc);
+        REQUIRE(1 == num_bytes_read);
+        REQUIRE(1 == string_reader.get_pos());
+        REQUIRE(1 == checkpoint_reader.get_pos());
+    }
+
+    SECTION("CheckpointReader does allow reads before checkpoint.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, 1};
+        char buf{};
+        size_t num_bytes_read{};
+        auto rc = checkpoint_reader.try_read(&buf, 1, num_bytes_read);
+        REQUIRE(clp::ErrorCode_Success == rc);
+        REQUIRE(1 == num_bytes_read);
+        REQUIRE(1 == string_reader.get_pos());
+        REQUIRE(1 == checkpoint_reader.get_pos());
+    }
+
+    SECTION("CheckpointReader does not allow seeks beyond end of underlying stream.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, cTestStringLen + 1};
+        auto rc = checkpoint_reader.try_seek_from_begin(cTestStringLen + 1);
+        REQUIRE(clp::ErrorCode_EndOfFile == rc);
+        REQUIRE(cTestStringLen == string_reader.get_pos());
+        REQUIRE(cTestStringLen == checkpoint_reader.get_pos());
+    }
+
+    SECTION("CheckpointReader does not allow seeks beyond checkpoint.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, 1};
+        char buf[cTestStringLen];
+        size_t num_bytes_read{};
+        auto rc = checkpoint_reader.try_seek_from_begin(cTestStringLen);
+        REQUIRE(clp::ErrorCode_EndOfFile == rc);
+        REQUIRE(1 == string_reader.get_pos());
+        REQUIRE(1 == checkpoint_reader.get_pos());
+    }
+
+    SECTION("CheckpointReader does allow seeks before checkpoint.") {
+        clp::StringReader string_reader;
+        string_reader.open(cTestString);
+        clp::CheckpointReader checkpoint_reader{&string_reader, 2};
+        char buf[cTestStringLen];
+        size_t num_bytes_read{};
+        auto rc = checkpoint_reader.try_seek_from_begin(1);
+        REQUIRE(clp::ErrorCode_Success == rc);
+        REQUIRE(1 == string_reader.get_pos());
+        REQUIRE(1 == checkpoint_reader.get_pos());
+    }
+}