xref initial trial

This commit is contained in:
ari committed 2020-10-30 14:14:21 -04:00
1 parent 68dd42fea1
commit 3b82f4c309
5 files changed
+828 -90

No files matched your search

+1 -1
View File
@@ -1,4 +1,4 @@
from pdfmajor.exceptions import PDFMajorException, BrokenFile
from pdfmajor.exceptions import BrokenFile, PDFMajorException
class XRefError(PDFMajorException):
+68
View File
@@ -0,0 +1,68 @@
from typing import NamedTuple, Optional
from pdfmajor.lexer import iter_tokens
from pdfmajor.lexer.token import TokenKeyword
from pdfmajor.parser import get_first_object
from pdfmajor.parser.objects.base import PDFObject
from pdfmajor.parser.objects.collections import PDFArray, PDFDictionary
from pdfmajor.parser.objects.primitives import PDFInteger
from pdfmajor.streambuffer import BufferStream
from .exceptions import BrokenFile
class PDFFileTrailer(NamedTuple):
"""an object representing a PDF file trailer as is specified in PDF spec 1.7 section 7.5.5"""
size: PDFInteger
root: Optional[PDFObject]
prev: Optional[PDFObject]
info: Optional[PDFObject]
encrypt: Optional[PDFObject]
encrypt_id: Optional[PDFArray]
@classmethod
def from_pdfdict(cls, pdfdict: PDFDictionary) -> "PDFFileTrailer":
try:
size = pdfdict["Size"]
except KeyError as e:
raise BrokenFile(f"Failed to get required fields from trailer {e}")
if not isinstance(size, PDFInteger):
raise BrokenFile(f"Size of trailer should be an integer instead got {size}")
root = pdfdict.get("Root", None)
encrypt = pdfdict.get("Encrypt", None)
encrypt_id = pdfdict.get("ID", None)
if encrypt is not None:
if not isinstance(encrypt_id, PDFArray):
raise BrokenFile(
f"PDF is encrypted without a valid encrypt id encrypt_id={encrypt_id}"
)
return cls(
size=size,
root=root,
prev=pdfdict.get("Prev", None),
info=pdfdict.get("Info", None),
encrypt=encrypt,
encrypt_id=encrypt_id,
)
@classmethod
def from_buffer(cls, buffer: BufferStream) -> "PDFFileTrailer":
"""attempts to get a trailer from the buffer stream
Raises:
BrokenFile: if the word 'trailer' is missing as the first token
BrokenFile: if the next object after the word 'trailer' is not a dictionary
"""
next_token = next(iter_tokens(buffer))
if not (
isinstance(next_token, TokenKeyword) and next_token.value == b"trailer"
):
raise BrokenFile(f"Expected trailer but got {next_token}")
next_obj = get_first_object(buffer, buffer.tell())
if not isinstance(next_obj, PDFDictionary):
raise BrokenFile(f"Expected trailer to be a dictionary but got {next_obj}")
return cls.from_pdfdict(next_obj)
+9 -6
View File
@@ -1,9 +1,10 @@
from typing import Iterator, Literal, NamedTuple, Union
from pdfmajor.lexer.token import TokenInteger, TokenKeyword
from pdfmajor.lexer import iter_tokens
from pdfmajor.lexer.token import TokenInteger, TokenKeyword
from pdfmajor.streambuffer import BufferStream
from .exceptions import PDFNoValidXRef, BrokenFile, UnexpectedEOF
from .exceptions import BrokenFile, PDFNoValidXRef, UnexpectedEOF
class XRefRow(NamedTuple):
@@ -37,16 +38,18 @@ def find_start_of_xref(buffer: BufferStream, strict: bool = False) -> int:
return int(prev)
def iter_over_xref(buffer: BufferStream, strict: bool = False) -> Iterator[XRefRow]:
start_offset = find_start_of_xref(buffer, strict)
def iter_over_xref(
buffer: BufferStream, start_offset: int, strict: bool = False
) -> Iterator[XRefRow]:
buffer.seek(start_offset)
first_token = next(iter_tokens(buffer))
if isinstance(first_token, TokenInteger):
raise NotImplementedError("XRefStream: PDF-1.5")
elif isinstance(first_token, TokenKeyword):
if first_token.value == b"xref":
return iter_over_standard_xref(buffer, strict)
raise BrokenFile("Missing a valid XRef table")
yield from iter_over_standard_xref(buffer, strict)
else:
raise BrokenFile("Missing a valid XRef table")
# # read xref table
+53 -15
View File
@@ -1,11 +1,15 @@
from pdfmajor.parser.objects.collections import PDFDictionary
from pdfmajor.streambuffer import BufferStream
from typing import Dict, Iterator, List, Optional, Tuple
from pdfmajor.parser.objects.indirect import IndirectObject
from pdfmajor.parser import get_first_object
from .xref import XRefRow, iter_over_xref
from .exceptions import InvalidIndirectObjAccess, InvalidXref, XRefError
from pdfmajor.parser.objects.base import PDFObject
from pdfmajor.parser.objects.collections import PDFDictionary
from pdfmajor.parser.objects.indirect import IndirectObject, ObjectRef
from pdfmajor.parser.objects.primitives import PDFInteger
from pdfmajor.streambuffer import BufferStream
from .exceptions import BrokenFile, InvalidXref, XRefError
from .trailer import PDFFileTrailer
from .xref import XRefRow, find_start_of_xref, iter_over_xref
# simple type aliases for better readability
ObjNum = int
@@ -21,11 +25,35 @@ class XRefDB:
self.objs: Dict[RawRef, IndirectObject] = {}
self.types: Dict[RawRef, ObjType] = {}
self.xrefs: Dict[RawRef, XRefRow] = {}
self.trailers: List[PDFFileTrailer] = []
with buffer.get_window():
for xref in iter_over_xref(buffer):
if xref.use == b"n":
self.xrefs[(xref.obj_num, xref.gen_num)] = xref
start_offset = find_start_of_xref(buffer, True)
while True:
for xref in iter_over_xref(buffer, start_offset, True):
if xref.use == b"n":
self.xrefs[(xref.obj_num, xref.gen_num)] = xref
trailer = PDFFileTrailer.from_buffer(buffer)
self.trailers.append(trailer)
if trailer.prev is not None:
if isinstance(trailer.prev, PDFInteger):
start_offset = trailer.prev.to_python()
elif isinstance(trailer.prev, ObjectRef):
obj = self.get_obj(
trailer.prev.obj_num, trailer.prev.gen_num, buffer=buffer
)
if not isinstance(obj, PDFInteger):
raise BrokenFile(
f"trailer had an invalid prev options {trailer.prev}"
)
else:
start_offset = obj.to_python()
else:
raise BrokenFile(
f"trailer had an invalid prev options {trailer.prev}"
)
else:
break
def get_obj_by_type(
self, buffer: BufferStream, obj_type: ObjType
@@ -55,13 +83,7 @@ class XRefDB:
raw_ref, xref = (obj_num, gen_num), self.xrefs[(obj_num, gen_num)]
found_obj_type: Optional[str] = self.types.get(raw_ref, None)
if found_obj_type is None:
obj = self.objs.get(raw_ref, None)
if obj is None:
obj = get_first_object(buffer, xref.offset)
if not isinstance(obj, IndirectObject):
raise InvalidXref(
f"Offset for {xref} returned an invalid object {obj}"
)
obj = self.get_obj(*raw_ref, buffer=buffer)
obj_dict = obj.get_object()
if isinstance(obj_dict, PDFDictionary):
type_name = obj_dict.get("Type", None)
@@ -79,6 +101,22 @@ class XRefDB:
raise XRefError("WARN: Failed to find a valid type for", xref)
return found_obj_type
def get_obj(
self,
obj_num: ObjNum,
gen_num: GenNum,
buffer: BufferStream,
) -> PDFObject:
raw_ref, xref = (obj_num, gen_num), self.xrefs[(obj_num, gen_num)]
obj = self.objs.get(raw_ref, None)
if obj is None:
with buffer.get_window():
obj = get_first_object(buffer, xref.offset)
if not isinstance(obj, IndirectObject):
raise InvalidXref(f"Offset for {xref} returned an invalid object {obj}")
self.objs[raw_ref] = obj
return self.objs[raw_ref]
def has_xref(self, obj_num: ObjNum, gen_num: GenNum) -> bool:
return (obj_num, gen_num) in self.xrefs.keys()