octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-12-22 02:49:00 +00:00
Code Issues Releases Wiki Activity

Move QPDF::insertXrefEntry etc to QPDF::Xref_table

Browse Source
This commit is contained in:
m-holger 2024-08-09 14:14:56 +01:00
parent 0ac37bc956
commit 1e072e223a
3 changed files with 37 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/qpdf/QPDF.hh
View File

@ -777,9 +777,6 @@ class QPDF
QPDFObjectHandle& dict,
int max_num_entries,
std::function<QPDFExc(std::string_view)> damaged);
void insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2);
void insertFreeXrefEntry(QPDFObjGen);
void insertReconstructedXrefEntry(int obj, qpdf_offset_t f1, int f2);
void setLastObjectDescription(std::string const& description, QPDFObjGen const& og);
QPDFObjectHandle readTrailer();
QPDFObjectHandle readObject(std::string const& description, QPDFObjGen og);

45
libqpdf/QPDF.cc
View File

@ -196,15 +196,16 @@ QPDF::EncryptionParameters::EncryptionParameters() :
{
}
QPDF::Members::Members() :
QPDF::Members::Members(QPDF& qpdf) :
log(QPDFLogger::defaultLogger()),
file(new InvalidInputSource()),
encp(new EncryptionParameters)
encp(new EncryptionParameters),
xref_table(qpdf)
{
}
QPDF::QPDF() :
m(new Members())
m(new Members(*this))
{
m->tokenizer.allowEOF();
// Generate a unique ID. It just has to be unique among all QPDF objects allocated throughout
@ -585,7 +586,7 @@ QPDF::reconstruct_xref(QPDFExc& e)
int obj = QUtil::string_to_int(t1.getValue().c_str());
int gen = QUtil::string_to_int(t2.getValue().c_str());
if (obj <= m->xref_table.max_id) {
insertReconstructedXrefEntry(obj, token_start, gen);
m->xref_table.insert_reconstructed(obj, token_start, gen);
} else {
warn(damagedPDF(
"", 0, "ignoring object with impossibly large id " + std::to_string(obj)));
@ -981,9 +982,9 @@ QPDF::read_xrefTable(qpdf_offset_t xref_offset)
"xref table", "invalid xref entry (obj=" + std::to_string(i) + ")");
}
if (type == 'f') {
insertFreeXrefEntry(QPDFObjGen(toI(i), f2));
m->xref_table.insert_free(QPDFObjGen(toI(i), f2));
} else {
insertXrefEntry(toI(i), 1, f1, f2);
m->xref_table.insert(toI(i), 1, f1, f2);
}
}
qpdf_offset_t pos = m->file->tell();
@ -1251,9 +1252,9 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
// 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.
insertFreeXrefEntry(QPDFObjGen(obj, 0));
m->xref_table.insert_free(QPDFObjGen(obj, 0));
} else {
insertXrefEntry(obj, toI(fields[0]), fields[1], toI(fields[2]));
m->xref_table.insert(obj, toI(fields[0]), fields[1], toI(fields[2]));
}
++obj;
}
@ -1276,7 +1277,7 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
}
void
QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
QPDF::Xref_table::insert(int obj, int f0, qpdf_offset_t f1, int f2)
{
// 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.
@ -1285,22 +1286,23 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
// 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.
if (obj > m->xref_table.max_id) {
if (obj > max_id) {
// ignore impossibly large object ids or object ids > Size.
return;
}
if (m->xref_table.deleted_objects.count(obj)) {
if (deleted_objects.count(obj)) {
QTC::TC("qpdf", "QPDF xref deleted object");
return;
}
if (f0 == 2 && static_cast<int>(f1) == obj) {
warn(damagedPDF("xref stream", "self-referential object stream " + std::to_string(obj)));
qpdf.warn(qpdf.damagedPDF(
"xref stream", "self-referential object stream " + std::to_string(obj)));
return;
}
auto [iter, created] = m->xref_table.try_emplace(QPDFObjGen(obj, (f0 == 2 ? 0 : f2)));
auto [iter, created] = try_emplace(QPDFObjGen(obj, (f0 == 2 ? 0 : f2)));
if (!created) {
QTC::TC("qpdf", "QPDF xref reused object");
return;
@ -1318,35 +1320,36 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
break;
default:
throw damagedPDF("xref stream", "unknown xref stream entry type " + std::to_string(f0));
throw qpdf.damagedPDF(
"xref stream", "unknown xref stream entry type " + std::to_string(f0));
break;
}
}
void
QPDF::insertFreeXrefEntry(QPDFObjGen og)
QPDF::Xref_table::insert_free(QPDFObjGen og)
{
if (!m->xref_table.count(og)) {
m->xref_table.deleted_objects.insert(og.getObj());
if (!count(og)) {
deleted_objects.insert(og.getObj());
}
}
// Replace uncompressed object. This is used in xref recovery mode, which reads the file from
// beginning to end.
void
QPDF::insertReconstructedXrefEntry(int obj, qpdf_offset_t f1, int f2)
QPDF::Xref_table::insert_reconstructed(int obj, qpdf_offset_t f1, int f2)
{
if (!(obj > 0 && obj <= m->xref_table.max_id && 0 <= f2 && f2 < 65535)) {
if (!(obj > 0 && obj <= max_id && 0 <= f2 && f2 < 65535)) {
QTC::TC("qpdf", "QPDF xref overwrite invalid objgen");
return;
}
QPDFObjGen og(obj, f2);
if (!m->xref_table.deleted_objects.count(obj)) {
if (!deleted_objects.count(obj)) {
// deleted_objects stores the uncompressed objects removed from the xref table at the start
// of recovery.
QTC::TC("qpdf", "QPDF xref overwrite object");
m->xref_table[QPDFObjGen(obj, f2)] = QPDFXRefEntry(f1);
insert_or_assign(QPDFObjGen(obj, f2), QPDFXRefEntry(f1));
}
}

14
libqpdf/qpdf/QPDF_private.hh
View File

@ -7,6 +7,15 @@
class QPDF::Xref_table: public std::map<QPDFObjGen, QPDFXRefEntry>
{
public:
Xref_table(QPDF& qpdf) :
qpdf(qpdf)
{
}
void insert_reconstructed(int obj, qpdf_offset_t f1, int f2);
void insert(int obj, int f0, qpdf_offset_t f1, int f2);
void insert_free(QPDFObjGen);
QPDFObjectHandle trailer;
bool reconstructed{false};
// Various tables are indexed by object id, with potential size id + 1
@ -20,6 +29,9 @@ class QPDF::Xref_table: public std::map<QPDFObjGen, QPDFXRefEntry>
// Linearization data
bool uncompressed_after_compressed{false};
qpdf_offset_t first_item_offset{0}; // actual value from file
private:
QPDF& qpdf;
};
// Writer class is restricted to QPDFWriter so that only it can call certain methods.
@ -469,7 +481,7 @@ class QPDF::Members
~Members() = default;
private:
Members();
Members(QPDF& qpdf);
Members(Members const&) = delete;
std::shared_ptr<QPDFLogger> log;