/*
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @bug 8282008
* @requires (os.family == "windows")
* @run main/othervm ArgCheck
* @summary Check invocation of exe and non-exe programs using ProcessBuilder
* and arguments with spaces, backslashes, and simple quoting.
*/
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* Class to check invocation of java, .cmd, and vbs scripts with arguments and various quote cases.
* Can be run standalone to compare results with other Java versions.
*/
public class ArgCheck {
private static final Path SRC_DIR = Paths.get(System.getProperty("test.src", "."));
private static final Path WORK_DIR = Paths.get(System.getProperty("user.dir", "."));
private static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));
private static final String ECHO_CMD_PATH = WORK_DIR.resolve("EchoArguments.cmd").toString();
private static final String ECHO_VBS_PATH = WORK_DIR.resolve("EchoArguments.vbs").toString();
// Test argument containing both a space and a trailing backslash
// Depending on the mode the final backslash may act as an escape that may turn an added quote to a literal quote
private static final String SPACE_AND_BACKSLASH = "SPACE AND BACKSLASH\\";
private static final char DOUBLE_QUOTE = '"';
private static final char BACKSLASH = '\\';
private static final String AMBIGUOUS_PROP_NAME = "jdk.lang.Process.allowAmbiguousCommands";
private static final String AMBIGUOUS_PROP_VALUE = System.getProperty(AMBIGUOUS_PROP_NAME);
private static final Boolean AMBIGUOUS_PROP_BOOLEAN = AMBIGUOUS_PROP_VALUE == null ? null :
Boolean.valueOf(!"false".equals(AMBIGUOUS_PROP_VALUE));
private static final List<String> ECHO_JAVA_ARGS = Arrays.asList("java", "-classpath", TEST_CLASSES.toString(), "ArgCheck");
private static final List<String> ECHO_CMD_ARGS = Arrays.asList(ECHO_CMD_PATH);
private static final List<String> ECHO_VBS_ARGS = Arrays.asList("CScript", "/b", ECHO_VBS_PATH);
/**
* If zero arguments are supplied, run the test cases, by launching each as a child process.
* If there are arguments, then this is a child Java process that prints each argument to stdout.
* The test can be run manually with -Djdk.lang.Process.allowAmbiguousCommands={"true", "false", ""}
* to run a matching subset of the tests.
*/
public static void main(String[] args) throws IOException {
if (args.length > 0) {
// Echo supplied arguments and exit
for (String arg : args)
System.out.println(arg);
return;
}
System.out.println("Java Version: " + System.getProperty("java.version"));
createFiles();
int errors = 0;
int success = 0;
int skipped = 0;
for (CMD cmd : CASES) {
// If System property jdk.lang.process.allowAmbiguousCommands matches the case, test it
// If undefined, test them all
if (AMBIGUOUS_PROP_BOOLEAN == null ||
AMBIGUOUS_PROP_BOOLEAN.booleanValue() == cmd.allowAmbiguous) {
try {
testCommand(cmd);
success++;
} catch (Exception ex) {
ex.printStackTrace();
errors++;
}
} else {
// skip unmatched cases
skipped++;
}
}
if (skipped > 0) {
System.out.printf("%d cases skipped, they did not match the tests with jdk.lang.Process.allowAmbiguousCommands: %s%n",
skipped, AMBIGUOUS_PROP_BOOLEAN);
}
System.out.printf("\nSuccess: %d, errors: %d%n", success, errors);
if (errors > 0) {
throw new RuntimeException("Errors: " + errors);
}
}
/**
* A CMD holds the parameters and the expected result of invoking a process with the parameters.
*/
static class CMD {
/**
* Construct a test case.
* @param allowAmbiguous true/false to set property jdk.lang.Process.allowAmbiguousCommands
* @param command list of command parameters to invoke the executable or script
* @param arguments list of arguments (appended to the command)
* @param expected expected lines of output from invoked command
*/
CMD(boolean allowAmbiguous, List<String> command, List<String> arguments, List<String> expected) {
this.allowAmbiguous = allowAmbiguous;
this.command = command;
this.arguments = arguments;
this.expected = expected;
}
final boolean allowAmbiguous;
final List<String> command;
final List<String> arguments;
final List<String> expected;
}
/**
* List of cases with the command, arguments, allowAmbiguous setting, and the expected results
*/
static final List<CMD> CASES = Arrays.asList(
// allowAmbiguousCommands = false, without application supplied double-quotes.
// The space in the argument requires it to be quoted, the final backslash
// must not be allowed to turn the quote that is added into a literal
// instead of closing the quote.
new CMD(false,
ECHO_JAVA_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_1"),
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_1")),
new CMD(false,
ECHO_CMD_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_2"),
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_2")),
new CMD(false,
ECHO_VBS_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_3"),
Arrays.asList(SPACE_AND_BACKSLASH + BACKSLASH, "ARG_3")),
// allowAmbiguousCommands = false, WITH application supplied double-quotes around the argument
// The argument has surrounding quotes so does not need further quoting.
// However, for exe commands, the final backslash must not be allowed to turn the quote
// into a literal instead of closing the quote.
new CMD(false,
ECHO_JAVA_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_11"),
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_11")),
new CMD(false,
ECHO_CMD_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_12"),
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_12")),
new CMD(false,
ECHO_VBS_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_13"),
Arrays.asList(SPACE_AND_BACKSLASH + BACKSLASH, "ARG_13")),
// Legacy mode tests; allowAmbiguousCommands = true; no application supplied quotes
// The space in the argument requires it to be quoted, the final backslash
// must not be allowed to turn the quote that is added into a literal
// instead of closing the quote.
new CMD(true,
ECHO_JAVA_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_21"),
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_21")),
new CMD(true,
ECHO_CMD_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_22"),
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + BACKSLASH + DOUBLE_QUOTE, "ARG_22")),
new CMD(true,
ECHO_VBS_ARGS,
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_23"),
Arrays.asList(SPACE_AND_BACKSLASH + BACKSLASH, "ARG_23")),
// allowAmbiguousCommands = true, WITH application supplied double-quotes around the argument
// The argument has surrounding quotes so does not need further quoting.
// The backslash before the final quote is ignored and is interpreted differently for each command.
new CMD(true,
ECHO_JAVA_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_31"),
Arrays.asList("SPACE AND BACKSLASH\" ARG_31")),
new CMD(true,
ECHO_CMD_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_32"),
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_32")),
new CMD(true,
ECHO_VBS_ARGS,
Arrays.asList(DOUBLE_QUOTE + SPACE_AND_BACKSLASH + DOUBLE_QUOTE, "ARG_33"),
Arrays.asList(SPACE_AND_BACKSLASH, "ARG_33"))
);
/**
* Common function to Invoke a process with the commands and check the result.
*
* @param cmd a CMD test case with arguments, allowAmbiguousCommands mode, and expected output
*/
private static void testCommand(CMD cmd) throws Exception {
System.setProperty(AMBIGUOUS_PROP_NAME, Boolean.toString(cmd.allowAmbiguous));
List<String> actual = null;
List<String> arguments = new ArrayList<>(cmd.command);
arguments.addAll(cmd.arguments);
try {
// Launch the process and wait for termination
ProcessBuilder pb = new ProcessBuilder(arguments);
Process process = pb.start();
try (InputStream is = process.getInputStream()) {
String str = readAllBytesAsString(is);
str = str.replace("\r", "");
actual = Arrays.asList(str.split("\n"));
} catch (IOException ioe) {
throw new RuntimeException(ioe.getMessage(), ioe);
}
int exitCode = process.waitFor();
if (exitCode != 0) {
actual = new ArrayList(actual);
actual.add("Exit code: " + exitCode);
}
} catch (IOException ioe) {
actual = Arrays.asList(ioe.getMessage().replace(arguments.get(0), "CMD"));
} catch (Exception ex) {
actual = Arrays.asList(ex.getMessage()); // Use exception message as output
}
if (!Objects.equals(actual, cmd.expected)) {
System.out.println("Invoking(" + cmd.allowAmbiguous + "): " + arguments);
if (actual.size() != cmd.expected.size()) {
System.out.println("Args Length: actual: " + actual.size() + " expected: " + cmd.expected.size());
}
System.out.println("Actual: " + actual);
System.out.println("Expected: " + cmd.expected);
System.out.println();
throw new RuntimeException("Unexpected output");
}
}
/**
* Private method to readAllBytes as a String.
* (InputStream.readAllBytes is not supported by the JDK until 9)
* @param is an InputStream
* @return a String with the contents
* @throws IOException if an error occurs
*/
private static String readAllBytesAsString(InputStream is) throws IOException {
final int BUF_SIZE = 8192;
byte[] bytes = new byte[BUF_SIZE];
int off = 0;
int len;
while ((len = is.read(bytes, off, bytes.length - off)) > 0) {
off += len;
if (off >= bytes.length) {
// no space in buffer, reallocate larger
bytes = Arrays.copyOf(bytes, bytes.length + BUF_SIZE);
}
}
return new String(bytes, 0, off, Charset.defaultCharset());
}
/**
* Initialize .cmd and .vbs scripts.
*
* @throws Error if an exception occurs
*/
private static void createFiles() throws IOException {
Files.write(Paths.get(ECHO_CMD_PATH), EchoArgumentsCmd.getBytes(StandardCharsets.UTF_8));
Files.write(Paths.get(ECHO_VBS_PATH), EchoArgumentsVbs.getBytes(StandardCharsets.UTF_8));
}
/**
* Self contained .cmd to echo each argument on a separate line.
*/
static final String EchoArgumentsCmd = "@echo off\n" +
"set p1=\n" +
"set p2=\n" +
"\n" +
"if not [%1]==[] set p1=%1\n" +
"if not [%2]==[] set p2=%2\n" +
"if not [%3]==[] set p3=%3\n" +
"if defined p1 echo %p1%\n" +
"if defined p2 echo %p2%\n" +
"if defined p3 echo %p3%\n" +
"exit /b 0\n";
/**
* Self contained .vbs to echo each argument on a separate line.
*/
static final String EchoArgumentsVbs = "Option Explicit\n" +
"Dim arg\n" +
"for each arg in WScript.Arguments\n" +
" WScript.StdOut.WriteLine(arg)\n" +
"Next\n";
}