WebSVN - OpenConcerto - Diff - Rev 180 and 182 - /trunk/OpenConcerto/src/org/openconcerto/utils/Platform.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
 import static org.openconcerto.utils.DesktopEnvironment.cmdSubstitution;
 import org.openconcerto.utils.cc.ITransformer;
 import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.math.BigDecimal;
 import java.net.InetAddress;
 import java.net.SocketException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.regex.Matcher;
  * @author Sylvain
  * @see DesktopEnvironment
  */
 public abstract class Platform {
+    public static final String PROCESS_ALLOW_AMBIGUOUS_COMMANDS = "jdk.lang.Process.allowAmbiguousCommands";
     private static final int PING_TIMEOUT = 250;
     public static final Platform getInstance() {
         final OSFamily os = OSFamily.getInstance();
         if (os == OSFamily.Windows) {
         } else {
             return LINUX;
+        }
+    }
+    public static class CannotPassArgumentException extends RuntimeException {
+        private final String arg;
+        private CannotPassArgumentException(String arg, String message) {
+            super("Cannot pass " + arg + message);
+            this.arg = arg;
+        }
+        public final String getArg() {
+            return this.arg;
+        }
+    }
     public abstract boolean supportsPID();
     public abstract boolean isRunning(final int pid) throws IOException;
     public abstract String getPath(final File f);
+    public String getPath(final Path p) {
+        return this.getPath(p.toFile());
+    }
+    public String getProcessArg(final String arg) {
+        return arg;
+    }
     public final String getPID() throws IOException {
         // TODO remove reflection and getPreJava9PID() once on java 11
         try {
             final Class<?> phClass = Class.forName("java.lang.ProcessHandle");
             final Object ph = phClass.getMethod("current").invoke(null);
         if (requiredCount <= 0)
             requiredCount = totalCount;
         // Keep errors out of cmdSubstitution() (e.g. "ping: sendto: Message too long" when
         // setDontFragment(true))
         final Process proc = evalPB(command).redirectErrorStream(false).start();
+        // some programs won't write anything until they read everything
+        proc.getOutputStream().close();
+        final ByteArrayOutputStream out = new ByteArrayOutputStream(5 * 1024);
+        final ByteArrayOutputStream err = new ByteArrayOutputStream(2 * 1024);
+        try (final ProcessStreams streams = new ProcessStreams(proc)) {
+            streams.start(out, err);
+            streams.awaitTermination();
+        } catch (Exception e) {
+            throw new IllegalStateException("Couldn't capture output of ping", e);
+        }
-        final String output = cmdSubstitution(proc);
+        final String output = out.toString();
         try {
             this.waitForSuccess(proc, "ping");
             final List<String> countAndLastLine = StringUtils.splitIntoLines(output);
             if (countAndLastLine.size() != 2)
                 throw new IllegalStateException("Not 2 lines in " + countAndLastLine);
             final int replied = Integer.parseInt(countAndLastLine.get(0));
             assert replied <= totalCount;
             final BigDecimal averageRTT = replied == 0 ? null : parsePingAverageRT(countAndLastLine.get(1).trim());
             return new PingResult(totalCount, replied, requiredCount, averageRTT);
         } catch (Exception e) {
-            throw new IllegalStateException("Couldn't use output :<<<\n" + output + "\n<<<", e);
+            throw new IllegalStateException("Couldn't use output :<<<\n" + output + "\n<<<\nerr:<<<\n" + err.toString() + "\n<<<", e);
+        }
+    }
     /**
      * Eval the passed string with bash.
             // --pid only works on Linux, -p also on Nexenta
             final Process p = Runtime.getRuntime().exec(new String[] { "ps", "-p", String.valueOf(pid) });
             return this.exitStatus(p) == 0;
+        }
+        @Override
         public String getPath(final File f) {
             return f.getPath();
+        }
         @Override
+        public String getPath(final Path f) {
+            return f.toString();
+        }
+        @Override
         protected String getBash() {
             return "bash";
+        }
         @Override
         protected PingResult ping(InetAddress host, PingBuilder pingBuilder, int routingTableIndex) throws IOException {
             return FREEBSD.ping(host, pingBuilder, routingTableIndex);
+        }
     };
+    // return 171 for "1.8.0_171"
+    // return 11 for "11.0.11"
+    public static final int getUpdateVersion(final char sep) {
+        final String vers = System.getProperty("java.version");
+        final int lastIndexOf = vers.lastIndexOf(sep);
+        // e.g. "13"
+        if (lastIndexOf < 0)
+            return 0;
+        return Integer.parseInt(vers.substring(lastIndexOf + 1));
+    }
+    public static abstract class WindowsPlatform extends Platform {
+        // on Windows program themselves are required to parse the command line, thus a lot of them
+        // do it differently, see "How Command Line Parameters Are Parsed"
+        // https://daviddeley.com/autohotkey/parameters/parameters.htm
+        static private final Pattern quotePatrn = Pattern.compile("([\\\\]*)\"");
+        static private final Pattern endSlashPatrn = Pattern.compile("([\\\\]+)\\z");
+        static private boolean needsQuoting(String s) {
+            final int len = s.length();
+            if (len == 0) // empty string have to be quoted
+                return true;
+            for (int i = 0; i < len; i++) {
+                switch (s.charAt(i)) {
+                case ' ':
+                case '\t':
+                case '"':
+                    return true;
+                }
+            }
+            return false;
+        }
+        // see http://bugs.sun.com/view_bug.do?bug_id=6468220
+        // e.g. find.exe, choice.exe
+        public String quoteParamForMsftC(String s) {
+            if (!needsQuoting(s))
+                return s;
+            if (s.length() > 0) {
+                // replace '(\*)"' by '$1$1\"', e.g. '\quote " \"' by '\quote \" \\\"'
+                // $1 needed so that the backslash we add isn't escaped itself by a preceding
+                // backslash
+                s = quotePatrn.matcher(s).replaceAll("$1$1\\\\\"");
+                // replace '(\*)\z' by '$1$1', e.g. 'foo\' by 'foo\\'
+                // needed to not escape closing quote
+                s = endSlashPatrn.matcher(s).replaceAll("$1$1");
+            }
+            return '"' + s + '"';
+        }
+        @Override
+        public String getProcessArg(String arg) {
+            return this.getProcessArg(arg, false);
+        }
+        public final String getScriptProcessArg(String arg) {
+            return this.getProcessArg(arg, true);
+        }
+        private String getProcessArg(String arg, final boolean script) {
+            // Perhaps should have one method for .exe and one for .cmd/.bat (ProcessImpl checks
+            // with isShellFile() and isExe()).
+            if (script && arg.indexOf('"') >= 0)
+                throw new CannotPassArgumentException(arg, ", it contains a double quote which is always removed by wscript!SplitCommandLine()");
+            /*
+             * If has VERIFICATION_WIN32_SAFE && !allowAmbiguousCommands, then ProcessImpl behaves
+             * almost correctly : the argument we pass arrives as-is to the process (so the caller
+             * shouldn't quote, ProcessImpl will fail with "Malformed argument has embedded quote"
+             * if a character was escaped). Otherwise ProcessImpl does nothing if arg begins and
+             * ends with double quotes (it's the caller responsibility to correctly quote).
+             */
+            final boolean doubleQuote;
+            // 1.8 or 11
+            final String specVers = System.getProperty("java.specification.version");
+            // 8 or 11
+            final int jreFamilyVersion = Integer.parseInt(specVers.startsWith("1.") ? specVers.substring(2) : specVers);
+            final String javaVendor = System.getProperty("java.vendor");
+            // VERIFICATION_WIN32_SAFE thanks to https://nvd.nist.gov/vuln/detail/CVE-2019-2958
+            // For Oracle and OpenJDK :
+            // https://www.oracle.com/java/technologies/javase/8u231-relnotes.html#JDK-8221858
+            // https://github.com/openjdk/jdk/commit/5a98b8cfb0cd4c5ce84746e9fa5e42a86d1b2d24#diff-71e1dde85b2937bbf08d0bfd9e8a2e3553c578a3f58907ba6f4f30ec350db184
+            // For AdoptOpenJDK :
+            // https://github.com/AdoptOpenJDK/openjdk-jdk11u/commit/0074850a15405a676a492d09e4955d4053966bbc#diff-71e1dde85b2937bbf08d0bfd9e8a2e3553c578a3f58907ba6f4f30ec350db184
+            if (jreFamilyVersion >= 14 || (javaVendor.equals("AdoptOpenJDK") && (jreFamilyVersion == 11 && getUpdateVersion('.') >= 5 || jreFamilyVersion == 13 && getUpdateVersion('.') >= 1))
+                    || (jreFamilyVersion == 8 && getUpdateVersion('_') >= 231)) {
+                // copied from ProcessImpl
+                final SecurityManager security = System.getSecurityManager();
+                final String value = System.getProperty(PROCESS_ALLOW_AMBIGUOUS_COMMANDS, (security == null ? "true" : "false"));
+                final boolean allowAmbiguousCommands = !"false".equalsIgnoreCase(value);
+                if ((script || allowAmbiguousCommands) && arg.endsWith("\\")) {
+                    // with script, we always do our own quoting since ProcessBuilder will double
+                    // back slashes.
+                    if (script || needsQuoting(arg)) {
+                        throw new CannotPassArgumentException(arg,
+                                ", if we'd double quote, then the string would end with 2 back slashes and 1 double quote, but ProcessImpl.unQuote() : 'not properly quoted, treat as unquoted'. So it would get quoted a second time. Try setting '"
+                                        + PROCESS_ALLOW_AMBIGUOUS_COMMANDS + "' to 'false'.");
+                    } else {
+                        doubleQuote = false;
+                    }
+                } else if (!allowAmbiguousCommands && arg.length() >= 2 && arg.charAt(0) == '"' && arg.charAt(arg.length() - 1) == '"') {
+                    throw new CannotPassArgumentException(arg,
+                            "\nif we pass it as-is then ProcessImpl will consider the string already quoted and needsEscaping() will return false, thus the quotes will be removed by CommandLineToArgvW()"
+                                    + "\nif we quote it then ProcessImpl.needsEscaping() will throw 'Malformed argument has embedded quote'");
+                } else {
+                    doubleQuote = allowAmbiguousCommands;
+                }
+            } else {
+                doubleQuote = true;
+            }
+            if (script)
+                return '"' + arg + '"';
+            else
+                return doubleQuote ? quoteParamForMsftC(arg) : arg;
+        }
+    }
-    private static final class CygwinPlatform extends Platform {
+    private static final class CygwinPlatform extends WindowsPlatform {
         @Override
         public boolean supportsPID() {
             return false;
+        }

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/utils/Platform.java - Rev 180 → 182