Working

Author: robotdan

src/main/java/io/fusionauth/http/HTTPValues.java

@@ -216,6 +216,8 @@ public static final class Headers {
 
     public static final String ContentEncoding = "Content-Encoding";
 
+    public static final String ContentEncodingLower = "content-encoding";
+
     public static final String ContentLength = "Content-Length";
 
     public static final String ContentLengthLower = "content-length";

src/main/java/io/fusionauth/http/server/HTTPRequest.java

@@ -68,6 +68,8 @@ public class HTTPRequest implements Buildable<HTTPRequest> {
 
   private final Map<String, Object> attributes = new HashMap<>();
 
+  private final List<String> contentEncodings = new LinkedList<>();
+
   private final Map<String, Cookie> cookies = new HashMap<>();
 
   private final List<FileInfo> files = new LinkedList<>();
@@ -296,6 +298,15 @@ public void setCharacterEncoding(Charset encoding) {
     this.encoding = encoding;
   }
 
+  public List<String> getContentEncodings() {
+    return contentEncodings;
+  }
+
+  public void setContentEncodings(List<String> encodings) {
+    this.contentEncodings.clear();
+    this.contentEncodings.addAll(encodings);
+  }
+
   public Long getContentLength() {
     return contentLength;
   }
@@ -715,7 +726,7 @@ public void setURLParameters(String name, Collection<String> values) {
 
   private void decodeHeader(String name, String value) {
     switch (name) {
-      case Headers.AcceptEncodingLower:
+      case Headers.AcceptEncodingLower, Headers.ContentEncodingLower:
         SortedSet<WeightedString> weightedStrings = new TreeSet<>();
         String[] parts = value.split(",");
         int index = 0;
@@ -738,11 +749,15 @@ private void decodeHeader(String name, String value) {
         }
 
         // Transfer the Strings in weighted-position order
-        setAcceptEncodings(
-            weightedStrings.stream()
-                           .map(WeightedString::value)
-                           .toList()
-        );
+        var result = weightedStrings.stream()
+                                    .map(WeightedString::value)
+                                    .toList();
+
+        if (name.equals(Headers.AcceptEncodingLower)) {
+          setAcceptEncodings(result);
+        } else {
+          setContentEncodings(result);
+        }
         break;
       case Headers.AcceptLanguageLower:
         try {
@@ -801,15 +816,12 @@ private void decodeHeader(String name, String value) {
             }
           }
         } else {
+          this.host = value;
           if ("http".equalsIgnoreCase(scheme)) {
             this.port = 80;
-          }
-          else if ("https".equalsIgnoreCase(scheme)) {
+          } else if ("https".equalsIgnoreCase(scheme)) {
             this.port = 443;
-          } else {
-            // fallback, intentionally do nothing
           }
-          this.host = value;
         }
         break;
     }

src/main/java/io/fusionauth/http/server/internal/HTTPWorker.java

@@ -144,6 +144,11 @@ public void run() {
           instrumenter.acceptedRequest();
         }
 
+        // TODO : Content-Encoding, we are currently keeping the PushbackInputStream for the entire keep-alive session.
+        //        Ideally we'd set the InputStream for gzip, deflate, etc lower.
+        //        Also... with Pushback bytes... the bytes may be compressed for the next request. So we'll need to be able to
+        //        read handle this. So perhaps this should all be handled at a high level?
+
         httpInputStream = new HTTPInputStream(configuration, request, inputStream);
         request.setInputStream(httpInputStream);
 

src/main/java/io/fusionauth/http/server/io/HTTPInputStream.java

@@ -17,7 +17,10 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.zip.DeflaterInputStream;
+import java.util.zip.GZIPInputStream;
 
+import io.fusionauth.http.HTTPValues.ContentEncodings;
 import io.fusionauth.http.io.ChunkedInputStream;
 import io.fusionauth.http.io.PushbackInputStream;
 import io.fusionauth.http.log.Logger;
@@ -161,13 +164,27 @@ public int read(byte[] b, int off, int len) throws IOException {
     return read;
   }
 
-  private void commit() {
+  private void commit() throws IOException {
     committed = true;
 
-    // Note that isChunked() should take precedence over the fact that we have a Content-Length.
-    // - The client should not send both, but in the case they are both present we ignore Content-Length
     Long contentLength = request.getContentLength();
     boolean hasBody = (contentLength != null && contentLength > 0) || request.isChunked();
+
+//    if (hasBody) {
+//      // The request may contain more than one value, apply in reverse order.
+//      for (String contentEncoding : request.getContentEncodings().reversed()) {
+//        if (contentEncoding.equalsIgnoreCase(ContentEncodings.Deflate)) {
+//          // Use the default buffer size of 512
+//          delegate = new DeflaterInputStream(delegate);
+//        } else if (contentEncoding.equalsIgnoreCase(ContentEncodings.Gzip)) {
+//          // Use the default buffer size of 512
+//          delegate = new GZIPInputStream(delegate);
+//        }
+//      }
+//    }
+
+    // Note that isChunked() should take precedence over the fact that we have a Content-Length.
+    // - The client should not send both, but in the case they are both present we ignore Content-Length
     if (!hasBody) {
       delegate = InputStream.nullInputStream();
     } else if (request.isChunked()) {

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

@@ -144,7 +144,7 @@ public void chunkedRequest_doNotReadTheInputStream(String scheme) throws Excepti
         var response = client.send(HttpRequest.newBuilder()
                                               .uri(uri)
                                               .header(Headers.ContentType, "text/plain")
-                                              // Note that using a InputStream baed publisher will caues the JDK to
+                                              // Note that using a InputStream based publisher will caues the JDK to
                                               // enable Transfer-Encoding: chunked
                                               .POST(BodyPublishers.ofInputStream(() ->
                                                   new ByteArrayInputStream(responseBodyBytes)))

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

@@ -105,10 +105,11 @@ public void compress(String encoding, boolean chunked, String scheme) throws Exc
       }
     };
 
+    // Compress the request using the encoding parameter
     ByteArrayOutputStream baseOutputStream = new ByteArrayOutputStream();
     DeflaterOutputStream out = encoding.equals(ContentEncodings.Deflate)
-        ? new DeflaterOutputStream(baseOutputStream)
-        : new GZIPOutputStream(baseOutputStream);
+        ? new DeflaterOutputStream(baseOutputStream, true)
+        : new GZIPOutputStream(baseOutputStream, true);
     out.write("Hello world!".getBytes(StandardCharsets.UTF_8));
     out.finish();
     byte[] payload = baseOutputStream.toByteArray();
@@ -122,6 +123,10 @@ public void compress(String encoding, boolean chunked, String scheme) throws Exc
                      .header(Headers.AcceptEncoding, encoding)
                      // Send the request using the same encoding
                      .header(Headers.ContentEncoding, encoding)
+                     .header(Headers.ContentType, "text/plain")
+                     // Manually set the header since the body is small, the client not turn on chunked.
+                     .header(Headers.TransferEncoding, "chunked")
+                     // A ByteArrayInputStream should cause the request to be chunk encoded
                      .POST(BodyPublishers.ofInputStream(() -> new ByteArrayInputStream(payload)))
                      .uri(uri).GET().build(),
           r -> BodySubscribers.ofInputStream()