Fix #82, #86 repairs corrupt xref sections

pkg/pdfcpu/context.go

@@ -156,6 +156,7 @@ type ReadContext struct {
 	FileName            string // The input PDF-File.
 	FileSize            int64
 	rs                  io.ReadSeeker
+	EolCount            int    // 1 or 2 characters used for eol.
 	BinaryTotalSize     int64  // total stream data
 	BinaryImageSize     int64  // total image stream data
 	BinaryFontSize      int64  // total font stream data (fontfiles)

pkg/pdfcpu/read.go

@@ -764,7 +764,38 @@ func parseTrailerDict(trailerDict Dict, ctx *Context) (*int64, error) {
 	return offset, nil
 }
 
-func scanLine(s *bufio.Scanner) (string, error) {
+func scanLineRaw(s *bufio.Scanner) (string, error) {
+	if ok := s.Scan(); !ok {
+		if s.Err() != nil {
+			return "", s.Err()
+		}
+		return "", errors.New("scanner: returning nothing")
+	}
+	return s.Text(), nil
+}
+
+func scanLine(s *bufio.Scanner) (s1 string, err error) {
+	for i := 0; i <= 1; i++ {
+		s1, err = scanLineRaw(s)
+		if err != nil {
+			return "", err
+		}
+		if len(s1) > 0 {
+			break
+		}
+	}
+
+	// Remove comment.
+	i := strings.Index(s1, "%")
+	if i >= 0 {
+		s1 = s1[:i]
+	}
+
+	return s1, nil
+}
+
+// scanLine ignores comments and empty lines.
+func scanLineOrig(s *bufio.Scanner) (string, error) {
 	for i := 0; i <= 1; i++ {
 		if ok := s.Scan(); !ok {
 			err := s.Err()
@@ -906,6 +937,39 @@ func scanTrailerDict(s *bufio.Scanner, startTag bool) (string, error) {
 	return buf.String(), nil
 }
 
+func processTrailer(ctx *Context, s *bufio.Scanner, line string) (*int64, error) {
+
+	var trailerString string
+
+	if line != "trailer" {
+		trailerString = line[7:]
+		log.Read.Printf("processTrailer: trailer leftover: <%s>\n", trailerString)
+	} else {
+		log.Read.Printf("line (len %d) <%s>\n", len(line), line)
+	}
+
+	trailerString, err := scanTrailer(s, trailerString)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Read.Printf("processTrailer: trailerString: (len:%d) <%s>\n", len(trailerString), trailerString)
+
+	o, err := parseObject(&trailerString)
+	if err != nil {
+		return nil, err
+	}
+
+	trailerDict, ok := o.(Dict)
+	if !ok {
+		return nil, errors.New("processTrailer: corrupt trailer dict")
+	}
+
+	log.Read.Printf("processTrailer: trailerDict:\n%s\n", trailerDict)
+
+	return parseTrailerDict(trailerDict, ctx)
+}
+
 // Parse xRef section into corresponding number of xRef table entries.
 func parseXRefSection(s *bufio.Scanner, ctx *Context) (*int64, error) {
 
@@ -950,42 +1014,7 @@ func parseXRefSection(s *bufio.Scanner, ctx *Context) (*int64, error) {
 
 	log.Read.Println("parseXRefSection: parsing trailer dict..")
 
-	var trailerString string
-
-	if line != "trailer" {
-		trailerString = line[7:]
-		log.Read.Printf("parseXRefSection: trailer leftover: <%s>\n", trailerString)
-	} else {
-		log.Read.Printf("line (len %d) <%s>\n", len(line), line)
-	}
-
-	trailerString, err = scanTrailer(s, trailerString)
-	if err != nil {
-		return nil, err
-	}
-
-	log.Read.Printf("parseXRefSection: trailerString: (len:%d) <%s>\n", len(trailerString), trailerString)
-
-	o, err := parseObject(&trailerString)
-	if err != nil {
-		return nil, err
-	}
-
-	trailerDict, ok := o.(Dict)
-	if !ok {
-		return nil, errors.New("parseXRefSection: corrupt trailer dict")
-	}
-
-	log.Read.Printf("parseXRefSection: trailerDict:\n%s\n", trailerDict)
-
-	offset, err := parseTrailerDict(trailerDict, ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	log.Read.Println("parseXRefSection end")
-
-	return offset, nil
+	return processTrailer(ctx, s, line)
 }
 
 // Get version from first line of file.
@@ -994,22 +1023,40 @@ func parseXRefSection(s *bufio.Scanner, ctx *Context) (*int64, error) {
 // if present, shall be used instead of the version specified in the Header.
 // Save PDF Version from header to xRefTable.
 // The header version comes as the first line of the file.
-func headerVersion(rs io.ReadSeeker) (*Version, error) {
+// eolCount is the number of characters used for eol (1 or 2).
+func headerVersion(rs io.ReadSeeker) (v *Version, eolCount int, err error) {
 
 	log.Read.Println("headerVersion begin")
 
+	var errCorruptHeader = errors.New("headerVersion: corrupt pfd file - no header version available")
+
 	// Get first line of file which holds the version of this PDFFile.
 	// We call this the header version.
 
-	_, err := rs.Seek(0, io.SeekStart)
+	_, err = rs.Seek(0, io.SeekStart)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
-	buf := make([]byte, 10)
+	buf := make([]byte, 20)
 	_, err = rs.Read(buf)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
+	}
+
+	b := string(buf)
+
+	// Detect the used eol which should be 1 (0x00, 0x0D) or 2 chars (0x0D0A)long.
+	// %PDF-1.x{eol}
+	if b[8] == 0x0A {
+		eolCount = 1
+	} else if b[8] == 0x0D {
+		eolCount = 1
+		if b[9] == 0x0A {
+			eolCount = 2
+		}
+	} else {
+		return nil, 0, errCorruptHeader
 	}
 
 	// Parse the PDF-Version.
@@ -1019,17 +1066,113 @@ func headerVersion(rs io.ReadSeeker) (*Version, error) {
 	s := strings.TrimSpace(string(buf))
 
 	if len(s) < 8 || !strings.HasPrefix(s, prefix) {
-		return nil, errors.New("headerVersion: corrupt pfd file - no header version available")
+		return nil, 0, errCorruptHeader
 	}
 
 	pdfVersion, err := PDFVersion(s[len(prefix) : len(prefix)+3])
 	if err != nil {
-		return nil, errors.Wrapf(err, "headerVersion: unknown PDF Header Version")
+		return nil, 0, errors.Wrapf(err, "headerVersion: unknown PDF Header Version")
 	}
 
 	log.Read.Printf("headerVersion: end, found header version: %s\n", pdfVersion)
 
-	return &pdfVersion, nil
+	return &pdfVersion, eolCount, nil
+}
+
+// bypassXrefSection is a hack for digesting corrupt xref sections.
+// It populates the xRefTable by reading in all indirect objects line by line
+// and works on the assumption of a single xref section - meaning no incremental updates have been made.
+func bypassXrefSection(ctx *Context) error {
+	var z int64
+	g := FreeHeadGeneration
+	ctx.Table[0] = &XRefTableEntry{
+		Free:       true,
+		Offset:     &z,
+		Generation: &g}
+
+	rs := ctx.Read.rs
+	eolCount := ctx.Read.EolCount
+	var off, offset int64
+
+	rd, err := newPositionedReader(rs, &offset)
+	if err != nil {
+		return err
+	}
+
+	s := bufio.NewScanner(rd)
+	s.Split(scanLines)
+
+	bb := []byte{}
+	var (
+		withinObj     bool
+		withinXref    bool
+		withinTrailer bool
+	)
+
+	for {
+		line, err := scanLineRaw(s)
+		if err != nil {
+			break
+		}
+		if withinXref {
+			offset += int64(len(line) + eolCount)
+			if withinTrailer {
+				bb = append(bb, ' ')
+				bb = append(bb, line...)
+				i := strings.Index(line, "startxref")
+				if i >= 0 {
+					// Parse trailer.
+					_, err = processTrailer(ctx, s, string(bb))
+					return err
+				}
+				continue
+			}
+			// Ignore all until "trailer".
+			i := strings.Index(line, "trailer")
+			if i >= 0 {
+				bb = append(bb, line...)
+				withinTrailer = true
+			}
+			continue
+		}
+		i := strings.Index(line, "xref")
+		if i >= 0 {
+			offset += int64(len(line) + eolCount)
+			withinXref = true
+			continue
+		}
+		if !withinObj {
+			i := strings.Index(line, "obj")
+			if i >= 0 {
+				withinObj = true
+				off = offset
+				bb = append(bb, line[:i+3]...)
+			}
+			offset += int64(len(line) + eolCount)
+			continue
+		}
+
+		// within obj
+		offset += int64(len(line) + eolCount)
+		bb = append(bb, ' ')
+		bb = append(bb, line...)
+		i = strings.Index(line, "endobj")
+		if i >= 0 {
+			l := string(bb)
+			objNr, generation, err := parseObjectAttributes(&l)
+			if err != nil {
+				return err
+			}
+			of := off
+			ctx.Table[*objNr] = &XRefTableEntry{
+				Free:       false,
+				Offset:     &of,
+				Generation: generation}
+			bb = nil
+			withinObj = false
+		}
+	}
+	return nil
 }
 
 // Build XRefTable by reading XRef streams or XRef sections.
@@ -1039,12 +1182,13 @@ func buildXRefTableStartingAt(ctx *Context, offset *int64) error {
 
 	rs := ctx.Read.rs
 
-	hv, err := headerVersion(rs)
+	hv, eolCount, err := headerVersion(rs)
 	if err != nil {
 		return err
 	}
 
 	ctx.HeaderVersion = hv
+	ctx.Read.EolCount = eolCount
 
 	for offset != nil {
 
@@ -1063,26 +1207,23 @@ func buildXRefTableStartingAt(ctx *Context, offset *int64) error {
 
 		log.Read.Printf("line: <%s>\n", line)
 
-		if strings.TrimSpace(line) != "xref" {
+		if strings.TrimSpace(line) == "xref" {
+			log.Read.Println("buildXRefTableStartingAt: found xref section")
+			if offset, err = parseXRefSection(s, ctx); err != nil {
+				return err
+			}
+		} else {
 
 			log.Read.Println("buildXRefTableStartingAt: found xref stream")
 			ctx.Read.UsingXRefStreams = true
 			rd, err = newPositionedReader(rs, offset)
 			if err != nil {
 				return err
 			}
-
 			if offset, err = parseXRefStream(rd, offset, ctx); err != nil {
-				return err
+				// Try fix for corrupt single xref section.
+				return bypassXrefSection(ctx)
 			}
-
-		} else {
-
-			log.Read.Println("buildXRefTableStartingAt: found xref section")
-			if offset, err = parseXRefSection(s, ctx); err != nil {
-				return err
-			}
-
 		}
 	}