working

Author: robotdan

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025, FusionAuth, All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the License.
+ */
+package io.fusionauth.http.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A filter InputStream that reads a fixed length body.
+ *
+ * @author Daniel DeGroff
+ */
+public class FixedLengthInputStream extends InputStream {
+  private final byte[] b1 = new byte[1];
+
+  private final PushbackInputStream delegate;
+
+  private long bytesRemaining;
+
+  public FixedLengthInputStream(PushbackInputStream delegate, long contentLength) {
+    this.delegate = delegate;
+    this.bytesRemaining = contentLength;
+  }
+
+  @Override
+  public int read(byte[] b, int off, int len) throws IOException {
+    if (bytesRemaining <= 0) {
+      return -1;
+    }
+
+    int read = delegate.read(b, off, len);
+    int reportBytesRead = read;
+    if (read > 0) {
+      int extraBytes = (int) (read - bytesRemaining);
+      if (extraBytes > 0) {
+        reportBytesRead -= extraBytes;
+        delegate.push(b, (int) bytesRemaining, extraBytes);
+      }
+
+      bytesRemaining -= reportBytesRead;
+    }
+
+    return reportBytesRead;
+  }
+
+  @Override
+  public int read() throws IOException {
+    var read = read(b1);
+    if (read <= 0) {
+      return read;
+    }
+
+    return b1[0] & 0xFF;
+  }
+}

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

@@ -23,6 +23,7 @@
 import io.fusionauth.http.ContentTooLargeException;
 import io.fusionauth.http.HTTPValues.ContentEncodings;
 import io.fusionauth.http.io.ChunkedInputStream;
+import io.fusionauth.http.io.FixedLengthInputStream;
 import io.fusionauth.http.io.PushbackInputStream;
 import io.fusionauth.http.log.Logger;
 import io.fusionauth.http.server.HTTPRequest;
@@ -55,8 +56,6 @@ public class HTTPInputStream extends InputStream {
 
   private int bytesRead;
 
-  private long bytesRemaining;
-
   private boolean closed;
 
   private InputStream delegate;
@@ -75,11 +74,6 @@ public HTTPInputStream(HTTPServerConfiguration configuration, HTTPRequest reques
     this.chunkedBufferSize = configuration.getChunkedBufferSize();
     this.maximumBytesToDrain = configuration.getMaxBytesToDrain();
     this.maximumContentLength = maximumContentLength;
-
-    // Start the countdown
-    if (request.getContentLength() != null) {
-      this.bytesRemaining = request.getContentLength();
-    }
   }
 
   @Override
@@ -142,23 +136,6 @@ public int read(byte[] b, int off, int len) throws IOException {
       return 0;
     }
 
-    // TODO : Re: Compression - fixedLength and Content-Length needs to account for the Content-Length referring to the compressed body.
-
-    // Preamble, this could push back compressed bytes.
-    //   Pushback > Throughput > Socket
-    //
-    // HTTPInputStream (this) -> Decompress > Pushback > Throughput > Socket
-    // HTTPInputStream (this) -> Decompress > Chunked > Pushback > Throughput > Socket
-    //
-    // Pushback doesn't care if the bytes are compressed or not, it is up to the caller?
-    //
-
-    // If this is a fixed length request, and we have less than or equal to 0 bytes remaining, return -1
-    boolean fixedLength = !request.isChunked();
-    if (fixedLength && bytesRemaining <= 0) {
-      return -1;
-    }
-
     if (!initialized) {
       initialize();
     }
@@ -167,49 +144,19 @@ public int read(byte[] b, int off, int len) throws IOException {
     // - If we have read past the end of the current request, push those bytes back onto the InputStream.
     // - When a maximum content length has been specified, read at most one byte past the maximum.
     int maxReadLen = maximumContentLength == -1 ? len : Math.min(len, maximumContentLength - bytesRead + 1);
-
-    // TODO : Hack - This makes compression work with fixed length requests
-    if (fixedLength) {
-      // TODO : Note : The len arg for an inflater stream is the number of un-compressed bytes.
-      //               The returned number of bytes is the un-compressed bytes. So the problem here
-      //               is that the bytesRemaining value we have is the compressed size of the payload so we can't
-      //               us it to ensure we do not read past the current fixed length request. Sad.
-//      maxReadLen = Math.min(maxReadLen, (int) bytesRemaining);
-    }
-
     int read = delegate.read(b, off, maxReadLen);
-
-    // TODO : Can I optionally never override here? If I am fixed length, I could change len -> maxLen., and then never pushback.
-    //        Would this help with compression?
-//    int maxLen = (int) Math.min(len, bytesRemaining);
-//    int maxLen = len;
-//    int read = delegate.read(b, off, maxLen);
-
-    // TODO : This is busted with compression.
-    //        bytesRemaining is calculated based upon the Content-Length.
-    //        But the bytes read from the InputStream will be the bytes read that are un-compressed.
-    //        So we can't use the bytes read to calculate pushback. This has to go below the Decompression in the chain.
-    int reportBytesRead = read;
-    if (fixedLength && read > 0) {
-      int extraBytes = (int) (read - bytesRemaining);
-      if (extraBytes > 0) {
-        reportBytesRead -= extraBytes;
-        pushbackInputStream.push(b, (int) bytesRemaining, extraBytes);
-      }
-
-      bytesRemaining -= reportBytesRead;
+    if (read > 0) {
+      bytesRead += read;
     }
 
-    bytesRead += reportBytesRead;
-
     // Note that when the request is fixed length, we will have failed early during commit().
     // - This will handle all requests that are not fixed length.
     if (maximumContentLength != -1 && bytesRead > maximumContentLength) {
       String detailedMessage = "The maximum request size has been exceeded. The maximum request size is [" + maximumContentLength + "] bytes.";
       throw new ContentTooLargeException(maximumContentLength, detailedMessage);
     }
 
-    return reportBytesRead;
+    return read;
   }
 
   private void initialize() throws IOException {
@@ -248,29 +195,26 @@ private void initialize() throws IOException {
       }
     } else if (contentLength != null) {
       logger.trace("Client indicated it was sending an entity-body in the request. Handling body using Content-Length header {}.", contentLength);
+      delegate = new FixedLengthInputStream(pushbackInputStream, contentLength);
     } else {
       logger.trace("Client indicated it was NOT sending an entity-body in the request");
     }
 
     // If we have a maximumContentLength, and this is a fixed content length request, before we read any bytes, fail early.
     // For good measure do this last so if anyone downstream wants to read from the InputStream they could in theory because
     // we will have set up the InputStream.
+    // TODO : Compression : we may have to delete this code, or only enforce it when compression was not used.
+    //        Content-Length represents the compressed size, not the uncompressed bytes.
     if (contentLength != null && maximumContentLength != -1 && contentLength > maximumContentLength) {
       String detailedMessage = "The maximum request size has been exceeded. The reported Content-Length is [" + contentLength + "] and the maximum request size is [" + maximumContentLength + "] bytes.";
       throw new ContentTooLargeException(maximumContentLength, detailedMessage);
     }
 
-    // Those who push back:
-    // HTTPInputStream when fixed
-    // ChunkedInputStream when chunked
-    // Preamble parser
-
-    // HTTPInputStream (this) > Pushback (delegate) > Throughput > Socket
-    // HTTPInputStream (this) > Chunked (delegate) > Pushback > Throughput > Socket
-
     // The way it is currently coded
-    // HTTPInputStream (this) > Decompress > Pushback > Throughput > Socket
-    // HTTPInputStream (this) > Decompress > Chunked > Pushback > Throughput > Socket
+    // HTTPInputStream (this) > Decompress > Fixed   > Pushback > Throughput > Socket
+
+    // HTTPInputStream (this) > Chunked > Pushback > Throughput > Socket
+    //    > HTTPInputStream (this) > Decompress > Chunked > Pushback > Throughput > Socket
 
     // TODO : Note I could leave this alone, but when we parse the header we can lower case these values and then remove the equalsIgnoreCase here?
     //        Seems like ideally we would normalize them to lowercase earlier.

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

@@ -50,11 +50,8 @@ public void read_chunked_withPushback(String contentEncoding) throws Exception {
     // we read past the end of the current request and use the PushbackInputStream.
 
     String content = "These pretzels are making me thirsty. These pretzels are making me thirsty. These pretzels are making me thirsty.";
-    int contentLength = content.getBytes(StandardCharsets.UTF_8).length;
-
-    // Chunk the content, add part of the next request
-    String chunked = chunkItUp(content, 38, null);
-    byte[] payload = chunked.getBytes(StandardCharsets.UTF_8);
+    byte[] payload = content.getBytes(StandardCharsets.UTF_8);
+    int contentLength = payload.length;
 
     // Optionally compress the payload
     if (!contentEncoding.isEmpty()) {
@@ -69,6 +66,14 @@ public void read_chunked_withPushback(String contentEncoding) throws Exception {
       }
     }
 
+    // Chunk the content, add part of the next request
+    var temp1 = payload;
+    var temp2 = new String(payload, StandardCharsets.UTF_8).getBytes(StandardCharsets.UTF_8);
+    assertEquals(temp1, temp2);
+
+    String chunked = chunkItUp(new String(payload, StandardCharsets.UTF_8), 38, null);
+    payload = chunked.getBytes(StandardCharsets.UTF_8);
+
     ByteArrayOutputStream out = new ByteArrayOutputStream();
     out.write(payload);