Merge branch '2.19'

Author: cowtowncoder

release-notes/CREDITS-2.x

@@ -477,6 +477,9 @@ Yanming Zhou (@quaff)
 Fawzi Essam (@iifawzi)
  * Contributed #633: Allow skipping `RS` CTRL-CHAR to support JSON Text Sequences
   (2.19.0)
+ * Contributed #1144: `FilteringParserDelegate` can go into an infinite loop if underlying
+  parser is non-blocking
+  (2.19.0)
 
 Eduard Gomoliako (@Gems)
  * Contributed #1356: Make `JsonGenerator::writeTypePrefix` method to not write a

release-notes/VERSION-2.x

@@ -19,6 +19,10 @@ a pure JSON library.
 #633: Allow skipping `RS` CTRL-CHAR to support JSON Text Sequences
  (requested by Yanming Z)
  (contributed by Fawzi E)
+#1144: `FilteringParserDelegate` can go into an infinite loop if underlying
+  parser is non-blocking
+ (reported by @simonbasle)
+ (contributed by Fawzi E)
 #1328: Optimize handling of `JsonPointer.head()`
 #1356: Make `JsonGenerator::writeTypePrefix` method to not write a
   `WRAPPER_ARRAY` when `typeIdDef.id == null`

src/main/java/tools/jackson/core/filter/FilteringParserDelegate.java

@@ -100,13 +100,66 @@ public class FilteringParserDelegate extends JsonParserDelegate
      * @param f Filter to use
      * @param inclusion Definition of inclusion criteria
      * @param allowMultipleMatches Whether to allow multiple matches
+     *
+     * @throws IllegalArgumentException if non-blocking (async) parser
+     *    (for which {@code parser.canParseAsync()} returns `true`) is
+     *    used -- doing so requires use of different constructor:
+     *    {@link #FilteringParserDelegate(JsonParser, TokenFilter, TokenFilter.Inclusion, boolean, boolean)}
      */
     public FilteringParserDelegate(JsonParser p, TokenFilter f,
             TokenFilter.Inclusion inclusion, boolean allowMultipleMatches)
     {
         super(p);
+
+        _checkAsyncParser(p);
+
+        initializeFilters(f, inclusion, allowMultipleMatches);
+    }
+
+    private static void _checkAsyncParser(JsonParser p) throws IllegalArgumentException {
+        if (p.canParseAsync()) {
+            throw new IllegalArgumentException(
+                    String.format(
+"%s is an asynchronous parser (canParseAsync() == true), " +
+"which requires explicit permission to be used: " +
+"to allow use, call constructor with `allowNonBlockingParser` passed as `true`",
+                            p.getClass().getSimpleName()
+                    )
+            );
+        }
+    }
+    
+    /**
+     * @param p Parser to delegate calls to
+     * @param f Filter to use
+     * @param inclusion Definition of inclusion criteria
+     * @param allowMultipleMatches Whether to allow multiple matches
+     * @param allowNonBlockingParser If true, allows use of NonBlockingJsonParser: must
+     *   also feed all input to parser before calling nextToken on this delegate
+     *
+     * @throws IllegalArgumentException if NonBlockingJsonParser is used without explicit permission
+     */
+    public FilteringParserDelegate(JsonParser p, TokenFilter f,
+            TokenFilter.Inclusion inclusion, boolean allowMultipleMatches,
+            boolean allowNonBlockingParser) {
+        super(p);
+
+        if (!allowNonBlockingParser) {
+            _checkAsyncParser(p);
+        }
+
+        initializeFilters(f, inclusion, allowMultipleMatches);
+    }
+
+    /**
+     * Initializes filter-related fields
+     *
+     * @param f Filter to use
+     * @param inclusion Definition of inclusion criteria
+     * @param allowMultipleMatches Whether to allow multiple matches
+     */
+    private void initializeFilters(TokenFilter f, TokenFilter.Inclusion inclusion, boolean allowMultipleMatches) {
         rootFilter = f;
-        // and this is the currently active filter for root values
         _itemFilter = f;
         _headContext = TokenFilterContext.createRootContext(f);
         _inclusion = inclusion;
@@ -286,7 +339,9 @@ public JsonToken nextToken() throws JacksonException
         TokenFilter f;
 
         switch (t.id()) {
-        case ID_START_ARRAY:
+            case JsonTokenId.ID_NOT_AVAILABLE:
+                throw _constructReadException("`JsonToken.NOT_AVAILABLE` received: ensure all input is fed to the Parser before use");
+            case ID_START_ARRAY:
             f = _itemFilter;
             if (f == TokenFilter.INCLUDE_ALL) {
                 _headContext = _headContext.createChildArrayContext(f, null, true);

src/test/java/tools/jackson/core/unittest/json/async/AsyncTokenFilterTest.java

@@ -2,10 +2,10 @@
 
 import org.junit.jupiter.api.Test;
 
-import tools.jackson.core.JsonToken;
-import tools.jackson.core.ObjectReadContext;
+import tools.jackson.core.*;
 import tools.jackson.core.exc.StreamReadException;
 import tools.jackson.core.filter.FilteringParserDelegate;
+import tools.jackson.core.filter.JsonPointerBasedFilter;
 import tools.jackson.core.filter.TokenFilter;
 import tools.jackson.core.filter.TokenFilter.Inclusion;
 import tools.jackson.core.json.JsonFactory;
@@ -28,13 +28,36 @@ public TokenFilter includeProperty(String name) {
         }
     };
 
+    @Test
+    void filteredNonBlockingParserNotExplicitlyAllowed() throws Exception {
+        NonBlockingByteArrayJsonParser nbParser = _nonBlockingParser();
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () ->
+                new FilteringParserDelegate(nbParser, TOKEN_FILTER, Inclusion.INCLUDE_ALL_AND_PATH, true)
+        );
+
+        verifyException(exception, "NonBlockingByteArrayJsonParser");
+        verifyException(exception, "(canParseAsync() == true)");
+    }
+
+    @Test
+    void filteringNonBlockingParserWithoutInputFed() throws Exception
+    {
+        NonBlockingByteArrayJsonParser nbParser = _nonBlockingParser();
+        try (JsonParser filteringParser = new FilteringParserDelegate(nbParser,
+                new JsonPointerBasedFilter("/second"),
+                TokenFilter.Inclusion.ONLY_INCLUDE_ALL, false, true)) {
+            StreamReadException e = assertThrows(StreamReadException.class, filteringParser::nextToken);
+            verifyException(e, "JsonToken.NOT_AVAILABLE");
+        }
+    }
+
     // Passes if (but only if) all content is actually available
     @Test
     public void testFilteredNonBlockingParserAllContent()
     {
         NonBlockingByteArrayJsonParser nbParser = _nonBlockingParser();
         FilteringParserDelegate filteredParser = new FilteringParserDelegate(nbParser,
-                TOKEN_FILTER, Inclusion.INCLUDE_ALL_AND_PATH, true);
+                TOKEN_FILTER, Inclusion.INCLUDE_ALL_AND_PATH, true, true);
         nbParser.feedInput(INPUT_BYTES, 0, INPUT_BYTES.length);
 
         assertToken(JsonToken.START_OBJECT, filteredParser.nextToken());
@@ -53,7 +76,7 @@ public void testSkipChildrenFailOnSplit()
     {
         NonBlockingByteArrayJsonParser nbParser = _nonBlockingParser();
         FilteringParserDelegate filteredParser = new FilteringParserDelegate(nbParser,
-                TOKEN_FILTER, Inclusion.INCLUDE_ALL_AND_PATH, true);
+                TOKEN_FILTER, Inclusion.INCLUDE_ALL_AND_PATH, true, true);
         nbParser.feedInput(INPUT_BYTES, 0, 5);
 
         assertToken(JsonToken.START_OBJECT, nbParser.nextToken());