2012-06-25 14:51:44 +00:00
|
|
|
#include <qpdf/qpdf-config.h> // include first for large file support
|
2022-02-04 21:31:31 +00:00
|
|
|
|
2024-07-05 13:09:43 +00:00
|
|
|
#include <qpdf/QPDF_private.hh>
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-05-21 20:28:58 +00:00
|
|
|
#include <array>
|
2020-04-04 01:48:25 +00:00
|
|
|
#include <atomic>
|
2023-05-20 18:56:01 +00:00
|
|
|
#include <cstring>
|
2019-08-27 21:57:38 +00:00
|
|
|
#include <limits>
|
2008-04-29 12:55:25 +00:00
|
|
|
#include <map>
|
2022-02-08 16:07:37 +00:00
|
|
|
#include <regex>
|
2019-09-17 23:48:27 +00:00
|
|
|
#include <sstream>
|
2008-04-29 12:55:25 +00:00
|
|
|
#include <vector>
|
|
|
|
|
2012-07-21 09:37:14 +00:00
|
|
|
#include <qpdf/BufferInputSource.hh>
|
|
|
|
#include <qpdf/FileInputSource.hh>
|
2012-12-25 19:38:18 +00:00
|
|
|
#include <qpdf/OffsetInputSource.hh>
|
2008-04-29 12:55:25 +00:00
|
|
|
#include <qpdf/Pipeline.hh>
|
|
|
|
#include <qpdf/QPDFExc.hh>
|
2022-06-05 17:30:42 +00:00
|
|
|
#include <qpdf/QPDFLogger.hh>
|
2022-09-08 15:12:10 +00:00
|
|
|
#include <qpdf/QPDFObject_private.hh>
|
2022-09-28 15:58:42 +00:00
|
|
|
#include <qpdf/QPDFParser.hh>
|
2008-04-29 12:55:25 +00:00
|
|
|
#include <qpdf/QPDF_Array.hh>
|
|
|
|
#include <qpdf/QPDF_Dictionary.hh>
|
2019-01-07 02:18:36 +00:00
|
|
|
#include <qpdf/QPDF_Null.hh>
|
2022-08-02 16:18:00 +00:00
|
|
|
#include <qpdf/QPDF_Reserved.hh>
|
2019-01-07 02:18:36 +00:00
|
|
|
#include <qpdf/QPDF_Stream.hh>
|
2022-08-10 12:16:06 +00:00
|
|
|
#include <qpdf/QPDF_Unresolved.hh>
|
2022-06-05 17:30:42 +00:00
|
|
|
#include <qpdf/QTC.hh>
|
|
|
|
#include <qpdf/QUtil.hh>
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-02-05 13:26:32 +00:00
|
|
|
// This must be a fixed value. This API returns a const reference to it, and the C API relies on its
|
|
|
|
// being static as well.
|
|
|
|
std::string const QPDF::qpdf_version(QPDF_VERSION);
|
2009-10-24 04:47:17 +00:00
|
|
|
|
2022-04-03 20:10:27 +00:00
|
|
|
static char const* EMPTY_PDF = (
|
|
|
|
// force line break
|
|
|
|
"%PDF-1.3\n"
|
|
|
|
"1 0 obj\n"
|
|
|
|
"<< /Type /Catalog /Pages 2 0 R >>\n"
|
|
|
|
"endobj\n"
|
|
|
|
"2 0 obj\n"
|
|
|
|
"<< /Type /Pages /Kids [] /Count 0 >>\n"
|
|
|
|
"endobj\n"
|
|
|
|
"xref\n"
|
|
|
|
"0 3\n"
|
|
|
|
"0000000000 65535 f \n"
|
|
|
|
"0000000009 00000 n \n"
|
|
|
|
"0000000058 00000 n \n"
|
|
|
|
"trailer << /Size 3 /Root 1 0 R >>\n"
|
|
|
|
"startxref\n"
|
|
|
|
"110\n"
|
|
|
|
"%%EOF\n");
|
2012-06-22 03:06:48 +00:00
|
|
|
|
2022-04-16 17:21:57 +00:00
|
|
|
namespace
|
2021-01-06 14:49:10 +00:00
|
|
|
{
|
2022-04-16 17:21:57 +00:00
|
|
|
class InvalidInputSource: public InputSource
|
2021-01-06 14:49:10 +00:00
|
|
|
{
|
2022-04-16 17:21:57 +00:00
|
|
|
public:
|
2023-05-20 13:25:46 +00:00
|
|
|
~InvalidInputSource() override = default;
|
2023-05-20 12:56:33 +00:00
|
|
|
qpdf_offset_t
|
2022-04-16 17:21:57 +00:00
|
|
|
findAndSkipNextEOL() override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
return 0;
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
std::string const&
|
2022-04-16 17:21:57 +00:00
|
|
|
getName() const override
|
|
|
|
{
|
|
|
|
static std::string name("closed input source");
|
|
|
|
return name;
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
qpdf_offset_t
|
2022-04-16 17:21:57 +00:00
|
|
|
tell() override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
return 0;
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
void
|
2022-04-16 17:21:57 +00:00
|
|
|
seek(qpdf_offset_t offset, int whence) override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
void
|
2022-04-16 17:21:57 +00:00
|
|
|
rewind() override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
size_t
|
2022-04-16 17:21:57 +00:00
|
|
|
read(char* buffer, size_t length) override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
return 0;
|
|
|
|
}
|
2023-05-20 12:56:33 +00:00
|
|
|
void
|
2022-04-16 17:21:57 +00:00
|
|
|
unreadCh(char ch) override
|
|
|
|
{
|
|
|
|
throwException();
|
|
|
|
}
|
2021-01-06 14:49:10 +00:00
|
|
|
|
2022-04-16 17:21:57 +00:00
|
|
|
private:
|
|
|
|
void
|
|
|
|
throwException()
|
|
|
|
{
|
|
|
|
throw std::logic_error("QPDF operation attempted on a QPDF object with no input "
|
|
|
|
"source. QPDF operations are invalid before processFile (or "
|
|
|
|
"another process method) or after closeInputSource");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
2021-01-06 14:49:10 +00:00
|
|
|
|
2019-01-07 02:18:36 +00:00
|
|
|
QPDF::ForeignStreamData::ForeignStreamData(
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<EncryptionParameters> encp,
|
|
|
|
std::shared_ptr<InputSource> file,
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDFObjGen const& foreign_og,
|
2019-01-07 02:18:36 +00:00
|
|
|
qpdf_offset_t offset,
|
|
|
|
size_t length,
|
|
|
|
QPDFObjectHandle local_dict) :
|
|
|
|
encp(encp),
|
|
|
|
file(file),
|
2022-07-23 15:48:28 +00:00
|
|
|
foreign_og(foreign_og),
|
2019-01-07 02:18:36 +00:00
|
|
|
offset(offset),
|
|
|
|
length(length),
|
|
|
|
local_dict(local_dict)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(QPDF& destination_qpdf) :
|
2020-04-05 03:35:35 +00:00
|
|
|
QPDFObjectHandle::StreamDataProvider(true),
|
2019-01-07 02:18:36 +00:00
|
|
|
destination_qpdf(destination_qpdf)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2020-04-05 03:35:35 +00:00
|
|
|
bool
|
2012-07-11 19:29:41 +00:00
|
|
|
QPDF::CopiedStreamDataProvider::provideStreamData(
|
2020-04-05 03:35:35 +00:00
|
|
|
QPDFObjGen const& og, Pipeline* pipeline, bool suppress_warnings, bool will_retry)
|
2012-07-11 19:29:41 +00:00
|
|
|
{
|
2022-07-24 13:16:37 +00:00
|
|
|
std::shared_ptr<ForeignStreamData> foreign_data = foreign_stream_data[og];
|
2020-04-05 03:35:35 +00:00
|
|
|
bool result = false;
|
2022-02-04 15:10:19 +00:00
|
|
|
if (foreign_data.get()) {
|
2020-04-05 03:35:35 +00:00
|
|
|
result = destination_qpdf.pipeForeignStreamData(
|
|
|
|
foreign_data, pipeline, suppress_warnings, will_retry);
|
|
|
|
QTC::TC("qpdf", "QPDF copy foreign with data", result ? 0 : 1);
|
2019-01-07 02:18:36 +00:00
|
|
|
} else {
|
2022-07-24 13:16:37 +00:00
|
|
|
auto foreign_stream = foreign_streams[og];
|
2020-04-05 03:35:35 +00:00
|
|
|
result = foreign_stream.pipeStreamData(
|
|
|
|
pipeline, nullptr, 0, qpdf_dl_none, suppress_warnings, will_retry);
|
|
|
|
QTC::TC("qpdf", "QPDF copy foreign with foreign_stream", result ? 0 : 1);
|
2019-01-07 02:18:36 +00:00
|
|
|
}
|
2020-04-05 03:35:35 +00:00
|
|
|
return result;
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::CopiedStreamDataProvider::registerForeignStream(
|
2013-06-14 15:22:04 +00:00
|
|
|
QPDFObjGen const& local_og, QPDFObjectHandle foreign_stream)
|
2012-07-11 19:29:41 +00:00
|
|
|
{
|
|
|
|
this->foreign_streams[local_og] = foreign_stream;
|
|
|
|
}
|
|
|
|
|
2019-01-07 02:18:36 +00:00
|
|
|
void
|
|
|
|
QPDF::CopiedStreamDataProvider::registerForeignStream(
|
2022-04-09 18:35:56 +00:00
|
|
|
QPDFObjGen const& local_og, std::shared_ptr<ForeignStreamData> foreign_stream)
|
2019-01-07 02:18:36 +00:00
|
|
|
{
|
|
|
|
this->foreign_stream_data[local_og] = foreign_stream;
|
|
|
|
}
|
|
|
|
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::StringDecrypter::StringDecrypter(QPDF* qpdf, QPDFObjGen const& og) :
|
2012-07-21 13:00:06 +00:00
|
|
|
qpdf(qpdf),
|
2022-07-23 15:48:28 +00:00
|
|
|
og(og)
|
2012-07-21 13:00:06 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::StringDecrypter::decryptString(std::string& val)
|
|
|
|
{
|
2022-07-23 15:48:28 +00:00
|
|
|
qpdf->decryptString(val, og);
|
2012-07-21 13:00:06 +00:00
|
|
|
}
|
2012-07-11 19:29:41 +00:00
|
|
|
|
2009-10-24 04:47:17 +00:00
|
|
|
std::string const&
|
|
|
|
QPDF::QPDFVersion()
|
|
|
|
{
|
2022-02-05 13:26:32 +00:00
|
|
|
// The C API relies on this being a static value.
|
2009-10-24 04:47:17 +00:00
|
|
|
return QPDF::qpdf_version;
|
|
|
|
}
|
|
|
|
|
2019-01-06 14:58:16 +00:00
|
|
|
QPDF::EncryptionParameters::EncryptionParameters() :
|
2008-04-29 12:55:25 +00:00
|
|
|
encrypted(false),
|
|
|
|
encryption_initialized(false),
|
2009-10-17 18:54:51 +00:00
|
|
|
encryption_V(0),
|
2012-12-30 02:31:21 +00:00
|
|
|
encryption_R(0),
|
2009-10-17 18:54:51 +00:00
|
|
|
encrypt_metadata(true),
|
2009-10-17 23:37:55 +00:00
|
|
|
cf_stream(e_none),
|
|
|
|
cf_string(e_none),
|
|
|
|
cf_file(e_none),
|
2019-08-24 13:34:48 +00:00
|
|
|
user_password_matched(false),
|
|
|
|
owner_password_matched(false)
|
2019-01-06 14:58:16 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2024-08-09 13:14:56 +00:00
|
|
|
QPDF::Members::Members(QPDF& qpdf) :
|
2022-06-05 17:30:42 +00:00
|
|
|
log(QPDFLogger::defaultLogger()),
|
2024-09-05 13:50:38 +00:00
|
|
|
file_sp(new InvalidInputSource()),
|
|
|
|
file(file_sp.get()),
|
2024-08-09 13:14:56 +00:00
|
|
|
encp(new EncryptionParameters),
|
2024-08-12 11:22:58 +00:00
|
|
|
xref_table(qpdf, file)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-08-22 01:33:44 +00:00
|
|
|
QPDF::QPDF() :
|
2024-08-09 13:14:56 +00:00
|
|
|
m(new Members(*this))
|
2017-08-22 01:33:44 +00:00
|
|
|
{
|
2018-02-16 22:25:27 +00:00
|
|
|
m->tokenizer.allowEOF();
|
2019-01-06 15:07:23 +00:00
|
|
|
// Generate a unique ID. It just has to be unique among all QPDF objects allocated throughout
|
|
|
|
// the lifetime of this running application.
|
2020-04-04 01:48:25 +00:00
|
|
|
static std::atomic<unsigned long long> unique_id{0};
|
|
|
|
m->unique_id = unique_id.fetch_add(1ULL);
|
2017-08-22 01:33:44 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDF::~QPDF()
|
|
|
|
{
|
2010-06-06 18:03:21 +00:00
|
|
|
// If two objects are mutually referential (through each object having an array or dictionary
|
|
|
|
// that contains an indirect reference to the other), the circular references in the
|
2022-04-09 18:35:56 +00:00
|
|
|
// std::shared_ptr objects will prevent the objects from being deleted. Walk through all objects
|
2022-09-07 20:49:31 +00:00
|
|
|
// in the object cache, which is those objects that we read from the file, and break all
|
2022-09-08 12:03:57 +00:00
|
|
|
// resolved indirect references by replacing them with an internal object type representing that
|
2022-09-07 20:49:31 +00:00
|
|
|
// they have been destroyed. Note that we can't break references like this at any time when the
|
2022-09-08 15:06:15 +00:00
|
|
|
// QPDF object is active. The call to reset also causes all direct QPDFObjectHandle objects that
|
|
|
|
// are reachable from this object to release their association with this QPDF. Direct objects
|
|
|
|
// are not destroyed since they can be moved to other QPDF objects safely.
|
2023-05-24 15:28:17 +00:00
|
|
|
|
2022-04-30 17:23:18 +00:00
|
|
|
for (auto const& iter: m->obj_cache) {
|
2022-09-08 15:06:15 +00:00
|
|
|
iter.second.object->disconnect();
|
2023-04-11 16:16:40 +00:00
|
|
|
if (iter.second.object->getTypeCode() != ::ot_null) {
|
|
|
|
iter.second.object->destroy();
|
|
|
|
}
|
2010-06-06 13:32:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2022-09-02 12:53:27 +00:00
|
|
|
std::shared_ptr<QPDF>
|
|
|
|
QPDF::create()
|
|
|
|
{
|
|
|
|
return std::make_shared<QPDF>();
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF::processFile(char const* filename, char const* password)
|
|
|
|
{
|
2023-05-20 12:24:10 +00:00
|
|
|
auto* fi = new FileInputSource(filename);
|
2022-04-09 18:35:56 +00:00
|
|
|
processInputSource(std::shared_ptr<InputSource>(fi), password);
|
2010-10-01 10:20:38 +00:00
|
|
|
}
|
|
|
|
|
2012-06-21 11:59:56 +00:00
|
|
|
void
|
2012-06-23 22:23:06 +00:00
|
|
|
QPDF::processFile(char const* description, FILE* filep, bool close_file, char const* password)
|
2012-06-21 11:59:56 +00:00
|
|
|
{
|
2023-05-20 12:24:10 +00:00
|
|
|
auto* fi = new FileInputSource(description, filep, close_file);
|
2022-04-09 18:35:56 +00:00
|
|
|
processInputSource(std::shared_ptr<InputSource>(fi), password);
|
2012-06-21 11:59:56 +00:00
|
|
|
}
|
|
|
|
|
2010-10-01 10:20:38 +00:00
|
|
|
void
|
|
|
|
QPDF::processMemoryFile(
|
|
|
|
char const* description, char const* buf, size_t length, char const* password)
|
|
|
|
{
|
2012-09-23 21:42:26 +00:00
|
|
|
processInputSource(
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<InputSource>(
|
2022-04-03 20:10:27 +00:00
|
|
|
// line-break
|
|
|
|
new BufferInputSource(
|
|
|
|
description, new Buffer(QUtil::unsigned_char_pointer(buf), length), true)),
|
2012-09-23 21:42:26 +00:00
|
|
|
password);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-04-09 18:35:56 +00:00
|
|
|
QPDF::processInputSource(std::shared_ptr<InputSource> source, char const* password)
|
2012-09-23 21:42:26 +00:00
|
|
|
{
|
2024-09-05 13:50:38 +00:00
|
|
|
m->file_sp = source;
|
|
|
|
m->file = source.get();
|
2010-10-01 10:20:38 +00:00
|
|
|
parse(password);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2019-08-31 19:10:29 +00:00
|
|
|
void
|
|
|
|
QPDF::closeInputSource()
|
|
|
|
{
|
2024-09-05 13:50:38 +00:00
|
|
|
m->file_sp = std::shared_ptr<InputSource>(new InvalidInputSource());
|
|
|
|
m->file = m->file_sp.get();
|
2019-08-31 19:10:29 +00:00
|
|
|
}
|
|
|
|
|
2018-01-14 15:17:17 +00:00
|
|
|
void
|
|
|
|
QPDF::setPasswordIsHexKey(bool val)
|
|
|
|
{
|
|
|
|
m->provided_password_is_hex_key = val;
|
|
|
|
}
|
|
|
|
|
2012-06-22 03:06:48 +00:00
|
|
|
void
|
|
|
|
QPDF::emptyPDF()
|
|
|
|
{
|
2012-06-22 13:46:33 +00:00
|
|
|
processMemoryFile("empty PDF", EMPTY_PDF, strlen(EMPTY_PDF));
|
2012-06-22 03:06:48 +00:00
|
|
|
}
|
|
|
|
|
2020-12-23 11:12:49 +00:00
|
|
|
void
|
|
|
|
QPDF::registerStreamFilter(
|
|
|
|
std::string const& filter_name, std::function<std::shared_ptr<QPDFStreamFilter>()> factory)
|
|
|
|
{
|
|
|
|
QPDF_Stream::registerStreamFilter(filter_name, factory);
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF::setIgnoreXRefStreams(bool val)
|
|
|
|
{
|
2024-08-09 13:10:26 +00:00
|
|
|
m->xref_table.ignore_streams = val;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 17:30:42 +00:00
|
|
|
std::shared_ptr<QPDFLogger>
|
|
|
|
QPDF::getLogger()
|
|
|
|
{
|
|
|
|
return m->log;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::setLogger(std::shared_ptr<QPDFLogger> l)
|
|
|
|
{
|
|
|
|
m->log = l;
|
|
|
|
}
|
|
|
|
|
2010-10-01 11:02:35 +00:00
|
|
|
void
|
|
|
|
QPDF::setOutputStreams(std::ostream* out, std::ostream* err)
|
|
|
|
{
|
2022-09-09 11:03:29 +00:00
|
|
|
setLogger(QPDFLogger::create());
|
2022-06-05 17:30:42 +00:00
|
|
|
m->log->setOutputStreams(out, err);
|
2010-10-01 11:02:35 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF::setSuppressWarnings(bool val)
|
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
m->suppress_warnings = val;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-07-02 13:14:21 +00:00
|
|
|
void
|
2024-07-18 09:41:15 +00:00
|
|
|
QPDF::setMaxWarnings(size_t val)
|
2024-07-02 13:14:21 +00:00
|
|
|
{
|
2024-07-09 15:38:02 +00:00
|
|
|
m->max_warnings = val;
|
2024-07-02 13:14:21 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF::setAttemptRecovery(bool val)
|
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
m->attempt_recovery = val;
|
2024-08-09 13:10:26 +00:00
|
|
|
m->xref_table.attempt_recovery = val;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2019-01-11 03:11:38 +00:00
|
|
|
void
|
|
|
|
QPDF::setImmediateCopyFrom(bool val)
|
|
|
|
{
|
|
|
|
m->immediate_copy_from = val;
|
|
|
|
}
|
|
|
|
|
2009-10-20 00:24:44 +00:00
|
|
|
std::vector<QPDFExc>
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDF::getWarnings()
|
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
std::vector<QPDFExc> result = m->warnings;
|
|
|
|
m->warnings.clear();
|
2008-04-29 12:55:25 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-08-31 19:10:29 +00:00
|
|
|
bool
|
|
|
|
QPDF::anyWarnings() const
|
|
|
|
{
|
|
|
|
return !m->warnings.empty();
|
|
|
|
}
|
|
|
|
|
2021-03-01 22:33:34 +00:00
|
|
|
size_t
|
|
|
|
QPDF::numWarnings() const
|
|
|
|
{
|
|
|
|
return m->warnings.size();
|
|
|
|
}
|
|
|
|
|
2017-08-06 02:34:25 +00:00
|
|
|
bool
|
2022-05-21 11:41:09 +00:00
|
|
|
QPDF::validatePDFVersion(char const*& p, std::string& version)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2017-08-06 02:34:25 +00:00
|
|
|
bool valid = QUtil::is_digit(*p);
|
|
|
|
if (valid) {
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
version.append(1, *p++);
|
|
|
|
}
|
|
|
|
if ((*p == '.') && QUtil::is_digit(*(p + 1))) {
|
|
|
|
version.append(1, *p++);
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
version.append(1, *p++);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
valid = false;
|
|
|
|
}
|
|
|
|
}
|
2022-05-21 11:41:09 +00:00
|
|
|
return valid;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::findHeader()
|
|
|
|
{
|
|
|
|
qpdf_offset_t global_offset = m->file->tell();
|
|
|
|
std::string line = m->file->readLine(1024);
|
|
|
|
char const* p = line.c_str();
|
|
|
|
if (strncmp(p, "%PDF-", 5) != 0) {
|
|
|
|
throw std::logic_error("findHeader is not looking at %PDF-");
|
|
|
|
}
|
|
|
|
p += 5;
|
|
|
|
std::string version;
|
|
|
|
// Note: The string returned by line.c_str() is always null-terminated. The code below never
|
|
|
|
// overruns the buffer because a null character always short-circuits further advancement.
|
|
|
|
bool valid = validatePDFVersion(p, version);
|
2017-08-06 02:34:25 +00:00
|
|
|
if (valid) {
|
2017-08-22 01:33:44 +00:00
|
|
|
m->pdf_version = version;
|
2012-12-25 19:38:18 +00:00
|
|
|
if (global_offset != 0) {
|
2012-12-31 15:31:38 +00:00
|
|
|
// Empirical evidence strongly suggests that when there is leading material prior to the
|
2012-12-25 19:38:18 +00:00
|
|
|
// PDF header, all explicit offsets in the file are such that 0 points to the beginning
|
|
|
|
// of the header.
|
|
|
|
QTC::TC("qpdf", "QPDF global offset");
|
2024-09-05 13:50:38 +00:00
|
|
|
m->file_sp =
|
|
|
|
std::shared_ptr<InputSource>(new OffsetInputSource(m->file_sp, global_offset));
|
|
|
|
m->file = m->file_sp.get();
|
2012-12-25 19:38:18 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2017-08-06 02:34:25 +00:00
|
|
|
return valid;
|
|
|
|
}
|
|
|
|
|
2017-08-05 18:54:07 +00:00
|
|
|
bool
|
|
|
|
QPDF::findStartxref()
|
|
|
|
{
|
2024-08-21 23:30:18 +00:00
|
|
|
if (readToken(*m->file).isWord("startxref") && readToken(*m->file).isInteger()) {
|
2022-09-29 13:33:11 +00:00
|
|
|
// Position in front of offset token
|
|
|
|
m->file->seek(m->file->getLastOffset(), SEEK_SET);
|
|
|
|
return true;
|
2017-08-05 18:54:07 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-08-06 02:34:25 +00:00
|
|
|
void
|
|
|
|
QPDF::parse(char const* password)
|
|
|
|
{
|
|
|
|
if (password) {
|
2022-02-08 14:18:08 +00:00
|
|
|
m->encp->provided_password = password;
|
2017-08-06 02:34:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Find the header anywhere in the first 1024 bytes of the file.
|
|
|
|
PatternFinder hf(*this, &QPDF::findHeader);
|
2017-08-22 01:33:44 +00:00
|
|
|
if (!m->file->findFirst("%PDF-", 0, 1024, hf)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF not a pdf file");
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF("", 0, "can't find PDF header"));
|
2017-07-29 13:24:43 +00:00
|
|
|
// QPDFWriter writes files that usually require at least version 1.2 for /FlateDecode
|
2017-08-22 01:33:44 +00:00
|
|
|
m->pdf_version = "1.2";
|
2017-07-28 02:27:00 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-10 12:11:23 +00:00
|
|
|
m->xref_table.initialize();
|
2008-04-29 12:55:25 +00:00
|
|
|
initializeEncryption();
|
2024-06-25 14:10:09 +00:00
|
|
|
if (m->xref_table.size() > 0 && !getRoot().getKey("/Pages").isDictionary()) {
|
|
|
|
// QPDFs created from JSON have an empty xref table and no root object yet.
|
2024-06-25 14:46:47 +00:00
|
|
|
throw damagedPDF("", 0, "unable to find page tree");
|
2024-06-25 14:10:09 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2019-08-21 16:50:36 +00:00
|
|
|
void
|
|
|
|
QPDF::inParse(bool v)
|
|
|
|
{
|
|
|
|
if (m->in_parse == v) {
|
2022-09-28 15:58:42 +00:00
|
|
|
// This happens if QPDFParser::parse tries to resolve an indirect object while it is
|
2019-08-21 16:50:36 +00:00
|
|
|
// parsing.
|
|
|
|
throw std::logic_error("QPDF: re-entrant parsing detected. This is a qpdf bug."
|
|
|
|
" Please report at https://github.com/qpdf/qpdf/issues.");
|
|
|
|
}
|
|
|
|
m->in_parse = v;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF::warn(QPDFExc const& e)
|
|
|
|
{
|
2024-07-18 09:41:15 +00:00
|
|
|
if (m->max_warnings > 0 && m->warnings.size() >= m->max_warnings) {
|
|
|
|
stopOnError("Too many warnings - file is too badly damaged");
|
|
|
|
}
|
2017-08-22 01:33:44 +00:00
|
|
|
m->warnings.push_back(e);
|
|
|
|
if (!m->suppress_warnings) {
|
2022-06-05 17:30:42 +00:00
|
|
|
*m->log->getWarn() << "WARNING: " << m->warnings.back().what() << "\n";
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-23 22:03:44 +00:00
|
|
|
void
|
|
|
|
QPDF::warn(
|
|
|
|
qpdf_error_code_e error_code,
|
|
|
|
std::string const& object,
|
|
|
|
qpdf_offset_t offset,
|
|
|
|
std::string const& message)
|
|
|
|
{
|
|
|
|
warn(QPDFExc(error_code, getFilename(), object, offset, message));
|
|
|
|
}
|
|
|
|
|
2024-08-10 12:11:23 +00:00
|
|
|
void
|
|
|
|
QPDF::Xref_table::initialize()
|
|
|
|
{
|
|
|
|
// PDF spec says %%EOF must be found within the last 1024 bytes of/ the file. We add an extra
|
|
|
|
// 30 characters to leave room for the startxref stuff.
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(0, SEEK_END);
|
|
|
|
qpdf_offset_t end_offset = file->tell();
|
2024-08-10 12:11:23 +00:00
|
|
|
max_offset = end_offset;
|
|
|
|
// Sanity check on object ids. All objects must appear in xref table / stream. In all realistic
|
|
|
|
// scenarios at least 3 bytes are required.
|
|
|
|
if (max_id > max_offset / 3) {
|
|
|
|
max_id = static_cast<int>(max_offset / 3);
|
|
|
|
}
|
|
|
|
qpdf_offset_t start_offset = (end_offset > 1054 ? end_offset - 1054 : 0);
|
|
|
|
PatternFinder sf(qpdf, &QPDF::findStartxref);
|
|
|
|
qpdf_offset_t xref_offset = 0;
|
2024-08-12 11:22:58 +00:00
|
|
|
if (file->findLast("startxref", start_offset, 0, sf)) {
|
|
|
|
xref_offset = QUtil::string_to_ll(read_token().getValue().c_str());
|
2024-08-10 12:11:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
if (xref_offset == 0) {
|
|
|
|
QTC::TC("qpdf", "QPDF can't find startxref");
|
|
|
|
throw damaged_pdf("can't find startxref");
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
read(xref_offset);
|
|
|
|
} catch (QPDFExc&) {
|
|
|
|
throw;
|
|
|
|
} catch (std::exception& e) {
|
|
|
|
throw damaged_pdf(std::string("error reading xref: ") + e.what());
|
|
|
|
}
|
|
|
|
} catch (QPDFExc& e) {
|
|
|
|
if (attempt_recovery) {
|
|
|
|
reconstruct(e);
|
|
|
|
QTC::TC("qpdf", "QPDF reconstructed xref table");
|
|
|
|
} else {
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
parsed = true;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
2024-08-09 23:12:53 +00:00
|
|
|
QPDF::Xref_table::reconstruct(QPDFExc& e)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2024-08-09 23:12:53 +00:00
|
|
|
if (reconstructed) {
|
2017-07-26 18:38:49 +00:00
|
|
|
// Avoid xref reconstruction infinite loops. This is getting very hard to reproduce because
|
|
|
|
// qpdf is throwing many fewer exceptions while parsing. Most situations are warnings now.
|
2017-07-25 14:21:27 +00:00
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
|
2024-07-11 11:22:57 +00:00
|
|
|
// If recovery generates more than 1000 warnings, the file is so severely damaged that there
|
|
|
|
// probably is no point trying to continue.
|
2024-08-12 11:22:58 +00:00
|
|
|
const auto max_warnings = qpdf.m->warnings.size() + 1000U;
|
2024-07-13 10:00:19 +00:00
|
|
|
auto check_warnings = [this, max_warnings]() {
|
2024-08-09 23:12:53 +00:00
|
|
|
if (qpdf.m->warnings.size() > max_warnings) {
|
|
|
|
throw damaged_pdf("too many errors while reconstructing cross-reference table");
|
2024-07-13 10:00:19 +00:00
|
|
|
}
|
|
|
|
};
|
2024-07-11 11:22:57 +00:00
|
|
|
|
2024-08-09 23:12:53 +00:00
|
|
|
reconstructed = true;
|
2022-11-24 16:50:46 +00:00
|
|
|
// We may find more objects, which may contain dangling references.
|
2024-08-12 11:22:58 +00:00
|
|
|
qpdf.m->fixed_dangling_refs = false;
|
2017-07-25 14:21:27 +00:00
|
|
|
|
2024-08-09 23:12:53 +00:00
|
|
|
warn_damaged("file is damaged");
|
|
|
|
qpdf.warn(e);
|
|
|
|
warn_damaged("Attempting to reconstruct cross-reference table");
|
2009-10-19 23:09:19 +00:00
|
|
|
|
|
|
|
// Delete all references to type 1 (uncompressed) objects
|
2013-06-14 15:22:04 +00:00
|
|
|
std::set<QPDFObjGen> to_delete;
|
2024-08-09 23:12:53 +00:00
|
|
|
for (auto const& iter: *this) {
|
2022-04-30 17:23:18 +00:00
|
|
|
if (iter.second.getType() == 1) {
|
|
|
|
to_delete.insert(iter.first);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2009-10-19 23:09:19 +00:00
|
|
|
}
|
2022-04-30 17:23:18 +00:00
|
|
|
for (auto const& iter: to_delete) {
|
2024-08-09 23:12:53 +00:00
|
|
|
erase(iter);
|
2009-10-19 23:09:19 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(0, SEEK_END);
|
|
|
|
qpdf_offset_t eof = file->tell();
|
|
|
|
file->seek(0, SEEK_SET);
|
2024-07-28 17:03:30 +00:00
|
|
|
// Don't allow very long tokens here during recovery. All the interesting tokens are covered.
|
|
|
|
static size_t const MAX_LEN = 10;
|
2024-08-12 11:22:58 +00:00
|
|
|
while (file->tell() < eof) {
|
|
|
|
QPDFTokenizer::Token t1 = read_token(MAX_LEN);
|
|
|
|
qpdf_offset_t token_start = file->tell() - toO(t1.getValue().length());
|
2024-07-28 17:03:30 +00:00
|
|
|
if (t1.isInteger()) {
|
2024-08-12 11:22:58 +00:00
|
|
|
auto pos = file->tell();
|
|
|
|
QPDFTokenizer::Token t2 = read_token(MAX_LEN);
|
|
|
|
if (t2.isInteger() && read_token(MAX_LEN).isWord("obj")) {
|
2021-11-07 20:23:29 +00:00
|
|
|
int obj = QUtil::string_to_int(t1.getValue().c_str());
|
|
|
|
int gen = QUtil::string_to_int(t2.getValue().c_str());
|
2024-08-09 23:12:53 +00:00
|
|
|
if (obj <= max_id) {
|
|
|
|
insert_reconstructed(obj, token_start, gen);
|
2024-06-25 14:46:47 +00:00
|
|
|
} else {
|
2024-08-09 23:12:53 +00:00
|
|
|
warn_damaged("ignoring object with impossibly large id " + std::to_string(obj));
|
2024-06-25 14:46:47 +00:00
|
|
|
}
|
2017-08-10 23:00:06 +00:00
|
|
|
}
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(pos, SEEK_SET);
|
2024-08-09 23:12:53 +00:00
|
|
|
} else if (!trailer && t1.isWord("trailer")) {
|
2024-08-12 11:22:58 +00:00
|
|
|
auto pos = file->tell();
|
2024-08-12 15:01:37 +00:00
|
|
|
QPDFObjectHandle t = read_trailer();
|
2021-11-07 20:23:29 +00:00
|
|
|
if (!t.isDictionary()) {
|
|
|
|
// Oh well. It was worth a try.
|
|
|
|
} else {
|
2024-08-10 11:17:01 +00:00
|
|
|
trailer = t;
|
2017-08-10 23:00:06 +00:00
|
|
|
}
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(pos, SEEK_SET);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-07-13 10:00:19 +00:00
|
|
|
check_warnings();
|
2024-08-12 11:22:58 +00:00
|
|
|
file->findAndSkipNextEOL();
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2024-08-09 23:12:53 +00:00
|
|
|
deleted_objects.clear();
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-09 23:12:53 +00:00
|
|
|
if (!trailer) {
|
2024-01-06 21:51:03 +00:00
|
|
|
qpdf_offset_t max_offset{0};
|
|
|
|
// If there are any xref streams, take the last one to appear.
|
2024-08-09 23:12:53 +00:00
|
|
|
for (auto const& iter: *this) {
|
2024-01-06 21:51:03 +00:00
|
|
|
auto entry = iter.second;
|
|
|
|
if (entry.getType() != 1) {
|
|
|
|
continue;
|
|
|
|
}
|
2024-08-09 23:12:53 +00:00
|
|
|
auto oh = qpdf.getObjectByObjGen(iter.first);
|
2024-01-06 21:51:03 +00:00
|
|
|
try {
|
|
|
|
if (!oh.isStreamOfType("/XRef")) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} catch (std::exception&) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
auto offset = entry.getOffset();
|
|
|
|
if (offset > max_offset) {
|
|
|
|
max_offset = offset;
|
2024-08-09 23:12:53 +00:00
|
|
|
trailer = oh.getDict();
|
2024-01-06 21:51:03 +00:00
|
|
|
}
|
2024-07-13 10:00:19 +00:00
|
|
|
check_warnings();
|
2024-01-06 21:51:03 +00:00
|
|
|
}
|
|
|
|
if (max_offset > 0) {
|
|
|
|
try {
|
2024-08-10 11:40:59 +00:00
|
|
|
read(max_offset);
|
2024-01-06 21:51:03 +00:00
|
|
|
} catch (std::exception&) {
|
2024-08-09 23:12:53 +00:00
|
|
|
throw damaged_pdf(
|
|
|
|
"error decoding candidate xref stream while recovering damaged file");
|
2024-01-06 21:51:03 +00:00
|
|
|
}
|
|
|
|
QTC::TC("qpdf", "QPDF recover xref stream");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-08-09 23:12:53 +00:00
|
|
|
if (!trailer) {
|
2022-02-08 14:18:08 +00:00
|
|
|
// We could check the last encountered object to see if it was an xref stream. If so, we
|
|
|
|
// could try to get the trailer from there. This may make it possible to recover files with
|
|
|
|
// bad startxref pointers even when they have object streams.
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-09 23:12:53 +00:00
|
|
|
throw damaged_pdf("unable to find trailer dictionary while recovering damaged file");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2024-08-09 23:12:53 +00:00
|
|
|
if (empty()) {
|
2024-07-09 15:53:33 +00:00
|
|
|
// We cannot check for an empty xref table in parse because empty tables are valid when
|
|
|
|
// creating QPDF objects from JSON.
|
2024-08-09 23:12:53 +00:00
|
|
|
throw damaged_pdf("unable to find objects while recovering damaged file");
|
2024-07-09 15:53:33 +00:00
|
|
|
}
|
2024-07-13 10:00:19 +00:00
|
|
|
check_warnings();
|
2024-08-09 23:12:53 +00:00
|
|
|
if (!parsed) {
|
|
|
|
parsed = true;
|
|
|
|
qpdf.getAllPages();
|
2024-07-13 10:00:19 +00:00
|
|
|
check_warnings();
|
2024-08-12 11:22:58 +00:00
|
|
|
if (qpdf.m->all_pages.empty()) {
|
2024-08-09 23:12:53 +00:00
|
|
|
parsed = false;
|
|
|
|
throw damaged_pdf("unable to find any pages while recovering damaged file");
|
2024-07-13 10:00:19 +00:00
|
|
|
}
|
2024-07-11 11:22:57 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
// We could iterate through the objects looking for streams and try to find objects inside of
|
|
|
|
// them, but it's probably not worth the trouble. Acrobat can't recover files with any errors
|
|
|
|
// in an xref stream, and this would be a real long shot anyway. If we wanted to do anything
|
|
|
|
// that involved looking at stream contents, we'd also have to call initializeEncryption() here.
|
|
|
|
// It's safe to call it more than once.
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2024-08-10 11:40:59 +00:00
|
|
|
QPDF::Xref_table::read(qpdf_offset_t xref_offset)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
|
|
|
std::map<int, int> free_table;
|
2017-08-25 23:58:31 +00:00
|
|
|
std::set<qpdf_offset_t> visited;
|
2008-04-29 12:55:25 +00:00
|
|
|
while (xref_offset) {
|
2017-08-25 23:58:31 +00:00
|
|
|
visited.insert(xref_offset);
|
2013-06-15 16:38:25 +00:00
|
|
|
char buf[7];
|
|
|
|
memset(buf, 0, sizeof(buf));
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(xref_offset, SEEK_SET);
|
2019-08-20 01:43:28 +00:00
|
|
|
// Some files miss the mark a little with startxref. We could do a better job of searching
|
|
|
|
// in the neighborhood for something that looks like either an xref table or stream, but the
|
|
|
|
// simple heuristic of skipping whitespace can help with the xref table case and is harmless
|
|
|
|
// with the stream case.
|
|
|
|
bool done = false;
|
|
|
|
bool skipped_space = false;
|
|
|
|
while (!done) {
|
|
|
|
char ch;
|
2024-08-12 11:22:58 +00:00
|
|
|
if (1 == file->read(&ch, 1)) {
|
2019-08-20 01:43:28 +00:00
|
|
|
if (QUtil::is_space(ch)) {
|
|
|
|
skipped_space = true;
|
|
|
|
} else {
|
2024-08-12 11:22:58 +00:00
|
|
|
file->unreadCh(ch);
|
2019-08-20 01:43:28 +00:00
|
|
|
done = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF eof skipping spaces before xref", skipped_space ? 0 : 1);
|
|
|
|
done = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-08-12 11:22:58 +00:00
|
|
|
file->read(buf, sizeof(buf) - 1);
|
2013-06-15 16:38:25 +00:00
|
|
|
// The PDF spec says xref must be followed by a line terminator, but files exist in the wild
|
|
|
|
// where it is terminated by arbitrary whitespace.
|
2017-08-10 00:46:02 +00:00
|
|
|
if ((strncmp(buf, "xref", 4) == 0) && QUtil::is_space(buf[4])) {
|
2019-08-20 01:43:28 +00:00
|
|
|
if (skipped_space) {
|
|
|
|
QTC::TC("qpdf", "QPDF xref skipped space");
|
2024-08-10 11:40:59 +00:00
|
|
|
warn_damaged("extraneous whitespace seen before xref");
|
2019-08-20 01:43:28 +00:00
|
|
|
}
|
2013-06-15 16:38:25 +00:00
|
|
|
QTC::TC(
|
|
|
|
"qpdf",
|
|
|
|
"QPDF xref space",
|
|
|
|
((buf[4] == '\n') ? 0
|
|
|
|
: (buf[4] == '\r') ? 1
|
|
|
|
: (buf[4] == ' ') ? 2
|
|
|
|
: 9999));
|
2017-08-10 00:46:02 +00:00
|
|
|
int skip = 4;
|
|
|
|
// buf is null-terminated, and QUtil::is_space('\0') is false, so this won't overrun.
|
|
|
|
while (QUtil::is_space(buf[skip])) {
|
|
|
|
++skip;
|
|
|
|
}
|
2024-08-10 11:40:59 +00:00
|
|
|
xref_offset = read_table(xref_offset + skip);
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
2024-08-10 11:40:59 +00:00
|
|
|
xref_offset = read_stream(xref_offset);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2017-08-25 23:58:31 +00:00
|
|
|
if (visited.count(xref_offset) != 0) {
|
2018-03-05 19:25:17 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref loop");
|
2024-08-10 11:40:59 +00:00
|
|
|
throw damaged_pdf("loop detected following xref tables");
|
2017-08-25 23:58:31 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-08-10 11:40:59 +00:00
|
|
|
if (!trailer) {
|
|
|
|
throw damaged_pdf("unable to find trailer while reading xref");
|
2012-06-24 19:26:28 +00:00
|
|
|
}
|
2024-08-10 11:40:59 +00:00
|
|
|
int size = trailer.getKey("/Size").getIntValueAsInt();
|
2010-06-05 19:48:32 +00:00
|
|
|
int max_obj = 0;
|
2024-08-10 11:40:59 +00:00
|
|
|
if (!empty()) {
|
|
|
|
max_obj = rbegin()->first.getObj();
|
2010-06-05 19:48:32 +00:00
|
|
|
}
|
2024-08-10 11:40:59 +00:00
|
|
|
if (!deleted_objects.empty()) {
|
|
|
|
max_obj = std::max(max_obj, *deleted_objects.rbegin());
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2019-11-03 23:54:39 +00:00
|
|
|
if ((size < 1) || (size - 1 != max_obj)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref size mismatch");
|
2024-08-10 12:11:23 +00:00
|
|
|
warn_damaged(
|
|
|
|
"reported number of objects (" + std::to_string(size) +
|
|
|
|
") is not one plus the highest object number (" + std::to_string(max_obj) + ")");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// We no longer need the deleted_objects table, so go ahead and clear it out to make sure we
|
|
|
|
// never depend on its being set.
|
2024-08-10 11:40:59 +00:00
|
|
|
deleted_objects.clear();
|
2024-01-07 22:05:35 +00:00
|
|
|
|
|
|
|
// Make sure we keep only the highest generation for any object.
|
2024-01-08 11:43:57 +00:00
|
|
|
QPDFObjGen last_og{-1, 0};
|
2024-08-10 11:40:59 +00:00
|
|
|
for (auto const& item: *this) {
|
2024-01-17 10:39:06 +00:00
|
|
|
auto id = item.first.getObj();
|
2024-02-04 21:11:53 +00:00
|
|
|
if (id == last_og.getObj() && id > 0) {
|
2024-08-12 16:52:42 +00:00
|
|
|
erase(last_og);
|
2024-08-10 11:40:59 +00:00
|
|
|
qpdf.removeObject(last_og);
|
2024-02-04 21:11:53 +00:00
|
|
|
}
|
2024-01-17 10:39:06 +00:00
|
|
|
last_og = item.first;
|
2024-01-07 22:05:35 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2017-08-10 23:37:05 +00:00
|
|
|
bool
|
2024-08-10 10:47:02 +00:00
|
|
|
QPDF::Xref_table::parse_first(std::string const& line, int& obj, int& num, int& bytes)
|
2017-08-10 23:37:05 +00:00
|
|
|
{
|
|
|
|
// is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
|
|
|
|
// buffer.
|
|
|
|
char const* p = line.c_str();
|
|
|
|
char const* start = line.c_str();
|
|
|
|
|
|
|
|
// Skip zero or more spaces
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
// Require digit
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Gather digits
|
|
|
|
std::string obj_str;
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
obj_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
// Require space
|
|
|
|
if (!QUtil::is_space(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Skip spaces
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
// Require digit
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Gather digits
|
|
|
|
std::string num_str;
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
num_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
// Skip any space including line terminators
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
}
|
2019-06-21 03:35:23 +00:00
|
|
|
bytes = toI(p - start);
|
2017-08-29 16:27:59 +00:00
|
|
|
obj = QUtil::string_to_int(obj_str.c_str());
|
|
|
|
num = QUtil::string_to_int(num_str.c_str());
|
2017-08-10 23:37:05 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2024-08-10 10:47:02 +00:00
|
|
|
QPDF::Xref_table::read_bad_entry(qpdf_offset_t& f1, int& f2, char& type)
|
2017-08-10 23:37:05 +00:00
|
|
|
{
|
2024-03-07 12:02:47 +00:00
|
|
|
// Reposition after initial read attempt and reread.
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(file->getLastOffset(), SEEK_SET);
|
|
|
|
auto line = file->readLine(30);
|
2024-03-07 12:02:47 +00:00
|
|
|
|
2017-08-10 23:37:05 +00:00
|
|
|
// is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
|
|
|
|
// buffer.
|
2024-03-07 12:02:47 +00:00
|
|
|
char const* p = line.data();
|
2017-08-10 23:37:05 +00:00
|
|
|
|
|
|
|
// Skip zero or more spaces. There aren't supposed to be any.
|
|
|
|
bool invalid = false;
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
QTC::TC("qpdf", "QPDF ignore first space in xref entry");
|
|
|
|
invalid = true;
|
|
|
|
}
|
|
|
|
// Require digit
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Gather digits
|
|
|
|
std::string f1_str;
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
f1_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
// Require space
|
|
|
|
if (!QUtil::is_space(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (QUtil::is_space(*(p + 1))) {
|
|
|
|
QTC::TC("qpdf", "QPDF ignore first extra space in xref entry");
|
|
|
|
invalid = true;
|
|
|
|
}
|
|
|
|
// Skip spaces
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
// Require digit
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Gather digits
|
|
|
|
std::string f2_str;
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
f2_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
// Require space
|
|
|
|
if (!QUtil::is_space(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (QUtil::is_space(*(p + 1))) {
|
|
|
|
QTC::TC("qpdf", "QPDF ignore second extra space in xref entry");
|
|
|
|
invalid = true;
|
|
|
|
}
|
|
|
|
// Skip spaces
|
|
|
|
while (QUtil::is_space(*p)) {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if ((*p == 'f') || (*p == 'n')) {
|
|
|
|
type = *p;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if ((f1_str.length() != 10) || (f2_str.length() != 5)) {
|
|
|
|
QTC::TC("qpdf", "QPDF ignore length error xref entry");
|
|
|
|
invalid = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (invalid) {
|
2024-08-10 10:47:02 +00:00
|
|
|
qpdf.warn(damaged_table("accepting invalid xref table entry"));
|
2017-08-10 23:37:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
f1 = QUtil::string_to_ll(f1_str.c_str());
|
2017-08-29 16:27:59 +00:00
|
|
|
f2 = QUtil::string_to_int(f2_str.c_str());
|
2017-08-10 23:37:05 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2024-03-07 12:02:47 +00:00
|
|
|
// Optimistically read and parse xref entry. If entry is bad, call read_bad_xrefEntry and return
|
|
|
|
// result.
|
|
|
|
bool
|
2024-08-10 10:47:02 +00:00
|
|
|
QPDF::Xref_table::read_entry(qpdf_offset_t& f1, int& f2, char& type)
|
2024-03-07 12:02:47 +00:00
|
|
|
{
|
|
|
|
std::array<char, 21> line;
|
2024-08-12 11:22:58 +00:00
|
|
|
if (file->read(line.data(), 20) != 20) {
|
2024-03-07 12:02:47 +00:00
|
|
|
// C++20: [[unlikely]]
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
line[20] = '\0';
|
|
|
|
char const* p = line.data();
|
|
|
|
|
|
|
|
int f1_len = 0;
|
|
|
|
int f2_len = 0;
|
|
|
|
|
|
|
|
// is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
|
|
|
|
// buffer.
|
|
|
|
|
|
|
|
// Gather f1 digits. NB No risk of overflow as 9'999'999'999 < max long long.
|
|
|
|
while (*p == '0') {
|
|
|
|
++f1_len;
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
while (QUtil::is_digit(*p) && f1_len++ < 10) {
|
|
|
|
f1 *= 10;
|
|
|
|
f1 += *p++ - '0';
|
|
|
|
}
|
|
|
|
// Require space
|
|
|
|
if (!QUtil::is_space(*p++)) {
|
|
|
|
// Entry doesn't start with space or digit.
|
|
|
|
// C++20: [[unlikely]]
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Gather digits. NB No risk of overflow as 99'999 < max int.
|
|
|
|
while (*p == '0') {
|
|
|
|
++f2_len;
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
while (QUtil::is_digit(*p) && f2_len++ < 5) {
|
|
|
|
f2 *= 10;
|
|
|
|
f2 += static_cast<int>(*p++ - '0');
|
|
|
|
}
|
|
|
|
if (QUtil::is_space(*p++) && (*p == 'f' || *p == 'n')) {
|
|
|
|
// C++20: [[likely]]
|
|
|
|
type = *p;
|
2024-06-26 11:20:46 +00:00
|
|
|
// No test for valid line[19].
|
|
|
|
if (*(++p) && *(++p) && (*p == '\n' || *p == '\r') && f1_len == 10 && f2_len == 5) {
|
2024-03-07 12:02:47 +00:00
|
|
|
// C++20: [[likely]]
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2024-08-10 10:47:02 +00:00
|
|
|
return read_bad_entry(f1, f2, type);
|
2024-03-07 12:02:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read a single cross-reference table section and associated trailer.
|
2012-06-23 19:08:21 +00:00
|
|
|
qpdf_offset_t
|
2024-08-10 10:47:02 +00:00
|
|
|
QPDF::Xref_table::read_table(qpdf_offset_t xref_offset)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(xref_offset, SEEK_SET);
|
2024-03-07 12:02:47 +00:00
|
|
|
std::string line;
|
|
|
|
while (true) {
|
|
|
|
line.assign(50, '\0');
|
2024-08-12 11:22:58 +00:00
|
|
|
file->read(line.data(), line.size());
|
2017-08-10 23:37:05 +00:00
|
|
|
int obj = 0;
|
|
|
|
int num = 0;
|
|
|
|
int bytes = 0;
|
2024-08-10 10:47:02 +00:00
|
|
|
if (!parse_first(line, obj, num, bytes)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF invalid xref");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw damaged_table("xref syntax invalid");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(file->getLastOffset() + bytes, SEEK_SET);
|
2022-02-08 14:18:08 +00:00
|
|
|
for (qpdf_offset_t i = obj; i - num < obj; ++i) {
|
|
|
|
if (i == 0) {
|
|
|
|
// This is needed by checkLinearization()
|
2024-08-12 11:22:58 +00:00
|
|
|
first_item_offset = file->tell();
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2017-08-10 23:37:05 +00:00
|
|
|
// For xref_table, these will always be small enough to be ints
|
2022-02-08 14:18:08 +00:00
|
|
|
qpdf_offset_t f1 = 0;
|
|
|
|
int f2 = 0;
|
|
|
|
char type = '\0';
|
2024-08-10 10:47:02 +00:00
|
|
|
if (!read_entry(f1, f2, type)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF invalid xref entry");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw damaged_table("invalid xref entry (obj=" + std::to_string(i) + ")");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
if (type == 'f') {
|
2024-08-10 10:47:02 +00:00
|
|
|
insert_free(QPDFObjGen(toI(i), f2));
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
2024-08-10 10:47:02 +00:00
|
|
|
insert(toI(i), 1, f1, f2);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
2024-08-12 11:22:58 +00:00
|
|
|
qpdf_offset_t pos = file->tell();
|
|
|
|
if (read_token().isWord("trailer")) {
|
2024-03-07 12:02:47 +00:00
|
|
|
break;
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
2024-08-12 11:22:58 +00:00
|
|
|
file->seek(pos, SEEK_SET);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set offset to previous xref table if any
|
2024-08-12 15:01:37 +00:00
|
|
|
auto cur_trailer = read_trailer();
|
2008-04-29 12:55:25 +00:00
|
|
|
if (!cur_trailer.isDictionary()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF missing trailer");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw qpdf.damagedPDF("", "expected trailer dictionary");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-08-10 10:47:02 +00:00
|
|
|
if (!trailer) {
|
|
|
|
trailer = cur_trailer;
|
2022-02-08 14:18:08 +00:00
|
|
|
|
2024-08-10 10:47:02 +00:00
|
|
|
if (!trailer.hasKey("/Size")) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF trailer lacks size");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw qpdf.damagedPDF("trailer", "trailer dictionary lacks /Size key");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-08-10 10:47:02 +00:00
|
|
|
if (!trailer.getKey("/Size").isInteger()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF trailer size not integer");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw qpdf.damagedPDF("trailer", "/Size key in trailer dictionary is not an integer");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_trailer.hasKey("/XRefStm")) {
|
2024-08-10 10:47:02 +00:00
|
|
|
if (ignore_streams) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF ignoring XRefStm in trailer");
|
|
|
|
} else {
|
|
|
|
if (cur_trailer.getKey("/XRefStm").isInteger()) {
|
|
|
|
// Read the xref stream but disregard any return value -- we'll use our trailer's
|
|
|
|
// /Prev key instead of the xref stream's.
|
2024-08-10 11:17:01 +00:00
|
|
|
(void)read_stream(cur_trailer.getKey("/XRefStm").getIntValue());
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
2024-08-10 10:47:02 +00:00
|
|
|
throw qpdf.damagedPDF("xref stream", xref_offset, "invalid /XRefStm");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_trailer.hasKey("/Prev")) {
|
2022-02-08 14:18:08 +00:00
|
|
|
if (!cur_trailer.getKey("/Prev").isInteger()) {
|
|
|
|
QTC::TC("qpdf", "QPDF trailer prev not integer");
|
2024-08-10 10:47:02 +00:00
|
|
|
throw qpdf.damagedPDF("trailer", "/Prev key in trailer dictionary is not an integer");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
QTC::TC("qpdf", "QPDF prev key in trailer dictionary");
|
2024-08-16 14:58:55 +00:00
|
|
|
return cur_trailer.getKey("/Prev").getIntValue();
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-08-16 14:58:55 +00:00
|
|
|
return 0;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-03-07 12:02:47 +00:00
|
|
|
// Read a single cross-reference stream.
|
2012-06-23 19:08:21 +00:00
|
|
|
qpdf_offset_t
|
2024-08-10 11:17:01 +00:00
|
|
|
QPDF::Xref_table::read_stream(qpdf_offset_t xref_offset)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2024-08-10 11:17:01 +00:00
|
|
|
if (!ignore_streams) {
|
2022-07-23 12:47:18 +00:00
|
|
|
QPDFObjGen x_og;
|
2022-02-08 14:18:08 +00:00
|
|
|
QPDFObjectHandle xref_obj;
|
|
|
|
try {
|
2024-08-10 11:17:01 +00:00
|
|
|
xref_obj = qpdf.readObjectAtOffset(
|
|
|
|
false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og, true);
|
2022-02-08 14:18:08 +00:00
|
|
|
} catch (QPDFExc&) {
|
|
|
|
// ignore -- report error below
|
|
|
|
}
|
2022-01-26 08:00:23 +00:00
|
|
|
if (xref_obj.isStreamOfType("/XRef")) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF found xref stream");
|
2024-08-10 11:17:01 +00:00
|
|
|
return process_stream(xref_offset, xref_obj);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2023-07-04 16:07:44 +00:00
|
|
|
QTC::TC("qpdf", "QPDF can't find xref");
|
2024-08-10 11:17:01 +00:00
|
|
|
throw qpdf.damagedPDF("", xref_offset, "xref not found");
|
2023-07-04 16:07:44 +00:00
|
|
|
return 0; // unreachable
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-05-22 11:36:01 +00:00
|
|
|
// Return the entry size of the xref stream and the processed W array.
|
2024-05-22 14:36:45 +00:00
|
|
|
std::pair<int, std::array<int, 3>>
|
2024-08-10 11:17:01 +00:00
|
|
|
QPDF::Xref_table::process_W(
|
|
|
|
QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2024-05-22 11:36:01 +00:00
|
|
|
auto W_obj = dict.getKey("/W");
|
2024-08-10 11:17:01 +00:00
|
|
|
if (!(W_obj.isArray() && W_obj.getArrayNItems() >= 3 && W_obj.getArrayItem(0).isInteger() &&
|
2024-05-22 11:36:01 +00:00
|
|
|
W_obj.getArrayItem(1).isInteger() && W_obj.getArrayItem(2).isInteger())) {
|
|
|
|
throw damaged("Cross-reference stream does not have a proper /W key");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2013-10-05 16:28:52 +00:00
|
|
|
|
2024-05-22 11:36:01 +00:00
|
|
|
std::array<int, 3> W;
|
|
|
|
int entry_size = 0;
|
|
|
|
auto w_vector = W_obj.getArrayAsVector();
|
2013-10-05 16:28:52 +00:00
|
|
|
int max_bytes = sizeof(qpdf_offset_t);
|
2024-05-22 11:36:01 +00:00
|
|
|
for (size_t i = 0; i < 3; ++i) {
|
|
|
|
W[i] = w_vector[i].getIntValueAsInt();
|
2013-10-05 16:28:52 +00:00
|
|
|
if (W[i] > max_bytes) {
|
2024-05-22 11:36:01 +00:00
|
|
|
throw damaged("Cross-reference stream's /W contains impossibly large values");
|
2013-10-05 16:28:52 +00:00
|
|
|
}
|
2024-05-22 11:36:01 +00:00
|
|
|
if (W[i] < 0) {
|
|
|
|
throw damaged("Cross-reference stream's /W contains negative values");
|
|
|
|
}
|
|
|
|
entry_size += W[i];
|
2013-10-05 16:28:52 +00:00
|
|
|
}
|
2017-08-12 00:10:28 +00:00
|
|
|
if (entry_size == 0) {
|
2024-05-22 11:36:01 +00:00
|
|
|
throw damaged("Cross-reference stream's /W indicates entry size of 0");
|
2017-08-12 00:10:28 +00:00
|
|
|
}
|
2024-05-22 14:36:45 +00:00
|
|
|
return {entry_size, W};
|
2024-05-22 11:36:01 +00:00
|
|
|
}
|
|
|
|
|
2024-05-22 14:36:45 +00:00
|
|
|
// Validate Size key and return the maximum number of entries that the xref stream can contain.
|
|
|
|
int
|
2024-08-10 11:17:01 +00:00
|
|
|
QPDF::Xref_table::process_Size(
|
2024-05-22 14:36:45 +00:00
|
|
|
QPDFObjectHandle& dict, int entry_size, std::function<QPDFExc(std::string_view)> damaged)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2024-05-22 14:36:45 +00:00
|
|
|
// Number of entries is limited by the highest possible object id and stream size.
|
|
|
|
auto max_num_entries = std::numeric_limits<int>::max();
|
|
|
|
if (max_num_entries > (std::numeric_limits<qpdf_offset_t>::max() / entry_size)) {
|
|
|
|
max_num_entries = toI(std::numeric_limits<qpdf_offset_t>::max() / entry_size);
|
|
|
|
}
|
2024-05-22 10:09:46 +00:00
|
|
|
|
2024-05-21 19:26:36 +00:00
|
|
|
auto Size_obj = dict.getKey("/Size");
|
2024-05-22 14:36:45 +00:00
|
|
|
long long size;
|
|
|
|
if (!dict.getKey("/Size").getValueAsInt(size)) {
|
|
|
|
throw damaged("Cross-reference stream does not have a proper /Size key");
|
|
|
|
} else if (size < 0) {
|
|
|
|
throw damaged("Cross-reference stream has a negative /Size key");
|
|
|
|
} else if (size >= max_num_entries) {
|
|
|
|
throw damaged("Cross-reference stream has an impossibly large /Size key");
|
|
|
|
}
|
|
|
|
// We are not validating that Size <= (Size key of parent xref / trailer).
|
|
|
|
return max_num_entries;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the number of entries of the xref stream and the processed Index array.
|
2024-05-21 20:28:58 +00:00
|
|
|
std::pair<int, std::vector<std::pair<int, int>>>
|
2024-08-10 11:17:01 +00:00
|
|
|
QPDF::Xref_table::process_Index(
|
2024-05-22 14:36:45 +00:00
|
|
|
QPDFObjectHandle& dict, int max_num_entries, std::function<QPDFExc(std::string_view)> damaged)
|
|
|
|
{
|
|
|
|
auto size = dict.getKey("/Size").getIntValueAsInt();
|
2024-05-22 10:09:46 +00:00
|
|
|
auto Index_obj = dict.getKey("/Index");
|
2013-10-05 16:28:52 +00:00
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
if (Index_obj.isArray()) {
|
2024-05-21 20:28:58 +00:00
|
|
|
std::vector<std::pair<int, int>> indx;
|
|
|
|
int num_entries = 0;
|
|
|
|
auto index_vec = Index_obj.getArrayAsVector();
|
|
|
|
if ((index_vec.size() % 2) || index_vec.size() < 2) {
|
2024-05-22 10:09:46 +00:00
|
|
|
throw damaged("Cross-reference stream's /Index has an invalid number of values");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-05-21 20:28:58 +00:00
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
long long first = 0;
|
|
|
|
for (auto& val: index_vec) {
|
|
|
|
if (val.isInteger()) {
|
|
|
|
if (i % 2) {
|
|
|
|
auto count = val.getIntValue();
|
2024-07-06 15:09:50 +00:00
|
|
|
if (count <= 0) {
|
|
|
|
throw damaged(
|
|
|
|
"Cross-reference stream section claims to contain " +
|
|
|
|
std::to_string(count) + " entries");
|
|
|
|
}
|
2024-05-21 20:28:58 +00:00
|
|
|
// We are guarding against the possibility of num_entries * entry_size
|
|
|
|
// overflowing. We are not checking that entries are in ascending order as
|
|
|
|
// required by the spec, which probably should generate a warning. We are also
|
|
|
|
// not checking that for each subsection first object number + number of entries
|
|
|
|
// <= /Size. The spec requires us to ignore object number > /Size.
|
|
|
|
if (first > (max_num_entries - count) ||
|
|
|
|
count > (max_num_entries - num_entries)) {
|
|
|
|
throw damaged(
|
|
|
|
"Cross-reference stream claims to contain too many entries: " +
|
|
|
|
std::to_string(first) + " " + std::to_string(max_num_entries) + " " +
|
|
|
|
std::to_string(num_entries));
|
|
|
|
}
|
|
|
|
indx.emplace_back(static_cast<int>(first), static_cast<int>(count));
|
|
|
|
num_entries += static_cast<int>(count);
|
|
|
|
} else {
|
|
|
|
first = val.getIntValue();
|
|
|
|
if (first < 0) {
|
|
|
|
throw damaged(
|
|
|
|
"Cross-reference stream's /Index contains a negative object id");
|
|
|
|
} else if (first > max_num_entries) {
|
|
|
|
throw damaged("Cross-reference stream's /Index contains an impossibly "
|
|
|
|
"large object id");
|
|
|
|
}
|
|
|
|
}
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
2024-05-22 10:09:46 +00:00
|
|
|
throw damaged(
|
|
|
|
"Cross-reference stream's /Index's item " + std::to_string(i) +
|
|
|
|
" is not an integer");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-05-21 20:28:58 +00:00
|
|
|
i++;
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-05-21 20:28:58 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref /Index is array", index_vec.size() == 2 ? 0 : 1);
|
|
|
|
return {num_entries, indx};
|
|
|
|
} else if (Index_obj.isNull()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref /Index is null");
|
2024-05-21 20:28:58 +00:00
|
|
|
return {size, {{0, size}}};
|
|
|
|
} else {
|
|
|
|
throw damaged("Cross-reference stream does not have a proper /Index key");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2024-05-21 19:26:36 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-05-21 19:26:36 +00:00
|
|
|
qpdf_offset_t
|
2024-08-10 11:17:01 +00:00
|
|
|
QPDF::Xref_table::process_stream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
|
2024-05-21 19:26:36 +00:00
|
|
|
{
|
|
|
|
auto damaged = [this, xref_offset](std::string_view msg) -> QPDFExc {
|
2024-08-10 11:17:01 +00:00
|
|
|
return qpdf.damagedPDF("xref stream", xref_offset, msg.data());
|
2024-05-21 19:26:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
auto dict = xref_obj.getDict();
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-10 11:17:01 +00:00
|
|
|
auto [entry_size, W] = process_W(dict, damaged);
|
|
|
|
int max_num_entries = process_Size(dict, entry_size, damaged);
|
|
|
|
auto [num_entries, indx] = process_Index(dict, max_num_entries, damaged);
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<Buffer> bp = xref_obj.getStreamData(qpdf_dl_specialized);
|
2012-06-20 15:20:57 +00:00
|
|
|
size_t actual_size = bp->getSize();
|
2024-05-22 14:36:45 +00:00
|
|
|
auto expected_size = toS(entry_size) * toS(num_entries);
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
if (expected_size != actual_size) {
|
2024-05-21 19:26:36 +00:00
|
|
|
QPDFExc x = damaged(
|
|
|
|
"Cross-reference stream data has the wrong size; expected = " +
|
|
|
|
std::to_string(expected_size) + "; actual = " + std::to_string(actual_size));
|
2022-02-08 14:18:08 +00:00
|
|
|
if (expected_size > actual_size) {
|
|
|
|
throw x;
|
|
|
|
} else {
|
2024-08-10 11:17:01 +00:00
|
|
|
qpdf.warn(x);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool saw_first_compressed_object = false;
|
|
|
|
|
2013-10-05 16:28:52 +00:00
|
|
|
// Actual size vs. expected size check above ensures that we will not overflow any buffers here.
|
2024-05-21 18:06:24 +00:00
|
|
|
// We know that entry_size * num_entries is less or equal to the size of the buffer.
|
|
|
|
auto p = bp->getBuffer();
|
2024-05-21 20:28:58 +00:00
|
|
|
for (auto [obj, sec_entries]: indx) {
|
2024-05-21 18:46:13 +00:00
|
|
|
// Process a subsection.
|
2024-05-21 20:28:58 +00:00
|
|
|
for (int i = 0; i < sec_entries; ++i) {
|
2024-05-21 18:46:13 +00:00
|
|
|
// Read this entry
|
2024-05-21 20:28:58 +00:00
|
|
|
std::array<qpdf_offset_t, 3> fields{};
|
|
|
|
if (W[0] == 0) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF default for xref stream field 0");
|
|
|
|
fields[0] = 1;
|
|
|
|
}
|
2024-05-22 11:36:01 +00:00
|
|
|
for (size_t j = 0; j < 3; ++j) {
|
2024-05-21 18:46:13 +00:00
|
|
|
for (int k = 0; k < W[j]; ++k) {
|
|
|
|
fields[j] <<= 8;
|
|
|
|
fields[j] |= *p++;
|
|
|
|
}
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
|
2024-05-21 18:46:13 +00:00
|
|
|
// Get the generation number. The generation number is 0 unless this is an uncompressed
|
|
|
|
// object record, in which case the generation number appears as the third field.
|
|
|
|
if (saw_first_compressed_object) {
|
|
|
|
if (fields[0] != 2) {
|
2024-08-10 11:17:01 +00:00
|
|
|
uncompressed_after_compressed = true;
|
2024-05-21 18:46:13 +00:00
|
|
|
}
|
|
|
|
} else if (fields[0] == 2) {
|
|
|
|
saw_first_compressed_object = true;
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-05-21 18:46:13 +00:00
|
|
|
if (obj == 0) {
|
|
|
|
// This is needed by checkLinearization()
|
2024-08-10 11:17:01 +00:00
|
|
|
first_item_offset = xref_offset;
|
2024-05-21 18:46:13 +00:00
|
|
|
} else if (fields[0] == 0) {
|
|
|
|
// Ignore fields[2], which we don't care about in this case. This works around the
|
|
|
|
// issue of some PDF files that put invalid values, like -1, here for deleted
|
|
|
|
// objects.
|
2024-08-10 11:17:01 +00:00
|
|
|
insert_free(QPDFObjGen(obj, 0));
|
2024-05-21 18:46:13 +00:00
|
|
|
} else {
|
2024-08-10 11:17:01 +00:00
|
|
|
insert(obj, toI(fields[0]), fields[1], toI(fields[2]));
|
2024-05-21 18:46:13 +00:00
|
|
|
}
|
|
|
|
++obj;
|
2020-11-04 12:46:46 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-08-10 11:17:01 +00:00
|
|
|
if (!trailer) {
|
|
|
|
trailer = dict;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dict.hasKey("/Prev")) {
|
2022-02-08 14:18:08 +00:00
|
|
|
if (!dict.getKey("/Prev").isInteger()) {
|
2024-08-10 11:17:01 +00:00
|
|
|
throw qpdf.damagedPDF(
|
2022-09-28 11:25:52 +00:00
|
|
|
"xref stream", "/Prev key in xref stream dictionary is not an integer");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
QTC::TC("qpdf", "QPDF prev key in xref stream dictionary");
|
2024-05-21 20:28:58 +00:00
|
|
|
return dict.getKey("/Prev").getIntValue();
|
2008-04-29 12:55:25 +00:00
|
|
|
} else {
|
2024-05-21 20:28:58 +00:00
|
|
|
return 0;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2024-08-09 13:14:56 +00:00
|
|
|
QPDF::Xref_table::insert(int obj, int f0, qpdf_offset_t f1, int f2)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
|
|
|
// Populate the xref table in such a way that the first reference to an object that we see,
|
2009-02-21 02:31:32 +00:00
|
|
|
// which is the one in the latest xref table in which it appears, is the one that gets stored.
|
2023-07-04 13:24:30 +00:00
|
|
|
// This works because we are reading more recent appends before older ones.
|
2023-05-24 15:28:17 +00:00
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
// If there is already an entry for this object and generation in the table, it means that a
|
|
|
|
// later xref table has registered this object. Disregard this one.
|
2023-07-04 13:24:30 +00:00
|
|
|
|
2024-08-09 13:14:56 +00:00
|
|
|
if (obj > max_id) {
|
2024-07-01 17:11:51 +00:00
|
|
|
// ignore impossibly large object ids or object ids > Size.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2024-08-09 13:14:56 +00:00
|
|
|
if (deleted_objects.count(obj)) {
|
2023-07-04 13:24:30 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref deleted object");
|
|
|
|
return;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2024-07-01 17:11:51 +00:00
|
|
|
if (f0 == 2 && static_cast<int>(f1) == obj) {
|
2024-08-09 13:14:56 +00:00
|
|
|
qpdf.warn(qpdf.damagedPDF(
|
|
|
|
"xref stream", "self-referential object stream " + std::to_string(obj)));
|
2024-07-01 17:11:51 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2024-08-09 13:14:56 +00:00
|
|
|
auto [iter, created] = try_emplace(QPDFObjGen(obj, (f0 == 2 ? 0 : f2)));
|
2023-07-04 15:34:22 +00:00
|
|
|
if (!created) {
|
|
|
|
QTC::TC("qpdf", "QPDF xref reused object");
|
|
|
|
return;
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2023-07-04 15:34:22 +00:00
|
|
|
switch (f0) {
|
2008-04-29 12:55:25 +00:00
|
|
|
case 1:
|
2022-02-08 14:18:08 +00:00
|
|
|
// f2 is generation
|
|
|
|
QTC::TC("qpdf", "QPDF xref gen > 0", ((f2 > 0) ? 1 : 0));
|
2023-07-04 15:34:22 +00:00
|
|
|
iter->second = QPDFXRefEntry(f1);
|
2022-02-08 14:18:08 +00:00
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
case 2:
|
2023-07-04 15:34:22 +00:00
|
|
|
iter->second = QPDFXRefEntry(toI(f1), f2);
|
2022-02-08 14:18:08 +00:00
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
default:
|
2024-08-09 13:14:56 +00:00
|
|
|
throw qpdf.damagedPDF(
|
|
|
|
"xref stream", "unknown xref stream entry type " + std::to_string(f0));
|
2022-02-08 14:18:08 +00:00
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
2023-07-04 13:01:03 +00:00
|
|
|
|
2023-07-04 15:34:22 +00:00
|
|
|
void
|
2024-08-09 13:14:56 +00:00
|
|
|
QPDF::Xref_table::insert_free(QPDFObjGen og)
|
2023-07-04 15:34:22 +00:00
|
|
|
{
|
2024-08-09 13:14:56 +00:00
|
|
|
if (!count(og)) {
|
|
|
|
deleted_objects.insert(og.getObj());
|
2023-07-04 15:34:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-04 13:01:03 +00:00
|
|
|
// Replace uncompressed object. This is used in xref recovery mode, which reads the file from
|
|
|
|
// beginning to end.
|
|
|
|
void
|
2024-08-09 13:14:56 +00:00
|
|
|
QPDF::Xref_table::insert_reconstructed(int obj, qpdf_offset_t f1, int f2)
|
2023-07-04 13:01:03 +00:00
|
|
|
{
|
2024-08-09 13:14:56 +00:00
|
|
|
if (!(obj > 0 && obj <= max_id && 0 <= f2 && f2 < 65535)) {
|
2024-01-17 14:07:37 +00:00
|
|
|
QTC::TC("qpdf", "QPDF xref overwrite invalid objgen");
|
|
|
|
return;
|
|
|
|
}
|
2024-07-01 17:11:51 +00:00
|
|
|
|
2023-07-04 13:01:03 +00:00
|
|
|
QPDFObjGen og(obj, f2);
|
2024-08-09 13:14:56 +00:00
|
|
|
if (!deleted_objects.count(obj)) {
|
2023-07-04 13:01:03 +00:00
|
|
|
// deleted_objects stores the uncompressed objects removed from the xref table at the start
|
|
|
|
// of recovery.
|
|
|
|
QTC::TC("qpdf", "QPDF xref overwrite object");
|
2024-08-09 13:14:56 +00:00
|
|
|
insert_or_assign(QPDFObjGen(obj, f2), QPDFXRefEntry(f1));
|
2023-07-04 13:01:03 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::showXRefTable()
|
|
|
|
{
|
2024-08-12 13:53:38 +00:00
|
|
|
m->xref_table.show();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::Xref_table::show()
|
|
|
|
{
|
|
|
|
auto& cout = *qpdf.m->log->getInfo();
|
|
|
|
for (auto const& iter: *this) {
|
2022-04-30 17:23:18 +00:00
|
|
|
QPDFObjGen const& og = iter.first;
|
|
|
|
QPDFXRefEntry const& entry = iter.second;
|
2022-07-23 15:48:28 +00:00
|
|
|
cout << og.unparse('/') << ": ";
|
2022-02-08 14:18:08 +00:00
|
|
|
switch (entry.getType()) {
|
|
|
|
case 1:
|
2024-08-12 13:53:38 +00:00
|
|
|
cout << "uncompressed; offset = " << entry.getOffset() << "\n";
|
2022-02-08 14:18:08 +00:00
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-02-08 14:18:08 +00:00
|
|
|
case 2:
|
2024-08-12 13:53:38 +00:00
|
|
|
cout << "compressed; stream = " << entry.getObjStreamNumber()
|
|
|
|
<< ", index = " << entry.getObjStreamIndex() << "\n";
|
2022-02-08 14:18:08 +00:00
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-02-08 14:18:08 +00:00
|
|
|
default:
|
2024-08-10 11:17:01 +00:00
|
|
|
throw std::logic_error("unknown cross-reference table type while showing xref_table");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-24 16:50:46 +00:00
|
|
|
// Resolve all objects in the xref table. If this triggers a xref table reconstruction abort and
|
|
|
|
// return false. Otherwise return true.
|
|
|
|
bool
|
2024-08-12 13:58:14 +00:00
|
|
|
QPDF::Xref_table::resolve()
|
2019-01-04 15:17:33 +00:00
|
|
|
{
|
2024-08-12 13:58:14 +00:00
|
|
|
bool may_change = !reconstructed;
|
|
|
|
for (auto& iter: *this) {
|
|
|
|
if (qpdf.isUnresolved(iter.first)) {
|
|
|
|
qpdf.resolve(iter.first);
|
|
|
|
if (may_change && reconstructed) {
|
2022-11-24 16:50:46 +00:00
|
|
|
return false;
|
|
|
|
}
|
2019-01-04 15:17:33 +00:00
|
|
|
}
|
|
|
|
}
|
2022-11-24 16:50:46 +00:00
|
|
|
return true;
|
|
|
|
}
|
2022-11-26 21:43:41 +00:00
|
|
|
|
2022-11-24 16:50:46 +00:00
|
|
|
// Ensure all objects in the pdf file, including those in indirect references, appear in the object
|
|
|
|
// cache.
|
|
|
|
void
|
|
|
|
QPDF::fixDanglingReferences(bool force)
|
|
|
|
{
|
|
|
|
if (m->fixed_dangling_refs) {
|
|
|
|
return;
|
2022-11-26 21:43:41 +00:00
|
|
|
}
|
2024-08-12 13:58:14 +00:00
|
|
|
if (!m->xref_table.resolve()) {
|
2022-11-26 21:43:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF fix dangling triggered xref reconstruction");
|
2024-08-12 13:58:14 +00:00
|
|
|
m->xref_table.resolve();
|
2022-11-24 16:50:46 +00:00
|
|
|
}
|
2022-11-24 16:50:46 +00:00
|
|
|
m->fixed_dangling_refs = true;
|
2019-01-04 15:17:33 +00:00
|
|
|
}
|
|
|
|
|
2018-06-22 18:52:03 +00:00
|
|
|
size_t
|
|
|
|
QPDF::getObjectCount()
|
|
|
|
{
|
|
|
|
// This method returns the next available indirect object number. makeIndirectObject uses it for
|
2019-01-04 15:17:33 +00:00
|
|
|
// this purpose. After fixDanglingReferences is called, all objects in the xref table will also
|
|
|
|
// be in obj_cache.
|
|
|
|
fixDanglingReferences();
|
2022-09-14 11:35:32 +00:00
|
|
|
QPDFObjGen og;
|
2018-06-22 18:52:03 +00:00
|
|
|
if (!m->obj_cache.empty()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
og = (*(m->obj_cache.rbegin())).first;
|
2018-06-22 18:52:03 +00:00
|
|
|
}
|
2019-06-21 03:35:23 +00:00
|
|
|
return toS(og.getObj());
|
2018-06-22 18:52:03 +00:00
|
|
|
}
|
|
|
|
|
2017-07-28 23:18:57 +00:00
|
|
|
std::vector<QPDFObjectHandle>
|
|
|
|
QPDF::getAllObjects()
|
|
|
|
{
|
2019-01-04 15:17:33 +00:00
|
|
|
// After fixDanglingReferences is called, all objects are in the object cache.
|
2022-11-24 16:50:46 +00:00
|
|
|
fixDanglingReferences();
|
2017-07-28 23:18:57 +00:00
|
|
|
std::vector<QPDFObjectHandle> result;
|
2022-04-30 17:23:18 +00:00
|
|
|
for (auto const& iter: m->obj_cache) {
|
2022-08-02 15:20:24 +00:00
|
|
|
result.push_back(newIndirect(iter.first, iter.second.object));
|
2017-07-28 23:18:57 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2009-10-19 23:09:19 +00:00
|
|
|
void
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::setLastObjectDescription(std::string const& description, QPDFObjGen const& og)
|
2009-10-19 23:09:19 +00:00
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
m->last_object_description.clear();
|
2009-10-19 23:09:19 +00:00
|
|
|
if (!description.empty()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
m->last_object_description += description;
|
2022-07-23 15:48:28 +00:00
|
|
|
if (og.isIndirect()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
m->last_object_description += ": ";
|
|
|
|
}
|
2009-10-19 23:09:19 +00:00
|
|
|
}
|
2022-07-23 15:48:28 +00:00
|
|
|
if (og.isIndirect()) {
|
|
|
|
m->last_object_description += "object " + og.unparse(' ');
|
2009-10-19 23:09:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-07 23:38:50 +00:00
|
|
|
QPDFObjectHandle
|
2024-08-12 15:01:37 +00:00
|
|
|
QPDF::Xref_table::read_trailer()
|
2023-07-07 23:38:50 +00:00
|
|
|
{
|
2024-08-12 15:01:37 +00:00
|
|
|
qpdf_offset_t offset = file->tell();
|
2023-07-07 23:38:50 +00:00
|
|
|
bool empty = false;
|
2024-07-25 09:22:35 +00:00
|
|
|
auto object =
|
2024-08-12 15:01:37 +00:00
|
|
|
QPDFParser(*qpdf.m->file, "trailer", *tokenizer, nullptr, &qpdf, true).parse(empty, false);
|
2023-07-07 23:38:50 +00:00
|
|
|
if (empty) {
|
|
|
|
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
|
|
|
|
// actual PDF files and Adobe Reader appears to ignore them.
|
2024-08-12 15:01:37 +00:00
|
|
|
qpdf.warn(qpdf.damagedPDF("trailer", "empty object treated as null"));
|
|
|
|
} else if (object.isDictionary() && read_token().isWord("stream")) {
|
|
|
|
qpdf.warn(qpdf.damagedPDF("trailer", file->tell(), "stream keyword found in trailer"));
|
2023-07-07 23:38:50 +00:00
|
|
|
}
|
|
|
|
// Override last_offset so that it points to the beginning of the object we just read
|
2024-08-12 15:01:37 +00:00
|
|
|
file->setLastOffset(offset);
|
2023-07-07 23:38:50 +00:00
|
|
|
return object;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDFObjectHandle
|
2023-07-07 19:37:13 +00:00
|
|
|
QPDF::readObject(std::string const& description, QPDFObjGen og)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2022-07-23 15:48:28 +00:00
|
|
|
setLastObjectDescription(description, og);
|
2023-07-07 19:37:13 +00:00
|
|
|
qpdf_offset_t offset = m->file->tell();
|
2012-07-21 13:00:06 +00:00
|
|
|
bool empty = false;
|
2023-07-08 15:20:01 +00:00
|
|
|
|
|
|
|
StringDecrypter decrypter{this, og};
|
|
|
|
StringDecrypter* decrypter_ptr = m->encp->encrypted ? &decrypter : nullptr;
|
2024-07-25 09:22:35 +00:00
|
|
|
auto object =
|
2024-08-23 09:38:36 +00:00
|
|
|
QPDFParser(*m->file, m->last_object_description, m->tokenizer, decrypter_ptr, this, true)
|
2024-07-25 09:22:35 +00:00
|
|
|
.parse(empty, false);
|
2012-07-21 13:00:06 +00:00
|
|
|
if (empty) {
|
|
|
|
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
|
|
|
|
// actual PDF files and Adobe Reader appears to ignore them.
|
2024-08-21 10:14:39 +00:00
|
|
|
warn(damagedPDF(*m->file, m->file->getLastOffset(), "empty object treated as null"));
|
2023-07-08 15:20:01 +00:00
|
|
|
return object;
|
|
|
|
}
|
2024-08-21 23:30:18 +00:00
|
|
|
auto token = readToken(*m->file);
|
2023-07-08 15:20:01 +00:00
|
|
|
if (object.isDictionary() && token.isWord("stream")) {
|
|
|
|
readStream(object, og, offset);
|
2024-08-21 23:30:18 +00:00
|
|
|
token = readToken(*m->file);
|
2023-07-08 15:20:01 +00:00
|
|
|
}
|
|
|
|
if (!token.isWord("endobj")) {
|
|
|
|
QTC::TC("qpdf", "QPDF err expected endobj");
|
|
|
|
warn(damagedPDF("expected endobj"));
|
2023-07-08 10:38:23 +00:00
|
|
|
}
|
|
|
|
return object;
|
|
|
|
}
|
|
|
|
|
|
|
|
// After reading stream dictionary and stream keyword, read rest of stream.
|
|
|
|
void
|
|
|
|
QPDF::readStream(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
|
2023-07-08 11:17:48 +00:00
|
|
|
{
|
|
|
|
validateStreamLineEnd(object, og, offset);
|
|
|
|
|
|
|
|
// Must get offset before accessing any additional objects since resolving a previously
|
|
|
|
// unresolved indirect object will change file position.
|
|
|
|
qpdf_offset_t stream_offset = m->file->tell();
|
|
|
|
size_t length = 0;
|
|
|
|
|
|
|
|
try {
|
|
|
|
auto length_obj = object.getKey("/Length");
|
|
|
|
|
|
|
|
if (!length_obj.isInteger()) {
|
|
|
|
if (length_obj.isNull()) {
|
|
|
|
QTC::TC("qpdf", "QPDF stream without length");
|
|
|
|
throw damagedPDF(offset, "stream dictionary lacks /Length key");
|
|
|
|
}
|
|
|
|
QTC::TC("qpdf", "QPDF stream length not integer");
|
|
|
|
throw damagedPDF(offset, "/Length key in stream dictionary is not an integer");
|
|
|
|
}
|
|
|
|
|
|
|
|
length = toS(length_obj.getUIntValue());
|
|
|
|
// Seek in two steps to avoid potential integer overflow
|
|
|
|
m->file->seek(stream_offset, SEEK_SET);
|
|
|
|
m->file->seek(toO(length), SEEK_CUR);
|
2024-08-21 23:30:18 +00:00
|
|
|
if (!readToken(*m->file).isWord("endstream")) {
|
2023-07-08 11:17:48 +00:00
|
|
|
QTC::TC("qpdf", "QPDF missing endstream");
|
|
|
|
throw damagedPDF("expected endstream");
|
|
|
|
}
|
|
|
|
} catch (QPDFExc& e) {
|
|
|
|
if (m->attempt_recovery) {
|
|
|
|
warn(e);
|
2024-09-05 13:50:38 +00:00
|
|
|
length = recoverStreamLength(m->file_sp, og, stream_offset);
|
2023-07-08 11:17:48 +00:00
|
|
|
} else {
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
2024-09-04 12:10:17 +00:00
|
|
|
object = {QPDF_Stream::create(this, og, object, stream_offset, length)};
|
2023-07-08 11:17:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::validateStreamLineEnd(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
|
2023-07-08 10:38:23 +00:00
|
|
|
{
|
|
|
|
// The PDF specification states that the word "stream" should be followed by either a carriage
|
|
|
|
// return and a newline or by a newline alone. It specifically disallowed following it by a
|
|
|
|
// carriage return alone since, in that case, there would be no way to tell whether the NL in a
|
|
|
|
// CR NL sequence was part of the stream data. However, some readers, including Adobe reader,
|
|
|
|
// accept a carriage return by itself when followed by a non-newline character, so that's what
|
|
|
|
// we do here. We have also seen files that have extraneous whitespace between the stream
|
|
|
|
// keyword and the newline.
|
2023-07-08 10:53:48 +00:00
|
|
|
while (true) {
|
2023-07-08 10:38:23 +00:00
|
|
|
char ch;
|
|
|
|
if (m->file->read(&ch, 1) == 0) {
|
|
|
|
// A premature EOF here will result in some other problem that will get reported at
|
|
|
|
// another time.
|
2023-07-08 11:17:48 +00:00
|
|
|
return;
|
2023-07-08 10:53:48 +00:00
|
|
|
}
|
|
|
|
if (ch == '\n') {
|
2023-07-08 10:38:23 +00:00
|
|
|
// ready to read stream data
|
|
|
|
QTC::TC("qpdf", "QPDF stream with NL only");
|
2023-07-08 11:17:48 +00:00
|
|
|
return;
|
2023-07-08 10:53:48 +00:00
|
|
|
}
|
|
|
|
if (ch == '\r') {
|
2023-07-08 10:38:23 +00:00
|
|
|
// Read another character
|
|
|
|
if (m->file->read(&ch, 1) != 0) {
|
|
|
|
if (ch == '\n') {
|
|
|
|
// Ready to read stream data
|
|
|
|
QTC::TC("qpdf", "QPDF stream with CRNL");
|
2012-07-21 13:00:06 +00:00
|
|
|
} else {
|
2023-07-08 10:38:23 +00:00
|
|
|
// Treat the \r by itself as the whitespace after endstream and start reading
|
|
|
|
// stream data in spite of not having seen a newline.
|
|
|
|
QTC::TC("qpdf", "QPDF stream with CR only");
|
2023-07-07 19:37:13 +00:00
|
|
|
m->file->unreadCh(ch);
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF(
|
2023-07-08 10:38:23 +00:00
|
|
|
m->file->tell(), "stream keyword followed by carriage return only"));
|
2012-07-21 13:00:06 +00:00
|
|
|
}
|
|
|
|
}
|
2023-07-08 11:17:48 +00:00
|
|
|
return;
|
2023-07-08 10:53:48 +00:00
|
|
|
}
|
|
|
|
if (!QUtil::is_space(ch)) {
|
2023-07-08 10:38:23 +00:00
|
|
|
QTC::TC("qpdf", "QPDF stream without newline");
|
|
|
|
m->file->unreadCh(ch);
|
|
|
|
warn(damagedPDF(
|
|
|
|
m->file->tell(), "stream keyword not followed by proper line terminator"));
|
2023-07-08 11:17:48 +00:00
|
|
|
return;
|
2023-07-08 10:38:23 +00:00
|
|
|
}
|
2023-07-08 10:53:48 +00:00
|
|
|
warn(damagedPDF(m->file->tell(), "stream keyword followed by extraneous whitespace"));
|
2023-07-08 10:38:23 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2023-07-07 19:14:59 +00:00
|
|
|
QPDFObjectHandle
|
2023-07-08 13:04:10 +00:00
|
|
|
QPDF::readObjectInStream(std::shared_ptr<InputSource>& input, int obj)
|
2023-07-07 19:14:59 +00:00
|
|
|
{
|
2023-07-08 13:04:10 +00:00
|
|
|
m->last_object_description.erase(7); // last_object_description starts with "object "
|
|
|
|
m->last_object_description += std::to_string(obj);
|
|
|
|
m->last_object_description += " 0";
|
2023-07-07 19:14:59 +00:00
|
|
|
|
|
|
|
bool empty = false;
|
2024-08-23 09:38:36 +00:00
|
|
|
auto object = QPDFParser(*input, m->last_object_description, m->tokenizer, nullptr, this, true)
|
2023-07-07 19:14:59 +00:00
|
|
|
.parse(empty, false);
|
|
|
|
if (empty) {
|
|
|
|
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
|
|
|
|
// actual PDF files and Adobe Reader appears to ignore them.
|
2024-08-21 10:14:39 +00:00
|
|
|
warn(damagedPDF(*input, input->getLastOffset(), "empty object treated as null"));
|
2023-07-07 19:14:59 +00:00
|
|
|
}
|
|
|
|
return object;
|
|
|
|
}
|
|
|
|
|
2017-08-10 01:14:48 +00:00
|
|
|
bool
|
|
|
|
QPDF::findEndstream()
|
|
|
|
{
|
|
|
|
// Find endstream or endobj. Position the input at that token.
|
2024-08-21 23:30:18 +00:00
|
|
|
auto t = readToken(*m->file, 20);
|
2022-09-29 13:33:11 +00:00
|
|
|
if (t.isWord("endobj") || t.isWord("endstream")) {
|
2017-08-22 01:33:44 +00:00
|
|
|
m->file->seek(m->file->getLastOffset(), SEEK_SET);
|
2017-08-10 01:14:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-06-20 15:20:57 +00:00
|
|
|
size_t
|
2010-09-24 19:10:08 +00:00
|
|
|
QPDF::recoverStreamLength(
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<InputSource> input, QPDFObjGen const& og, qpdf_offset_t stream_offset)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
|
|
|
// Try to reconstruct stream length by looking for endstream or endobj
|
2024-08-21 10:14:39 +00:00
|
|
|
warn(damagedPDF(*input, stream_offset, "attempting to recover stream length"));
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2017-08-10 01:14:48 +00:00
|
|
|
PatternFinder ef(*this, &QPDF::findEndstream);
|
2012-06-20 15:20:57 +00:00
|
|
|
size_t length = 0;
|
2017-08-22 01:33:44 +00:00
|
|
|
if (m->file->findFirst("end", stream_offset, 0, ef)) {
|
2019-06-21 03:35:23 +00:00
|
|
|
length = toS(m->file->tell() - stream_offset);
|
2017-08-10 01:14:48 +00:00
|
|
|
// Reread endstream but, if it was endobj, don't skip that.
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDFTokenizer::Token t = readToken(*m->file);
|
2017-08-10 01:14:48 +00:00
|
|
|
if (t.getValue() == "endobj") {
|
2017-08-22 01:33:44 +00:00
|
|
|
m->file->seek(m->file->getLastOffset(), SEEK_SET);
|
2017-08-10 01:14:48 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (length) {
|
2024-08-20 11:44:19 +00:00
|
|
|
auto end = stream_offset + toO(length);
|
|
|
|
qpdf_offset_t found_offset = 0;
|
|
|
|
QPDFObjGen found_og;
|
2022-02-08 14:18:08 +00:00
|
|
|
|
|
|
|
// Make sure this is inside this object
|
2024-08-13 10:30:48 +00:00
|
|
|
for (auto const& [current_og, entry]: m->xref_table.as_map()) {
|
2022-02-08 14:18:08 +00:00
|
|
|
if (entry.getType() == 1) {
|
|
|
|
qpdf_offset_t obj_offset = entry.getOffset();
|
2024-08-20 11:44:19 +00:00
|
|
|
if (found_offset < obj_offset && obj_offset < end) {
|
|
|
|
found_offset = obj_offset;
|
|
|
|
found_og = current_og;
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-08-20 11:44:19 +00:00
|
|
|
if (!found_offset || found_og == og) {
|
|
|
|
// If we are trying to recover an XRef stream the xref table will not contain and
|
|
|
|
// won't contain any entries, therefore we cannot check the found length. Otherwise we
|
|
|
|
// found endstream\nendobj within the space allowed for this object, so we're probably
|
|
|
|
// in good shape.
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF found wrong endstream in recovery");
|
2024-08-20 11:44:19 +00:00
|
|
|
length = 0;
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (length == 0) {
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
*input, stream_offset, "unable to recover stream data; treating stream as empty"));
|
2017-07-29 23:15:06 +00:00
|
|
|
} else {
|
2024-08-21 10:14:39 +00:00
|
|
|
warn(damagedPDF(
|
|
|
|
*input, stream_offset, "recovered stream length: " + std::to_string(length)));
|
2017-07-29 23:15:06 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
QTC::TC("qpdf", "QPDF recovered stream length");
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDFTokenizer::Token
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDF::readToken(InputSource& input, size_t max_len)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2018-02-16 22:25:27 +00:00
|
|
|
return m->tokenizer.readToken(input, m->last_object_description, true, max_len);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
2009-10-19 23:09:19 +00:00
|
|
|
QPDF::readObjectAtOffset(
|
|
|
|
bool try_recovery,
|
2022-02-08 14:18:08 +00:00
|
|
|
qpdf_offset_t offset,
|
|
|
|
std::string const& description,
|
2022-11-24 16:50:46 +00:00
|
|
|
QPDFObjGen exp_og,
|
2022-11-19 21:01:54 +00:00
|
|
|
QPDFObjGen& og,
|
|
|
|
bool skip_cache_if_in_xref)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2022-07-24 13:40:11 +00:00
|
|
|
bool check_og = true;
|
2022-07-23 12:47:18 +00:00
|
|
|
if (exp_og.getObj() == 0) {
|
2022-07-24 13:40:11 +00:00
|
|
|
// This method uses an expect object ID of 0 to indicate that we don't know or don't care
|
|
|
|
// what the actual object ID is at this offset. This is true when we read the xref stream
|
|
|
|
// and linearization hint streams. In this case, we don't verify the expect object
|
|
|
|
// ID/generation against what was read from the file. There is also no reason to attempt
|
|
|
|
// xref recovery if we get a failure in this case since the read attempt was not triggered
|
|
|
|
// by an xref lookup.
|
|
|
|
check_og = false;
|
|
|
|
try_recovery = false;
|
|
|
|
}
|
2022-09-13 15:21:29 +00:00
|
|
|
setLastObjectDescription(description, exp_og);
|
2022-07-24 13:40:11 +00:00
|
|
|
|
2017-08-22 01:33:44 +00:00
|
|
|
if (!m->attempt_recovery) {
|
2017-07-28 02:27:00 +00:00
|
|
|
try_recovery = false;
|
|
|
|
}
|
2012-11-20 18:15:14 +00:00
|
|
|
|
|
|
|
// Special case: if offset is 0, just return null. Some PDF writers, in particular
|
2012-12-31 15:31:38 +00:00
|
|
|
// "Mac OS X 10.7.5 Quartz PDFContext", may store deleted objects in the xref table as
|
2023-05-29 18:26:18 +00:00
|
|
|
// "0000000000 00000 n", which is not correct, but it won't hurt anything for us to ignore
|
|
|
|
// these.
|
2012-11-20 18:15:14 +00:00
|
|
|
if (offset == 0) {
|
|
|
|
QTC::TC("qpdf", "QPDF bogus 0 offset", 0);
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF(0, "object has offset 0"));
|
2012-11-20 18:15:14 +00:00
|
|
|
return QPDFObjectHandle::newNull();
|
|
|
|
}
|
|
|
|
|
2017-08-22 01:33:44 +00:00
|
|
|
m->file->seek(offset, SEEK_SET);
|
2008-04-29 12:55:25 +00:00
|
|
|
try {
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDFTokenizer::Token tobjid = readToken(*m->file);
|
2024-08-23 13:09:20 +00:00
|
|
|
bool objidok = tobjid.isInteger();
|
|
|
|
QTC::TC("qpdf", "QPDF check objid", objidok ? 1 : 0);
|
|
|
|
if (!objidok) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF expected n n obj");
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(offset, "expected n n obj");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDFTokenizer::Token tgen = readToken(*m->file);
|
2024-08-23 13:09:20 +00:00
|
|
|
bool genok = tgen.isInteger();
|
|
|
|
QTC::TC("qpdf", "QPDF check generation", genok ? 1 : 0);
|
|
|
|
if (!genok) {
|
|
|
|
throw damagedPDF(offset, "expected n n obj");
|
|
|
|
}
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDFTokenizer::Token tobj = readToken(*m->file);
|
2024-08-23 13:09:20 +00:00
|
|
|
|
|
|
|
bool objok = tobj.isWord("obj");
|
|
|
|
QTC::TC("qpdf", "QPDF check obj", objok ? 1 : 0);
|
|
|
|
|
|
|
|
if (!objok) {
|
|
|
|
throw damagedPDF(offset, "expected n n obj");
|
|
|
|
}
|
2022-07-23 12:47:18 +00:00
|
|
|
int objid = QUtil::string_to_int(tobjid.getValue().c_str());
|
|
|
|
int generation = QUtil::string_to_int(tgen.getValue().c_str());
|
|
|
|
og = QPDFObjGen(objid, generation);
|
2017-07-26 08:30:32 +00:00
|
|
|
if (objid == 0) {
|
|
|
|
QTC::TC("qpdf", "QPDF object id 0");
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(offset, "object with ID 0");
|
2017-07-26 08:30:32 +00:00
|
|
|
}
|
2022-07-23 12:47:18 +00:00
|
|
|
if (check_og && (exp_og != og)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF err wrong objid/generation");
|
2022-09-28 11:25:52 +00:00
|
|
|
QPDFExc e = damagedPDF(offset, "expected " + exp_og.unparse(' ') + " obj");
|
2017-07-28 02:27:00 +00:00
|
|
|
if (try_recovery) {
|
|
|
|
// Will be retried below
|
|
|
|
throw e;
|
|
|
|
} else {
|
|
|
|
// We can try reading the object anyway even if the ID doesn't match.
|
|
|
|
warn(e);
|
|
|
|
}
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
} catch (QPDFExc& e) {
|
2022-07-24 13:40:11 +00:00
|
|
|
if (try_recovery) {
|
2022-02-08 14:18:08 +00:00
|
|
|
// Try again after reconstructing xref table
|
2024-08-09 23:12:53 +00:00
|
|
|
m->xref_table.reconstruct(e);
|
2024-08-10 13:04:32 +00:00
|
|
|
if (m->xref_table.type(exp_og) == 1) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF recovered in readObjectAtOffset");
|
2024-08-10 13:04:32 +00:00
|
|
|
return readObjectAtOffset(
|
|
|
|
false, m->xref_table.offset(exp_og), description, exp_og, og, false);
|
2022-02-08 14:18:08 +00:00
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF object gone after xref reconstruction");
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF(
|
2022-02-08 14:18:08 +00:00
|
|
|
"",
|
|
|
|
0,
|
2022-09-28 11:25:52 +00:00
|
|
|
("object " + exp_og.unparse(' ') +
|
2024-08-10 13:04:32 +00:00
|
|
|
" not found in file after regenerating cross reference table")));
|
2022-02-08 14:18:08 +00:00
|
|
|
return QPDFObjectHandle::newNull();
|
|
|
|
}
|
|
|
|
} else {
|
2023-03-19 16:57:27 +00:00
|
|
|
throw;
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2023-07-07 19:37:13 +00:00
|
|
|
QPDFObjectHandle oh = readObject(description, og);
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-08-10 12:16:06 +00:00
|
|
|
if (isUnresolved(og)) {
|
2022-02-08 14:18:08 +00:00
|
|
|
// Store the object in the cache here so it gets cached whether we first know the offset or
|
|
|
|
// whether we first know the object ID and generation (in which we case we would get here
|
|
|
|
// through resolve).
|
2023-05-24 15:28:17 +00:00
|
|
|
|
2022-02-08 14:18:08 +00:00
|
|
|
// Determine the end offset of this object before and after white space. We use these
|
|
|
|
// numbers to validate linearization hint tables. Offsets and lengths of objects may imply
|
|
|
|
// the end of an object to be anywhere between these values.
|
|
|
|
qpdf_offset_t end_before_space = m->file->tell();
|
|
|
|
|
|
|
|
// skip over spaces
|
|
|
|
while (true) {
|
|
|
|
char ch;
|
|
|
|
if (m->file->read(&ch, 1)) {
|
|
|
|
if (!isspace(static_cast<unsigned char>(ch))) {
|
|
|
|
m->file->seek(-1, SEEK_CUR);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(m->file->tell(), "EOF after endobj");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
qpdf_offset_t end_after_space = m->file->tell();
|
2024-08-10 13:04:32 +00:00
|
|
|
if (skip_cache_if_in_xref && m->xref_table.type(og)) {
|
2022-11-19 21:01:54 +00:00
|
|
|
// Ordinarily, an object gets read here when resolved through xref table or stream. In
|
|
|
|
// the special case of the xref stream and linearization hint tables, the offset comes
|
|
|
|
// from another source. For the specific case of xref streams, the xref stream is read
|
|
|
|
// and loaded into the object cache very early in parsing. Ordinarily, when a file is
|
|
|
|
// updated by appending, items inserted into the xref table in later updates take
|
|
|
|
// precedence over earlier items. In the special case of reusing the object number
|
|
|
|
// previously used as the xref stream, we have the following order of events:
|
|
|
|
//
|
|
|
|
// * reused object gets loaded into the xref table
|
|
|
|
// * old object is read here while reading xref streams
|
|
|
|
// * original xref entry is ignored (since already in xref table)
|
|
|
|
//
|
|
|
|
// It is the second step that causes a problem. Even though the xref table is correct in
|
|
|
|
// this case, the old object is already in the cache and so effectively prevails over
|
|
|
|
// the reused object. To work around this issue, we have a special case for the xref
|
|
|
|
// stream (via the skip_cache_if_in_xref): if the object is already in the xref stream,
|
|
|
|
// don't cache what we read here.
|
|
|
|
//
|
|
|
|
// It is likely that the same bug may exist for linearization hint tables, but the
|
|
|
|
// existing code uses end_before_space and end_after_space from the cache, so fixing
|
|
|
|
// that would require more significant rework. The chances of a linearization hint
|
|
|
|
// stream being reused seems smaller because the xref stream is probably the highest
|
|
|
|
// object in the file and the linearization hint stream would be some random place in
|
|
|
|
// the middle, so I'm leaving that bug unfixed for now. If the bug were to be fixed, we
|
|
|
|
// could use !check_og in place of skip_cache_if_in_xref.
|
|
|
|
QTC::TC("qpdf", "QPDF skipping cache for known unchecked object");
|
|
|
|
} else {
|
2022-12-29 15:12:04 +00:00
|
|
|
updateCache(og, oh.getObj(), end_before_space, end_after_space);
|
2022-11-19 21:01:54 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return oh;
|
|
|
|
}
|
|
|
|
|
2024-03-10 15:34:58 +00:00
|
|
|
QPDFObject*
|
2022-11-24 16:50:46 +00:00
|
|
|
QPDF::resolve(QPDFObjGen og)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2022-09-13 15:20:28 +00:00
|
|
|
if (!isUnresolved(og)) {
|
2024-03-10 15:34:58 +00:00
|
|
|
return m->obj_cache[og].object.get();
|
2022-08-10 12:16:06 +00:00
|
|
|
}
|
|
|
|
|
2017-08-22 01:33:44 +00:00
|
|
|
if (m->resolving.count(og)) {
|
2017-07-26 09:03:38 +00:00
|
|
|
// This can happen if an object references itself directly or indirectly in some key that
|
|
|
|
// has to be resolved during object parsing, such as stream length.
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF recursion loop in resolve");
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF("", "loop detected resolving object " + og.unparse(' ')));
|
2022-08-10 12:16:06 +00:00
|
|
|
updateCache(og, QPDF_Null::create(), -1, -1);
|
2024-03-10 15:34:58 +00:00
|
|
|
return m->obj_cache[og].object.get();
|
2017-07-26 09:03:38 +00:00
|
|
|
}
|
|
|
|
ResolveRecorder rr(this, og);
|
|
|
|
|
2024-08-10 13:04:32 +00:00
|
|
|
try {
|
|
|
|
switch (m->xref_table.type(og)) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
{
|
|
|
|
// Object stored in cache by readObjectAtOffset
|
|
|
|
QPDFObjGen a_og;
|
|
|
|
QPDFObjectHandle oh =
|
|
|
|
readObjectAtOffset(true, m->xref_table.offset(og), "", og, a_og, false);
|
|
|
|
}
|
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-10 13:04:32 +00:00
|
|
|
case 2:
|
|
|
|
resolveObjectsInStream(m->xref_table.stream_number(og.getObj()));
|
|
|
|
break;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-08-10 13:04:32 +00:00
|
|
|
default:
|
|
|
|
throw damagedPDF(
|
|
|
|
"", 0, ("object " + og.unparse('/') + " has unexpected xref entry type"));
|
2018-02-16 22:25:27 +00:00
|
|
|
}
|
2024-08-10 13:04:32 +00:00
|
|
|
} catch (QPDFExc& e) {
|
|
|
|
warn(e);
|
|
|
|
} catch (std::exception& e) {
|
|
|
|
warn(damagedPDF(
|
|
|
|
"", 0, ("object " + og.unparse('/') + ": error reading object: " + e.what())));
|
2022-04-02 21:14:10 +00:00
|
|
|
}
|
2022-08-10 12:16:06 +00:00
|
|
|
|
|
|
|
if (isUnresolved(og)) {
|
2019-01-04 15:17:33 +00:00
|
|
|
// PDF spec says unknown objects resolve to the null object.
|
2018-02-16 22:25:27 +00:00
|
|
|
QTC::TC("qpdf", "QPDF resolve failure to null");
|
2022-08-10 12:16:06 +00:00
|
|
|
updateCache(og, QPDF_Null::create(), -1, -1);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2022-08-10 12:16:06 +00:00
|
|
|
auto result(m->obj_cache[og].object);
|
2022-12-16 16:19:15 +00:00
|
|
|
result->setDefaultDescription(this, og);
|
2024-03-10 15:34:58 +00:00
|
|
|
return result.get();
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::resolveObjectsInStream(int obj_stream_number)
|
|
|
|
{
|
2020-10-22 19:19:48 +00:00
|
|
|
if (m->resolved_object_streams.count(obj_stream_number)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m->resolved_object_streams.insert(obj_stream_number);
|
2008-04-29 12:55:25 +00:00
|
|
|
// Force resolution of object stream
|
|
|
|
QPDFObjectHandle obj_stream = getObjectByID(obj_stream_number, 0);
|
|
|
|
if (!obj_stream.isStream()) {
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(
|
|
|
|
"supposed object stream " + std::to_string(obj_stream_number) + " is not a stream");
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// For linearization data in the object, use the data from the object stream for the objects in
|
|
|
|
// the stream.
|
2013-06-14 15:22:04 +00:00
|
|
|
QPDFObjGen stream_og(obj_stream_number, 0);
|
2017-08-22 01:33:44 +00:00
|
|
|
qpdf_offset_t end_before_space = m->obj_cache[stream_og].end_before_space;
|
|
|
|
qpdf_offset_t end_after_space = m->obj_cache[stream_og].end_after_space;
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
QPDFObjectHandle dict = obj_stream.getDict();
|
2022-01-26 08:00:23 +00:00
|
|
|
if (!dict.isDictionaryOfType("/ObjStm")) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF ERR object stream with wrong type");
|
2022-09-28 11:25:52 +00:00
|
|
|
warn(damagedPDF(
|
|
|
|
"supposed object stream " + std::to_string(obj_stream_number) + " has wrong type"));
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(dict.getKey("/N").isInteger() && dict.getKey("/First").isInteger())) {
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(
|
2022-09-21 16:49:21 +00:00
|
|
|
("object stream " + std::to_string(obj_stream_number) + " has incorrect keys"));
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2019-06-21 03:35:23 +00:00
|
|
|
int n = dict.getKey("/N").getIntValueAsInt();
|
|
|
|
int first = dict.getKey("/First").getIntValueAsInt();
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
std::map<int, int> offsets;
|
|
|
|
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<Buffer> bp = obj_stream.getStreamData(qpdf_dl_specialized);
|
|
|
|
auto input = std::shared_ptr<InputSource>(
|
2022-04-03 20:10:27 +00:00
|
|
|
// line-break
|
|
|
|
new BufferInputSource(
|
|
|
|
(m->file->getName() + " object stream " + std::to_string(obj_stream_number)),
|
|
|
|
bp.get()));
|
2008-04-29 12:55:25 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < n; ++i) {
|
2024-08-21 23:30:18 +00:00
|
|
|
QPDFTokenizer::Token tnum = readToken(*input);
|
|
|
|
QPDFTokenizer::Token toffset = readToken(*input);
|
2022-09-29 11:52:19 +00:00
|
|
|
if (!(tnum.isInteger() && toffset.isInteger())) {
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
*input,
|
2022-09-29 11:52:19 +00:00
|
|
|
m->last_object_description,
|
2017-08-22 01:33:44 +00:00
|
|
|
input->getLastOffset(),
|
2022-02-08 14:18:08 +00:00
|
|
|
"expected integer in object stream header");
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2022-02-08 14:18:08 +00:00
|
|
|
int num = QUtil::string_to_int(tnum.getValue().c_str());
|
|
|
|
long long offset = QUtil::string_to_int(toffset.getValue().c_str());
|
2024-08-09 13:10:26 +00:00
|
|
|
if (num > m->xref_table.max_id) {
|
2024-07-01 17:11:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (num == obj_stream_number) {
|
2024-07-04 19:40:47 +00:00
|
|
|
QTC::TC("qpdf", "QPDF ignore self-referential object stream");
|
2024-07-01 17:11:51 +00:00
|
|
|
warn(damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
*input,
|
2024-07-01 17:11:51 +00:00
|
|
|
m->last_object_description,
|
|
|
|
input->getLastOffset(),
|
|
|
|
"object stream claims to contain itself"));
|
|
|
|
continue;
|
|
|
|
}
|
2022-07-13 13:24:19 +00:00
|
|
|
offsets[num] = toI(offset + first);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2013-02-23 22:41:27 +00:00
|
|
|
// To avoid having to read the object stream multiple times, store all objects that would be
|
|
|
|
// found here in the cache. Remember that some objects stored here might have been overridden
|
|
|
|
// by new objects appended to the file, so it is necessary to recheck the xref table and only
|
|
|
|
// cache what would actually be resolved here.
|
2023-07-08 13:04:10 +00:00
|
|
|
m->last_object_description.clear();
|
|
|
|
m->last_object_description += "object ";
|
2022-04-30 17:23:18 +00:00
|
|
|
for (auto const& iter: offsets) {
|
2022-08-10 12:16:06 +00:00
|
|
|
QPDFObjGen og(iter.first, 0);
|
2024-08-13 10:30:48 +00:00
|
|
|
if (m->xref_table.type(og) == 2 &&
|
|
|
|
m->xref_table.stream_number(og.getObj()) == obj_stream_number) {
|
2022-04-30 17:23:18 +00:00
|
|
|
int offset = iter.second;
|
2013-02-23 22:41:27 +00:00
|
|
|
input->seek(offset, SEEK_SET);
|
2023-07-08 13:04:10 +00:00
|
|
|
QPDFObjectHandle oh = readObjectInStream(input, iter.first);
|
2022-12-29 15:12:04 +00:00
|
|
|
updateCache(og, oh.getObj(), end_before_space, end_after_space);
|
2013-02-23 22:41:27 +00:00
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF not caching overridden objstm object");
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-02 15:20:24 +00:00
|
|
|
QPDFObjectHandle
|
2022-09-08 15:29:23 +00:00
|
|
|
QPDF::newIndirect(QPDFObjGen const& og, std::shared_ptr<QPDFObject> const& obj)
|
2022-08-02 15:20:24 +00:00
|
|
|
{
|
2022-12-16 16:19:15 +00:00
|
|
|
obj->setDefaultDescription(this, og);
|
2022-12-29 15:12:04 +00:00
|
|
|
return {obj};
|
2022-08-02 15:20:24 +00:00
|
|
|
}
|
|
|
|
|
2022-08-10 12:16:06 +00:00
|
|
|
void
|
|
|
|
QPDF::updateCache(
|
|
|
|
QPDFObjGen const& og,
|
2022-09-08 15:29:23 +00:00
|
|
|
std::shared_ptr<QPDFObject> const& object,
|
2022-08-10 12:16:06 +00:00
|
|
|
qpdf_offset_t end_before_space,
|
|
|
|
qpdf_offset_t end_after_space)
|
|
|
|
{
|
2022-08-14 00:05:32 +00:00
|
|
|
object->setObjGen(this, og);
|
2022-08-10 12:16:06 +00:00
|
|
|
if (isCached(og)) {
|
|
|
|
auto& cache = m->obj_cache[og];
|
|
|
|
cache.object->assign(object);
|
|
|
|
cache.end_before_space = end_before_space;
|
|
|
|
cache.end_after_space = end_after_space;
|
|
|
|
} else {
|
|
|
|
m->obj_cache[og] = ObjCache(object, end_before_space, end_after_space);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-10 12:16:06 +00:00
|
|
|
bool
|
|
|
|
QPDF::isCached(QPDFObjGen const& og)
|
|
|
|
{
|
|
|
|
return m->obj_cache.count(og) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::isUnresolved(QPDFObjGen const& og)
|
|
|
|
{
|
|
|
|
return !isCached(og) || m->obj_cache[og].object->isUnresolved();
|
|
|
|
}
|
|
|
|
|
2022-09-26 17:43:28 +00:00
|
|
|
QPDFObjGen
|
|
|
|
QPDF::nextObjGen()
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2019-06-21 03:35:23 +00:00
|
|
|
int max_objid = toI(getObjectCount());
|
2019-08-27 21:57:38 +00:00
|
|
|
if (max_objid == std::numeric_limits<int>::max()) {
|
|
|
|
throw std::range_error("max object id is too high to create new objects");
|
|
|
|
}
|
2022-09-26 17:43:28 +00:00
|
|
|
return QPDFObjGen(max_objid + 1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
2022-11-20 21:04:58 +00:00
|
|
|
QPDF::makeIndirectFromQPDFObject(std::shared_ptr<QPDFObject> const& obj)
|
2022-09-26 17:43:28 +00:00
|
|
|
{
|
|
|
|
QPDFObjGen next{nextObjGen()};
|
2022-09-26 17:27:25 +00:00
|
|
|
m->obj_cache[next] = ObjCache(obj, -1, -1);
|
2022-08-02 15:20:24 +00:00
|
|
|
return newIndirect(next, m->obj_cache[next].object);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2022-09-26 17:27:25 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::makeIndirectObject(QPDFObjectHandle oh)
|
|
|
|
{
|
2024-06-19 16:18:43 +00:00
|
|
|
if (!oh) {
|
2022-12-29 15:12:04 +00:00
|
|
|
throw std::logic_error("attempted to make an uninitialized QPDFObjectHandle indirect");
|
|
|
|
}
|
|
|
|
return makeIndirectFromQPDFObject(oh.getObj());
|
2022-09-26 17:27:25 +00:00
|
|
|
}
|
|
|
|
|
2023-05-20 18:56:01 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::newReserved()
|
|
|
|
{
|
|
|
|
return makeIndirectFromQPDFObject(QPDF_Reserved::create());
|
|
|
|
}
|
|
|
|
|
2023-08-25 12:28:48 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::newIndirectNull()
|
|
|
|
{
|
|
|
|
return makeIndirectFromQPDFObject(QPDF_Null::create());
|
|
|
|
}
|
|
|
|
|
2022-09-26 17:27:25 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::newStream()
|
|
|
|
{
|
2022-11-20 21:04:58 +00:00
|
|
|
return makeIndirectFromQPDFObject(
|
2022-09-26 17:27:25 +00:00
|
|
|
QPDF_Stream::create(this, nextObjGen(), QPDFObjectHandle::newDictionary(), 0, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::newStream(std::shared_ptr<Buffer> data)
|
|
|
|
{
|
|
|
|
auto result = newStream();
|
|
|
|
result.replaceStreamData(data, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::newStream(std::string const& data)
|
|
|
|
{
|
|
|
|
auto result = newStream();
|
|
|
|
result.replaceStreamData(data, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2024-03-08 16:57:56 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
|
|
|
QPDF::getObjectForParser(int id, int gen, bool parse_pdf)
|
|
|
|
{
|
|
|
|
// This method is called by the parser and therefore must not resolve any objects.
|
|
|
|
auto og = QPDFObjGen(id, gen);
|
|
|
|
if (auto iter = m->obj_cache.find(og); iter != m->obj_cache.end()) {
|
|
|
|
return iter->second.object;
|
|
|
|
}
|
2024-08-10 13:04:32 +00:00
|
|
|
if (m->xref_table.type(og) || !m->xref_table.parsed) {
|
2024-03-08 16:57:56 +00:00
|
|
|
return m->obj_cache.insert({og, QPDF_Unresolved::create(this, og)}).first->second.object;
|
2022-05-15 17:10:10 +00:00
|
|
|
}
|
2024-03-08 16:57:56 +00:00
|
|
|
if (parse_pdf) {
|
|
|
|
return QPDF_Null::create();
|
|
|
|
}
|
|
|
|
return m->obj_cache.insert({og, QPDF_Null::create(this, og)}).first->second.object;
|
2022-05-15 17:10:10 +00:00
|
|
|
}
|
|
|
|
|
2024-03-08 16:57:56 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
|
|
|
QPDF::getObjectForJSON(int id, int gen)
|
2022-05-15 21:38:06 +00:00
|
|
|
{
|
2024-03-08 16:57:56 +00:00
|
|
|
auto og = QPDFObjGen(id, gen);
|
|
|
|
auto [it, inserted] = m->obj_cache.try_emplace(og);
|
|
|
|
auto& obj = it->second.object;
|
|
|
|
if (inserted) {
|
2024-08-10 13:04:32 +00:00
|
|
|
obj = (m->xref_table.parsed && !m->xref_table.type(og)) ? QPDF_Null::create(this, og)
|
|
|
|
: QPDF_Unresolved::create(this, og);
|
2024-03-08 16:57:56 +00:00
|
|
|
}
|
|
|
|
return obj;
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
|
2013-06-14 15:58:37 +00:00
|
|
|
QPDFObjectHandle
|
2022-08-01 18:22:37 +00:00
|
|
|
QPDF::getObject(QPDFObjGen const& og)
|
2013-06-14 15:58:37 +00:00
|
|
|
{
|
2024-03-08 16:57:56 +00:00
|
|
|
if (auto it = m->obj_cache.find(og); it != m->obj_cache.end()) {
|
|
|
|
return {it->second.object};
|
2024-08-10 13:04:32 +00:00
|
|
|
} else if (m->xref_table.parsed && !m->xref_table.type(og)) {
|
2024-03-08 16:57:56 +00:00
|
|
|
return QPDF_Null::create();
|
|
|
|
} else {
|
|
|
|
auto result = m->obj_cache.try_emplace(og, QPDF_Unresolved::create(this, og), -1, -1);
|
|
|
|
return {result.first->second.object};
|
2022-08-10 12:16:06 +00:00
|
|
|
}
|
2013-06-14 15:58:37 +00:00
|
|
|
}
|
|
|
|
|
2022-08-01 18:22:37 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::getObject(int objid, int generation)
|
|
|
|
{
|
|
|
|
return getObject(QPDFObjGen(objid, generation));
|
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::getObjectByObjGen(QPDFObjGen const& og)
|
|
|
|
{
|
|
|
|
return getObject(og);
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::getObjectByID(int objid, int generation)
|
|
|
|
{
|
2022-08-01 18:22:37 +00:00
|
|
|
return getObject(QPDFObjGen(objid, generation));
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2013-06-14 15:58:37 +00:00
|
|
|
void
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh)
|
2013-06-14 15:58:37 +00:00
|
|
|
{
|
2022-07-23 15:48:28 +00:00
|
|
|
replaceObject(QPDFObjGen(objid, generation), oh);
|
2013-06-14 15:58:37 +00:00
|
|
|
}
|
|
|
|
|
2011-08-10 16:42:48 +00:00
|
|
|
void
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::replaceObject(QPDFObjGen const& og, QPDFObjectHandle oh)
|
2011-08-10 16:42:48 +00:00
|
|
|
{
|
2024-06-19 16:18:43 +00:00
|
|
|
if (!oh || (oh.isIndirect() && !(oh.isStream() && oh.getObjGen() == og))) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF replaceObject called with indirect object");
|
|
|
|
throw std::logic_error("QPDF::replaceObject called with indirect object handle");
|
2011-08-10 16:42:48 +00:00
|
|
|
}
|
2022-12-29 15:12:04 +00:00
|
|
|
updateCache(og, oh.getObj(), -1, -1);
|
2011-08-10 16:42:48 +00:00
|
|
|
}
|
|
|
|
|
2024-01-07 22:05:35 +00:00
|
|
|
void
|
2024-01-08 11:49:21 +00:00
|
|
|
QPDF::removeObject(QPDFObjGen og)
|
2024-01-07 22:05:35 +00:00
|
|
|
{
|
2024-01-08 11:49:21 +00:00
|
|
|
if (auto cached = m->obj_cache.find(og); cached != m->obj_cache.end()) {
|
2024-01-07 22:05:35 +00:00
|
|
|
// Take care of any object handles that may be floating around.
|
2024-01-08 11:49:21 +00:00
|
|
|
cached->second.object->assign(QPDF_Null::create());
|
|
|
|
cached->second.object->setObjGen(nullptr, QPDFObjGen());
|
|
|
|
m->obj_cache.erase(cached);
|
2024-01-07 22:05:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-08 18:19:19 +00:00
|
|
|
void
|
|
|
|
QPDF::replaceReserved(QPDFObjectHandle reserved, QPDFObjectHandle replacement)
|
|
|
|
{
|
|
|
|
QTC::TC("qpdf", "QPDF replaceReserved");
|
2023-08-25 11:37:24 +00:00
|
|
|
auto tc = reserved.getTypeCode();
|
|
|
|
if (!(tc == ::ot_reserved || tc == ::ot_null)) {
|
2023-09-03 18:06:38 +00:00
|
|
|
throw std::logic_error("replaceReserved called with non-reserved object");
|
2023-08-25 11:37:24 +00:00
|
|
|
}
|
2013-06-14 15:58:37 +00:00
|
|
|
replaceObject(reserved.getObjGen(), replacement);
|
2012-07-08 18:19:19 +00:00
|
|
|
}
|
|
|
|
|
2012-07-11 19:29:41 +00:00
|
|
|
QPDFObjectHandle
|
2019-01-29 02:53:55 +00:00
|
|
|
QPDF::copyForeignObject(QPDFObjectHandle foreign)
|
2012-07-11 19:29:41 +00:00
|
|
|
{
|
2020-10-31 15:57:28 +00:00
|
|
|
// Here's an explanation of what's going on here.
|
|
|
|
//
|
|
|
|
// A QPDFObjectHandle that is an indirect object has an owning QPDF. The object ID and
|
|
|
|
// generation refers to an object in the owning QPDF. When we copy the QPDFObjectHandle from a
|
|
|
|
// foreign QPDF into the local QPDF, we have to replace all indirect object references with
|
|
|
|
// references to the corresponding object in the local file.
|
|
|
|
//
|
|
|
|
// To do this, we maintain mappings from foreign object IDs to local object IDs for each foreign
|
|
|
|
// QPDF that we are copying from. The mapping is stored in an ObjCopier, which contains a
|
|
|
|
// mapping from the foreign ObjGen to the local QPDFObjectHandle.
|
|
|
|
//
|
|
|
|
// To copy, we do a deep traversal of the foreign object with loop detection to discover all
|
|
|
|
// indirect objects that are encountered, stopping at page boundaries. Whenever we encounter an
|
|
|
|
// indirect object, we check to see if we have already created a local copy of it. If not, we
|
|
|
|
// allocate a "reserved" object (or, for a stream, just a new stream) and store in the map the
|
|
|
|
// mapping from the foreign object ID to the new object. While we
|
|
|
|
// do this, we keep a list of objects to copy.
|
|
|
|
//
|
|
|
|
// Once we are done with the traversal, we copy all the objects that we need to copy. However,
|
|
|
|
// the copies will contain indirect object IDs that refer to objects in the foreign file. We
|
|
|
|
// need to replace them with references to objects in the local file. This is what
|
|
|
|
// replaceForeignIndirectObjects does. Once we have created a copy of the foreign object with
|
|
|
|
// all the indirect references replaced with new ones in the local context, we can replace the
|
|
|
|
// local reserved object with the copy. This mechanism allows us to copy objects with circular
|
|
|
|
// references in any order.
|
2023-05-24 15:28:17 +00:00
|
|
|
|
2020-10-31 15:57:28 +00:00
|
|
|
// For streams, rather than copying the objects, we set up the stream data to pull from the
|
|
|
|
// original stream by using a stream data provider. This is done in a manner that doesn't
|
|
|
|
// require the original QPDF object but may require the original source of the stream data with
|
|
|
|
// special handling for immediate_copy_from. This logic is also in
|
|
|
|
// replaceForeignIndirectObjects.
|
2023-05-24 15:28:17 +00:00
|
|
|
|
2020-10-31 15:57:28 +00:00
|
|
|
// Note that we explicitly allow use of copyForeignObject on page objects. It is a documented
|
|
|
|
// use case to copy pages this way if the intention is to not update the pages tree.
|
2012-07-11 19:29:41 +00:00
|
|
|
if (!foreign.isIndirect()) {
|
|
|
|
QTC::TC("qpdf", "QPDF copyForeign direct");
|
2022-02-08 14:18:08 +00:00
|
|
|
throw std::logic_error("QPDF::copyForeign called with direct object handle");
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
2022-09-07 15:29:17 +00:00
|
|
|
QPDF& other = foreign.getQPDF();
|
|
|
|
if (&other == this) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF copyForeign not foreign");
|
|
|
|
throw std::logic_error("QPDF::copyForeign called with object from this QPDF");
|
|
|
|
}
|
|
|
|
|
2022-09-07 15:29:17 +00:00
|
|
|
ObjCopier& obj_copier = m->object_copiers[other.m->unique_id];
|
2012-07-11 19:29:41 +00:00
|
|
|
if (!obj_copier.visiting.empty()) {
|
|
|
|
throw std::logic_error("obj_copier.visiting is not empty"
|
|
|
|
" at the beginning of copyForeignObject");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure we have an object in this file for every referenced object in the old file.
|
2013-06-14 15:22:04 +00:00
|
|
|
// obj_copier.object_map maps foreign QPDFObjGen to local objects. For everything new that we
|
|
|
|
// have to copy, the local object will be a reservation, unless it is a stream, in which case
|
2012-07-11 19:29:41 +00:00
|
|
|
// the local object will already be a stream.
|
|
|
|
reserveObjects(foreign, obj_copier, true);
|
|
|
|
|
|
|
|
if (!obj_copier.visiting.empty()) {
|
2023-08-25 12:28:48 +00:00
|
|
|
throw std::logic_error("obj_copier.visiting is not empty after reserving objects");
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Copy any new objects and replace the reservations.
|
2022-04-30 17:23:18 +00:00
|
|
|
for (auto& to_copy: obj_copier.to_copy) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QPDFObjectHandle copy = replaceForeignIndirectObjects(to_copy, obj_copier, true);
|
|
|
|
if (!to_copy.isStream()) {
|
2013-06-14 15:58:37 +00:00
|
|
|
QPDFObjGen og(to_copy.getObjGen());
|
2012-07-11 19:29:41 +00:00
|
|
|
replaceReserved(obj_copier.object_map[og], copy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
obj_copier.to_copy.clear();
|
|
|
|
|
2023-09-03 10:03:24 +00:00
|
|
|
auto og = foreign.getObjGen();
|
|
|
|
if (!obj_copier.object_map.count(og)) {
|
|
|
|
warn(damagedPDF("unexpected reference to /Pages object while copying foreign object; "
|
|
|
|
"replacing with null"));
|
|
|
|
return QPDFObjectHandle::newNull();
|
2023-07-25 13:34:14 +00:00
|
|
|
}
|
2023-09-03 10:03:24 +00:00
|
|
|
return obj_copier.object_map[foreign.getObjGen()];
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::reserveObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
|
|
|
|
{
|
2023-05-19 10:12:49 +00:00
|
|
|
auto foreign_tc = foreign.getTypeCode();
|
|
|
|
if (foreign_tc == ::ot_reserved) {
|
2020-10-31 15:43:31 +00:00
|
|
|
throw std::logic_error("QPDF: attempting to copy a foreign reserved object");
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (foreign.isPagesObject()) {
|
|
|
|
QTC::TC("qpdf", "QPDF not copying pages object");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (foreign.isIndirect()) {
|
2013-06-14 15:58:37 +00:00
|
|
|
QPDFObjGen foreign_og(foreign.getObjGen());
|
2023-05-19 10:12:49 +00:00
|
|
|
if (!obj_copier.visiting.add(foreign_og)) {
|
2023-09-05 12:34:03 +00:00
|
|
|
QTC::TC("qpdf", "QPDF loop reserving objects");
|
2013-12-26 16:51:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2023-09-05 12:34:03 +00:00
|
|
|
if (obj_copier.object_map.count(foreign_og) > 0) {
|
|
|
|
QTC::TC("qpdf", "QPDF already reserved object");
|
|
|
|
if (!(top && foreign.isPageObject() && obj_copier.object_map[foreign_og].isNull())) {
|
|
|
|
obj_copier.visiting.erase(foreign);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF copy indirect");
|
2023-08-25 12:28:48 +00:00
|
|
|
obj_copier.object_map[foreign_og] =
|
|
|
|
foreign.isStream() ? newStream() : newIndirectNull();
|
2023-08-25 12:29:24 +00:00
|
|
|
if ((!top) && foreign.isPageObject()) {
|
|
|
|
QTC::TC("qpdf", "QPDF not crossing page boundary");
|
2023-09-05 12:34:03 +00:00
|
|
|
obj_copier.visiting.erase(foreign_og);
|
2023-08-25 12:29:24 +00:00
|
|
|
return;
|
|
|
|
}
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
2023-09-05 12:34:03 +00:00
|
|
|
obj_copier.to_copy.push_back(foreign);
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
2023-05-19 10:12:49 +00:00
|
|
|
if (foreign_tc == ::ot_array) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF reserve array");
|
2022-02-08 14:18:08 +00:00
|
|
|
int n = foreign.getArrayNItems();
|
|
|
|
for (int i = 0; i < n; ++i) {
|
2012-07-11 19:29:41 +00:00
|
|
|
reserveObjects(foreign.getArrayItem(i), obj_copier, false);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2023-05-19 10:12:49 +00:00
|
|
|
} else if (foreign_tc == ::ot_dictionary) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF reserve dictionary");
|
2022-05-21 14:18:15 +00:00
|
|
|
for (auto const& key: foreign.getKeys()) {
|
2022-04-30 17:23:18 +00:00
|
|
|
reserveObjects(foreign.getKey(key), obj_copier, false);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2023-05-19 10:12:49 +00:00
|
|
|
} else if (foreign_tc == ::ot_stream) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF reserve stream");
|
|
|
|
reserveObjects(foreign.getDict(), obj_copier, false);
|
|
|
|
}
|
|
|
|
|
2023-05-19 10:12:49 +00:00
|
|
|
obj_copier.visiting.erase(foreign);
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::replaceForeignIndirectObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
|
|
|
|
{
|
2023-05-19 10:12:49 +00:00
|
|
|
auto foreign_tc = foreign.getTypeCode();
|
2012-07-11 19:29:41 +00:00
|
|
|
QPDFObjectHandle result;
|
|
|
|
if ((!top) && foreign.isIndirect()) {
|
|
|
|
QTC::TC("qpdf", "QPDF replace indirect");
|
2023-05-19 10:12:49 +00:00
|
|
|
auto mapping = obj_copier.object_map.find(foreign.getObjGen());
|
2012-07-11 19:29:41 +00:00
|
|
|
if (mapping == obj_copier.object_map.end()) {
|
2023-08-25 12:29:24 +00:00
|
|
|
// This case would occur if this is a reference to a Pages object that we didn't
|
2012-07-11 19:29:41 +00:00
|
|
|
// traverse into.
|
|
|
|
QTC::TC("qpdf", "QPDF replace foreign indirect with null");
|
|
|
|
result = QPDFObjectHandle::newNull();
|
|
|
|
} else {
|
2023-05-19 10:12:49 +00:00
|
|
|
result = mapping->second;
|
2012-07-11 19:29:41 +00:00
|
|
|
}
|
2023-05-19 10:12:49 +00:00
|
|
|
} else if (foreign_tc == ::ot_array) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF replace array");
|
|
|
|
result = QPDFObjectHandle::newArray();
|
2022-02-08 14:18:08 +00:00
|
|
|
int n = foreign.getArrayNItems();
|
|
|
|
for (int i = 0; i < n; ++i) {
|
2022-04-03 20:10:27 +00:00
|
|
|
result.appendItem(
|
|
|
|
// line-break
|
|
|
|
replaceForeignIndirectObjects(foreign.getArrayItem(i), obj_copier, false));
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2023-05-19 10:12:49 +00:00
|
|
|
} else if (foreign_tc == ::ot_dictionary) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF replace dictionary");
|
|
|
|
result = QPDFObjectHandle::newDictionary();
|
2022-02-08 14:18:08 +00:00
|
|
|
std::set<std::string> keys = foreign.getKeys();
|
2022-04-30 00:39:54 +00:00
|
|
|
for (auto const& iter: keys) {
|
2012-07-11 19:29:41 +00:00
|
|
|
result.replaceKey(
|
2022-04-30 00:39:54 +00:00
|
|
|
iter, replaceForeignIndirectObjects(foreign.getKey(iter), obj_copier, false));
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2023-05-19 10:12:49 +00:00
|
|
|
} else if (foreign_tc == ::ot_stream) {
|
2012-07-11 19:29:41 +00:00
|
|
|
QTC::TC("qpdf", "QPDF replace stream");
|
2023-05-19 10:12:49 +00:00
|
|
|
result = obj_copier.object_map[foreign.getObjGen()];
|
2012-07-11 19:29:41 +00:00
|
|
|
result.assertStream();
|
|
|
|
QPDFObjectHandle dict = result.getDict();
|
|
|
|
QPDFObjectHandle old_dict = foreign.getDict();
|
|
|
|
std::set<std::string> keys = old_dict.getKeys();
|
2022-04-30 00:39:54 +00:00
|
|
|
for (auto const& iter: keys) {
|
2012-07-11 19:29:41 +00:00
|
|
|
dict.replaceKey(
|
2022-04-30 00:39:54 +00:00
|
|
|
iter, replaceForeignIndirectObjects(old_dict.getKey(iter), obj_copier, false));
|
2019-01-07 02:18:36 +00:00
|
|
|
}
|
2021-02-21 10:56:52 +00:00
|
|
|
copyStreamData(result, foreign);
|
2012-07-11 19:29:41 +00:00
|
|
|
} else {
|
|
|
|
foreign.assertScalar();
|
|
|
|
result = foreign;
|
|
|
|
result.makeDirect();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (top && (!result.isStream()) && result.isIndirect()) {
|
|
|
|
throw std::logic_error("replacement for foreign object is indirect");
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2012-07-08 18:19:19 +00:00
|
|
|
|
2021-02-21 10:56:52 +00:00
|
|
|
void
|
|
|
|
QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign)
|
|
|
|
{
|
2021-02-21 11:35:53 +00:00
|
|
|
// This method was originally written for copying foreign streams, but it is used by
|
|
|
|
// QPDFObjectHandle to copy streams from the same QPDF object as well.
|
|
|
|
|
2021-02-21 10:56:52 +00:00
|
|
|
QPDFObjectHandle dict = result.getDict();
|
|
|
|
QPDFObjectHandle old_dict = foreign.getDict();
|
2022-07-26 11:37:50 +00:00
|
|
|
if (m->copied_stream_data_provider == nullptr) {
|
2021-02-21 10:56:52 +00:00
|
|
|
m->copied_stream_data_provider = new CopiedStreamDataProvider(*this);
|
2022-02-06 16:40:24 +00:00
|
|
|
m->copied_streams =
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<QPDFObjectHandle::StreamDataProvider>(m->copied_stream_data_provider);
|
2021-02-21 10:56:52 +00:00
|
|
|
}
|
|
|
|
QPDFObjGen local_og(result.getObjGen());
|
|
|
|
// Copy information from the foreign stream so we can pipe its data later without keeping the
|
|
|
|
// original QPDF object around.
|
2022-08-02 18:13:29 +00:00
|
|
|
|
2022-09-07 15:29:17 +00:00
|
|
|
QPDF& foreign_stream_qpdf =
|
|
|
|
foreign.getQPDF("unable to retrieve owning qpdf from foreign stream");
|
2022-08-06 18:52:07 +00:00
|
|
|
|
2022-12-29 15:12:04 +00:00
|
|
|
auto stream = foreign.getObjectPtr()->as<QPDF_Stream>();
|
2022-08-02 18:13:29 +00:00
|
|
|
if (stream == nullptr) {
|
2021-02-21 10:56:52 +00:00
|
|
|
throw std::logic_error("unable to retrieve underlying"
|
|
|
|
" stream object from foreign stream");
|
|
|
|
}
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<Buffer> stream_buffer = stream->getStreamDataBuffer();
|
2022-09-07 15:29:17 +00:00
|
|
|
if ((foreign_stream_qpdf.m->immediate_copy_from) && (stream_buffer == nullptr)) {
|
2021-02-21 10:56:52 +00:00
|
|
|
// Pull the stream data into a buffer before attempting the copy operation. Do it on the
|
|
|
|
// source stream so that if the source stream is copied multiple times, we don't have to
|
|
|
|
// keep duplicating the memory.
|
|
|
|
QTC::TC("qpdf", "QPDF immediate copy stream data");
|
|
|
|
foreign.replaceStreamData(
|
|
|
|
foreign.getRawStreamData(),
|
|
|
|
old_dict.getKey("/Filter"),
|
|
|
|
old_dict.getKey("/DecodeParms"));
|
|
|
|
stream_buffer = stream->getStreamDataBuffer();
|
|
|
|
}
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<QPDFObjectHandle::StreamDataProvider> stream_provider =
|
2021-02-21 10:56:52 +00:00
|
|
|
stream->getStreamDataProvider();
|
2022-02-04 15:10:19 +00:00
|
|
|
if (stream_buffer.get()) {
|
2021-02-21 10:56:52 +00:00
|
|
|
QTC::TC("qpdf", "QPDF copy foreign stream with buffer");
|
|
|
|
result.replaceStreamData(
|
|
|
|
stream_buffer, dict.getKey("/Filter"), dict.getKey("/DecodeParms"));
|
2022-02-04 15:10:19 +00:00
|
|
|
} else if (stream_provider.get()) {
|
2021-02-21 10:56:52 +00:00
|
|
|
// In this case, the remote stream's QPDF must stay in scope.
|
|
|
|
QTC::TC("qpdf", "QPDF copy foreign stream with provider");
|
|
|
|
m->copied_stream_data_provider->registerForeignStream(local_og, foreign);
|
|
|
|
result.replaceStreamData(
|
|
|
|
m->copied_streams, dict.getKey("/Filter"), dict.getKey("/DecodeParms"));
|
|
|
|
} else {
|
2022-04-09 18:35:56 +00:00
|
|
|
auto foreign_stream_data = std::make_shared<ForeignStreamData>(
|
2022-09-07 15:29:17 +00:00
|
|
|
foreign_stream_qpdf.m->encp,
|
2024-09-05 13:50:38 +00:00
|
|
|
foreign_stream_qpdf.m->file_sp,
|
2022-07-23 15:48:28 +00:00
|
|
|
foreign.getObjGen(),
|
2022-09-27 12:08:14 +00:00
|
|
|
stream->getParsedOffset(),
|
2021-02-21 10:56:52 +00:00
|
|
|
stream->getLength(),
|
|
|
|
dict);
|
|
|
|
m->copied_stream_data_provider->registerForeignStream(local_og, foreign_stream_data);
|
|
|
|
result.replaceStreamData(
|
|
|
|
m->copied_streams, dict.getKey("/Filter"), dict.getKey("/DecodeParms"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-14 15:58:37 +00:00
|
|
|
void
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::swapObjects(int objid1, int generation1, int objid2, int generation2)
|
2013-06-14 15:58:37 +00:00
|
|
|
{
|
2022-07-23 15:48:28 +00:00
|
|
|
swapObjects(QPDFObjGen(objid1, generation1), QPDFObjGen(objid2, generation2));
|
2013-06-14 15:58:37 +00:00
|
|
|
}
|
|
|
|
|
2011-08-10 16:42:48 +00:00
|
|
|
void
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDF::swapObjects(QPDFObjGen const& og1, QPDFObjGen const& og2)
|
2011-08-10 16:42:48 +00:00
|
|
|
{
|
2022-09-13 15:18:49 +00:00
|
|
|
// Force objects to be read from the input source if needed, then swap them in the cache.
|
2022-07-23 15:48:28 +00:00
|
|
|
resolve(og1);
|
|
|
|
resolve(og2);
|
2022-08-02 21:57:33 +00:00
|
|
|
m->obj_cache[og1].object->swapWith(m->obj_cache[og2].object);
|
2011-08-10 16:42:48 +00:00
|
|
|
}
|
|
|
|
|
2019-01-12 14:14:20 +00:00
|
|
|
unsigned long long
|
|
|
|
QPDF::getUniqueId() const
|
|
|
|
{
|
|
|
|
return m->unique_id;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
std::string
|
|
|
|
QPDF::getFilename() const
|
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
return m->file->getName();
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2022-02-08 16:07:37 +00:00
|
|
|
PDFVersion
|
|
|
|
QPDF::getVersionAsPDFVersion()
|
|
|
|
{
|
|
|
|
int major = 1;
|
|
|
|
int minor = 3;
|
|
|
|
int extension_level = getExtensionLevel();
|
|
|
|
|
|
|
|
std::regex v("^[[:space:]]*([0-9]+)\\.([0-9]+)");
|
|
|
|
std::smatch match;
|
|
|
|
if (std::regex_search(m->pdf_version, match, v)) {
|
|
|
|
major = QUtil::string_to_int(match[1].str().c_str());
|
|
|
|
minor = QUtil::string_to_int(match[2].str().c_str());
|
|
|
|
}
|
|
|
|
|
2023-05-27 20:04:32 +00:00
|
|
|
return {major, minor, extension_level};
|
2022-02-08 16:07:37 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
std::string
|
|
|
|
QPDF::getPDFVersion() const
|
|
|
|
{
|
2017-08-22 01:33:44 +00:00
|
|
|
return m->pdf_version;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2012-12-27 20:17:39 +00:00
|
|
|
int
|
|
|
|
QPDF::getExtensionLevel()
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
QPDFObjectHandle obj = getRoot();
|
|
|
|
if (obj.hasKey("/Extensions")) {
|
|
|
|
obj = obj.getKey("/Extensions");
|
|
|
|
if (obj.isDictionary() && obj.hasKey("/ADBE")) {
|
|
|
|
obj = obj.getKey("/ADBE");
|
|
|
|
if (obj.isDictionary() && obj.hasKey("/ExtensionLevel")) {
|
|
|
|
obj = obj.getKey("/ExtensionLevel");
|
|
|
|
if (obj.isInteger()) {
|
2019-06-21 03:35:23 +00:00
|
|
|
result = obj.getIntValueAsInt();
|
2012-12-27 20:17:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::getTrailer()
|
|
|
|
{
|
2024-08-09 13:10:26 +00:00
|
|
|
return m->xref_table.trailer;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::getRoot()
|
|
|
|
{
|
2024-08-09 13:10:26 +00:00
|
|
|
QPDFObjectHandle root = m->xref_table.trailer.getKey("/Root");
|
2017-07-28 22:02:39 +00:00
|
|
|
if (!root.isDictionary()) {
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF("", 0, "unable to find /Root dictionary");
|
2022-11-12 18:10:16 +00:00
|
|
|
} else if (
|
|
|
|
// Check_mode is an interim solution to request #810 pending a more comprehensive review of
|
|
|
|
// the approach to more extensive checks and warning levels.
|
|
|
|
m->check_mode && !root.getKey("/Type").isNameAndEquals("/Catalog")) {
|
|
|
|
warn(damagedPDF("", 0, "catalog /Type entry missing or invalid"));
|
|
|
|
root.replaceKey("/Type", "/Catalog"_qpdf);
|
2017-07-28 22:02:39 +00:00
|
|
|
}
|
|
|
|
return root;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2019-09-28 13:07:00 +00:00
|
|
|
std::map<QPDFObjGen, QPDFXRefEntry>
|
|
|
|
QPDF::getXRefTable()
|
2024-03-04 16:46:31 +00:00
|
|
|
{
|
|
|
|
return getXRefTableInternal();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::map<QPDFObjGen, QPDFXRefEntry> const&
|
|
|
|
QPDF::getXRefTableInternal()
|
2019-09-28 13:07:00 +00:00
|
|
|
{
|
2024-08-09 13:10:26 +00:00
|
|
|
if (!m->xref_table.parsed) {
|
2019-09-28 13:07:00 +00:00
|
|
|
throw std::logic_error("QPDF::getXRefTable called before parsing.");
|
|
|
|
}
|
|
|
|
|
2024-08-13 10:30:48 +00:00
|
|
|
return m->xref_table.as_map();
|
2019-09-28 13:07:00 +00:00
|
|
|
}
|
|
|
|
|
2024-02-18 01:42:47 +00:00
|
|
|
size_t
|
|
|
|
QPDF::tableSize()
|
|
|
|
{
|
|
|
|
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
|
|
|
|
// objects.
|
2024-08-13 10:30:48 +00:00
|
|
|
auto max_xref = m->xref_table.size() ? m->xref_table.as_map().crbegin()->first.getObj() : 0;
|
2024-02-18 01:42:47 +00:00
|
|
|
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
|
2024-05-21 11:50:19 +00:00
|
|
|
auto max_id = std::numeric_limits<int>::max() - 1;
|
|
|
|
if (max_obj >= max_id || max_xref >= max_id) {
|
|
|
|
// Temporary fix. Long-term solution is
|
|
|
|
// - QPDFObjGen to enforce objgens are valid and sensible
|
|
|
|
// - xref table and obj cache to protect against insertion of impossibly large obj ids
|
|
|
|
stopOnError("Impossibly large object id encountered.");
|
|
|
|
}
|
2024-02-18 01:42:47 +00:00
|
|
|
if (max_obj < 1.1 * std::max(toI(m->obj_cache.size()), max_xref)) {
|
|
|
|
return toS(++max_obj);
|
|
|
|
}
|
|
|
|
return toS(++max_xref);
|
|
|
|
}
|
|
|
|
|
2013-06-14 18:53:47 +00:00
|
|
|
std::vector<QPDFObjGen>
|
2024-02-25 22:40:09 +00:00
|
|
|
QPDF::getCompressibleObjVector()
|
|
|
|
{
|
|
|
|
return getCompressibleObjGens<QPDFObjGen>();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<bool>
|
|
|
|
QPDF::getCompressibleObjSet()
|
|
|
|
{
|
|
|
|
return getCompressibleObjGens<bool>();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
std::vector<T>
|
2013-06-14 18:53:47 +00:00
|
|
|
QPDF::getCompressibleObjGens()
|
|
|
|
{
|
|
|
|
// Return a list of objects that are allowed to be in object streams. Walk through the objects
|
|
|
|
// by traversing the document from the root, including a traversal of the pages tree. This
|
|
|
|
// makes that objects that are on the same page are more likely to be in the same object stream,
|
2008-04-29 12:55:25 +00:00
|
|
|
// which is slightly more efficient, particularly with linearized files. This is better than
|
|
|
|
// iterating through the xref table since it avoids preserving orphaned items.
|
|
|
|
|
|
|
|
// Exclude encryption dictionary, if any
|
2024-08-09 13:10:26 +00:00
|
|
|
QPDFObjectHandle encryption_dict = m->xref_table.trailer.getKey("/Encrypt");
|
2013-06-14 18:53:47 +00:00
|
|
|
QPDFObjGen encryption_dict_og = encryption_dict.getObjGen();
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2024-01-06 14:37:05 +00:00
|
|
|
const size_t max_obj = getObjectCount();
|
|
|
|
std::vector<bool> visited(max_obj, false);
|
2024-01-04 12:20:15 +00:00
|
|
|
std::vector<QPDFObjectHandle> queue;
|
|
|
|
queue.reserve(512);
|
2024-08-09 13:10:26 +00:00
|
|
|
queue.push_back(m->xref_table.trailer);
|
2024-02-25 22:40:09 +00:00
|
|
|
std::vector<T> result;
|
|
|
|
if constexpr (std::is_same_v<T, QPDFObjGen>) {
|
|
|
|
result.reserve(m->obj_cache.size());
|
|
|
|
} else if constexpr (std::is_same_v<T, bool>) {
|
|
|
|
result.resize(max_obj + 1U, false);
|
|
|
|
} else {
|
|
|
|
throw std::logic_error("Unsupported type in QPDF::getCompressibleObjGens");
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
while (!queue.empty()) {
|
2024-01-06 14:37:05 +00:00
|
|
|
auto obj = queue.back();
|
2024-01-04 12:20:15 +00:00
|
|
|
queue.pop_back();
|
2024-01-17 10:39:06 +00:00
|
|
|
if (obj.getObjectID() > 0) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QPDFObjGen og = obj.getObjGen();
|
2024-01-06 14:37:05 +00:00
|
|
|
const size_t id = toS(og.getObj() - 1);
|
2024-02-04 21:11:53 +00:00
|
|
|
if (id >= max_obj) {
|
2024-01-07 20:21:38 +00:00
|
|
|
throw std::logic_error(
|
2024-01-06 14:37:05 +00:00
|
|
|
"unexpected object id encountered in getCompressibleObjGens");
|
2024-02-04 21:11:53 +00:00
|
|
|
}
|
2024-01-08 13:42:05 +00:00
|
|
|
if (visited[id]) {
|
2022-02-08 14:18:08 +00:00
|
|
|
QTC::TC("qpdf", "QPDF loop detected traversing objects");
|
|
|
|
continue;
|
|
|
|
}
|
2024-01-08 13:42:05 +00:00
|
|
|
|
|
|
|
// Check whether this is the current object. If not, remove it (which changes it into a
|
|
|
|
// direct null and therefore stops us from revisiting it) and move on to the next object
|
|
|
|
// in the queue.
|
|
|
|
auto upper = m->obj_cache.upper_bound(og);
|
|
|
|
if (upper != m->obj_cache.end() && upper->first.getObj() == og.getObj()) {
|
|
|
|
removeObject(og);
|
|
|
|
continue;
|
2024-01-07 20:21:38 +00:00
|
|
|
}
|
2024-01-08 13:42:05 +00:00
|
|
|
|
|
|
|
visited[id] = true;
|
|
|
|
|
2022-02-08 14:18:08 +00:00
|
|
|
if (og == encryption_dict_og) {
|
|
|
|
QTC::TC("qpdf", "QPDF exclude encryption dictionary");
|
2022-01-26 08:00:23 +00:00
|
|
|
} else if (!(obj.isStream() ||
|
|
|
|
(obj.isDictionaryOfType("/Sig") && obj.hasKey("/ByteRange") &&
|
|
|
|
obj.hasKey("/Contents")))) {
|
2024-02-25 22:40:09 +00:00
|
|
|
if constexpr (std::is_same_v<T, QPDFObjGen>) {
|
|
|
|
result.push_back(og);
|
|
|
|
} else if constexpr (std::is_same_v<T, bool>) {
|
|
|
|
result[id + 1U] = true;
|
|
|
|
}
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (obj.isStream()) {
|
|
|
|
QPDFObjectHandle dict = obj.getDict();
|
|
|
|
std::set<std::string> keys = dict.getKeys();
|
2023-05-20 18:56:01 +00:00
|
|
|
for (auto iter = keys.rbegin(); iter != keys.rend(); ++iter) {
|
2022-02-08 14:18:08 +00:00
|
|
|
std::string const& key = *iter;
|
|
|
|
QPDFObjectHandle value = dict.getKey(key);
|
|
|
|
if (key == "/Length") {
|
|
|
|
// omit stream lengths
|
|
|
|
if (value.isIndirect()) {
|
|
|
|
QTC::TC("qpdf", "QPDF exclude indirect length");
|
|
|
|
}
|
|
|
|
} else {
|
2024-01-04 12:20:15 +00:00
|
|
|
queue.push_back(value);
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (obj.isDictionary()) {
|
|
|
|
std::set<std::string> keys = obj.getKeys();
|
2023-05-20 18:56:01 +00:00
|
|
|
for (auto iter = keys.rbegin(); iter != keys.rend(); ++iter) {
|
2024-01-04 12:20:15 +00:00
|
|
|
queue.push_back(obj.getKey(*iter));
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
} else if (obj.isArray()) {
|
|
|
|
int n = obj.getArrayNItems();
|
|
|
|
for (int i = 1; i <= n; ++i) {
|
2024-01-04 12:20:15 +00:00
|
|
|
queue.push_back(obj.getArrayItem(n - i));
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2017-07-28 03:42:27 +00:00
|
|
|
bool
|
2019-01-06 15:34:52 +00:00
|
|
|
QPDF::pipeStreamData(
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<EncryptionParameters> encp,
|
|
|
|
std::shared_ptr<InputSource> file,
|
2019-01-06 15:34:52 +00:00
|
|
|
QPDF& qpdf_for_warning,
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDFObjGen const& og,
|
2022-02-08 14:18:08 +00:00
|
|
|
qpdf_offset_t offset,
|
|
|
|
size_t length,
|
|
|
|
QPDFObjectHandle stream_dict,
|
|
|
|
Pipeline* pipeline,
|
2017-09-12 19:48:08 +00:00
|
|
|
bool suppress_warnings,
|
|
|
|
bool will_retry)
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2023-11-18 14:40:32 +00:00
|
|
|
std::unique_ptr<Pipeline> to_delete;
|
2019-01-06 15:34:52 +00:00
|
|
|
if (encp->encrypted) {
|
2022-07-23 15:48:28 +00:00
|
|
|
decryptStream(encp, file, qpdf_for_warning, pipeline, og, stream_dict, to_delete);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2023-10-07 17:29:10 +00:00
|
|
|
bool attempted_finish = false;
|
2009-03-08 19:00:19 +00:00
|
|
|
try {
|
2022-02-08 14:18:08 +00:00
|
|
|
file->seek(offset, SEEK_SET);
|
2023-11-18 13:11:12 +00:00
|
|
|
auto buf = std::make_unique<char[]>(length);
|
|
|
|
if (auto read = file->read(buf.get(), length); read != length) {
|
2024-08-21 10:14:39 +00:00
|
|
|
throw damagedPDF(*file, "", offset + toO(read), "unexpected EOF reading stream data");
|
2022-02-08 14:18:08 +00:00
|
|
|
}
|
2023-11-18 13:11:12 +00:00
|
|
|
pipeline->write(buf.get(), length);
|
2023-10-07 17:29:10 +00:00
|
|
|
attempted_finish = true;
|
2017-08-19 13:18:14 +00:00
|
|
|
pipeline->finish();
|
2023-11-18 13:11:12 +00:00
|
|
|
return true;
|
2009-10-19 23:09:19 +00:00
|
|
|
} catch (QPDFExc& e) {
|
2017-07-28 03:42:27 +00:00
|
|
|
if (!suppress_warnings) {
|
2019-01-06 15:34:52 +00:00
|
|
|
qpdf_for_warning.warn(e);
|
2017-07-28 03:42:27 +00:00
|
|
|
}
|
2017-07-29 16:07:19 +00:00
|
|
|
} catch (std::exception& e) {
|
2017-07-28 03:42:27 +00:00
|
|
|
if (!suppress_warnings) {
|
|
|
|
QTC::TC("qpdf", "QPDF decoding error warning");
|
2022-04-03 20:10:27 +00:00
|
|
|
qpdf_for_warning.warn(
|
|
|
|
// line-break
|
2022-09-28 11:25:52 +00:00
|
|
|
damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
*file,
|
2019-01-06 15:34:52 +00:00
|
|
|
"",
|
|
|
|
file->getLastOffset(),
|
2022-04-03 20:10:27 +00:00
|
|
|
("error decoding stream data for object " + og.unparse(' ') + ": " +
|
2022-07-23 15:48:28 +00:00
|
|
|
e.what())));
|
2022-04-03 20:10:27 +00:00
|
|
|
if (will_retry) {
|
|
|
|
qpdf_for_warning.warn(
|
|
|
|
// line-break
|
2022-09-28 11:25:52 +00:00
|
|
|
damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
*file,
|
2022-04-03 20:10:27 +00:00
|
|
|
"",
|
|
|
|
file->getLastOffset(),
|
2023-11-18 13:11:12 +00:00
|
|
|
"stream will be re-processed without filtering to avoid data loss"));
|
2017-09-12 19:48:08 +00:00
|
|
|
}
|
2017-07-28 03:42:27 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2023-10-07 17:29:10 +00:00
|
|
|
if (!attempted_finish) {
|
2017-08-19 13:18:14 +00:00
|
|
|
try {
|
|
|
|
pipeline->finish();
|
|
|
|
} catch (std::exception&) {
|
|
|
|
// ignore
|
|
|
|
}
|
2017-07-29 16:07:19 +00:00
|
|
|
}
|
2023-12-23 02:45:10 +00:00
|
|
|
return false;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2012-12-30 00:00:05 +00:00
|
|
|
|
2019-01-06 15:34:52 +00:00
|
|
|
bool
|
|
|
|
QPDF::pipeStreamData(
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDFObjGen const& og,
|
2022-02-08 14:18:08 +00:00
|
|
|
qpdf_offset_t offset,
|
|
|
|
size_t length,
|
|
|
|
QPDFObjectHandle stream_dict,
|
|
|
|
Pipeline* pipeline,
|
2019-01-06 15:34:52 +00:00
|
|
|
bool suppress_warnings,
|
|
|
|
bool will_retry)
|
|
|
|
{
|
|
|
|
return pipeStreamData(
|
|
|
|
m->encp,
|
2024-09-05 13:50:38 +00:00
|
|
|
m->file_sp,
|
2019-01-06 15:34:52 +00:00
|
|
|
*this,
|
2022-07-23 15:48:28 +00:00
|
|
|
og,
|
2019-01-06 15:34:52 +00:00
|
|
|
offset,
|
|
|
|
length,
|
2021-02-06 21:25:10 +00:00
|
|
|
stream_dict,
|
|
|
|
pipeline,
|
|
|
|
suppress_warnings,
|
|
|
|
will_retry);
|
2019-01-06 15:34:52 +00:00
|
|
|
}
|
|
|
|
|
2019-01-07 02:18:36 +00:00
|
|
|
bool
|
|
|
|
QPDF::pipeForeignStreamData(
|
2022-04-09 18:35:56 +00:00
|
|
|
std::shared_ptr<ForeignStreamData> foreign,
|
2019-01-07 02:18:36 +00:00
|
|
|
Pipeline* pipeline,
|
2020-04-05 03:35:35 +00:00
|
|
|
bool suppress_warnings,
|
|
|
|
bool will_retry)
|
2019-01-07 02:18:36 +00:00
|
|
|
{
|
|
|
|
if (foreign->encp->encrypted) {
|
|
|
|
QTC::TC("qpdf", "QPDF pipe foreign encrypted stream");
|
|
|
|
}
|
|
|
|
return pipeStreamData(
|
|
|
|
foreign->encp,
|
|
|
|
foreign->file,
|
|
|
|
*this,
|
2022-07-23 15:48:28 +00:00
|
|
|
foreign->foreign_og,
|
2019-01-07 02:18:36 +00:00
|
|
|
foreign->offset,
|
|
|
|
foreign->length,
|
2021-02-06 21:25:10 +00:00
|
|
|
foreign->local_dict,
|
|
|
|
pipeline,
|
|
|
|
suppress_warnings,
|
|
|
|
will_retry);
|
2012-12-30 00:00:05 +00:00
|
|
|
}
|
2019-01-04 16:50:02 +00:00
|
|
|
|
2022-09-28 11:25:52 +00:00
|
|
|
// Throw a generic exception when we lack context for something more specific. New code should not
|
|
|
|
// use this. This method exists to improve somewhat from calling assert in very old code.
|
2019-01-04 16:50:02 +00:00
|
|
|
void
|
|
|
|
QPDF::stopOnError(std::string const& message)
|
|
|
|
{
|
2022-09-28 11:25:52 +00:00
|
|
|
throw damagedPDF("", message);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf.
|
|
|
|
QPDFExc
|
|
|
|
QPDF::damagedPDF(
|
2024-08-21 10:14:39 +00:00
|
|
|
InputSource& input, std::string const& object, qpdf_offset_t offset, std::string const& message)
|
2022-09-28 11:25:52 +00:00
|
|
|
{
|
2024-08-21 10:14:39 +00:00
|
|
|
return {qpdf_e_damaged_pdf, input.getName(), object, offset, message};
|
2022-09-28 11:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf. The object is taken from
|
|
|
|
// m->last_object_description.
|
|
|
|
QPDFExc
|
2024-08-21 10:14:39 +00:00
|
|
|
QPDF::damagedPDF(InputSource& input, qpdf_offset_t offset, std::string const& message)
|
2022-09-28 11:25:52 +00:00
|
|
|
{
|
|
|
|
return damagedPDF(input, m->last_object_description, offset, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf. The filename is taken from m->file.
|
|
|
|
QPDFExc
|
|
|
|
QPDF::damagedPDF(std::string const& object, qpdf_offset_t offset, std::string const& message)
|
|
|
|
{
|
2023-05-27 20:04:32 +00:00
|
|
|
return {qpdf_e_damaged_pdf, m->file->getName(), object, offset, message};
|
2022-09-28 11:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf. The filename is taken from m->file and the
|
|
|
|
// offset from .m->file->getLastOffset().
|
|
|
|
QPDFExc
|
|
|
|
QPDF::damagedPDF(std::string const& object, std::string const& message)
|
|
|
|
{
|
|
|
|
return damagedPDF(object, m->file->getLastOffset(), message);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf. The filename is taken from m->file and the object
|
|
|
|
// from .m->last_object_description.
|
|
|
|
QPDFExc
|
|
|
|
QPDF::damagedPDF(qpdf_offset_t offset, std::string const& message)
|
|
|
|
{
|
|
|
|
return damagedPDF(m->last_object_description, offset, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return an exception of type qpdf_e_damaged_pdf. The filename is taken from m->file, the object
|
|
|
|
// from m->last_object_description and the offset from m->file->getLastOffset().
|
|
|
|
QPDFExc
|
|
|
|
QPDF::damagedPDF(std::string const& message)
|
|
|
|
{
|
|
|
|
return damagedPDF(m->last_object_description, m->file->getLastOffset(), message);
|
2019-01-04 16:50:02 +00:00
|
|
|
}
|
2022-06-25 17:55:45 +00:00
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::everCalledGetAllPages() const
|
|
|
|
{
|
|
|
|
return m->ever_called_get_all_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::everPushedInheritedAttributesToPages() const
|
|
|
|
{
|
|
|
|
return m->ever_pushed_inherited_attributes_to_pages;
|
|
|
|
}
|
2023-01-28 18:41:58 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::removeSecurityRestrictions()
|
|
|
|
{
|
|
|
|
auto root = getRoot();
|
|
|
|
root.removeKey("/Perms");
|
|
|
|
auto acroform = root.getKey("/AcroForm");
|
|
|
|
if (acroform.isDictionary() && acroform.hasKey("/SigFlags")) {
|
|
|
|
acroform.replaceKey("/SigFlags", QPDFObjectHandle::newInteger(0));
|
|
|
|
}
|
|
|
|
}
|