Merge pull request #1496 from m-holger/obis

Refactor is::OffsetBuffer and BufferInputSource

Merge pull request #1496 from m-holger/obis
Refactor is::OffsetBuffer and BufferInputSource
m-holger · GitHub
2 parents 3a055d5b 799080b0
Showing 13 changed files with 255 additions and 84 deletions
include/qpdf/BufferInputSource.hh
include/qpdf/QPDF.hh
include/qpdf/QPDFObjectHandle.hh
libqpdf/BufferInputSource.cc
libqpdf/JSON.cc
libqpdf/Pl_QPDFTokenizer.cc
libqpdf/QPDF.cc
libqpdf/QPDFObjectHandle.cc
libqpdf/QPDFParser.cc
libqpdf/QPDF_Stream.cc
libqpdf/QPDF_objects.cc
libqpdf/qpdf/InputSource_private.hh
libqpdf/qpdf/QPDFObjectHandle_private.hh
@@ -23,6 +23,8 @@
 #include <qpdf/Buffer.hh>
 #include <qpdf/InputSource.hh>
  
+#include <memory>
+
 class QPDF_DLL_CLASS BufferInputSource: public InputSource
 {
   public:
@@ -52,11 +54,17 @@ class QPDF_DLL_CLASS BufferInputSource: public InputSource
     void unreadCh(char ch) override;
  
   private:
+#ifndef QPDF_FUTURE
     bool own_memory;
     std::string description;
     Buffer* buf;
     qpdf_offset_t cur_offset;
     qpdf_offset_t max_offset;
+#else
+    class Members;
+
+    std::unique_ptr<Members> m;
+#endif
 };
  
 #endif // QPDF_BUFFERINPUTSOURCE_HH
@@ -95,7 +95,8 @@ class QPDF
  
     // Parse a PDF file loaded into a memory buffer.  This works exactly like processFile except
     // that the PDF file is in memory instead of on disk.  The description appears in any warning or
-    // error message in place of the file name.
+    // error message in place of the file name. The buffer is owned by the caller and must remain
+    // valid for the lifetime of the QPDF object.
     QPDF_DLL
     void processMemoryFile(
         char const* description, char const* buf, size_t length, char const* password = nullptr);
@@ -1351,7 +1351,7 @@ class QPDFObjectHandle: public qpdf::BaseHandle
     void setParsedOffset(qpdf_offset_t offset);
     void parseContentStream_internal(std::string const& description, ParserCallbacks* callbacks);
     static void parseContentStream_data(
-        std::shared_ptr<Buffer>,
+        std::string_view stream_data,
         std::string const& description,
         ParserCallbacks* callbacks,
         QPDF* context);
 #include <qpdf/BufferInputSource.hh>
+#include <qpdf/InputSource_private.hh>
  
+#include <qpdf/Buffer.hh>
 #include <qpdf/QIntC.hh>
+
 #include <algorithm>
 #include <cstring>
 #include <sstream>
  
+using namespace qpdf;
+
+#ifndef QPDF_FUTURE
+
 BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :
     own_memory(own_memory),
     description(description),
@@ -139,3 +146,166 @@ BufferInputSource::unreadCh(char ch)
         --cur_offset;
     }
 }
+
+#else
+
+class BufferInputSource::Members
+{
+  public:
+    Members(std::string const& description, Buffer* buf, bool own_memory) :
+        buf(own_memory ? buf : nullptr),
+        is(description,
+           buf && buf->getSize() > 0
+               ? std::string_view(reinterpret_cast<const char*>(buf->getBuffer()), buf->getSize())
+               : std::string_view())
+    {
+    }
+
+    Members(std::string const& description, std::string const& str) :
+        content(str),
+        is(description, content)
+    {
+    }
+
+    ~Members() = default;
+
+    std::unique_ptr<Buffer> buf{nullptr};
+    std::string content;
+    is::OffsetBuffer is;
+};
+
+BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :
+    m(std::make_unique<Members>(description, buf, own_memory))
+{
+}
+
+BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :
+    m(std::make_unique<Members>(description, contents))
+{
+}
+BufferInputSource::~BufferInputSource() = default;
+
+qpdf_offset_t
+BufferInputSource::findAndSkipNextEOL()
+{
+    auto result = m->is.findAndSkipNextEOL();
+    last_offset = m->is.getLastOffset();
+    return result;
+}
+std::string const&
+BufferInputSource::getName() const
+{
+    return m->is.getName();
+}
+qpdf_offset_t
+BufferInputSource::tell()
+{
+    return m->is.tell();
+}
+void
+BufferInputSource::seek(qpdf_offset_t offset, int whence)
+{
+    m->is.seek(offset, whence);
+}
+void
+BufferInputSource::rewind()
+{
+    m->is.rewind();
+}
+size_t
+BufferInputSource::read(char* buffer, size_t length)
+{
+    auto result = m->is.read(buffer, length);
+    last_offset = m->is.getLastOffset();
+    return result;
+}
+void
+BufferInputSource::unreadCh(char ch)
+{
+    m->is.unreadCh(ch);
+}
+
+#endif // QPDF_FUTURE
+
+qpdf_offset_t
+is::OffsetBuffer::findAndSkipNextEOL()
+{
+    if (pos < 0) {
+        throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");
+    }
+    auto end_pos = static_cast<qpdf_offset_t>(view_.size());
+    if (pos >= end_pos) {
+        last_offset = end_pos + global_offset;
+        pos = end_pos;
+        return end_pos + global_offset;
+    }
+
+    qpdf_offset_t result = 0;
+    auto buffer = view_.begin();
+    auto end = view_.end();
+    auto p = buffer + static_cast<std::ptrdiff_t>(pos);
+
+    while (p < end && !(*p == '\r' || *p == '\n')) {
+        ++p;
+    }
+    if (p < end) {
+        result = p - buffer;
+        pos = result + 1;
+        ++p;
+        while (pos < end_pos && (*p == '\r' || *p == '\n')) {
+            ++p;
+            ++pos;
+        }
+    } else {
+        pos = end_pos;
+        result = end_pos;
+    }
+    return result + global_offset;
+}
+
+void
+is::OffsetBuffer::seek(qpdf_offset_t offset, int whence)
+{
+    switch (whence) {
+    case SEEK_SET:
+        pos = offset - global_offset;
+        break;
+
+    case SEEK_END:
+        QIntC::range_check(static_cast<qpdf_offset_t>(view_.size()), offset);
+        pos = static_cast<qpdf_offset_t>(view_.size()) + offset;
+        break;
+
+    case SEEK_CUR:
+        QIntC::range_check(pos, offset);
+        pos += offset;
+        break;
+
+    default:
+        throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
+        break;
+    }
+
+    if (pos < 0) {
+        throw std::runtime_error(description + ": seek before beginning of buffer");
+    }
+}
+
+size_t
+is::OffsetBuffer::read(char* buffer, size_t length)
+{
+    if (pos < 0) {
+        throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");
+    }
+    auto end_pos = static_cast<qpdf_offset_t>(view_.size());
+    if (pos >= end_pos) {
+        last_offset = end_pos + global_offset;
+        return 0;
+    }
+
+    last_offset = pos + global_offset;
+    size_t len = std::min(QIntC::to_size(end_pos - pos), length);
+    memcpy(buffer, view_.data() + pos, len);
+    pos += QIntC::to_offset(len);
+    return len;
+}
@@ -2,7 +2,7 @@
  
 #include <qpdf/JSON_writer.hh>
  
-#include <qpdf/BufferInputSource.hh>
+#include <qpdf/InputSource_private.hh>
 #include <qpdf/Pl_Base64.hh>
 #include <qpdf/Pl_Concatenate.hh>
 #include <qpdf/Pl_String.hh>
@@ -1348,7 +1348,7 @@ JSON::parse(InputSource&amp; is, Reactor* reactor)
 JSON
 JSON::parse(std::string const& s)
 {
-    BufferInputSource bis("json input", s);
+    is::OffsetBuffer bis("json input", s);
     JSONParser jp(bis, nullptr);
     return jp.parse();
 }
 #include <qpdf/Pl_QPDFTokenizer.hh>
  
-#include <qpdf/BufferInputSource.hh>
+#include <qpdf/InputSource_private.hh>
+#include <qpdf/Pipeline_private.hh>
 #include <qpdf/QTC.hh>
+
 #include <stdexcept>
  
+using namespace qpdf;
+
 class Pl_QPDFTokenizer::Members
 {
   public:
@@ -13,7 +17,8 @@ class Pl_QPDFTokenizer::Members
  
     QPDFObjectHandle::TokenFilter* filter{nullptr};
     QPDFTokenizer tokenizer;
-    Pl_Buffer buf{"tokenizer buffer"};
+    std::string buffer;
+    pl::String buf{"pl_tokenizer", nullptr, buffer};
 };
  
 Pl_QPDFTokenizer::Pl_QPDFTokenizer(
@@ -39,8 +44,7 @@ Pl_QPDFTokenizer::write(unsigned char const* data, size_t len)
 void
 Pl_QPDFTokenizer::finish()
 {
-    m->buf.finish();
-    auto input = BufferInputSource("tokenizer data", m->buf.getBuffer(), true);
+    auto input = is::OffsetBuffer("tokenizer data", m->buffer);
     std::string empty;
     while (true) {
         auto token = m->tokenizer.readToken(input, empty, true);
@@ -11,7 +11,6 @@
 #include <sstream>
 #include <vector>
  
-#include <qpdf/BufferInputSource.hh>
 #include <qpdf/FileInputSource.hh>
 #include <qpdf/InputSource_private.hh>
 #include <qpdf/OffsetInputSource.hh>
@@ -259,12 +258,8 @@ void
 QPDF::processMemoryFile(
     char const* description, char const* buf, size_t length, char const* password)
 {
-    processInputSource(
-        std::shared_ptr<InputSource>(
-            // line-break
-            new BufferInputSource(
-                description, new Buffer(QUtil::unsigned_char_pointer(buf), length), true)),
-        password);
+    auto is = std::make_shared<is::OffsetBuffer>(description, std::string_view{buf, length});
+    processInputSource(is, password);
 }
  
 void
@@ -2,7 +2,6 @@
  
 #include <qpdf/QPDFObjectHandle_private.hh>
  
-#include <qpdf/InputSource_private.hh>
 #include <qpdf/JSON_writer.hh>
 #include <qpdf/Pipeline_private.hh>
 #include <qpdf/Pl_Buffer.hh>
@@ -1452,10 +1451,7 @@ QPDFObjectHandle
 QPDFObjectHandle::parse(
     QPDF* context, std::string const& object_str, std::string const& object_description)
 {
-    // BufferInputSource does not modify the input, but Buffer either requires a string& or copies
-    // the string.
-    Buffer buf(const_cast<std::string&>(object_str));
-    auto input = BufferInputSource("parsed object", &buf);
+    auto input = is::OffsetBuffer("parsed object", object_str);
     auto result = QPDFParser::parse(input, object_description, context);
     size_t offset = QIntC::to_size(input.tell());
     while (offset < object_str.length()) {
@@ -1549,11 +1545,11 @@ void
 QPDFObjectHandle::parseContentStream_internal(
     std::string const& description, ParserCallbacks* callbacks)
 {
-    Pl_Buffer buf("concatenated stream data buffer");
+    std::string stream_data;
+    pl::String buf(stream_data);
     std::string all_description;
     pipeContentStreams(&buf, description, all_description);
-    auto stream_data = buf.getBufferSharedPointer();
-    callbacks->contentSize(stream_data->getSize());
+    callbacks->contentSize(stream_data.size());
     try {
         parseContentStream_data(stream_data, all_description, callbacks, getOwningQPDF());
     } catch (TerminateParsing&) {
@@ -1564,13 +1560,13 @@ QPDFObjectHandle::parseContentStream_internal(
  
 void
 QPDFObjectHandle::parseContentStream_data(
-    std::shared_ptr<Buffer> stream_data,
+    std::string_view stream_data,
     std::string const& description,
     ParserCallbacks* callbacks,
     QPDF* context)
 {
-    size_t stream_length = stream_data->getSize();
-    auto input = BufferInputSource(description, stream_data.get());
+    size_t stream_length = stream_data.size();
+    auto input = is::OffsetBuffer(description, stream_data);
     Tokenizer tokenizer;
     tokenizer.allowEOF();
     auto sp_description = QPDFParser::make_description(description, "content");
 #include <qpdf/QPDFParser.hh>
  
-#include <qpdf/BufferInputSource.hh>
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFObjGen.hh>
 #include <qpdf/QPDFObjectHandle.hh>
@@ -3,6 +3,7 @@
 #include <qpdf/ContentNormalizer.hh>
 #include <qpdf/JSON_writer.hh>
 #include <qpdf/Pipeline.hh>
+#include <qpdf/Pipeline_private.hh>
 #include <qpdf/Pl_Base64.hh>
 #include <qpdf/Pl_Buffer.hh>
 #include <qpdf/Pl_Count.hh>
@@ -319,10 +320,11 @@ qpdf::Stream::setDictDescription()
     }
 }
  
-std::shared_ptr<Buffer>
+std::string
 Stream::getStreamData(qpdf_stream_decode_level_e decode_level)
 {
-    Pl_Buffer buf("stream data buffer");
+    std::string result;
+    pl::String buf(result);
     bool filtered;
     pipeStreamData(&buf, &filtered, 0, decode_level, false, false);
     if (!filtered) {
@@ -334,13 +336,14 @@ Stream::getStreamData(qpdf_stream_decode_level_e decode_level)
             "getStreamData called on unfilterable stream");
     }
     QTC::TC("qpdf", "QPDF_Stream getStreamData");
-    return buf.getBufferSharedPointer();
+    return result;
 }
  
-std::shared_ptr<Buffer>
+std::string
 Stream::getRawStreamData()
 {
-    Pl_Buffer buf("stream data buffer");
+    std::string result;
+    pl::String buf(result);
     if (!pipeStreamData(&buf, nullptr, 0, qpdf_dl_none, false, false)) {
         throw QPDFExc(
             qpdf_e_unsupported,
@@ -350,7 +353,7 @@ Stream::getRawStreamData()
             "error getting raw stream data");
     }
     QTC::TC("qpdf", "QPDF_Stream getRawStreamData");
-    return buf.getBufferSharedPointer();
+    return result;
 }
  
 bool
@@ -683,13 +686,13 @@ QPDFObjectHandle::isRootMetadata() const
 std::shared_ptr<Buffer>
 QPDFObjectHandle::getStreamData(qpdf_stream_decode_level_e level)
 {
-    return as_stream(error).getStreamData(level);
+    return std::make_shared<Buffer>(as_stream(error).getStreamData(level));
 }
  
 std::shared_ptr<Buffer>
 QPDFObjectHandle::getRawStreamData()
 {
-    return as_stream(error).getRawStreamData();
+    return std::make_shared<Buffer>(as_stream(error).getRawStreamData());
 }
  
 bool
@@ -2,19 +2,7 @@
  
 #include <qpdf/QPDF_private.hh>
  
-#include <array>
-#include <atomic>
-#include <cstring>
-#include <limits>
-#include <map>
-#include <regex>
-#include <sstream>
-#include <vector>
-
-#include <qpdf/BufferInputSource.hh>
-#include <qpdf/FileInputSource.hh>
 #include <qpdf/InputSource_private.hh>
-#include <qpdf/OffsetInputSource.hh>
 #include <qpdf/Pipeline.hh>
 #include <qpdf/QPDFExc.hh>
 #include <qpdf/QPDFLogger.hh>
@@ -25,6 +13,13 @@
 #include <qpdf/QUtil.hh>
 #include <qpdf/Util.hh>
  
+#include <array>
+#include <atomic>
+#include <cstring>
+#include <limits>
+#include <map>
+#include <vector>
+
 using namespace qpdf;
 using namespace std::literals;
  
@@ -1676,13 +1671,13 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
     // id, offset, size
     std::vector<std::tuple<int, qpdf_offset_t, size_t>> offsets;
  
-    auto bp = obj_stream.getStreamData(qpdf_dl_specialized);
+    auto stream_data = obj_stream.getStreamData(qpdf_dl_specialized);
  
-    BufferInputSource input("", bp.get());
+    is::OffsetBuffer input("", stream_data);
  
-    const auto b_size = bp->getSize();
+    const auto b_size = stream_data.size();
     const auto end_offset = static_cast<qpdf_offset_t>(b_size);
-    auto b_start = bp->getBuffer();
+    auto b_start = stream_data.data();
  
     if (first >= end_offset) {
         throw damagedPDF(
@@ -1763,8 +1758,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
         auto entry = m->xref_table.find(og);
         if (entry != m->xref_table.end() && entry->second.getType() == 2 &&
             entry->second.getObjStreamNumber() == obj_stream_number) {
-            Buffer obj_buffer{b_start + obj_offset, obj_size};
-            is::OffsetBuffer in("", &obj_buffer, obj_offset);
+            is::OffsetBuffer in("", {b_start + obj_offset, obj_size}, obj_offset);
             auto oh = readObjectInStream(in, obj_stream_number, obj_id);
             updateCache(og, oh.getObj(), end_before_space, end_after_space);
         } else {
 #ifndef QPDF_INPUTSOURCE_PRIVATE_HH
 #define QPDF_INPUTSOURCE_PRIVATE_HH
  
-#include <qpdf/BufferInputSource.hh>
+#include <qpdf/Buffer.hh>
 #include <qpdf/InputSource.hh>
  
 #include <limits>
@@ -13,8 +13,12 @@ namespace qpdf::is
     class OffsetBuffer final: public InputSource
     {
       public:
-        OffsetBuffer(std::string const& description, Buffer* buf, qpdf_offset_t global_offset) :
-            proxied(description, buf),
+        OffsetBuffer(
+            std::string const& description,
+            std::string_view view,
+            qpdf_offset_t global_offset = 0) :
+            description(description),
+            view_(view),
             global_offset(global_offset)
         {
             if (global_offset < 0) {
@@ -23,58 +27,55 @@ namespace qpdf::is
             last_offset = global_offset;
         }
  
-        ~OffsetBuffer() final = default;
-
-        qpdf_offset_t
-        findAndSkipNextEOL() final
+        OffsetBuffer(std::string const& description, Buffer* buf, qpdf_offset_t global_offset = 0) :
+            OffsetBuffer(
+                description,
+                {buf && buf->getSize()
+                     ? std::string_view(
+                           reinterpret_cast<const char*>(buf->getBuffer()), buf->getSize())
+                     : std::string_view()},
+                global_offset)
         {
-            return proxied.findAndSkipNextEOL() + global_offset;
         }
  
+        ~OffsetBuffer() final = default;
+
+        qpdf_offset_t findAndSkipNextEOL() final;
+
         std::string const&
         getName() const final
         {
-            return proxied.getName();
+            return description;
         }
  
         qpdf_offset_t
         tell() final
         {
-            return proxied.tell() + global_offset;
+            return pos + global_offset;
         }
  
-        void
-        seek(qpdf_offset_t offset, int whence) final
-        {
-            if (whence == SEEK_SET) {
-                proxied.seek(offset - global_offset, whence);
-            } else {
-                proxied.seek(offset, whence);
-            }
-        }
+        void seek(qpdf_offset_t offset, int whence) final;
  
         void
         rewind() final
         {
-            seek(0, SEEK_SET);
+            pos = 0;
         }
  
-        size_t
-        read(char* buffer, size_t length) final
-        {
-            size_t result = proxied.read(buffer, length);
-            setLastOffset(proxied.getLastOffset() + global_offset);
-            return result;
-        }
+        size_t read(char* buffer, size_t length) final;
  
         void
         unreadCh(char ch) final
         {
-            proxied.unreadCh(ch);
+            if (pos > 0) {
+                --pos;
+            }
         }
  
       private:
-        BufferInputSource proxied;
+        std::string description;
+        qpdf_offset_t pos{0};
+        std::string_view view_;
         qpdf_offset_t global_offset;
     };
  
@@ -254,8 +254,8 @@ namespace qpdf
             qpdf_stream_decode_level_e decode_level,
             bool suppress_warnings,
             bool will_retry);
-        std::shared_ptr<Buffer> getStreamData(qpdf_stream_decode_level_e level);
-        std::shared_ptr<Buffer> getRawStreamData();
+        std::string getStreamData(qpdf_stream_decode_level_e level);
+        std::string getRawStreamData();
         void replaceStreamData(
             std::shared_ptr<Buffer> data,
             QPDFObjectHandle const& filter,