Attachment 140530 Details for Bug 107057 – Skip XRef::constructXRef in XRef::readXRefUntil if last XRef section is a stream

[patch] Skip XRef::constructXRef in XRef::readXRefUntil if last XRef section is a stream

skip_reconstruction_in_readxrefuntil.patch (text/plain), 4.36 KB, created by Tobias Deiminger on 2018-07-09 22:02:55 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Tobias Deiminger

Created: 2018-07-09 22:02:55 UTC

Size: 4.36 KB

patch

obsolete

>diff --git a/poppler/XRef.cc b/poppler/XRef.cc
>index 6eadc0a1..6f6d6148 100644
>--- a/poppler/XRef.cc
>+++ b/poppler/XRef.cc
>@@ -846,40 +846,43 @@ GBool XRef::readXRefStreamSection(Stream *xrefStr, int *w, int first, int n) {
>       case 1:
> 	entries[i].offset = offset;
> 	entries[i].gen = gen;
> 	entries[i].type = xrefEntryUncompressed;
> 	break;
>       case 2:
> 	entries[i].offset = offset;
> 	entries[i].gen = gen;
> 	entries[i].type = xrefEntryCompressed;
> 	break;
>       default:
> 	return gFalse;
>       }
>     }
>   }
> 
>   return gTrue;
> }
> 
> // Attempt to construct an xref table for a damaged file.
>+// Warning: Reconstruction of files where last XRef section is a stream
>+//          or where some objects are defined inside an object stream is not yet supported.
>+//          Existing data in XRef::entries may get corrupted if applied anyway.
> GBool XRef::constructXRef(GBool *wasReconstructed, GBool needCatalogDict) {
>   Parser *parser;
>   Object obj;
>   char buf[256];
>   Goffset pos;
>   int num, gen;
>   int streamEndsSize;
>   char *p;
>   GBool gotRoot;
>   char* token = nullptr;
>   bool oneCycle = true;
>   int offset = 0;
> 
>   resize(0); // free entries properly
>   gfree(entries);
>   capacity = 0;
>   size = 0;
>   entries = nullptr;
> 
>   gotRoot = gFalse;
>@@ -1568,92 +1571,91 @@ GBool XRef::parseEntry(Goffset offset, XRefEntry *entry)
> }
> 
> /* Traverse all XRef tables and, if untilEntryNum != -1, stop as soon as
>  * untilEntryNum is found, or try to reconstruct the xref table if it's not
>  * present in any xref.
>  * If xrefStreamObjsNum is not NULL, it is filled with the list of the object
>  * numbers of the XRef streams that have been traversed */
> void XRef::readXRefUntil(int untilEntryNum, std::vector<int> *xrefStreamObjsNum)
> {
>   std::vector<Goffset> followedPrev;
>   while (prevXRefOffset && (untilEntryNum == -1 || (untilEntryNum < size && entries[untilEntryNum].type == xrefEntryNone))) {
>     bool followed = false;
>     for (size_t j = 0; j < followedPrev.size(); j++) {
>       if (followedPrev.at(j) == prevXRefOffset) {
>         followed = true;
>         break;
>       }
>     }
>     if (followed) {
>       error(errSyntaxError, -1, "Circular XRef");
>-      if (!(ok = constructXRef(nullptr))) {
>+      if (!xRefStream && !(ok = constructXRef(nullptr))) {
>         errCode = errDamaged;
>       }
>       break;
>     }
> 
>     followedPrev.push_back (prevXRefOffset);
> 
>     std::vector<Goffset> followedXRefStm;
>     if (!readXRef(&prevXRefOffset, &followedXRefStm, xrefStreamObjsNum)) {
>         prevXRefOffset = 0;
>     }
> 
>     // if there was a problem with the xref table, or we haven't found the entry
>     // we were looking for, try to reconstruct the xref
>     if (!ok || (!prevXRefOffset && untilEntryNum != -1 && entries[untilEntryNum].type == xrefEntryNone)) {
>-        GBool wasReconstructed = false;
>-        if (!(ok = constructXRef(&wasReconstructed))) {
>+        if (!xRefStream && !(ok = constructXRef(nullptr))) {
>             errCode = errDamaged;
>             break;
>         }
>         break;
>     }
>   }
> }
> 
> XRefEntry *XRef::getEntry(int i, GBool complainIfMissing)
> {
>   if (i >= size || entries[i].type == xrefEntryNone) {
> 
>     if ((!xRefStream) && mainXRefEntriesOffset) {
>       if (!parseEntry(mainXRefEntriesOffset + 20*i, &entries[i])) {
>         error(errSyntaxError, -1, "Failed to parse XRef entry [{0:d}].", i);
>       }
>     } else {
>       // Read XRef tables until the entry we're looking for is found
>       readXRefUntil(i);
>       
>       // We might have reconstructed the xref
>       // Check again i is in bounds
>       if (unlikely(i >= size)) {
>         static XRefEntry dummy;
>         dummy.offset = 0;
>         dummy.gen = -1;
>         dummy.type = xrefEntryNone;
>         dummy.flags = 0;
>         return &dummy;
>       }
> 
>       if (entries[i].type == xrefEntryNone) {
>         if (complainIfMissing) {
>-          error(errSyntaxError, -1, "Invalid XRef entry");
>+          error(errSyntaxError, -1, "Invalid XRef entry {0:d}", i);
>         }
>         entries[i].type = xrefEntryFree;
>       }
>     }
>   }
> 
>   return &entries[i];
> }
> 
> // Recursively sets the Unencrypted flag in all referenced xref entries
> void XRef::markUnencrypted(Object *obj) {
>   Object obj1;
> 
>   switch (obj->getType()) {
>     case objArray:
>     {
>       Array *array = obj->getArray();
>       for (int i = 0; i < array->getLength(); i++) {
> 	obj1 = array->getNF(i);
>         markUnencrypted(&obj1);

Actions: View | Splinter Review

Attachments on bug 107057: 140372 | 140484 | 140530

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.