Merge branch 'apache:main' into main

Author: gpitteloud

bom/pom.xml

@@ -20,7 +20,7 @@
     <parent>
         <groupId>org.apache.cxf</groupId>
         <artifactId>cxf</artifactId>
-        <version>4.1.4-SNAPSHOT</version>
+        <version>4.1.5-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>cxf-bom</artifactId>

core/pom.xml

@@ -27,7 +27,7 @@
     <parent>
         <groupId>org.apache.cxf</groupId>
         <artifactId>cxf-parent</artifactId>
-        <version>4.1.4-SNAPSHOT</version>
+        <version>4.1.5-SNAPSHOT</version>
         <relativePath>../parent/pom.xml</relativePath>
     </parent>
     <properties>

core/src/main/java/org/apache/cxf/attachment/AttachmentBoundaryDeserializer.java

@@ -0,0 +1,93 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.cxf.attachment;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+
+public class AttachmentBoundaryDeserializer {
+    private static final Pattern INPUT_STREAM_BOUNDARY_PATTERN = Pattern.compile("^--(\\S*)$", Pattern.MULTILINE);
+    private static final int PUSHBACK_AMOUNT = 2048;
+    
+    private final int maxHeaderLength;
+    private final Message message;
+
+    public AttachmentBoundaryDeserializer(Message message) {
+        this.message = message;
+        this.maxHeaderLength = MessageUtils.getContextualInteger(message, 
+            AttachmentDeserializer.ATTACHMENT_MAX_HEADER_SIZE, AttachmentDeserializer.DEFAULT_MAX_HEADER_SIZE);
+    }
+
+    public Attachment read(InputStream body) throws IOException {
+        final PushbackInputStream stream = new PushbackInputStream(body, PUSHBACK_AMOUNT);
+        final String boundaryString = findBoundaryFromInputStream(stream);
+
+        // If a boundary still wasn't found, throw an exception
+        if (null == boundaryString) {
+            throw new IOException("Couldn't determine the boundary from the message!");
+        }
+
+        final byte[] boundary = boundaryString.getBytes(StandardCharsets.UTF_8);
+        if (!AttachmentDeserializerUtil.readTillFirstBoundary(stream, boundary)) {
+            throw new IOException("Couldn't find MIME boundary: " + boundaryString);
+        }
+
+        Map<String, List<String>> ih = AttachmentDeserializerUtil.loadPartHeaders(stream, maxHeaderLength);
+        String val = AttachmentUtil.getHeader(ih, "Content-Transfer-Encoding");
+
+        MimeBodyPartInputStream mmps = new MimeBodyPartInputStream(stream, boundary, PUSHBACK_AMOUNT);
+        InputStream ins = AttachmentUtil.decode(mmps, val);
+        if (ins != mmps) {
+            ih.remove("Content-Transfer-Encoding");
+        }
+
+        return AttachmentUtil.createAttachment(new DelegatingInputStream(ins, is -> stream.close()), ih, message);
+    }
+
+    private String findBoundaryFromInputStream(PushbackInputStream stream) throws IOException {
+        //boundary should definitely be in the first 2K;
+        byte[] buf = new byte[2048];
+        int i = stream.read(buf);
+        int len = i;
+        while (i > 0 && len < buf.length) {
+            i = stream.read(buf, len, buf.length - len);
+            if (i > 0) {
+                len += i;
+            }
+        }
+        String msg = IOUtils.newStringFromBytes(buf, 0, len);
+        stream.unread(buf, 0, len);
+
+        // Use regex to get the boundary and return null if it's not found
+        Matcher m = INPUT_STREAM_BOUNDARY_PATTERN.matcher(msg);
+        return m.find() ? "--" + m.group(1) : null;
+    }
+}

core/src/main/java/org/apache/cxf/attachment/AttachmentDeserializer.java

@@ -30,13 +30,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.TreeMap;
-import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import jakarta.activation.DataSource;
-import org.apache.cxf.common.logging.LogUtils;
 import org.apache.cxf.common.util.StringUtils;
 import org.apache.cxf.common.util.SystemPropertyAction;
 import org.apache.cxf.helpers.HttpHeaderHelper;
@@ -84,8 +81,6 @@ public class AttachmentDeserializer {
     private static final Pattern INPUT_STREAM_BOUNDARY_PATTERN =
             Pattern.compile("^--(\\S*)$", Pattern.MULTILINE);
 
-    private static final Logger LOG = LogUtils.getL7dLogger(AttachmentDeserializer.class);
-
     private static final int PUSHBACK_AMOUNT = 2048;
 
     private boolean lazyLoading = true;
@@ -161,11 +156,11 @@ protected void initializeRootMessage() throws IOException {
             boundary = boundaryString.getBytes(StandardCharsets.UTF_8);
 
             stream = new PushbackInputStream(message.getContent(InputStream.class), PUSHBACK_AMOUNT);
-            if (!readTillFirstBoundary(stream, boundary)) {
+            if (!AttachmentDeserializerUtil.readTillFirstBoundary(stream, boundary)) {
                 throw new IOException("Couldn't find MIME boundary: " + boundaryString);
             }
 
-            Map<String, List<String>> ih = loadPartHeaders(stream);
+            Map<String, List<String>> ih = AttachmentDeserializerUtil.loadPartHeaders(stream, maxHeaderLength);
             message.put(ATTACHMENT_PART_HEADERS, ih);
             String val = AttachmentUtil.getHeader(ih, "Content-Type", "; ");
             if (!StringUtils.isEmpty(val)) {
@@ -230,7 +225,7 @@ public AttachmentImpl readNext() throws IOException {
         }
         stream.unread(v);
 
-        Map<String, List<String>> headers = loadPartHeaders(stream);
+        Map<String, List<String>> headers = AttachmentDeserializerUtil.loadPartHeaders(stream, maxHeaderLength);
         return (AttachmentImpl)createAttachment(headers);
     }
 
@@ -271,48 +266,6 @@ private void cache(DelegatingInputStream input) throws IOException {
         }
     }
 
-    /**
-     * Move the read pointer to the begining of the first part read till the end
-     * of first boundary
-     *
-     * @param pushbackInStream
-     * @param boundary
-     * @throws IOException
-     */
-    private static boolean readTillFirstBoundary(PushbackInputStream pushbackInStream,
-        byte[] boundary) throws IOException {
-
-        // work around a bug in PushBackInputStream where the buffer isn't
-        // initialized
-        // and available always returns 0.
-        int value = pushbackInStream.read();
-        pushbackInStream.unread(value);
-        while (value != -1) {
-            value = pushbackInStream.read();
-            if ((byte) value == boundary[0]) {
-                int boundaryIndex = 0;
-                while (value != -1 
-                    && boundaryIndex < boundary.length 
-                    && (byte)value == boundary[boundaryIndex]) {
-
-                    value = pushbackInStream.read();
-                    if (value == -1) {
-                        throw new IOException("Unexpected End while searching for first Mime Boundary");
-                    }
-                    boundaryIndex++;
-                }
-                if (boundaryIndex == boundary.length) {
-                    // boundary found, read the newline
-                    if (value == 13) {
-                        pushbackInStream.read();
-                    }
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
     /**
      * Create an Attachment from the MIME stream. If there is a previous attachment
      * that is not read, cache that attachment.
@@ -366,98 +319,4 @@ public boolean hasNext() throws IOException {
         stream.unread(v);
         return true;
     }
-
-
-
-    private Map<String, List<String>> loadPartHeaders(InputStream in) throws IOException {
-        StringBuilder buffer = new StringBuilder(128);
-        StringBuilder b = new StringBuilder(128);
-        Map<String, List<String>> heads = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
-
-        // loop until we hit the end or a null line
-        while (readLine(in, b)) {
-            // lines beginning with white space get special handling
-            char c = b.charAt(0);
-            if (c == ' ' || c == '\t') {
-                if (buffer.length() != 0) {
-                    // preserve the line break and append the continuation
-                    buffer.append("\r\n");
-                    buffer.append(b);
-                }
-            } else {
-                // if we have a line pending in the buffer, flush it
-                if (buffer.length() > 0) {
-                    addHeaderLine(heads, buffer);
-                    buffer.setLength(0);
-                }
-                // add this to the accumulator
-                buffer.append(b);
-            }
-        }
-
-        // if we have a line pending in the buffer, flush it
-        if (buffer.length() > 0) {
-            addHeaderLine(heads, buffer);
-        }
-        return heads;
-    }
-
-    private boolean readLine(InputStream in, StringBuilder buffer) throws IOException {
-        if (buffer.length() != 0) {
-            buffer.setLength(0);
-        }
-        int c;
-
-        while ((c = in.read()) != -1) {
-            // a linefeed is a terminator, always.
-            if (c == '\n') {
-                break;
-            } else if (c == '\r') {
-                //just ignore the CR.  The next character SHOULD be an NL.  If not, we're
-                //just going to discard this
-                continue;
-            } else {
-                // just add to the buffer
-                buffer.append((char)c);
-            }
-
-            if (buffer.length() > maxHeaderLength) {
-                LOG.fine("The attachment header size has exceeded the configured parameter: " + maxHeaderLength);
-                throw new HeaderSizeExceededException();
-            }
-        }
-
-        // no characters found...this was either an eof or a null line.
-        return buffer.length() != 0;
-    }
-
-    private void addHeaderLine(Map<String, List<String>> heads, StringBuilder line) {
-        // null lines are a nop
-        final int size = line.length();
-        if (size == 0) {
-            return;
-        }
-        int separator = line.indexOf(":");
-        final String name;
-        String value = "";
-        if (separator == -1) {
-            name = line.toString().trim();
-        } else {
-            name = line.substring(0, separator);
-            // step past the separator.  Now we need to remove any leading white space characters.
-            separator++;
-
-            while (separator < size) {
-                char ch = line.charAt(separator);
-                if (ch != ' ' && ch != '\t' && ch != '\r' && ch != '\n') {
-                    break;
-                }
-                separator++;
-            }
-            value = line.substring(separator);
-        }
-        List<String> v = heads.computeIfAbsent(name, k -> new ArrayList<>(1));
-        v.add(value);
-    }
-
 }