octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-10-31 19:02:30 +00:00
Code Issues Releases Wiki Activity
c5f61fcbd3
qpdf/libqpdf/QPDF.cc
Jay Berkenbilt 31b2cfbb79 Fix up a few comments
2022-09-13 11:18:49 -04:00

2886 lines
92 KiB
C++
Raw Blame History

#include <qpdf/qpdf-config.h> // include first for large file support
#include <qpdf/QPDF.hh>
#include <algorithm>
#include <atomic>
#include <limits>
#include <map>
#include <memory.h>
#include <regex>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <qpdf/BufferInputSource.hh>
#include <qpdf/FileInputSource.hh>
#include <qpdf/OffsetInputSource.hh>
#include <qpdf/Pipeline.hh>
#include <qpdf/Pl_Discard.hh>
#include <qpdf/Pl_OStream.hh>
#include <qpdf/QPDFExc.hh>
#include <qpdf/QPDFLogger.hh>
#include <qpdf/QPDFObject_private.hh>
#include <qpdf/QPDF_Array.hh>
#include <qpdf/QPDF_Dictionary.hh>
#include <qpdf/QPDF_Null.hh>
#include <qpdf/QPDF_Reserved.hh>
#include <qpdf/QPDF_Stream.hh>
#include <qpdf/QPDF_Unresolved.hh>
#include <qpdf/QTC.hh>
#include <qpdf/QUtil.hh>
// 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);
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");
namespace
{
class InvalidInputSource: public InputSource
{
public:
virtual ~InvalidInputSource() = default;
virtual qpdf_offset_t
findAndSkipNextEOL() override
{
throwException();
return 0;
}
virtual std::string const&
getName() const override
{
static std::string name("closed input source");
return name;
}
virtual qpdf_offset_t
tell() override
{
throwException();
return 0;
}
virtual void
seek(qpdf_offset_t offset, int whence) override
{
throwException();
}
virtual void
rewind() override
{
throwException();
}
virtual size_t
read(char* buffer, size_t length) override
{
throwException();
return 0;
}
virtual void
unreadCh(char ch) override
{
throwException();
}
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
QPDF::ForeignStreamData::ForeignStreamData(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDFObjGen const& foreign_og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle local_dict) :
encp(encp),
file(file),
foreign_og(foreign_og),
offset(offset),
length(length),
local_dict(local_dict)
{
}
QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(
QPDF& destination_qpdf) :
QPDFObjectHandle::StreamDataProvider(true),
destination_qpdf(destination_qpdf)
{
}
bool
QPDF::CopiedStreamDataProvider::provideStreamData(
QPDFObjGen const& og,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
std::shared_ptr<ForeignStreamData> foreign_data = foreign_stream_data[og];
bool result = false;
if (foreign_data.get()) {
result = destination_qpdf.pipeForeignStreamData(
foreign_data, pipeline, suppress_warnings, will_retry);
QTC::TC("qpdf", "QPDF copy foreign with data", result ? 0 : 1);
} else {
auto foreign_stream = foreign_streams[og];
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);
}
return result;
}
void
QPDF::CopiedStreamDataProvider::registerForeignStream(
QPDFObjGen const& local_og, QPDFObjectHandle foreign_stream)
{
this->foreign_streams[local_og] = foreign_stream;
}
void
QPDF::CopiedStreamDataProvider::registerForeignStream(
QPDFObjGen const& local_og,
std::shared_ptr<ForeignStreamData> foreign_stream)
{
this->foreign_stream_data[local_og] = foreign_stream;
}
QPDF::StringDecrypter::StringDecrypter(QPDF* qpdf, QPDFObjGen const& og) :
qpdf(qpdf),
og(og)
{
}
void
QPDF::StringDecrypter::decryptString(std::string& val)
{
qpdf->decryptString(val, og);
}
std::string const&
QPDF::QPDFVersion()
{
// The C API relies on this being a static value.
return QPDF::qpdf_version;
}
QPDF::EncryptionParameters::EncryptionParameters() :
encrypted(false),
encryption_initialized(false),
encryption_V(0),
encryption_R(0),
encrypt_metadata(true),
cf_stream(e_none),
cf_string(e_none),
cf_file(e_none),
user_password_matched(false),
owner_password_matched(false)
{
}
QPDF::Members::Members() :
log(QPDFLogger::defaultLogger()),
unique_id(0),
file(new InvalidInputSource()),
provided_password_is_hex_key(false),
ignore_xref_streams(false),
suppress_warnings(false),
attempt_recovery(true),
encp(new EncryptionParameters),
pushed_inherited_attributes_to_pages(false),
ever_pushed_inherited_attributes_to_pages(false),
ever_called_get_all_pages(false),
copied_stream_data_provider(nullptr),
reconstructed_xref(false),
fixed_dangling_refs(false),
immediate_copy_from(false),
in_parse(false),
parsed(false),
first_xref_item_offset(0),
uncompressed_after_compressed(false)
{
}
QPDF::QPDF() :
m(new Members())
{
m->tokenizer.allowEOF();
// Generate a unique ID. It just has to be unique among all QPDF
// objects allocated throughout the lifetime of this running
// application.
static std::atomic<unsigned long long> unique_id{0};
m->unique_id = unique_id.fetch_add(1ULL);
}
QPDF::~QPDF()
{
// 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
// std::shared_ptr objects will prevent the objects from being
// deleted. Walk through all objects in the object cache, which is
// those objects that we read from the file, and break all
// resolved indirect references by replacing them with an internal
// object type representing that they have been destroyed. Note
// that we can't break references like this at any time when the
// 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.
// At this point, obviously no one is still using the QPDF object,
// but we'll explicitly clear the xref table anyway just to
// prevent any possibility of resolve() succeeding.
this->m->xref_table.clear();
auto null_obj = QPDF_Null::create();
for (auto const& iter: this->m->obj_cache) {
iter.second.object->disconnect();
iter.second.object->destroy();
}
}
std::shared_ptr<QPDF>
QPDF::create()
{
return std::make_shared<QPDF>();
}
void
QPDF::processFile(char const* filename, char const* password)
{
FileInputSource* fi = new FileInputSource(filename);
processInputSource(std::shared_ptr<InputSource>(fi), password);
}
void
QPDF::processFile(
char const* description, FILE* filep, bool close_file, char const* password)
{
FileInputSource* fi = new FileInputSource(description, filep, close_file);
processInputSource(std::shared_ptr<InputSource>(fi), password);
}
void
QPDF::processMemoryFile(
char const* description,
char const* buf,
size_t length,
char const* password)
{
processInputSource(
std::shared_ptr<InputSource>(
// line-break
new BufferInputSource(
description,
new Buffer(QUtil::unsigned_char_pointer(buf), length),
true)),
password);
}
void
QPDF::processInputSource(
std::shared_ptr<InputSource> source, char const* password)
{
this->m->file = source;
parse(password);
}
void
QPDF::closeInputSource()
{
this->m->file = std::shared_ptr<InputSource>(new InvalidInputSource());
}
void
QPDF::setPasswordIsHexKey(bool val)
{
this->m->provided_password_is_hex_key = val;
}
void
QPDF::emptyPDF()
{
processMemoryFile("empty PDF", EMPTY_PDF, strlen(EMPTY_PDF));
}
void
QPDF::registerStreamFilter(
std::string const& filter_name,
std::function<std::shared_ptr<QPDFStreamFilter>()> factory)
{
QPDF_Stream::registerStreamFilter(filter_name, factory);
}
void
QPDF::setIgnoreXRefStreams(bool val)
{
this->m->ignore_xref_streams = val;
}
std::shared_ptr<QPDFLogger>
QPDF::getLogger()
{
return this->m->log;
}
void
QPDF::setLogger(std::shared_ptr<QPDFLogger> l)
{
this->m->log = l;
}
void
QPDF::setOutputStreams(std::ostream* out, std::ostream* err)
{
setLogger(QPDFLogger::create());
this->m->log->setOutputStreams(out, err);
}
void
QPDF::setSuppressWarnings(bool val)
{
this->m->suppress_warnings = val;
}
void
QPDF::setAttemptRecovery(bool val)
{
this->m->attempt_recovery = val;
}
void
QPDF::setImmediateCopyFrom(bool val)
{
this->m->immediate_copy_from = val;
}
std::vector<QPDFExc>
QPDF::getWarnings()
{
std::vector<QPDFExc> result = this->m->warnings;
this->m->warnings.clear();
return result;
}
bool
QPDF::anyWarnings() const
{
return !this->m->warnings.empty();
}
size_t
QPDF::numWarnings() const
{
return this->m->warnings.size();
}
bool
QPDF::validatePDFVersion(char const*& p, std::string& version)
{
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;
}
}
return valid;
}
bool
QPDF::findHeader()
{
qpdf_offset_t global_offset = this->m->file->tell();
std::string line = this->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);
if (valid) {
this->m->pdf_version = version;
if (global_offset != 0) {
// Empirical evidence strongly suggests that when there is
// leading material prior to the 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");
this->m->file = std::shared_ptr<InputSource>(
new OffsetInputSource(this->m->file, global_offset));
}
}
return valid;
}
bool
QPDF::findStartxref()
{
QPDFTokenizer::Token t = readToken(this->m->file);
if (t == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "startxref")) {
t = readToken(this->m->file);
if (t.getType() == QPDFTokenizer::tt_integer) {
// Position in front of offset token
this->m->file->seek(this->m->file->getLastOffset(), SEEK_SET);
return true;
}
}
return false;
}
void
QPDF::parse(char const* password)
{
if (password) {
this->m->encp->provided_password = password;
}
// Find the header anywhere in the first 1024 bytes of the file.
PatternFinder hf(*this, &QPDF::findHeader);
if (!this->m->file->findFirst("%PDF-", 0, 1024, hf)) {
QTC::TC("qpdf", "QPDF not a pdf file");
warn(qpdf_e_damaged_pdf, "", 0, "can't find PDF header");
// QPDFWriter writes files that usually require at least
// version 1.2 for /FlateDecode
this->m->pdf_version = "1.2";
}
// 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.
this->m->file->seek(0, SEEK_END);
qpdf_offset_t end_offset = this->m->file->tell();
qpdf_offset_t start_offset = (end_offset > 1054 ? end_offset - 1054 : 0);
PatternFinder sf(*this, &QPDF::findStartxref);
qpdf_offset_t xref_offset = 0;
if (this->m->file->findLast("startxref", start_offset, 0, sf)) {
xref_offset =
QUtil::string_to_ll(readToken(this->m->file).getValue().c_str());
}
try {
if (xref_offset == 0) {
QTC::TC("qpdf", "QPDF can't find startxref");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
"can't find startxref");
}
try {
read_xref(xref_offset);
} catch (QPDFExc&) {
throw;
} catch (std::exception& e) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
std::string("error reading xref: ") + e.what());
}
} catch (QPDFExc& e) {
if (this->m->attempt_recovery) {
reconstruct_xref(e);
QTC::TC("qpdf", "QPDF reconstructed xref table");
} else {
throw e;
}
}
initializeEncryption();
this->m->parsed = true;
}
void
QPDF::inParse(bool v)
{
if (this->m->in_parse == v) {
// This happens of QPDFObjectHandle::parseInternal tries to
// resolve an indirect object while it is parsing.
throw std::logic_error(
"QPDF: re-entrant parsing detected. This is a qpdf bug."
" Please report at https://github.com/qpdf/qpdf/issues.");
}
this->m->in_parse = v;
}
void
QPDF::warn(QPDFExc const& e)
{
this->m->warnings.push_back(e);
if (!this->m->suppress_warnings) {
*this->m->log->getWarn()
<< "WARNING: " << this->m->warnings.back().what() << "\n";
}
}
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, this->getFilename(), object, offset, message));
}
void
QPDF::setTrailer(QPDFObjectHandle obj)
{
if (this->m->trailer.isInitialized()) {
return;
}
this->m->trailer = obj;
}
void
QPDF::reconstruct_xref(QPDFExc& e)
{
if (this->m->reconstructed_xref) {
// 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.
throw e;
}
this->m->reconstructed_xref = true;
warn(qpdf_e_damaged_pdf, "", 0, "file is damaged");
warn(e);
warn(
qpdf_e_damaged_pdf,
"",
0,
"Attempting to reconstruct cross-reference table");
// Delete all references to type 1 (uncompressed) objects
std::set<QPDFObjGen> to_delete;
for (auto const& iter: this->m->xref_table) {
if (iter.second.getType() == 1) {
to_delete.insert(iter.first);
}
}
for (auto const& iter: to_delete) {
this->m->xref_table.erase(iter);
}
this->m->file->seek(0, SEEK_END);
qpdf_offset_t eof = this->m->file->tell();
this->m->file->seek(0, SEEK_SET);
qpdf_offset_t line_start = 0;
// Don't allow very long tokens here during recovery.
static size_t const MAX_LEN = 100;
while (this->m->file->tell() < eof) {
this->m->file->findAndSkipNextEOL();
qpdf_offset_t next_line_start = this->m->file->tell();
this->m->file->seek(line_start, SEEK_SET);
QPDFTokenizer::Token t1 = readToken(this->m->file, MAX_LEN);
qpdf_offset_t token_start =
this->m->file->tell() - toO(t1.getValue().length());
if (token_start >= next_line_start) {
// don't process yet -- wait until we get to the line
// containing this token
} else if (t1.getType() == QPDFTokenizer::tt_integer) {
QPDFTokenizer::Token t2 = readToken(this->m->file, MAX_LEN);
QPDFTokenizer::Token t3 = readToken(this->m->file, MAX_LEN);
if ((t2.getType() == QPDFTokenizer::tt_integer) &&
(t3 == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "obj"))) {
int obj = QUtil::string_to_int(t1.getValue().c_str());
int gen = QUtil::string_to_int(t2.getValue().c_str());
insertXrefEntry(obj, 1, token_start, gen, true);
}
} else if (
(!this->m->trailer.isInitialized()) &&
(t1 == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "trailer"))) {
QPDFObjectHandle t =
readObject(this->m->file, "trailer", QPDFObjGen(), false);
if (!t.isDictionary()) {
// Oh well. It was worth a try.
} else {
setTrailer(t);
}
}
this->m->file->seek(next_line_start, SEEK_SET);
line_start = next_line_start;
}
if (!this->m->trailer.isInitialized()) {
// 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.
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
"unable to find trailer "
"dictionary while recovering damaged file");
}
// 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
QPDF::read_xref(qpdf_offset_t xref_offset)
{
std::map<int, int> free_table;
std::set<qpdf_offset_t> visited;
while (xref_offset) {
visited.insert(xref_offset);
char buf[7];
memset(buf, 0, sizeof(buf));
this->m->file->seek(xref_offset, SEEK_SET);
// 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;
if (1 == this->m->file->read(&ch, 1)) {
if (QUtil::is_space(ch)) {
skipped_space = true;
} else {
this->m->file->unreadCh(ch);
done = true;
}
} else {
QTC::TC(
"qpdf",
"QPDF eof skipping spaces before xref",
skipped_space ? 0 : 1);
done = true;
}
}
this->m->file->read(buf, sizeof(buf) - 1);
// 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.
if ((strncmp(buf, "xref", 4) == 0) && QUtil::is_space(buf[4])) {
if (skipped_space) {
QTC::TC("qpdf", "QPDF xref skipped space");
warn(
qpdf_e_damaged_pdf,
"",
0,
"extraneous whitespace seen before xref");
}
QTC::TC(
"qpdf",
"QPDF xref space",
((buf[4] == '\n') ? 0
: (buf[4] == '\r') ? 1
: (buf[4] == ' ') ? 2
: 9999));
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;
}
xref_offset = read_xrefTable(xref_offset + skip);
} else {
xref_offset = read_xrefStream(xref_offset);
}
if (visited.count(xref_offset) != 0) {
QTC::TC("qpdf", "QPDF xref loop");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
"loop detected following xref tables");
}
}
if (!this->m->trailer.isInitialized()) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
"unable to find trailer while reading xref");
}
int size = this->m->trailer.getKey("/Size").getIntValueAsInt();
int max_obj = 0;
if (!this->m->xref_table.empty()) {
max_obj = (*(this->m->xref_table.rbegin())).first.getObj();
}
if (!this->m->deleted_objects.empty()) {
max_obj = std::max(max_obj, *(this->m->deleted_objects.rbegin()));
}
if ((size < 1) || (size - 1 != max_obj)) {
QTC::TC("qpdf", "QPDF xref size mismatch");
warn(
qpdf_e_damaged_pdf,
"",
0,
(std::string("reported number of objects (") +
QUtil::int_to_string(size) +
") is not one plus the highest object number (" +
QUtil::int_to_string(max_obj) + ")"));
}
// 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.
this->m->deleted_objects.clear();
}
bool
QPDF::parse_xrefFirst(std::string const& line, int& obj, int& num, int& bytes)
{
// 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;
}
bytes = toI(p - start);
obj = QUtil::string_to_int(obj_str.c_str());
num = QUtil::string_to_int(num_str.c_str());
return true;
}
bool
QPDF::parse_xrefEntry(
std::string const& line, qpdf_offset_t& f1, int& f2, char& type)
{
// 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();
// 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) {
warn(
qpdf_e_damaged_pdf,
"xref table",
this->m->file->getLastOffset(),
"accepting invalid xref table entry");
}
f1 = QUtil::string_to_ll(f1_str.c_str());
f2 = QUtil::string_to_int(f2_str.c_str());
return true;
}
qpdf_offset_t
QPDF::read_xrefTable(qpdf_offset_t xref_offset)
{
std::vector<QPDFObjGen> deleted_items;
this->m->file->seek(xref_offset, SEEK_SET);
bool done = false;
while (!done) {
char linebuf[51];
memset(linebuf, 0, sizeof(linebuf));
this->m->file->read(linebuf, sizeof(linebuf) - 1);
std::string line = linebuf;
int obj = 0;
int num = 0;
int bytes = 0;
if (!parse_xrefFirst(line, obj, num, bytes)) {
QTC::TC("qpdf", "QPDF invalid xref");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref table",
this->m->file->getLastOffset(),
"xref syntax invalid");
}
this->m->file->seek(this->m->file->getLastOffset() + bytes, SEEK_SET);
for (qpdf_offset_t i = obj; i - num < obj; ++i) {
if (i == 0) {
// This is needed by checkLinearization()
this->m->first_xref_item_offset = this->m->file->tell();
}
std::string xref_entry = this->m->file->readLine(30);
// For xref_table, these will always be small enough to be ints
qpdf_offset_t f1 = 0;
int f2 = 0;
char type = '\0';
if (!parse_xrefEntry(xref_entry, f1, f2, type)) {
QTC::TC("qpdf", "QPDF invalid xref entry");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref table",
this->m->file->getLastOffset(),
"invalid xref entry (obj=" + QUtil::int_to_string(i) + ")");
}
if (type == 'f') {
// Save deleted items until after we've checked the
// XRefStm, if any.
deleted_items.push_back(QPDFObjGen(toI(i), f2));
} else {
insertXrefEntry(toI(i), 1, f1, f2);
}
}
qpdf_offset_t pos = this->m->file->tell();
QPDFTokenizer::Token t = readToken(this->m->file);
if (t == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "trailer")) {
done = true;
} else {
this->m->file->seek(pos, SEEK_SET);
}
}
// Set offset to previous xref table if any
QPDFObjectHandle cur_trailer =
readObject(this->m->file, "trailer", QPDFObjGen(), false);
if (!cur_trailer.isDictionary()) {
QTC::TC("qpdf", "QPDF missing trailer");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
this->m->file->getLastOffset(),
"expected trailer dictionary");
}
if (!this->m->trailer.isInitialized()) {
setTrailer(cur_trailer);
if (!this->m->trailer.hasKey("/Size")) {
QTC::TC("qpdf", "QPDF trailer lacks size");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"trailer",
this->m->file->getLastOffset(),
"trailer dictionary lacks /Size key");
}
if (!this->m->trailer.getKey("/Size").isInteger()) {
QTC::TC("qpdf", "QPDF trailer size not integer");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"trailer",
this->m->file->getLastOffset(),
"/Size key in trailer dictionary is not "
"an integer");
}
}
if (cur_trailer.hasKey("/XRefStm")) {
if (this->m->ignore_xref_streams) {
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.
(void)read_xrefStream(
cur_trailer.getKey("/XRefStm").getIntValue());
} else {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
"invalid /XRefStm");
}
}
}
// Handle any deleted items now that we've read the /XRefStm.
for (auto const& og: deleted_items) {
insertXrefEntry(og.getObj(), 0, 0, og.getGen());
}
if (cur_trailer.hasKey("/Prev")) {
if (!cur_trailer.getKey("/Prev").isInteger()) {
QTC::TC("qpdf", "QPDF trailer prev not integer");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"trailer",
this->m->file->getLastOffset(),
"/Prev key in trailer dictionary is not "
"an integer");
}
QTC::TC("qpdf", "QPDF prev key in trailer dictionary");
xref_offset = cur_trailer.getKey("/Prev").getIntValue();
} else {
xref_offset = 0;
}
return xref_offset;
}
qpdf_offset_t
QPDF::read_xrefStream(qpdf_offset_t xref_offset)
{
bool found = false;
if (!this->m->ignore_xref_streams) {
QPDFObjGen x_og;
QPDFObjectHandle xref_obj;
try {
xref_obj = readObjectAtOffset(
false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og);
} catch (QPDFExc&) {
// ignore -- report error below
}
if (xref_obj.isStreamOfType("/XRef")) {
QTC::TC("qpdf", "QPDF found xref stream");
found = true;
xref_offset = processXRefStream(xref_offset, xref_obj);
}
}
if (!found) {
QTC::TC("qpdf", "QPDF can't find xref");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
xref_offset,
"xref not found");
}
return xref_offset;
}
qpdf_offset_t
QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
{
QPDFObjectHandle dict = xref_obj.getDict();
QPDFObjectHandle W_obj = dict.getKey("/W");
QPDFObjectHandle Index_obj = dict.getKey("/Index");
if (!(W_obj.isArray() && (W_obj.getArrayNItems() >= 3) &&
W_obj.getArrayItem(0).isInteger() &&
W_obj.getArrayItem(1).isInteger() &&
W_obj.getArrayItem(2).isInteger() &&
dict.getKey("/Size").isInteger() &&
(Index_obj.isArray() || Index_obj.isNull()))) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
"Cross-reference stream does not have"
" proper /W and /Index keys");
}
int W[3];
size_t entry_size = 0;
int max_bytes = sizeof(qpdf_offset_t);
for (int i = 0; i < 3; ++i) {
W[i] = W_obj.getArrayItem(i).getIntValueAsInt();
if (W[i] > max_bytes) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
"Cross-reference stream's /W contains"
" impossibly large values");
}
entry_size += toS(W[i]);
}
if (entry_size == 0) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
"Cross-reference stream's /W indicates"
" entry size of 0");
}
unsigned long long max_num_entries =
static_cast<unsigned long long>(-1) / entry_size;
std::vector<long long> indx;
if (Index_obj.isArray()) {
int n_index = Index_obj.getArrayNItems();
if ((n_index % 2) || (n_index < 2)) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
"Cross-reference stream's /Index has an"
" invalid number of values");
}
for (int i = 0; i < n_index; ++i) {
if (Index_obj.getArrayItem(i).isInteger()) {
indx.push_back(Index_obj.getArrayItem(i).getIntValue());
} else {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
("Cross-reference stream's /Index's item " +
QUtil::int_to_string(i) + " is not an integer"));
}
}
QTC::TC("qpdf", "QPDF xref /Index is array", n_index == 2 ? 0 : 1);
} else {
QTC::TC("qpdf", "QPDF xref /Index is null");
long long size = dict.getKey("/Size").getIntValue();
indx.push_back(0);
indx.push_back(size);
}
size_t num_entries = 0;
for (size_t i = 1; i < indx.size(); i += 2) {
if (indx.at(i) > QIntC::to_longlong(max_num_entries - num_entries)) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
("Cross-reference stream claims to contain"
" too many entries: " +
QUtil::int_to_string(indx.at(i)) + " " +
QUtil::uint_to_string(max_num_entries) + " " +
QUtil::uint_to_string(num_entries)));
}
num_entries += toS(indx.at(i));
}
// entry_size and num_entries have both been validated to ensure
// that this multiplication does not cause an overflow.
size_t expected_size = entry_size * num_entries;
std::shared_ptr<Buffer> bp = xref_obj.getStreamData(qpdf_dl_specialized);
size_t actual_size = bp->getSize();
if (expected_size != actual_size) {
QPDFExc x(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
xref_offset,
("Cross-reference stream data has the wrong size;"
" expected = " +
QUtil::uint_to_string(expected_size) +
"; actual = " + QUtil::uint_to_string(actual_size)));
if (expected_size > actual_size) {
throw x;
} else {
warn(x);
}
}
size_t cur_chunk = 0;
int chunk_count = 0;
bool saw_first_compressed_object = false;
// Actual size vs. expected size check above ensures that we will
// not overflow any buffers here. We know that entry_size *
// num_entries is equal to the size of the buffer.
unsigned char const* data = bp->getBuffer();
for (size_t i = 0; i < num_entries; ++i) {
// Read this entry
unsigned char const* entry = data + (entry_size * i);
qpdf_offset_t fields[3];
unsigned char const* p = entry;
for (int j = 0; j < 3; ++j) {
fields[j] = 0;
if ((j == 0) && (W[0] == 0)) {
QTC::TC("qpdf", "QPDF default for xref stream field 0");
fields[0] = 1;
}
for (int k = 0; k < W[j]; ++k) {
fields[j] <<= 8;
fields[j] += toI(*p++);
}
}
// Get the object and generation number. The object number is
// based on /Index. The generation number is 0 unless this is
// an uncompressed object record, in which case the generation
// number appears as the third field.
int obj = toI(indx.at(cur_chunk));
if ((obj < 0) ||
((std::numeric_limits<int>::max() - obj) < chunk_count)) {
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "adding " << chunk_count << " to " << obj
<< " while computing index in xref stream would cause"
<< " an integer overflow";
throw std::range_error(msg.str());
}
obj += chunk_count;
++chunk_count;
if (chunk_count >= indx.at(cur_chunk + 1)) {
cur_chunk += 2;
chunk_count = 0;
}
if (saw_first_compressed_object) {
if (fields[0] != 2) {
this->m->uncompressed_after_compressed = true;
}
} else if (fields[0] == 2) {
saw_first_compressed_object = true;
}
if (obj == 0) {
// This is needed by checkLinearization()
this->m->first_xref_item_offset = xref_offset;
}
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.
fields[2] = 0;
}
insertXrefEntry(obj, toI(fields[0]), fields[1], toI(fields[2]));
}
if (!this->m->trailer.isInitialized()) {
setTrailer(dict);
}
if (dict.hasKey("/Prev")) {
if (!dict.getKey("/Prev").isInteger()) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
this->m->file->getLastOffset(),
"/Prev key in xref stream dictionary is not "
"an integer");
}
QTC::TC("qpdf", "QPDF prev key in xref stream dictionary");
xref_offset = dict.getKey("/Prev").getIntValue();
} else {
xref_offset = 0;
}
return xref_offset;
}
void
QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2, bool overwrite)
{
// Populate the xref table in such a way that the first reference
// to an object that we see, which is the one in the latest xref
// table in which it appears, is the one that gets stored. This
// works because we are reading more recent appends before older
// ones. Exception: if overwrite is true, then replace any
// existing object. This is used in xref recovery mode, which
// reads the file from beginning to end.
// 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.
{ // private scope
int gen = (f0 == 2 ? 0 : f2);
QPDFObjGen og(obj, gen);
if (this->m->xref_table.count(og)) {
if (overwrite) {
QTC::TC("qpdf", "QPDF xref overwrite object");
this->m->xref_table.erase(og);
} else {
QTC::TC("qpdf", "QPDF xref reused object");
return;
}
}
if (this->m->deleted_objects.count(obj)) {
QTC::TC("qpdf", "QPDF xref deleted object");
return;
}
}
switch (f0) {
case 0:
this->m->deleted_objects.insert(obj);
break;
case 1:
// f2 is generation
QTC::TC("qpdf", "QPDF xref gen > 0", ((f2 > 0) ? 1 : 0));
this->m->xref_table[QPDFObjGen(obj, f2)] = QPDFXRefEntry(f0, f1, f2);
break;
case 2:
this->m->xref_table[QPDFObjGen(obj, 0)] = QPDFXRefEntry(f0, f1, f2);
break;
default:
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"xref stream",
this->m->file->getLastOffset(),
"unknown xref stream entry type " + QUtil::int_to_string(f0));
break;
}
}
void
QPDF::showXRefTable()
{
auto& cout = *this->m->log->getInfo();
for (auto const& iter: this->m->xref_table) {
QPDFObjGen const& og = iter.first;
QPDFXRefEntry const& entry = iter.second;
cout << og.unparse('/') << ": ";
switch (entry.getType()) {
case 1:
cout << "uncompressed; offset = " << entry.getOffset();
break;
case 2:
*this->m->log->getInfo()
<< "compressed; stream = " << entry.getObjStreamNumber()
<< ", index = " << entry.getObjStreamIndex();
break;
default:
throw std::logic_error("unknown cross-reference table type while"
" showing xref_table");
break;
}
this->m->log->info("\n");
}
}
void
QPDF::fixDanglingReferences(bool force)
{
if (this->m->fixed_dangling_refs && (!force)) {
return;
}
this->m->fixed_dangling_refs = true;
// Create a set of all known indirect objects including those
// we've previously resolved and those that we have created.
std::set<QPDFObjGen> to_process;
for (auto const& iter: this->m->obj_cache) {
to_process.insert(iter.first);
}
for (auto const& iter: this->m->xref_table) {
to_process.insert(iter.first);
}
// For each non-scalar item to process, put it in the queue.
std::list<QPDFObjectHandle> queue;
queue.push_back(this->m->trailer);
for (auto const& og: to_process) {
auto obj = getObject(og);
if (obj.isDictionary() || obj.isArray()) {
queue.push_back(obj);
} else if (obj.isStream()) {
queue.push_back(obj.getDict());
}
}
// Process the queue by recursively resolving all object
// references. We don't need to do loop detection because we don't
// traverse known indirect objects when processing the queue.
while (!queue.empty()) {
QPDFObjectHandle obj = queue.front();
queue.pop_front();
std::list<QPDFObjectHandle> to_check;
if (obj.isDictionary()) {
std::map<std::string, QPDFObjectHandle> members =
obj.getDictAsMap();
for (auto const& iter: members) {
to_check.push_back(iter.second);
}
} else if (obj.isArray()) {
auto arr = QPDFObjectHandle::ObjAccessor::asArray(obj);
arr->addExplicitElementsToList(to_check);
}
for (auto sub: to_check) {
if (sub.isIndirect()) {
if ((sub.getOwningQPDF() == this) &&
isUnresolved(sub.getObjGen())) {
QTC::TC("qpdf", "QPDF detected dangling ref");
queue.push_back(sub);
}
} else {
queue.push_back(sub);
}
}
}
}
size_t
QPDF::getObjectCount()
{
// This method returns the next available indirect object number.
// makeIndirectObject uses it for this purpose. After
// fixDanglingReferences is called, all objects in the xref table
// will also be in obj_cache.
fixDanglingReferences();
QPDFObjGen og(0, 0);
if (!this->m->obj_cache.empty()) {
og = (*(this->m->obj_cache.rbegin())).first;
}
return toS(og.getObj());
}
std::vector<QPDFObjectHandle>
QPDF::getAllObjects()
{
// After fixDanglingReferences is called, all objects are in the
// object cache.
fixDanglingReferences(true);
std::vector<QPDFObjectHandle> result;
for (auto const& iter: this->m->obj_cache) {
result.push_back(newIndirect(iter.first, iter.second.object));
}
return result;
}
void
QPDF::setLastObjectDescription(
std::string const& description, QPDFObjGen const& og)
{
this->m->last_object_description.clear();
if (!description.empty()) {
this->m->last_object_description += description;
if (og.isIndirect()) {
this->m->last_object_description += ": ";
}
}
if (og.isIndirect()) {
this->m->last_object_description += "object " + og.unparse(' ');
}
}
QPDFObjectHandle
QPDF::readObject(
std::shared_ptr<InputSource> input,
std::string const& description,
QPDFObjGen const& og,
bool in_object_stream)
{
setLastObjectDescription(description, og);
qpdf_offset_t offset = input->tell();
bool empty = false;
std::shared_ptr<StringDecrypter> decrypter_ph;
StringDecrypter* decrypter = nullptr;
if (this->m->encp->encrypted && (!in_object_stream)) {
decrypter_ph = std::make_shared<StringDecrypter>(this, og);
decrypter = decrypter_ph.get();
}
QPDFObjectHandle object = QPDFObjectHandle::parse(
input,
this->m->last_object_description,
this->m->tokenizer,
empty,
decrypter,
this);
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.
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->getLastOffset(),
"empty object treated as null"));
} else if (object.isDictionary() && (!in_object_stream)) {
// check for stream
qpdf_offset_t cur_offset = input->tell();
if (readToken(input) ==
QPDFTokenizer::Token(QPDFTokenizer::tt_word, "stream")) {
// 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.
bool done = false;
while (!done) {
done = true;
char ch;
if (input->read(&ch, 1) == 0) {
// A premature EOF here will result in some
// other problem that will get reported at
// another time.
} else if (ch == '\n') {
// ready to read stream data
QTC::TC("qpdf", "QPDF stream with NL only");
} else if (ch == '\r') {
// Read another character
if (input->read(&ch, 1) != 0) {
if (ch == '\n') {
// Ready to read stream data
QTC::TC("qpdf", "QPDF stream with CRNL");
} else {
// 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");
input->unreadCh(ch);
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->tell(),
"stream keyword followed"
" by carriage return only"));
}
}
} else if (QUtil::is_space(ch)) {
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->tell(),
"stream keyword followed by"
" extraneous whitespace"));
done = false;
} else {
QTC::TC("qpdf", "QPDF stream without newline");
input->unreadCh(ch);
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->tell(),
"stream keyword not followed"
" by proper line terminator"));
}
}
// Must get offset before accessing any additional
// objects since resolving a previously unresolved
// indirect object will change file position.
qpdf_offset_t stream_offset = input->tell();
size_t length = 0;
try {
std::map<std::string, QPDFObjectHandle> dict =
object.getDictAsMap();
if (dict.count("/Length") == 0) {
QTC::TC("qpdf", "QPDF stream without length");
throw QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
offset,
"stream dictionary lacks /Length key");
}
QPDFObjectHandle length_obj = dict["/Length"];
if (!length_obj.isInteger()) {
QTC::TC("qpdf", "QPDF stream length not integer");
throw QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
offset,
"/Length key in stream dictionary is not "
"an integer");
}
length = toS(length_obj.getUIntValue());
// Seek in two steps to avoid potential integer overflow
input->seek(stream_offset, SEEK_SET);
input->seek(toO(length), SEEK_CUR);
if (!(readToken(input) ==
QPDFTokenizer::Token(
QPDFTokenizer::tt_word, "endstream"))) {
QTC::TC("qpdf", "QPDF missing endstream");
throw QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->getLastOffset(),
"expected endstream");
}
} catch (QPDFExc& e) {
if (this->m->attempt_recovery) {
warn(e);
length = recoverStreamLength(input, og, stream_offset);
} else {
throw e;
}
}
object = QPDFObjectHandle::Factory::newStream(
this, og, object, stream_offset, length);
} else {
input->seek(cur_offset, SEEK_SET);
}
}
// Override last_offset so that it points to the beginning of the
// object we just read
input->setLastOffset(offset);
return object;
}
bool
QPDF::findEndstream()
{
// Find endstream or endobj. Position the input at that token.
QPDFTokenizer::Token t = readToken(this->m->file, 20);
if ((t.getType() == QPDFTokenizer::tt_word) &&
((t.getValue() == "endobj") || (t.getValue() == "endstream"))) {
this->m->file->seek(this->m->file->getLastOffset(), SEEK_SET);
return true;
}
return false;
}
size_t
QPDF::recoverStreamLength(
std::shared_ptr<InputSource> input,
QPDFObjGen const& og,
qpdf_offset_t stream_offset)
{
// Try to reconstruct stream length by looking for
// endstream or endobj
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
stream_offset,
"attempting to recover stream length"));
PatternFinder ef(*this, &QPDF::findEndstream);
size_t length = 0;
if (this->m->file->findFirst("end", stream_offset, 0, ef)) {
length = toS(this->m->file->tell() - stream_offset);
// Reread endstream but, if it was endobj, don't skip that.
QPDFTokenizer::Token t = readToken(this->m->file);
if (t.getValue() == "endobj") {
this->m->file->seek(this->m->file->getLastOffset(), SEEK_SET);
}
}
if (length) {
qpdf_offset_t this_obj_offset = 0;
QPDFObjGen this_og;
// Make sure this is inside this object
for (auto const& iter: this->m->xref_table) {
QPDFXRefEntry const& entry = iter.second;
if (entry.getType() == 1) {
qpdf_offset_t obj_offset = entry.getOffset();
if ((obj_offset > stream_offset) &&
((this_obj_offset == 0) ||
(this_obj_offset > obj_offset))) {
this_obj_offset = obj_offset;
this_og = iter.first;
}
}
}
if (this_obj_offset && (this_og == og)) {
// Well, we found endstream\nendobj within the space
// allowed for this object, so we're probably in good
// shape.
} else {
QTC::TC("qpdf", "QPDF found wrong endstream in recovery");
}
}
if (length == 0) {
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
stream_offset,
"unable to recover stream data;"
" treating stream as empty"));
} else {
warn(QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
stream_offset,
"recovered stream length: " + QUtil::uint_to_string(length)));
}
QTC::TC("qpdf", "QPDF recovered stream length");
return length;
}
QPDFTokenizer::Token
QPDF::readToken(std::shared_ptr<InputSource> input, size_t max_len)
{
return this->m->tokenizer.readToken(
input, this->m->last_object_description, true, max_len);
}
QPDFObjectHandle
QPDF::readObjectAtOffset(
bool try_recovery,
qpdf_offset_t offset,
std::string const& description,
QPDFObjGen const& exp_og,
QPDFObjGen& og)
{
bool check_og = true;
if (exp_og.getObj() == 0) {
// 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;
} else {
setLastObjectDescription(description, exp_og);
}
if (!this->m->attempt_recovery) {
try_recovery = false;
}
// Special case: if offset is 0, just return null. Some PDF
// writers, in particular "Mac OS X 10.7.5 Quartz PDFContext", may
// store deleted objects in the xref table as "0000000000 00000
// n", which is not correct, but it won't hurt anything for to
// ignore these.
if (offset == 0) {
QTC::TC("qpdf", "QPDF bogus 0 offset", 0);
warn(
qpdf_e_damaged_pdf,
this->m->last_object_description,
0,
"object has offset 0");
return QPDFObjectHandle::newNull();
}
this->m->file->seek(offset, SEEK_SET);
QPDFTokenizer::Token tobjid = readToken(this->m->file);
QPDFTokenizer::Token tgen = readToken(this->m->file);
QPDFTokenizer::Token tobj = readToken(this->m->file);
bool objidok = (tobjid.getType() == QPDFTokenizer::tt_integer);
int genok = (tgen.getType() == QPDFTokenizer::tt_integer);
int objok = (tobj == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "obj"));
QTC::TC("qpdf", "QPDF check objid", objidok ? 1 : 0);
QTC::TC("qpdf", "QPDF check generation", genok ? 1 : 0);
QTC::TC("qpdf", "QPDF check obj", objok ? 1 : 0);
try {
if (!(objidok && genok && objok)) {
QTC::TC("qpdf", "QPDF expected n n obj");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
offset,
"expected n n obj");
}
int objid = QUtil::string_to_int(tobjid.getValue().c_str());
int generation = QUtil::string_to_int(tgen.getValue().c_str());
og = QPDFObjGen(objid, generation);
if (objid == 0) {
QTC::TC("qpdf", "QPDF object id 0");
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
offset,
"object with ID 0");
}
if (check_og && (exp_og != og)) {
QTC::TC("qpdf", "QPDF err wrong objid/generation");
QPDFExc e(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
offset,
(std::string("expected ") + exp_og.unparse(' ') + " obj"));
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);
}
}
} catch (QPDFExc& e) {
if (try_recovery) {
// Try again after reconstructing xref table
reconstruct_xref(e);
if (this->m->xref_table.count(exp_og) &&
(this->m->xref_table[exp_og].getType() == 1)) {
qpdf_offset_t new_offset =
this->m->xref_table[exp_og].getOffset();
QPDFObjectHandle result = readObjectAtOffset(
false, new_offset, description, exp_og, og);
QTC::TC("qpdf", "QPDF recovered in readObjectAtOffset");
return result;
} else {
QTC::TC("qpdf", "QPDF object gone after xref reconstruction");
warn(
qpdf_e_damaged_pdf,
"",
0,
std::string(
"object " + exp_og.unparse(' ') +
" not found in file after regenerating"
" cross reference table"));
return QPDFObjectHandle::newNull();
}
} else {
throw e;
}
}
QPDFObjectHandle oh = readObject(this->m->file, description, og, false);
if (!(readToken(this->m->file) ==
QPDFTokenizer::Token(QPDFTokenizer::tt_word, "endobj"))) {
QTC::TC("qpdf", "QPDF err expected endobj");
warn(
qpdf_e_damaged_pdf,
this->m->last_object_description,
this->m->file->getLastOffset(),
"expected endobj");
}
if (isUnresolved(og)) {
// 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).
// 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 = this->m->file->tell();
// skip over spaces
while (true) {
char ch;
if (this->m->file->read(&ch, 1)) {
if (!isspace(static_cast<unsigned char>(ch))) {
this->m->file->seek(-1, SEEK_CUR);
break;
}
} else {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
this->m->file->tell(),
"EOF after endobj");
}
}
qpdf_offset_t end_after_space = this->m->file->tell();
updateCache(
og,
QPDFObjectHandle::ObjAccessor::getObject(oh),
end_before_space,
end_after_space);
}
return oh;
}
void
QPDF::resolve(QPDFObjGen const& og)
{
if (isCached(og) && !isUnresolved(og)) {
// We only need to resolve unresolved objects
return;
}
if (this->m->resolving.count(og)) {
// 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.
QTC::TC("qpdf", "QPDF recursion loop in resolve");
warn(
qpdf_e_damaged_pdf,
"",
this->m->file->getLastOffset(),
("loop detected resolving object " + og.unparse(' ')));
updateCache(og, QPDF_Null::create(), -1, -1);
return;
}
ResolveRecorder rr(this, og);
if (m->xref_table.count(og) != 0) {
QPDFXRefEntry const& entry = this->m->xref_table[og];
try {
switch (entry.getType()) {
case 1:
{
qpdf_offset_t offset = entry.getOffset();
// Object stored in cache by readObjectAtOffset
QPDFObjGen a_og;
QPDFObjectHandle oh =
readObjectAtOffset(true, offset, "", og, a_og);
}
break;
case 2:
resolveObjectsInStream(entry.getObjStreamNumber());
break;
default:
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
("object " + og.unparse('/') +
" has unexpected xref entry type"));
}
} catch (QPDFExc& e) {
warn(e);
} catch (std::exception& e) {
warn(
qpdf_e_damaged_pdf,
"",
0,
("object " + og.unparse('/') +
": error reading object: " + e.what()));
}
}
if (isUnresolved(og)) {
// PDF spec says unknown objects resolve to the null object.
QTC::TC("qpdf", "QPDF resolve failure to null");
updateCache(og, QPDF_Null::create(), -1, -1);
}
auto result(this->m->obj_cache[og].object);
if (!result->hasDescription()) {
result->setDescription(this, ("object " + og.unparse(' ')));
}
}
void
QPDF::resolveObjectsInStream(int obj_stream_number)
{
if (this->m->resolved_object_streams.count(obj_stream_number)) {
return;
}
this->m->resolved_object_streams.insert(obj_stream_number);
// Force resolution of object stream
QPDFObjectHandle obj_stream = getObjectByID(obj_stream_number, 0);
if (!obj_stream.isStream()) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
this->m->file->getLastOffset(),
("supposed object stream " +
QUtil::int_to_string(obj_stream_number) + " is not a stream"));
}
// For linearization data in the object, use the data from the
// object stream for the objects in the stream.
QPDFObjGen stream_og(obj_stream_number, 0);
qpdf_offset_t end_before_space =
this->m->obj_cache[stream_og].end_before_space;
qpdf_offset_t end_after_space =
this->m->obj_cache[stream_og].end_after_space;
QPDFObjectHandle dict = obj_stream.getDict();
if (!dict.isDictionaryOfType("/ObjStm")) {
QTC::TC("qpdf", "QPDF ERR object stream with wrong type");
warn(
qpdf_e_damaged_pdf,
this->m->last_object_description,
this->m->file->getLastOffset(),
("supposed object stream " +
QUtil::int_to_string(obj_stream_number) + " has wrong type"));
}
if (!(dict.getKey("/N").isInteger() && dict.getKey("/First").isInteger())) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
this->m->last_object_description,
this->m->file->getLastOffset(),
("object stream " + QUtil::int_to_string(obj_stream_number) +
" has incorrect keys"));
}
int n = dict.getKey("/N").getIntValueAsInt();
int first = dict.getKey("/First").getIntValueAsInt();
std::map<int, int> offsets;
std::shared_ptr<Buffer> bp = obj_stream.getStreamData(qpdf_dl_specialized);
auto input = std::shared_ptr<InputSource>(
// line-break
new BufferInputSource(
(this->m->file->getName() + " object stream " +
QUtil::int_to_string(obj_stream_number)),
bp.get()));
for (int i = 0; i < n; ++i) {
QPDFTokenizer::Token tnum = readToken(input);
QPDFTokenizer::Token toffset = readToken(input);
if (!((tnum.getType() == QPDFTokenizer::tt_integer) &&
(toffset.getType() == QPDFTokenizer::tt_integer))) {
throw QPDFExc(
qpdf_e_damaged_pdf,
input->getName(),
this->m->last_object_description,
input->getLastOffset(),
"expected integer in object stream header");
}
int num = QUtil::string_to_int(tnum.getValue().c_str());
long long offset = QUtil::string_to_int(toffset.getValue().c_str());
offsets[num] = QIntC::to_int(offset + first);
}
// 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.
for (auto const& iter: offsets) {
QPDFObjGen og(iter.first, 0);
QPDFXRefEntry const& entry = this->m->xref_table[og];
if ((entry.getType() == 2) &&
(entry.getObjStreamNumber() == obj_stream_number)) {
int offset = iter.second;
input->seek(offset, SEEK_SET);
QPDFObjectHandle oh = readObject(input, "", og, true);
updateCache(
og,
QPDFObjectHandle::ObjAccessor::getObject(oh),
end_before_space,
end_after_space);
} else {
QTC::TC("qpdf", "QPDF not caching overridden objstm object");
}
}
}
QPDFObjectHandle
QPDF::newIndirect(QPDFObjGen const& og, std::shared_ptr<QPDFObject> const& obj)
{
obj->setObjGen(this, og);
if (!obj->hasDescription()) {
obj->setDescription(this, "object " + og.unparse(' '));
}
return QPDFObjectHandle::Factory::newIndirect(obj);
}
void
QPDF::updateCache(
QPDFObjGen const& og,
std::shared_ptr<QPDFObject> const& object,
qpdf_offset_t end_before_space,
qpdf_offset_t end_after_space)
{
object->setObjGen(this, og);
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);
}
}
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();
}
QPDFObjectHandle
QPDF::makeIndirectObject(QPDFObjectHandle oh)
{
int max_objid = toI(getObjectCount());
if (max_objid == std::numeric_limits<int>::max()) {
throw std::range_error(
"max object id is too high to create new objects");
}
QPDFObjGen next(max_objid + 1, 0);
m->obj_cache[next] =
ObjCache(QPDFObjectHandle::ObjAccessor::getObject(oh), -1, -1);
return newIndirect(next, m->obj_cache[next].object);
}
QPDFObjectHandle
QPDF::reserveObjectIfNotExists(QPDFObjGen const& og)
{
if (!isCached(og) && !m->xref_table.count(og)) {
resolve(og);
m->obj_cache[og].object = QPDF_Reserved::create();
return newIndirect(og, m->obj_cache[og].object);
} else {
return getObject(og);
}
}
QPDFObjectHandle
QPDF::reserveStream(QPDFObjGen const& og)
{
return QPDFObjectHandle::Factory::newStream(
this, og, QPDFObjectHandle::newDictionary(), 0, 0);
}
QPDFObjectHandle
QPDF::getObject(QPDFObjGen const& og)
{
if (!og.isIndirect()) {
return QPDFObjectHandle::newNull();
}
if (!isCached(og)) {
m->obj_cache[og] = ObjCache(QPDF_Unresolved::create(this, og), -1, -1);
}
return newIndirect(og, m->obj_cache[og].object);
}
QPDFObjectHandle
QPDF::getObject(int objid, int generation)
{
return getObject(QPDFObjGen(objid, generation));
}
QPDFObjectHandle
QPDF::getObjectByObjGen(QPDFObjGen const& og)
{
return getObject(og);
}
QPDFObjectHandle
QPDF::getObjectByID(int objid, int generation)
{
return getObject(QPDFObjGen(objid, generation));
}
void
QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh)
{
replaceObject(QPDFObjGen(objid, generation), oh);
}
void
QPDF::replaceObject(QPDFObjGen const& og, QPDFObjectHandle oh)
{
if (oh.isIndirect()) {
QTC::TC("qpdf", "QPDF replaceObject called with indirect object");
throw std::logic_error(
"QPDF::replaceObject called with indirect object handle");
}
// Force new object to appear in the cache
resolve(og);
// Replace the object in the object cache
updateCache(og, QPDFObjectHandle::ObjAccessor::getObject(oh), -1, -1);
}
void
QPDF::replaceReserved(QPDFObjectHandle reserved, QPDFObjectHandle replacement)
{
QTC::TC("qpdf", "QPDF replaceReserved");
reserved.assertReserved();
replaceObject(reserved.getObjGen(), replacement);
}
QPDFObjectHandle
QPDF::copyForeignObject(QPDFObjectHandle foreign)
{
// 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.
// 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.
// 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.
if (!foreign.isIndirect()) {
QTC::TC("qpdf", "QPDF copyForeign direct");
throw std::logic_error(
"QPDF::copyForeign called with direct object handle");
}
QPDF& other = foreign.getQPDF();
if (&other == this) {
QTC::TC("qpdf", "QPDF copyForeign not foreign");
throw std::logic_error(
"QPDF::copyForeign called with object from this QPDF");
}
ObjCopier& obj_copier = this->m->object_copiers[other.m->unique_id];
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. 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 the local object will already be a
// stream.
reserveObjects(foreign, obj_copier, true);
if (!obj_copier.visiting.empty()) {
throw std::logic_error("obj_copier.visiting is not empty"
" after reserving objects");
}
// Copy any new objects and replace the reservations.
for (auto& to_copy: obj_copier.to_copy) {
QPDFObjectHandle copy =
replaceForeignIndirectObjects(to_copy, obj_copier, true);
if (!to_copy.isStream()) {
QPDFObjGen og(to_copy.getObjGen());
replaceReserved(obj_copier.object_map[og], copy);
}
}
obj_copier.to_copy.clear();
return obj_copier.object_map[foreign.getObjGen()];
}
void
QPDF::reserveObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
{
if (foreign.isReserved()) {
throw std::logic_error(
"QPDF: attempting to copy a foreign reserved object");
}
if (foreign.isPagesObject()) {
QTC::TC("qpdf", "QPDF not copying pages object");
return;
}
if ((!top) && foreign.isPageObject()) {
QTC::TC("qpdf", "QPDF not crossing page boundary");
return;
}
if (foreign.isIndirect()) {
QPDFObjGen foreign_og(foreign.getObjGen());
if (obj_copier.visiting.find(foreign_og) != obj_copier.visiting.end()) {
QTC::TC("qpdf", "QPDF loop reserving objects");
return;
}
if (obj_copier.object_map.find(foreign_og) !=
obj_copier.object_map.end()) {
QTC::TC("qpdf", "QPDF already reserved object");
return;
}
QTC::TC("qpdf", "QPDF copy indirect");
obj_copier.visiting.insert(foreign_og);
auto mapping = obj_copier.object_map.find(foreign_og);
if (mapping == obj_copier.object_map.end()) {
obj_copier.to_copy.push_back(foreign);
QPDFObjectHandle reservation;
if (foreign.isStream()) {
reservation = QPDFObjectHandle::newStream(this);
} else {
reservation = QPDFObjectHandle::newReserved(this);
}
obj_copier.object_map[foreign_og] = reservation;
}
}
if (foreign.isArray()) {
QTC::TC("qpdf", "QPDF reserve array");
int n = foreign.getArrayNItems();
for (int i = 0; i < n; ++i) {
reserveObjects(foreign.getArrayItem(i), obj_copier, false);
}
} else if (foreign.isDictionary()) {
QTC::TC("qpdf", "QPDF reserve dictionary");
for (auto const& key: foreign.getKeys()) {
reserveObjects(foreign.getKey(key), obj_copier, false);
}
} else if (foreign.isStream()) {
QTC::TC("qpdf", "QPDF reserve stream");
reserveObjects(foreign.getDict(), obj_copier, false);
}
if (foreign.isIndirect()) {
QPDFObjGen foreign_og(foreign.getObjGen());
obj_copier.visiting.erase(foreign_og);
}
}
QPDFObjectHandle
QPDF::replaceForeignIndirectObjects(
QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
{
QPDFObjectHandle result;
if ((!top) && foreign.isIndirect()) {
QTC::TC("qpdf", "QPDF replace indirect");
QPDFObjGen foreign_og(foreign.getObjGen());
auto mapping = obj_copier.object_map.find(foreign_og);
if (mapping == obj_copier.object_map.end()) {
// This case would occur if this is a reference to a Page
// or Pages object that we didn't traverse into.
QTC::TC("qpdf", "QPDF replace foreign indirect with null");
result = QPDFObjectHandle::newNull();
} else {
result = obj_copier.object_map[foreign_og];
}
} else if (foreign.isArray()) {
QTC::TC("qpdf", "QPDF replace array");
result = QPDFObjectHandle::newArray();
int n = foreign.getArrayNItems();
for (int i = 0; i < n; ++i) {
result.appendItem(
// line-break
replaceForeignIndirectObjects(
foreign.getArrayItem(i), obj_copier, false));
}
} else if (foreign.isDictionary()) {
QTC::TC("qpdf", "QPDF replace dictionary");
result = QPDFObjectHandle::newDictionary();
std::set<std::string> keys = foreign.getKeys();
for (auto const& iter: keys) {
result.replaceKey(
iter,
replaceForeignIndirectObjects(
foreign.getKey(iter), obj_copier, false));
}
} else if (foreign.isStream()) {
QTC::TC("qpdf", "QPDF replace stream");
QPDFObjGen foreign_og(foreign.getObjGen());
result = obj_copier.object_map[foreign_og];
result.assertStream();
QPDFObjectHandle dict = result.getDict();
QPDFObjectHandle old_dict = foreign.getDict();
std::set<std::string> keys = old_dict.getKeys();
for (auto const& iter: keys) {
dict.replaceKey(
iter,
replaceForeignIndirectObjects(
old_dict.getKey(iter), obj_copier, false));
}
copyStreamData(result, foreign);
} 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;
}
void
QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign)
{
// 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.
QPDFObjectHandle dict = result.getDict();
QPDFObjectHandle old_dict = foreign.getDict();
if (this->m->copied_stream_data_provider == nullptr) {
this->m->copied_stream_data_provider =
new CopiedStreamDataProvider(*this);
this->m->copied_streams =
std::shared_ptr<QPDFObjectHandle::StreamDataProvider>(
this->m->copied_stream_data_provider);
}
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.
QPDF& foreign_stream_qpdf =
foreign.getQPDF("unable to retrieve owning qpdf from foreign stream");
auto stream = QPDFObjectHandle::ObjAccessor::asStream(foreign);
if (stream == nullptr) {
throw std::logic_error("unable to retrieve underlying"
" stream object from foreign stream");
}
std::shared_ptr<Buffer> stream_buffer = stream->getStreamDataBuffer();
if ((foreign_stream_qpdf.m->immediate_copy_from) &&
(stream_buffer == nullptr)) {
// 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();
}
std::shared_ptr<QPDFObjectHandle::StreamDataProvider> stream_provider =
stream->getStreamDataProvider();
if (stream_buffer.get()) {
QTC::TC("qpdf", "QPDF copy foreign stream with buffer");
result.replaceStreamData(
stream_buffer, dict.getKey("/Filter"), dict.getKey("/DecodeParms"));
} else if (stream_provider.get()) {
// In this case, the remote stream's QPDF must stay in scope.
QTC::TC("qpdf", "QPDF copy foreign stream with provider");
this->m->copied_stream_data_provider->registerForeignStream(
local_og, foreign);
result.replaceStreamData(
this->m->copied_streams,
dict.getKey("/Filter"),
dict.getKey("/DecodeParms"));
} else {
auto foreign_stream_data = std::make_shared<ForeignStreamData>(
foreign_stream_qpdf.m->encp,
foreign_stream_qpdf.m->file,
foreign.getObjGen(),
stream->getOffset(),
stream->getLength(),
dict);
this->m->copied_stream_data_provider->registerForeignStream(
local_og, foreign_stream_data);
result.replaceStreamData(
this->m->copied_streams,
dict.getKey("/Filter"),
dict.getKey("/DecodeParms"));
}
}
void
QPDF::swapObjects(int objid1, int generation1, int objid2, int generation2)
{
swapObjects(
QPDFObjGen(objid1, generation1), QPDFObjGen(objid2, generation2));
}
void
QPDF::swapObjects(QPDFObjGen const& og1, QPDFObjGen const& og2)
{
// Force objects to be read from the input source if needed, then
// swap them in the cache.
resolve(og1);
resolve(og2);
m->obj_cache[og1].object->swapWith(m->obj_cache[og2].object);
}
unsigned long long
QPDF::getUniqueId() const
{
return this->m->unique_id;
}
std::string
QPDF::getFilename() const
{
return this->m->file->getName();
}
PDFVersion
QPDF::getVersionAsPDFVersion()
{
int major = 1;
int minor = 3;
int extension_level = getExtensionLevel();
std::regex v("^[[:space:]]*([0-9]+)\\.([0-9]+)");
std::smatch m;
if (std::regex_search(this->m->pdf_version, m, v)) {
major = QUtil::string_to_int(m[1].str().c_str());
minor = QUtil::string_to_int(m[2].str().c_str());
}
return PDFVersion(major, minor, extension_level);
}
std::string
QPDF::getPDFVersion() const
{
return this->m->pdf_version;
}
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()) {
result = obj.getIntValueAsInt();
}
}
}
}
return result;
}
QPDFObjectHandle
QPDF::getTrailer()
{
return this->m->trailer;
}
QPDFObjectHandle
QPDF::getRoot()
{
QPDFObjectHandle root = this->m->trailer.getKey("/Root");
if (!root.isDictionary()) {
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
0,
"unable to find /Root dictionary");
}
return root;
}
std::map<QPDFObjGen, QPDFXRefEntry>
QPDF::getXRefTable()
{
if (!this->m->parsed) {
throw std::logic_error("QPDF::getXRefTable called before parsing.");
}
return this->m->xref_table;
}
void
QPDF::getObjectStreamData(std::map<int, int>& omap)
{
for (auto const& iter: this->m->xref_table) {
QPDFObjGen const& og = iter.first;
QPDFXRefEntry const& entry = iter.second;
if (entry.getType() == 2) {
omap[og.getObj()] = entry.getObjStreamNumber();
}
}
}
std::vector<QPDFObjGen>
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, 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
QPDFObjectHandle encryption_dict = this->m->trailer.getKey("/Encrypt");
QPDFObjGen encryption_dict_og = encryption_dict.getObjGen();
std::set<QPDFObjGen> visited;
std::list<QPDFObjectHandle> queue;
queue.push_front(this->m->trailer);
std::vector<QPDFObjGen> result;
while (!queue.empty()) {
QPDFObjectHandle obj = queue.front();
queue.pop_front();
if (obj.isIndirect()) {
QPDFObjGen og = obj.getObjGen();
if (visited.count(og)) {
QTC::TC("qpdf", "QPDF loop detected traversing objects");
continue;
}
if (og == encryption_dict_og) {
QTC::TC("qpdf", "QPDF exclude encryption dictionary");
} else if (!(obj.isStream() ||
(obj.isDictionaryOfType("/Sig") &&
obj.hasKey("/ByteRange") &&
obj.hasKey("/Contents")))) {
result.push_back(og);
}
visited.insert(og);
}
if (obj.isStream()) {
QPDFObjectHandle dict = obj.getDict();
std::set<std::string> keys = dict.getKeys();
for (std::set<std::string>::reverse_iterator iter = keys.rbegin();
iter != keys.rend();
++iter) {
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 {
queue.push_front(value);
}
}
} else if (obj.isDictionary()) {
std::set<std::string> keys = obj.getKeys();
for (std::set<std::string>::reverse_iterator iter = keys.rbegin();
iter != keys.rend();
++iter) {
queue.push_front(obj.getKey(*iter));
}
} else if (obj.isArray()) {
int n = obj.getArrayNItems();
for (int i = 1; i <= n; ++i) {
queue.push_front(obj.getArrayItem(n - i));
}
}
}
return result;
}
bool
QPDF::pipeStreamData(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDF& qpdf_for_warning,
QPDFObjGen const& og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle stream_dict,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
std::vector<std::shared_ptr<Pipeline>> to_delete;
if (encp->encrypted) {
decryptStream(
encp, file, qpdf_for_warning, pipeline, og, stream_dict, to_delete);
}
bool success = false;
try {
file->seek(offset, SEEK_SET);
char buf[10240];
while (length > 0) {
size_t to_read = (sizeof(buf) < length ? sizeof(buf) : length);
size_t len = file->read(buf, to_read);
if (len == 0) {
throw QPDFExc(
qpdf_e_damaged_pdf,
file->getName(),
"",
file->getLastOffset(),
"unexpected EOF reading stream data");
}
length -= len;
pipeline->write(buf, len);
}
pipeline->finish();
success = true;
} catch (QPDFExc& e) {
if (!suppress_warnings) {
qpdf_for_warning.warn(e);
}
} catch (std::exception& e) {
if (!suppress_warnings) {
QTC::TC("qpdf", "QPDF decoding error warning");
qpdf_for_warning.warn(
// line-break
QPDFExc(
qpdf_e_damaged_pdf,
file->getName(),
"",
file->getLastOffset(),
("error decoding stream data for object " +
og.unparse(' ') + ": " + e.what())));
if (will_retry) {
qpdf_for_warning.warn(
// line-break
QPDFExc(
qpdf_e_damaged_pdf,
file->getName(),
"",
file->getLastOffset(),
"stream will be re-processed without"
" filtering to avoid data loss"));
}
}
}
if (!success) {
try {
pipeline->finish();
} catch (std::exception&) {
// ignore
}
}
return success;
}
bool
QPDF::pipeStreamData(
QPDFObjGen const& og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle stream_dict,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
return pipeStreamData(
this->m->encp,
this->m->file,
*this,
og,
offset,
length,
stream_dict,
pipeline,
suppress_warnings,
will_retry);
}
bool
QPDF::pipeForeignStreamData(
std::shared_ptr<ForeignStreamData> foreign,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
if (foreign->encp->encrypted) {
QTC::TC("qpdf", "QPDF pipe foreign encrypted stream");
}
return pipeStreamData(
foreign->encp,
foreign->file,
*this,
foreign->foreign_og,
foreign->offset,
foreign->length,
foreign->local_dict,
pipeline,
suppress_warnings,
will_retry);
}
void
QPDF::stopOnError(std::string const& message)
{
// 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.
throw QPDFExc(
qpdf_e_damaged_pdf,
this->m->file->getName(),
"",
this->m->file->getLastOffset(),
message);
}
bool
QPDF::everCalledGetAllPages() const
{
return this->m->ever_called_get_all_pages;
}
bool
QPDF::everPushedInheritedAttributesToPages() const
{
return this->m->ever_pushed_inherited_attributes_to_pages;
}
View Git Blame Copy Permalink