Working

Author: robotdan

src/main/java/io/fusionauth/http/util/HTTPTools.java

@@ -276,6 +276,9 @@ public static HeaderValue parseHeaderValue(String value) {
 
   /**
    * Parses the request preamble directly from the given InputStream.
+   * <p>
+   * The HTTP request is made up of the request line, headers and an optional body. The request preamble comprises the Request line and the
+   * Headers. All that remains after the preamble is the optional body.
    *
    * @param inputStream          The input stream to read the preamble from.
    * @param maxRequestHeaderSize The maximum number of bytes to read for the header. If exceed throw an exception.
@@ -317,6 +320,10 @@ public static void parseRequestPreamble(PushbackInputStream inputStream, int max
         readObserver.run();
       }
 
+      // bytesRead will include bytes that are read past the end of the preamble. This should be ok because we will only throw an exception
+      // for readExceeded once we have reached this state AND we are not yet in a complete state.
+      // - So if we exceed the max header size from this read, as long as this buffer includes the entire preamble we will not throw
+      //   an exception.
       bytesRead += read;
       readExceeded = maxRequestHeaderSize != -1 && bytesRead >= maxRequestHeaderSize;
 

src/test/java/io/fusionauth/http/io/HTTPInputStreamTest.java

@@ -74,8 +74,6 @@ public void read_fixedLength_withPushback() throws Exception {
 
   private void assertReadWithPushback(byte[] bytes, String content, int contentLength, HTTPRequest request) throws Exception {
     int bytesAvailable = bytes.length;
-    System.out.println("available bytes [" + bytesAvailable + "]");
-    System.out.println("buffer size [" + (bytesAvailable + 100) + "]");
     HTTPServerConfiguration configuration = new HTTPServerConfiguration().withRequestBufferSize(bytesAvailable + 100);
 
     ByteArrayInputStream is = new ByteArrayInputStream(bytes);

src/test/java/io/fusionauth/http/util/HTTPToolsTest.java

@@ -15,13 +15,20 @@
  */
 package io.fusionauth.http.util;
 
+import java.io.ByteArrayInputStream;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import com.inversoft.json.ToString;
+import io.fusionauth.http.HTTPMethod;
+import io.fusionauth.http.io.PushbackInputStream;
+import io.fusionauth.http.server.HTTPRequest;
+import io.fusionauth.http.server.HTTPServerConfiguration;
+import io.fusionauth.http.server.internal.HTTPBuffers;
+import io.fusionauth.http.server.io.HTTPInputStream;
 import io.fusionauth.http.util.HTTPTools.HeaderValue;
 import org.testng.annotations.Test;
 import static org.testng.Assert.assertEquals;
@@ -101,4 +108,78 @@ public void parseHeaderValue() {
     assertEquals(HTTPTools.parseHeaderValue("value; f =f"), new HeaderValue("value", Map.of("f ", "f")));
     assertEquals(HTTPTools.parseHeaderValue("value; f= f"), new HeaderValue("value", Map.of("f", " f")));
   }
+
+  @Test
+  public void parsePreamble() throws Exception {
+    // Ensure that we can correctly read the preamble when the InputStream contains the next request.
+
+    //noinspection ExtractMethodRecommender
+    String request = """
+        GET / HTTP/1.1\r
+        Host: localhost:42\r
+        Connection: close\r
+        Content-Length: 113\r
+        Header1: Value1\r
+        Header2: Value2\r
+        Header3: Value3\r
+        Header4: Value4\r
+        Header5: Value5\r
+        Header6: Value6\r
+        Header7: Value7\r
+        Header8: Value8\r
+        Header9: Value9\r
+        Header10: Value10\r
+        \r
+        These pretzels are making me thirsty. These pretzels are making me thirsty. These pretzels are making me thirsty.GET / HTTP/1.1\r
+        """;
+
+    // Fixed length body with the start of the next request in the buffer
+    byte[] bytes = request.getBytes(StandardCharsets.UTF_8);
+    int bytesAvailable = bytes.length;
+
+    // Ensure the request buffer size will contain the entire request.
+    HTTPServerConfiguration configuration = new HTTPServerConfiguration().withRequestBufferSize(bytesAvailable + 100);
+
+    ByteArrayInputStream is = new ByteArrayInputStream(bytes);
+    PushbackInputStream pushbackInputStream = new PushbackInputStream(is, null);
+
+    HTTPRequest httpRequest = new HTTPRequest();
+    HTTPBuffers buffers = new HTTPBuffers(configuration);
+    byte[] requestBuffer = buffers.requestBuffer();
+
+    HTTPTools.initialize(configuration.getLoggerFactory());
+    HTTPTools.parseRequestPreamble(pushbackInputStream, 128 * 1024, httpRequest, requestBuffer, () -> {
+    });
+
+    // Ensure we parsed the request and that the right number of bytes is left over
+    assertEquals(httpRequest.getMethod(), HTTPMethod.GET);
+    assertEquals(httpRequest.getHost(), "localhost");
+    assertEquals(httpRequest.getPort(), 42);
+    assertEquals(httpRequest.getContentLength(), 113);
+    assertEquals(httpRequest.getHeaders().size(), 13);
+    assertEquals(httpRequest.getHeader("Content-Length"), "113");
+    assertEquals(httpRequest.getHeader("Connection"), "close");
+    assertEquals(httpRequest.getHeader("Host"), "localhost:42");
+    for (int i = 1; i <= 10; i++) {
+      assertEquals(httpRequest.getHeader("Header" + i), "Value" + i);
+    }
+
+    // Expect 129 bytes left over which is 113 for the body + 16 from the next request
+    assertEquals(pushbackInputStream.getAvailableBufferedBytesRemaining(), 113 + 16);
+
+    // Read the remaining bytes for this request, we should still have some left over.
+    HTTPInputStream httpInputStream = new HTTPInputStream(configuration, httpRequest, pushbackInputStream, -1);
+    byte[] buffer = new byte[1024];
+    int read = httpInputStream.read(buffer);
+    assertEquals(read, 113);
+
+    // Another read should return -1 because we are at the end of this request.
+    int nextRead = httpInputStream.read(buffer);
+    assertEquals(nextRead, -1);
+
+    // The next read from the pushback which will be used by the next request should return the remaining bytes.
+    assertEquals(pushbackInputStream.getAvailableBufferedBytesRemaining(), 16);
+    int nextRequestRead = pushbackInputStream.read(buffer);
+    assertEquals(nextRequestRead, 16);
+  }
 }