Issue #11387: Reintroduce MultiPartCompliance.LEGACY in ee9/ee8

jetty-core/jetty-http/pom.xml

@@ -28,12 +28,17 @@
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
     </dependency>
-
     <dependency>
       <groupId>org.eclipse.jetty</groupId>
       <artifactId>jetty-slf4j-impl</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty.tests</groupId>
+      <artifactId>jetty-test-multipart</artifactId>
+      <version>${project.version}</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.eclipse.jetty.toolchain</groupId>
       <artifactId>jetty-test-helper</artifactId>

jetty-core/jetty-http/src/main/java/org/eclipse/jetty/http/HttpHeader.java

@@ -47,6 +47,7 @@ public enum HttpHeader
     CONTENT_LOCATION("Content-Location"),
     CONTENT_MD5("Content-MD5"),
     CONTENT_RANGE("Content-Range"),
+    CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding"),
     CONTENT_TYPE("Content-Type"),
     EXPIRES("Expires"),
     LAST_MODIFIED("Last-Modified"),

jetty-core/jetty-http/src/main/java/org/eclipse/jetty/http/MultiPart.java

@@ -25,6 +25,7 @@
 import java.nio.file.StandardCopyOption;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
@@ -908,6 +909,7 @@ public static class Parser
         private final Utf8StringBuilder text = new Utf8StringBuilder();
         private final String boundary;
         private final SearchPattern boundaryFinder;
+        private final MultiPartCompliance compliance;
         private final Listener listener;
         private int partHeadersLength;
         private int partHeadersMaxLength = -1;
@@ -920,13 +922,33 @@ public static class Parser
         private String fieldValue;
         private long maxParts = 1000;
         private int numParts;
+        private EnumSet<MultiPartCompliance.Violation> eols;
 
         public Parser(String boundary, Listener listener)
+        {
+            this(boundary, MultiPartCompliance.RFC7578, listener);
+        }
+
+        public Parser(String boundary, MultiPartCompliance compliance, Listener listener)
         {
             this.boundary = boundary;
             // While the spec mandates CRLF before the boundary, be more lenient and only require LF.
             this.boundaryFinder = SearchPattern.compile("\n--" + boundary);
+            this.compliance = compliance;
             this.listener = listener;
+
+            if (LOG.isDebugEnabled())
+            {
+                List.of(
+                    MultiPartCompliance.Violation.CR_LINE_TERMINATION,
+                    MultiPartCompliance.Violation.BASE64_TRANSFER_ENCODING,
+                    MultiPartCompliance.Violation.WHITESPACE_BEFORE_BOUNDARY
+                ).forEach(viol ->
+                {
+                    if (compliance.allows(viol))
+                        LOG.debug("{} ignoring compliance {}: unable to allow() it.", this.getClass().getName(), viol.name());
+                });
+            }
             reset();
         }
 
@@ -1050,6 +1072,7 @@ else if (type != HttpTokens.Type.SPACE && type != HttpTokens.Type.HTAB)
                             HttpTokens.Token token = next(buffer);
                             if (token.getByte() != '-')
                                 throw new BadMessageException("bad last boundary");
+                            notifyEolViolations();
                             state = State.EPILOGUE;
                         }
                         case HEADER_START ->
@@ -1099,6 +1122,7 @@ else if (type != HttpTokens.Type.SPACE && type != HttpTokens.Type.HTAB)
                 if (LOG.isDebugEnabled())
                     LOG.debug("parse failure {} {}", state, BufferUtil.toDetailString(buffer), x);
                 buffer.position(buffer.limit());
+                notifyEolViolations();
                 notifyFailure(x);
             }
         }
@@ -1123,18 +1147,35 @@ private HttpTokens.Token next(ByteBuffer buffer)
                 }
                 case LF ->
                 {
+                    if (!crFlag)
+                    {
+                        MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.LF_LINE_TERMINATION;
+                        addEolViolation(violation);
+                        if (!compliance.allows(violation))
+                            throw new BadMessageException("invalid LF-only EOL");
+                    }
                     crFlag = false;
                 }
                 case CR ->
                 {
                     if (crFlag)
-                        throw new BadMessageException("invalid EOL");
+                    {
+                        MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.CR_LINE_TERMINATION;
+                        addEolViolation(violation);
+                        if (!compliance.allows(violation))
+                            throw new BadMessageException("invalid CR-only EOL");
+                    }
                     crFlag = true;
                 }
                 default ->
                 {
                     if (crFlag)
-                        throw new BadMessageException("invalid EOL");
+                    {
+                        MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.CR_LINE_TERMINATION;
+                        addEolViolation(violation);
+                        if (!compliance.allows(violation))
+                            throw new BadMessageException("invalid CR-only EOL");
+                    }
                 }
             }
             return t;
@@ -1331,6 +1372,13 @@ private boolean parseContent(Content.Chunk chunk)
                     {
                         // The boundary was fully matched, so the part is complete.
                         buffer.position(buffer.position() + boundaryMatch - partialBoundaryMatch);
+                        if (!crContent)
+                        {
+                            MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.LF_LINE_TERMINATION;
+                            addEolViolation(violation);
+                            if (!compliance.allows(violation))
+                                throw new BadMessageException("invalid LF-only EOL");
+                        }
                         partialBoundaryMatch = 0;
                         crContent = false;
                         notifyPartContent(Content.Chunk.EOF);
@@ -1373,7 +1421,16 @@ private boolean parseContent(Content.Chunk chunk)
             if (boundaryOffset >= 0)
             {
                 if (boundaryOffset == 0)
+                {
+                    if (!crContent)
+                    {
+                        MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.LF_LINE_TERMINATION;
+                        addEolViolation(violation);
+                        if (!compliance.allows(violation))
+                            throw new BadMessageException("invalid LF-only EOL");
+                    }
                     crContent = false;
+                }
 
                 // Emit as content the last CR byte of the previous chunk, if any.
                 notifyCRContent();
@@ -1384,7 +1441,16 @@ private boolean parseContent(Content.Chunk chunk)
                 // BoundaryFinder is configured to search for '\n--Boundary';
                 // if '\r\n--Boundary' is found, then the '\r' is not content.
                 if (length > 0 && buffer.get(position + length - 1) == '\r')
+                {
                     --length;
+                }
+                else
+                {
+                    MultiPartCompliance.Violation violation = MultiPartCompliance.Violation.LF_LINE_TERMINATION;
+                    addEolViolation(violation);
+                    if (!compliance.allows(violation))
+                        throw new BadMessageException("invalid LF-only EOL");
+                }
                 Content.Chunk content = asSlice(chunk, position, length, true);
                 buffer.position(position + boundaryOffset + boundaryFinder.getLength());
                 notifyPartContent(content);
@@ -1536,6 +1602,39 @@ private void notifyFailure(Throwable failure)
             }
         }
 
+        private void notifyEolViolations()
+        {
+            if (eols != null)
+            {
+                for (MultiPartCompliance.Violation violation: eols)
+                {
+                    notifyViolation(violation);
+                }
+                eols = null;
+            }
+        }
+
+        private void addEolViolation(MultiPartCompliance.Violation violation)
+        {
+            if (eols == null)
+                eols = EnumSet.of(violation);
+            else
+                eols.add(violation);
+        }
+
+        private void notifyViolation(MultiPartCompliance.Violation violation)
+        {
+            try
+            {
+                listener.onViolation(violation);
+            }
+            catch (Throwable x)
+            {
+                if (LOG.isDebugEnabled())
+                    LOG.debug("failure while notifying listener {}", listener, x);
+            }
+        }
+
         /**
          * <p>A listener for events emitted by a {@link Parser}.</p>
          */
@@ -1598,6 +1697,16 @@ default void onComplete()
             default void onFailure(Throwable failure)
             {
             }
+
+            /**
+             * <p>Callback method invoked when the low level parser encounters
+             * a fundamental multipart violation</p>>
+             *
+             * @param violation the violation detected
+             */
+            default void onViolation(MultiPartCompliance.Violation violation)
+            {
+            }
         }
 
         private enum State