Fix content type detection with leading whitespace (#32632)

Today content type detection on an input stream works by peeking up to
twenty bytes into the stream. If the stream is headed by more whitespace
than twenty bytes, we might fail to detect the content type. We should
be ignoring this whitespace before attempting to detect the content
type. This commit does that by ignoring all leading whitespace in an
input stream before attempting to guess the content type.

Author: jasontedor

core/src/main/java/org/elasticsearch/common/xcontent/XContentFactory.java

@@ -39,7 +39,7 @@
  */
 public class XContentFactory {
 
-    private static final int GUESS_HEADER_LENGTH = 20;
+    static final int GUESS_HEADER_LENGTH = 20;
 
     /**
      * Returns a content builder using JSON format ({@link org.elasticsearch.common.xcontent.XContentType#JSON}.
@@ -213,17 +213,41 @@ public static XContentType xContentType(byte[] data) {
      * Guesses the content type based on the provided input stream without consuming it.
      */
     public static XContentType xContentType(InputStream si) throws IOException {
+        /*
+         * We need to guess the content type. To do this, we look for the first non-whitespace character and then try to guess the content
+         * type on the GUESS_HEADER_LENGTH bytes that follow. We do this in a way that does not modify the initial read position in the
+         * underlying input stream. This is why the input stream must support mark/reset and why we repeatedly mark the read position and
+         * reset.
+         */
         if (si.markSupported() == false) {
             throw new IllegalArgumentException("Cannot guess the xcontent type without mark/reset support on " + si.getClass());
         }
-        si.mark(GUESS_HEADER_LENGTH);
+        si.mark(Integer.MAX_VALUE);
         try {
+            // scan until we find the first non-whitespace character or the end of the stream
+            int current;
+            do {
+                current = si.read();
+                if (current == -1) {
+                    return null;
+                }
+            } while (Character.isWhitespace((char) current));
+            // now guess the content type off the next GUESS_HEADER_LENGTH bytes including the current byte
             final byte[] firstBytes = new byte[GUESS_HEADER_LENGTH];
-            final int read = Streams.readFully(si, firstBytes);
-            return xContentType(new BytesArray(firstBytes, 0, read));
+            firstBytes[0] = (byte) current;
+            int read = 1;
+            while (read < GUESS_HEADER_LENGTH) {
+                final int r = si.read(firstBytes, read, GUESS_HEADER_LENGTH - read);
+                if (r == -1) {
+                    break;
+                }
+                read += r;
+            }
+            return xContentType(firstBytes, 0, read);
         } finally {
             si.reset();
         }
+
     }
 
     /**

core/src/test/java/org/elasticsearch/common/xcontent/XContentFactoryTests.java

@@ -21,12 +21,15 @@
 
 import com.fasterxml.jackson.dataformat.cbor.CBORConstants;
 import com.fasterxml.jackson.dataformat.smile.SmileConstants;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.bytes.BytesArray;
+import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.test.ESTestCase;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.util.Arrays;
 
 import static org.hamcrest.Matchers.equalTo;
 
@@ -56,8 +59,21 @@ private void testGuessType(XContentType type) throws IOException {
         builder.field("field1", "value1");
         builder.endObject();
 
-        assertThat(XContentFactory.xContentType(builder.bytes()), equalTo(type));
-        assertThat(XContentFactory.xContentType(builder.bytes().streamInput()), equalTo(type));
+        final BytesReference bytes;
+        if (type == XContentType.JSON && randomBoolean()) {
+            final int length = randomIntBetween(0, 8 * XContentFactory.GUESS_HEADER_LENGTH);
+            final String content = builder.string();
+            final StringBuilder sb = new StringBuilder(length + content.length());
+            final char[] chars = new char[length];
+            Arrays.fill(chars, ' ');
+            sb.append(new String(chars)).append(content);
+            bytes = new BytesArray(sb.toString());
+        } else {
+            bytes = builder.bytes();
+        }
+
+        assertThat(XContentFactory.xContentType(bytes), equalTo(type));
+        assertThat(XContentFactory.xContentType(bytes.streamInput()), equalTo(type));
 
         // CBOR is binary, cannot use String
         if (type != XContentType.CBOR && type != XContentType.SMILE) {