/src/qpdf/libqpdf/BufferInputSource.cc

Source
#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),
    buf(buf),
    cur_offset(0),
    max_offset(buf ? QIntC::to_offset(buf->getSize()) : 0)
{
}

BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :
    own_memory(true),
    description(description),
    buf(new Buffer(contents.length())),
    cur_offset(0),
    max_offset(QIntC::to_offset(buf->getSize()))
{
    memcpy(buf->getBuffer(), contents.c_str(), contents.length());
}

BufferInputSource::~BufferInputSource()
{
    if (own_memory) {
        delete buf;
    }
}

qpdf_offset_t
BufferInputSource::findAndSkipNextEOL()
{
    if (cur_offset < 0) {
        throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
    }
    qpdf_offset_t end_pos = max_offset;
    if (cur_offset >= end_pos) {
        last_offset = end_pos;
        cur_offset = end_pos;
        return end_pos;
    }

    qpdf_offset_t result = 0;
    unsigned char const* buffer = buf->getBuffer();
    unsigned char const* end = buffer + end_pos;
    unsigned char const* p = buffer + cur_offset;

    while ((p < end) && !((*p == '\r') || (*p == '\n'))) {
        ++p;
    }
    if (p < end) {
        result = p - buffer;
        cur_offset = result + 1;
        ++p;
        while ((cur_offset < end_pos) && ((*p == '\r') || (*p == '\n'))) {
            ++p;
            ++cur_offset;
        }
    } else {
        cur_offset = end_pos;
        result = end_pos;
    }
    return result;
}

std::string const&
BufferInputSource::getName() const
{
    return description;
}

qpdf_offset_t
BufferInputSource::tell()
{
    return cur_offset;
}

void
BufferInputSource::seek(qpdf_offset_t offset, int whence)
{
    switch (whence) {
    case SEEK_SET:
        cur_offset = offset;
        break;

    case SEEK_END:
        QIntC::range_check(max_offset, offset);
        cur_offset = max_offset + offset;
        break;

    case SEEK_CUR:
        QIntC::range_check(cur_offset, offset);
        cur_offset += offset;
        break;

    default:
        throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
        break;
    }

    if (cur_offset < 0) {
        throw std::runtime_error(description + ": seek before beginning of buffer");
    }
}

void
BufferInputSource::rewind()
{
    cur_offset = 0;
}

size_t
BufferInputSource::read(char* buffer, size_t length)
{
    if (cur_offset < 0) {
        throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
    }
    qpdf_offset_t end_pos = max_offset;
    if (cur_offset >= end_pos) {
        last_offset = end_pos;
        return 0;
    }

    last_offset = cur_offset;
    size_t len = std::min(QIntC::to_size(end_pos - cur_offset), length);
    memcpy(buffer, buf->getBuffer() + cur_offset, len);
    cur_offset += QIntC::to_offset(len);
    return len;
}

void
BufferInputSource::unreadCh(char ch)
{
    if (cur_offset > 0) {
        --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;
}

Coverage Report

Created: 2025-11-09 06:16

Line	Count	Source
1		#include <qpdf/BufferInputSource.hh>
2		#include <qpdf/InputSource_private.hh>
3
4		#include <qpdf/Buffer.hh>
5		#include <qpdf/QIntC.hh>
6
7		#include <algorithm>
8		#include <cstring>
9		#include <sstream>
10
11		using namespace qpdf;
12
13		#ifndef QPDF_FUTURE
14
15		BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :
16		own_memory(own_memory),
17		description(description),
18		buf(buf),
19		cur_offset(0),
20		max_offset(buf ? QIntC::to_offset(buf->getSize()) : 0)
21		{
22		}
23
24		BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :
25		own_memory(true),
26		description(description),
27		buf(new Buffer(contents.length())),
28		cur_offset(0),
29		max_offset(QIntC::to_offset(buf->getSize()))
30		{
31		memcpy(buf->getBuffer(), contents.c_str(), contents.length());
32		}
33
34		BufferInputSource::~BufferInputSource()
35		{
36		if (own_memory) {
37		delete buf;
38		}
39		}
40
41		qpdf_offset_t
42		BufferInputSource::findAndSkipNextEOL()
43		{
44		if (cur_offset < 0) {
45		throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
46		}
47		qpdf_offset_t end_pos = max_offset;
48		if (cur_offset >= end_pos) {
49		last_offset = end_pos;
50		cur_offset = end_pos;
51		return end_pos;
52		}
53
54		qpdf_offset_t result = 0;
55		unsigned char const* buffer = buf->getBuffer();
56		unsigned char const* end = buffer + end_pos;
57		unsigned char const* p = buffer + cur_offset;
58
59		while ((p < end) && !((p == '\r') \|\| (p == '\n'))) {
60		++p;
61		}
62		if (p < end) {
63		result = p - buffer;
64		cur_offset = result + 1;
65		++p;
66		while ((cur_offset < end_pos) && ((p == '\r') \|\| (p == '\n'))) {
67		++p;
68		++cur_offset;
69		}
70		} else {
71		cur_offset = end_pos;
72		result = end_pos;
73		}
74		return result;
75		}
76
77		std::string const&
78		BufferInputSource::getName() const
79		{
80		return description;
81		}
82
83		qpdf_offset_t
84		BufferInputSource::tell()
85		{
86		return cur_offset;
87		}
88
89		void
90		BufferInputSource::seek(qpdf_offset_t offset, int whence)
91		{
92		switch (whence) {
93		case SEEK_SET:
94		cur_offset = offset;
95		break;
96
97		case SEEK_END:
98		QIntC::range_check(max_offset, offset);
99		cur_offset = max_offset + offset;
100		break;
101
102		case SEEK_CUR:
103		QIntC::range_check(cur_offset, offset);
104		cur_offset += offset;
105		break;
106
107		default:
108		throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
109		break;
110		}
111
112		if (cur_offset < 0) {
113		throw std::runtime_error(description + ": seek before beginning of buffer");
114		}
115		}
116
117		void
118		BufferInputSource::rewind()
119		{
120		cur_offset = 0;
121		}
122
123		size_t
124		BufferInputSource::read(char* buffer, size_t length)
125		{
126		if (cur_offset < 0) {
127		throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
128		}
129		qpdf_offset_t end_pos = max_offset;
130		if (cur_offset >= end_pos) {
131		last_offset = end_pos;
132		return 0;
133		}
134
135		last_offset = cur_offset;
136		size_t len = std::min(QIntC::to_size(end_pos - cur_offset), length);
137		memcpy(buffer, buf->getBuffer() + cur_offset, len);
138		cur_offset += QIntC::to_offset(len);
139		return len;
140		}
141
142		void
143		BufferInputSource::unreadCh(char ch)
144		{
145		if (cur_offset > 0) {
146		--cur_offset;
147		}
148		}
149
150		#else
151
152		class BufferInputSource::Members
153		{
154		public:
155		Members(std::string const& description, Buffer* buf, bool own_memory) :
156	7.77k	buf(own_memory ? buf : nullptr),
157	7.77k	is(description,
158	7.77k	buf && buf->getSize() > 0
159	7.77k	? std::string_view(reinterpret_cast<const char*>(buf->getBuffer()), buf->getSize())
160	7.77k	: std::string_view())
161	7.77k	{
162	7.77k	}
163
164		Members(std::string const& description, std::string const& str) :
165	0	content(str),
166	0	is(description, content)
167	0	{
168	0	}
169
170	7.77k	~Members() = default;
171
172		std::unique_ptr<Buffer> buf{nullptr};
173		std::string content;
174		is::OffsetBuffer is;
175		};
176
177		BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :
178	7.77k	m(std::make_unique<Members>(description, buf, own_memory))
179	7.77k	{
180	7.77k	}
181
182		BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :
183	0	m(std::make_unique<Members>(description, contents))
184	0	{
185	0	}
186	7.77k	BufferInputSource::~BufferInputSource() = default;
187
188		qpdf_offset_t
189		BufferInputSource::findAndSkipNextEOL()
190	0	{
191	0	auto result = m->is.findAndSkipNextEOL();
192	0	last_offset = m->is.getLastOffset();
193	0	return result;
194	0	}
195		std::string const&
196		BufferInputSource::getName() const
197	106k	{
198	106k	return m->is.getName();
199	106k	}
200		qpdf_offset_t
201		BufferInputSource::tell()
202	0	{
203	0	return m->is.tell();
204	0	}
205		void
206		BufferInputSource::seek(qpdf_offset_t offset, int whence)
207	0	{
208	0	m->is.seek(offset, whence);
209	0	}
210		void
211		BufferInputSource::rewind()
212	0	{
213	0	m->is.rewind();
214	0	}
215		size_t
216		BufferInputSource::read(char* buffer, size_t length)
217	21.3k	{
218	21.3k	auto result = m->is.read(buffer, length);
219	21.3k	last_offset = m->is.getLastOffset();
220	21.3k	return result;
221	21.3k	}
222		void
223		BufferInputSource::unreadCh(char ch)
224	0	{
225	0	m->is.unreadCh(ch);
226	0	}
227
228		#endif // QPDF_FUTURE
229
230		qpdf_offset_t
231		is::OffsetBuffer::findAndSkipNextEOL()
232	0	{
233	0	if (pos < 0) {
234	0	throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");
235	0	}
236	0	auto end_pos = static_cast<qpdf_offset_t>(view_.size());
237	0	if (pos >= end_pos) {
238	0	last_offset = end_pos + global_offset;
239	0	pos = end_pos;
240	0	return end_pos + global_offset;
241	0	}
242
243	0	qpdf_offset_t result = 0;
244	0	auto buffer = view_.begin();
245	0	auto end = view_.end();
246	0	auto p = buffer + static_cast<std::ptrdiff_t>(pos);
247
248	0	while (p < end && !(p == '\r' \|\| p == '\n')) {
249	0	++p;
250	0	}
251	0	if (p < end) {
252	0	result = p - buffer;
253	0	pos = result + 1;
254	0	++p;
255	0	while (pos < end_pos && (p == '\r' \|\| p == '\n')) {
256	0	++p;
257	0	++pos;
258	0	}
259	0	} else {
260	0	pos = end_pos;
261	0	result = end_pos;
262	0	}
263	0	return result + global_offset;
264	0	}
265
266		void
267		is::OffsetBuffer::seek(qpdf_offset_t offset, int whence)
268	232k	{
269	232k	switch (whence) {
270	224k	case SEEK_SET:
271	224k	pos = offset - global_offset;
272	224k	break;
273
274	7.77k	case SEEK_END:
275	7.77k	QIntC::range_check(static_cast<qpdf_offset_t>(view_.size()), offset);
276	7.77k	pos = static_cast<qpdf_offset_t>(view_.size()) + offset;
277	7.77k	break;
278
279	0	case SEEK_CUR:
280	0	QIntC::range_check(pos, offset);
281	0	pos += offset;
282	0	break;
283
284	0	default:
285	0	throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
286	0	break;
287	232k	}
288
289	232k	if (pos < 0) {
290	0	throw std::runtime_error(description + ": seek before beginning of buffer");
291	0	}
292	232k	}
293
294		size_t
295		is::OffsetBuffer::read(char* buffer, size_t length)
296	190k	{
297	190k	if (pos < 0) {
298	0	throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");
299	0	}
300	190k	auto end_pos = static_cast<qpdf_offset_t>(view_.size());
301	190k	if (pos >= end_pos) {
302	19.5k	last_offset = end_pos + global_offset;
303	19.5k	return 0;
304	19.5k	}
305
306	170k	last_offset = pos + global_offset;
307	170k	size_t len = std::min(QIntC::to_size(end_pos - pos), length);
308	170k	memcpy(buffer, view_.data() + pos, len);
309	170k	pos += QIntC::to_offset(len);
310	170k	return len;
311	190k	}