[maven-4.0.x] Fix special characters in .mvn/jvm.config (fix #11363, #11485 and #11486) (#11365) (#11537)

Replace shell-based jvm.config parsing with a Java-based parser to fix issues
with special characters (pipes, @, quotes) that cause shell command errors.

Problems fixed:
- MNG-11363: Pipe symbols (|) in jvm.config cause shell parsing errors
- GH-11485: @ character in paths (common in Jenkins workspaces like
  project_PR-350@2) causes sed failures
- MNG-11486: POSIX compliance issues with xargs -0 on AIX, FreeBSD, etc.

Solution:
Add JvmConfigParser.java that runs via Java source-launch mode (JDK 11+) to
parse jvm.config files. This avoids all shell parsing complexities and works
consistently across Unix and Windows platforms.

Changes:
- Add apache-maven/bin/JvmConfigParser.java: Java parser that handles quoted
  arguments, comments, line continuations, and ${MAVEN_PROJECTBASEDIR}
  substitution
- Update mvn (Unix): Use JvmConfigParser instead of tr/sed/xargs pipeline
- Update mvn.cmd (Windows): Use JvmConfigParser with direct file output to
  avoid Windows file locking issues with shell redirection
- Add MAVEN_DEBUG_SCRIPT environment variable for debug logging in both
  scripts to aid troubleshooting
- Add integration tests for pipe symbols and @ character handling
- Improve Verifier to save stdout/stderr to separate files for debugging

The parser outputs arguments as quoted strings, preserving special characters
that would otherwise be interpreted by the shell.

(cherry picked from commit da5f27e)

Author: gnodet

apache-maven/src/assembly/component.xml

@@ -68,6 +68,7 @@ under the License.
       <includes>
         <include>*.cmd</include>
         <include>*.conf</include>
+        <include>*.java</include>
       </includes>
       <lineEnding>dos</lineEnding>
     </fileSet>

apache-maven/src/assembly/maven/bin/JvmConfigParser.java

@@ -0,0 +1,177 @@
+/*
+ * 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.
+ */
+
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Parses .mvn/jvm.config file for Windows batch/Unix shell scripts.
+ * This avoids the complexity of parsing special characters (pipes, quotes, etc.) in scripts.
+ *
+ * Usage: java JvmConfigParser.java <jvm.config-path> <maven-project-basedir> [output-file]
+ *
+ * If output-file is provided, writes result to that file (avoids Windows file locking issues).
+ * Otherwise, outputs to stdout.
+ *
+ * Outputs: Single line with space-separated quoted arguments (safe for batch scripts)
+ */
+public class JvmConfigParser {
+    public static void main(String[] args) {
+        if (args.length < 2 || args.length > 3) {
+            System.err.println("Usage: java JvmConfigParser.java <jvm.config-path> <maven-project-basedir> [output-file]");
+            System.exit(1);
+        }
+
+        Path jvmConfigPath = Paths.get(args[0]);
+        String mavenProjectBasedir = args[1];
+        Path outputFile = args.length == 3 ? Paths.get(args[2]) : null;
+
+        if (!Files.exists(jvmConfigPath)) {
+            // No jvm.config file - output nothing (create empty file if output specified)
+            if (outputFile != null) {
+                try {
+                    Files.writeString(outputFile, "", StandardCharsets.UTF_8);
+                } catch (IOException e) {
+                    System.err.println("ERROR: Failed to write output file: " + e.getMessage());
+                    System.err.flush();
+                    System.exit(1);
+                }
+            }
+            return;
+        }
+
+        try {
+            String result = parseJvmConfig(jvmConfigPath, mavenProjectBasedir);
+            if (outputFile != null) {
+                // Write directly to file - this ensures proper file handle cleanup on Windows
+                // Add newline at end for Windows 'for /f' command compatibility
+                try (Writer writer = Files.newBufferedWriter(outputFile, StandardCharsets.UTF_8)) {
+                    writer.write(result);
+                    if (!result.isEmpty()) {
+                        writer.write(System.lineSeparator());
+                    }
+                }
+            } else {
+                System.out.print(result);
+                System.out.flush();
+            }
+        } catch (IOException e) {
+            // If jvm.config exists but can't be read, this is a configuration error
+            // Print clear error and exit with error code to prevent Maven from running
+            System.err.println("ERROR: Failed to read .mvn/jvm.config: " + e.getMessage());
+            System.err.println("Please check file permissions and syntax.");
+            System.err.flush();
+            System.exit(1);
+        }
+    }
+
+    /**
+     * Parse jvm.config file and return formatted arguments.
+     * Package-private for testing.
+     */
+    static String parseJvmConfig(Path jvmConfigPath, String mavenProjectBasedir) throws IOException {
+        StringBuilder result = new StringBuilder();
+
+        for (String line : Files.readAllLines(jvmConfigPath, StandardCharsets.UTF_8)) {
+            line = processLine(line, mavenProjectBasedir);
+            if (line.isEmpty()) {
+                continue;
+            }
+
+            List<String> parsed = parseArguments(line);
+            appendQuotedArguments(result, parsed);
+        }
+
+        return result.toString();
+    }
+
+    /**
+     * Process a single line: remove comments, trim whitespace, and replace placeholders.
+     */
+    private static String processLine(String line, String mavenProjectBasedir) {
+        // Remove comments
+        int commentIndex = line.indexOf('#');
+        if (commentIndex >= 0) {
+            line = line.substring(0, commentIndex);
+        }
+
+        // Trim whitespace
+        line = line.trim();
+
+        // Replace MAVEN_PROJECTBASEDIR placeholders
+        line = line.replace("${MAVEN_PROJECTBASEDIR}", mavenProjectBasedir);
+        line = line.replace("$MAVEN_PROJECTBASEDIR", mavenProjectBasedir);
+
+        return line;
+    }
+
+    /**
+     * Append parsed arguments as quoted strings to the result builder.
+     */
+    private static void appendQuotedArguments(StringBuilder result, List<String> args) {
+        for (String arg : args) {
+            if (result.length() > 0) {
+                result.append(' ');
+            }
+            result.append('"').append(arg).append('"');
+        }
+    }
+
+    /**
+     * Parse a line into individual arguments, respecting quoted strings.
+     * Quotes are stripped from the arguments.
+     */
+    private static List<String> parseArguments(String line) {
+        List<String> args = new ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        boolean inDoubleQuotes = false;
+        boolean inSingleQuotes = false;
+
+        for (int i = 0; i < line.length(); i++) {
+            char c = line.charAt(i);
+
+            if (c == '"' && !inSingleQuotes) {
+                inDoubleQuotes = !inDoubleQuotes;
+            } else if (c == '\'' && !inDoubleQuotes) {
+                inSingleQuotes = !inSingleQuotes;
+            } else if (c == ' ' && !inDoubleQuotes && !inSingleQuotes) {
+                // Space outside quotes - end of argument
+                if (current.length() > 0) {
+                    args.add(current.toString());
+                    current.setLength(0);
+                }
+            } else {
+                current.append(c);
+            }
+        }
+
+        // Add last argument
+        if (current.length() > 0) {
+            args.add(current.toString());
+        }
+
+        return args;
+    }
+}

apache-maven/src/assembly/maven/bin/mvn

@@ -166,30 +166,66 @@ find_file_argument_basedir() {
 }
 
 # concatenates all lines of a file and replaces variables
+# Uses Java-based parser to handle all special characters correctly
+# This avoids shell parsing issues with pipes, quotes, @, and other special characters
+# and ensures POSIX compliance (no xargs -0, awk, or complex sed needed)
+# Set MAVEN_DEBUG_SCRIPT=1 to enable debug logging
 concat_lines() {
   if [ -f "$1" ]; then
-    # First convert all CR to LF using tr
-    tr '\r' '\n' < "$1" | \
-    sed -e '/^$/d' -e 's/#.*$//' | \
-    # Replace LF with NUL for xargs
-    tr '\n' '\0' | \
-    # Split into words and process each argument
-    # Use -0 with NUL to avoid special behaviour on quotes
-    xargs -n 1 -0 | \
-    while read -r arg; do
-      # Replace variables first
-      arg=$(echo "$arg" | sed \
-        -e "s@\${MAVEN_PROJECTBASEDIR}@$MAVEN_PROJECTBASEDIR@g" \
-        -e "s@\$MAVEN_PROJECTBASEDIR@$MAVEN_PROJECTBASEDIR@g")
-
-      echo "$arg"
-    done | \
-    tr '\n' ' '
+    # Use Java source-launch mode (JDK 11+) to run JvmConfigParser directly
+    # This avoids the need for compilation and temporary directories
+
+    # Debug logging
+    if [ -n "$MAVEN_DEBUG_SCRIPT" ]; then
+      echo "[DEBUG] Found jvm.config file at: $1" >&2
+      echo "[DEBUG] Running JvmConfigParser with Java: $JAVACMD" >&2
+      echo "[DEBUG] Parser arguments: $MAVEN_HOME/bin/JvmConfigParser.java $1 $MAVEN_PROJECTBASEDIR" >&2
+    fi
+
+    # Verify Java is available
+    "$JAVACMD" -version >/dev/null 2>&1 || {
+      echo "Error: Java not found. Please set JAVA_HOME." >&2
+      return 1
+    }
+
+    # Run the parser using source-launch mode
+    # Capture both stdout and stderr for comprehensive error reporting
+    parser_output=$("$JAVACMD" "$MAVEN_HOME/bin/JvmConfigParser.java" "$1" "$MAVEN_PROJECTBASEDIR" 2>&1)
+    parser_exit=$?
+
+    if [ -n "$MAVEN_DEBUG_SCRIPT" ]; then
+      echo "[DEBUG] JvmConfigParser exit code: $parser_exit" >&2
+      echo "[DEBUG] JvmConfigParser output: $parser_output" >&2
+    fi
+
+    if [ $parser_exit -ne 0 ]; then
+      # Parser failed - print comprehensive error information
+      echo "ERROR: JvmConfigParser failed with exit code $parser_exit" >&2
+      echo "  jvm.config path: $1" >&2
+      echo "  Maven basedir: $MAVEN_PROJECTBASEDIR" >&2
+      echo "  Java command: $JAVACMD" >&2
+      echo "  Parser output:" >&2
+      echo "$parser_output" | sed 's/^/    /' >&2
+      exit 1
+    fi
+
+    echo "$parser_output"
   fi
 }
 
 MAVEN_PROJECTBASEDIR="`find_maven_basedir "$@"`"
-MAVEN_OPTS="$MAVEN_OPTS `concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config"`"
+# Read JVM config and append to MAVEN_OPTS, preserving special characters
+_jvm_config="`concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config"`"
+if [ -n "$_jvm_config" ]; then
+  if [ -n "$MAVEN_OPTS" ]; then
+    MAVEN_OPTS="$MAVEN_OPTS $_jvm_config"
+  else
+    MAVEN_OPTS="$_jvm_config"
+  fi
+fi
+if [ -n "$MAVEN_DEBUG_SCRIPT" ]; then
+  echo "[DEBUG] Final MAVEN_OPTS: $MAVEN_OPTS" >&2
+fi
 LAUNCHER_JAR=`echo "$MAVEN_HOME"/boot/plexus-classworlds-*.jar`
 LAUNCHER_CLASS=org.codehaus.plexus.classworlds.launcher.Launcher
 
@@ -239,6 +275,7 @@ handle_args() {
 handle_args "$@"
 MAVEN_MAIN_CLASS=${MAVEN_MAIN_CLASS:=org.apache.maven.cling.MavenCling}
 
+# Build command string for eval
 cmd="\"$JAVACMD\" \
   $MAVEN_OPTS \
   $MAVEN_DEBUG_OPTS \
@@ -251,13 +288,15 @@ cmd="\"$JAVACMD\" \
   \"-Dmaven.multiModuleProjectDirectory=$MAVEN_PROJECTBASEDIR\" \
   $LAUNCHER_CLASS \
   $MAVEN_ARGS"
+
 # Add remaining arguments with proper quoting
 for arg in "$@"; do
     cmd="$cmd \"$arg\""
 done
 
-# Debug: print the command that will be executed
-#echo "About to execute:"
-#echo "$cmd"
+if [ -n "$MAVEN_DEBUG_SCRIPT" ]; then
+  echo "[DEBUG] Launching JVM with command:" >&2
+  echo "[DEBUG]   $cmd" >&2
+fi
 
 eval exec "$cmd"