Fix problem with infinite loop occurs

Add flexibily to PdfCatalog#constructOutlines logic relying on PdfReader#StrictnessLevel
Unignore some tests relying to problems with infinite loop in outlines while merging

DEVSIX-3703

Author: BlackEgoist

kernel/src/main/java/com/itextpdf/kernel/exceptions/KernelExceptionMessageConstant.java

@@ -122,6 +122,9 @@ public final class KernelExceptionMessageConstant {
     public static final String CONTENT_STREAM_MUST_NOT_INVOKE_OPERATORS_THAT_SPECIFY_COLORS_OR_OTHER_COLOR_RELATED_PARAMETERS =
             "Content stream must not invoke operators that specify colors or other color related parameters in "
                     + "the graphics state.";
+    public static final String CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP =
+            "Document outline dictionary is corrupted: some outline (PDF object: \"{0}\") has wrong first/next link "
+                    + "entry.";
     public static final String CORRUPTED_OUTLINE_NO_PARENT_ENTRY =
             "Document outline is corrupted: some outline (PDF object: \"{0}\") lacks the required parent entry.";
     public static final String CORRUPTED_OUTLINE_NO_TITLE_ENTRY =

kernel/src/main/java/com/itextpdf/kernel/logs/KernelLogMessageConstant.java

@@ -48,6 +48,10 @@ This file is part of the iText (R) project.
  */
 public final class KernelLogMessageConstant {
 
+    public static final String CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP =
+            "Document outline dictionary is corrupted: some outline (PDF object: \"{0}\") has wrong first/next link "
+                    + "entry. Next outlines in this dictionary will be unprocessed.";
+
     public static final String DCTDECODE_FILTER_DECODING =
             "DCTDecode filter decoding into the bit map is not supported. The stream data would be left in JPEG "
                     + "baseline format";

kernel/src/main/java/com/itextpdf/kernel/pdf/PdfCatalog.java

@@ -47,6 +47,8 @@ This file is part of the iText (R) project.
 import com.itextpdf.commons.utils.MessageFormatUtil;
 import com.itextpdf.kernel.exceptions.PdfException;
 import com.itextpdf.kernel.exceptions.KernelExceptionMessageConstant;
+import com.itextpdf.kernel.logs.KernelLogMessageConstant;
+import com.itextpdf.kernel.pdf.PdfReader.StrictnessLevel;
 import com.itextpdf.kernel.pdf.action.PdfAction;
 import com.itextpdf.kernel.pdf.collection.PdfCollection;
 import com.itextpdf.kernel.pdf.layer.PdfOCProperties;
@@ -91,7 +93,7 @@ public class PdfCatalog extends PdfObjectWrapper<PdfDictionary> {
      */
     protected PdfOCProperties ocProperties;
 
-    private static final String OutlineRoot = "Outlines";
+    private static final String ROOT_OUTLINE_TITLE = "Outlines";
 
     private PdfOutline outlines;
 
@@ -561,6 +563,91 @@ void addRootOutline(PdfOutline outline) {
         }
     }
 
+    /**
+     * Construct {@link PdfCatalog dictionary} iteratively. Invalid pdf documents will be processed depending on {@link
+     * StrictnessLevel}, if it set to lenient, we will ignore and process invalid outline structure, otherwise {@link
+     * PdfException} will be thrown.
+     *
+     * @param outlineRoot {@link PdfOutline dictionary} root.
+     * @param names map containing the PdfObjects stored in the tree.
+     */
+    void constructOutlines(PdfDictionary outlineRoot, Map<String, PdfObject> names) {
+        if (outlineRoot == null) {
+            return;
+        }
+
+        PdfReader reader = getDocument().getReader();
+        final boolean isLenientLevel =
+                reader == null || StrictnessLevel.CONSERVATIVE.isStricter(reader.getStrictnessLevel());
+        PdfDictionary current = outlineRoot.getAsDictionary(PdfName.First);
+
+        outlines = new PdfOutline(ROOT_OUTLINE_TITLE, outlineRoot, getDocument());
+        PdfOutline parentOutline = outlines;
+
+        Map<PdfOutline, PdfDictionary> nextUnprocessedChildForParentMap = new HashMap<>();
+        Set<PdfDictionary> alreadyVisitedOutlinesSet = new HashSet<>();
+
+        while (current != null) {
+            PdfDictionary parent = current.getAsDictionary(PdfName.Parent);
+            if (null == parent && !isLenientLevel) {
+                throw new PdfException(
+                        MessageFormatUtil.format(
+                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_NO_PARENT_ENTRY,
+                                current.indirectReference));
+            }
+            PdfString title = current.getAsString(PdfName.Title);
+            if (null == title) {
+                throw new PdfException(
+                        MessageFormatUtil.format(
+                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_NO_TITLE_ENTRY,
+                                current.indirectReference));
+            }
+            PdfOutline currentOutline = new PdfOutline(title.toUnicodeString(), current, parentOutline);
+            alreadyVisitedOutlinesSet.add(current);
+            addOutlineToPage(currentOutline, current, names);
+            parentOutline.getAllChildren().add(currentOutline);
+
+            PdfDictionary first = current.getAsDictionary(PdfName.First);
+            PdfDictionary next = current.getAsDictionary(PdfName.Next);
+            if (first != null) {
+                if (alreadyVisitedOutlinesSet.contains(first)) {
+                    if (!isLenientLevel) {
+                        throw new PdfException(MessageFormatUtil.format(
+                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP, first));
+                    }
+                    LOGGER.warn(MessageFormatUtil.format(
+                            KernelLogMessageConstant.CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP, first));
+                    return;
+                }
+                // Down in hierarchy; when returning up, process `next`.
+                nextUnprocessedChildForParentMap.put(parentOutline, next);
+                parentOutline = currentOutline;
+                current = first;
+            } else if (next != null) {
+                if (alreadyVisitedOutlinesSet.contains(next)) {
+                    if (!isLenientLevel) {
+                        throw new PdfException(MessageFormatUtil.format(
+                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP, next));
+                    }
+                    LOGGER.warn(MessageFormatUtil.format(
+                            KernelLogMessageConstant.CORRUPTED_OUTLINE_DICTIONARY_HAS_INFINITE_LOOP, next));
+                    return;
+                }
+                // Next sibling in hierarchy
+                current = next;
+            } else {
+                // Up in hierarchy using 'nextUnprocessedChildForParentMap'.
+                current = null;
+                while (current == null && parentOutline != null) {
+                    parentOutline = parentOutline.getParent();
+                    if (parentOutline != null) {
+                        current = nextUnprocessedChildForParentMap.get(parentOutline);
+                    }
+                }
+            }
+        }
+    }
+
     PdfDestination copyDestination(PdfObject dest, Map<PdfPage, PdfPage> page2page, PdfDocument toDocument) {
         if (null == dest) {
             return null;
@@ -683,61 +770,4 @@ private void addOutlineToPage(PdfOutline outline, PdfDictionary item, Map<String
             }
         }
     }
-
-    /**
-     * Constructs {@link PdfCatalog#outlines} iteratively
-     */
-    void constructOutlines(PdfDictionary outlineRoot, Map<String, PdfObject> names) {
-        if (outlineRoot == null) {
-            return;
-        }
-        PdfDictionary current = outlineRoot.getAsDictionary(PdfName.First);
-
-        outlines = new PdfOutline(OutlineRoot, outlineRoot, getDocument());
-        PdfOutline parentOutline = outlines;
-
-        // map `PdfOutline` to the next sibling to process in the hierarchy
-        HashMap<PdfOutline, PdfDictionary> positionMap = new HashMap<>();
-
-        while (current != null) {
-            PdfDictionary parent = current.getAsDictionary(PdfName.Parent);
-            if (null == parent) {
-                throw new PdfException(
-                        MessageFormatUtil.format(
-                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_NO_PARENT_ENTRY,
-                                current.indirectReference));
-            }
-            PdfString title = current.getAsString(PdfName.Title);
-            if (null == title) {
-                throw new PdfException(
-                        MessageFormatUtil.format(
-                                KernelExceptionMessageConstant.CORRUPTED_OUTLINE_NO_TITLE_ENTRY,
-                                current.indirectReference));
-            }
-            PdfOutline currentOutline = new PdfOutline(title.toUnicodeString(), current, parentOutline);
-            addOutlineToPage(currentOutline, current, names);
-            parentOutline.getAllChildren().add(currentOutline);
-
-            PdfDictionary first = current.getAsDictionary(PdfName.First);
-            PdfDictionary next = current.getAsDictionary(PdfName.Next);
-            if (first != null) {
-                // Down in hierarchy; when returning up, process `next`
-                positionMap.put(parentOutline, next);
-                parentOutline = currentOutline;
-                current = first;
-            } else if (next != null) {
-                // Next sibling in hierarchy
-                current = next;
-            } else {
-                // Up in hierarchy using `positionMap`
-                current = null;
-                while (current == null && parentOutline != null) {
-                    parentOutline = parentOutline.getParent();
-                    if (parentOutline != null) {
-                        current = positionMap.get(parentOutline);
-                    }
-                }
-            }
-        }
-    }
 }