/*

 * Copyright (c) 2016, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 */

package jdk.nashorn.internal.runtime;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.StreamTokenizer;

import java.io.StringReader;

import java.lang.ProcessBuilder.Redirect;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import static jdk.nashorn.internal.runtime.CommandExecutor.RedirectType.*;

import static jdk.nashorn.internal.runtime.ECMAErrors.rangeError;

/**

 * The CommandExecutor class provides support for Nashorn's $EXEC

 * builtin function. CommandExecutor provides support for command parsing,

 * I/O redirection, piping, completion timeouts, # comments, and simple

 * environment variable management (cd, setenv, and unsetenv).

 */

class CommandExecutor {

    // Size of byte buffers used for piping.

    private static final int BUFFER_SIZE = 1024;

    // Test to see if running on Windows.

    private static final boolean IS_WINDOWS =

        AccessController.doPrivileged((PrivilegedAction<Boolean>)() -> {

        return System.getProperty("os.name").contains("Windows");

    });

    // Cygwin drive alias prefix.

    private static final String CYGDRIVE = "/cygdrive/";

    // User's home directory

    private static final String HOME_DIRECTORY =

        AccessController.doPrivileged((PrivilegedAction<String>)() -> {

        return System.getProperty("user.home");

    });

    // Various types of standard redirects.

    enum RedirectType {

        NO_REDIRECT,

        REDIRECT_INPUT,

        REDIRECT_OUTPUT,

        REDIRECT_OUTPUT_APPEND,

        REDIRECT_ERROR,

        REDIRECT_ERROR_APPEND,

        REDIRECT_OUTPUT_ERROR_APPEND,

        REDIRECT_ERROR_TO_OUTPUT

    };

    // Prefix strings to standard redirects.

    private static final String[] redirectPrefixes = new String[] {

        "<",

        "0<",

        ">",

        "1>",

        ">>",

        "1>>",

        "2>",

        "2>>",

        "&>",

        "2>&1"

    };

    // Map from redirectPrefixes to RedirectType.

    private static final RedirectType[] redirects = new RedirectType[] {

        REDIRECT_INPUT,

        REDIRECT_INPUT,

        REDIRECT_OUTPUT,

        REDIRECT_OUTPUT,

        REDIRECT_OUTPUT_APPEND,

        REDIRECT_OUTPUT_APPEND,

        REDIRECT_ERROR,

        REDIRECT_ERROR_APPEND,

        REDIRECT_OUTPUT_ERROR_APPEND,

        REDIRECT_ERROR_TO_OUTPUT

    };

    /**

     * The RedirectInfo class handles checking the next token in a command

     * to see if it contains a redirect.  If the redirect file does not butt

     * against the prefix, then the next token is consumed.

     */

    private static class RedirectInfo {

        // true if a redirect was encountered on the current command.

        private boolean hasRedirects;

        // Redirect.PIPE or an input redirect from the command line.

        private Redirect inputRedirect;

        // Redirect.PIPE or an output redirect from the command line.

        private Redirect outputRedirect;

        // Redirect.PIPE or an error redirect from the command line.

        private Redirect errorRedirect;

        // true if the error stream should be merged with output.

        private boolean mergeError;

        RedirectInfo() {

            this.hasRedirects = false;

            this.inputRedirect = Redirect.PIPE;

            this.outputRedirect = Redirect.PIPE;

            this.errorRedirect = Redirect.PIPE;

            this.mergeError = false;

        }

        /**

         * check - tests to see if the current token contains a redirect

         * @param token    current command line token

         * @param iterator current command line iterator

         * @param cwd      current working directory

         * @return true if token is consumed

         */

        boolean check(String token, final Iterator<String> iterator, final String cwd) {

            // Iterate through redirect prefixes to file a match.

            for (int i = 0; i < redirectPrefixes.length; i++) {

               final String prefix = redirectPrefixes[i];

               // If a match is found.

                if (token.startsWith(prefix)) {

                    // Indicate we have at least one redirect (efficiency.)

                    hasRedirects = true;

                    // Map prefix to RedirectType.

                    final RedirectType redirect = redirects[i];

                    // Strip prefix from token

                    token = token.substring(prefix.length());

                    // Get file from either current or next token.

                    File file = null;

                    if (redirect != REDIRECT_ERROR_TO_OUTPUT) {

                        // Nothing left of current token.

                        if (token.length() == 0) {

                            if (iterator.hasNext()) {

                                // Use next token.

                                token = iterator.next();

                            } else {

                                // Send to null device if not provided.

                                token = IS_WINDOWS ? "NUL:" : "/dev/null";

                            }

                        }

                        // Redirect file.

                        file = resolvePath(cwd, token).toFile();

                    }

                    // Define redirect based on prefix.

                    switch (redirect) {

                        case REDIRECT_INPUT:

                            inputRedirect = Redirect.from(file);

                            break;

                        case REDIRECT_OUTPUT:

                            outputRedirect = Redirect.to(file);

                            break;

                        case REDIRECT_OUTPUT_APPEND:

                            outputRedirect = Redirect.appendTo(file);

                            break;

                        case REDIRECT_ERROR:

                            errorRedirect = Redirect.to(file);

                            break;

                        case REDIRECT_ERROR_APPEND:

                            errorRedirect = Redirect.appendTo(file);

                            break;

                        case REDIRECT_OUTPUT_ERROR_APPEND:

                            outputRedirect = Redirect.to(file);

                            errorRedirect = Redirect.to(file);

                            mergeError = true;

                            break;

                        case REDIRECT_ERROR_TO_OUTPUT:

                            mergeError = true;

                            break;

                        default:

                            return false;

                    }

                    // Indicate token is consumed.

                    return true;

                }

            }

            // No redirect found.

            return false;

        }

        /**

         * apply - apply the redirects to the current ProcessBuilder.

         * @param pb current ProcessBuilder

         */

        void apply(final ProcessBuilder pb) {

            // Only if there was redirects (saves new structure in ProcessBuilder.)

            if (hasRedirects) {

                // If output and error are the same file then merge.

                final File outputFile = outputRedirect.file();

                final File errorFile = errorRedirect.file();

                if (outputFile != null && outputFile.equals(errorFile)) {

                    mergeError = true;

                }

                // Apply redirects.

                pb.redirectInput(inputRedirect);

                pb.redirectOutput(outputRedirect);

                pb.redirectError(errorRedirect);

                pb.redirectErrorStream(mergeError);

            }

        }

    }

    /**

     * The Piper class is responsible for copying from an InputStream to an

     * OutputStream without blocking the current thread.

     */

    private static class Piper implements java.lang.Runnable {

        // Stream to copy from.

        private final InputStream input;

        // Stream to copy to.

        private final OutputStream output;

        private final Thread thread;

        Piper(final InputStream input, final OutputStream output) {

            this.input = input;

            this.output = output;

            this.thread = new Thread(this, "$EXEC Piper");

        }

        /**

         * start - start the Piper in a new daemon thread

         * @return this Piper

         */

        Piper start() {

            thread.setDaemon(true);

            thread.start();

            return this;

        }

        /**

         * run - thread action

         */

        @Override

        public void run() {

            try {

                // Buffer for copying.

                final byte[] b = new byte[BUFFER_SIZE];

                // Read from the InputStream until EOF.

                int read;

                while (-1 < (read = input.read(b, 0, b.length))) {

                    // Write available date to OutputStream.

                    output.write(b, 0, read);

                }

            } catch (final Exception e) {

                // Assume the worst.

                throw new RuntimeException("Broken pipe", e);

            } finally {

                // Make sure the streams are closed.

                try {

                    input.close();

                } catch (final IOException e) {

                    // Don't care.

                }

                try {

                    output.close();

                } catch (final IOException e) {

                    // Don't care.

                }

            }

        }

        public void join() throws InterruptedException {

            thread.join();

        }

        // Exit thread.

    }

    // Process exit statuses.

    static final int EXIT_SUCCESS  =  0;

    static final int EXIT_FAILURE  =  1;

    // Copy of environment variables used by all processes.

    private  Map<String, String> environment;

    // Input string if provided on CommandExecutor call.

    private String inputString;

    // Output string if required from CommandExecutor call.

    private String outputString;

    // Error string if required from CommandExecutor call.

    private String errorString;

    // Last process exit code.

    private int exitCode;

    // Input stream if provided on CommandExecutor call.

    private InputStream inputStream;

    // Output stream if provided on CommandExecutor call.

    private OutputStream outputStream;

    // Error stream if provided on CommandExecutor call.

    private OutputStream errorStream;

    // Ordered collection of current or piped ProcessBuilders.

    private List<ProcessBuilder> processBuilders = new ArrayList<>();

    CommandExecutor() {

        this.environment = new HashMap<>();

        this.inputString = "";

        this.outputString = "";

        this.errorString = "";

        this.exitCode = EXIT_SUCCESS;

        this.inputStream = null;

        this.outputStream = null;

        this.errorStream = null;

        this.processBuilders = new ArrayList<>();

    }

    /**

     * envVarValue - return the value of the environment variable key, or

     * deflt if not found.

     * @param key   name of environment variable

     * @param deflt value to return if not found

     * @return value of the environment variable

     */

    private String envVarValue(final String key, final String deflt) {

        return environment.getOrDefault(key, deflt);

    }

    /**

     * envVarLongValue - return the value of the environment variable key as a

     * long value.

     * @param key name of environment variable

     * @return long value of the environment variable

     */

    private long envVarLongValue(final String key) {

        try {

            return Long.parseLong(envVarValue(key, "0"));

        } catch (final NumberFormatException ex) {

            return 0L;

        }

    }

    /**

     * envVarBooleanValue - return the value of the environment variable key as a

     * boolean value.  true if the value was non-zero, false otherwise.

     * @param key name of environment variable

     * @return boolean value of the environment variable

     */

    private boolean envVarBooleanValue(final String key) {

        return envVarLongValue(key) != 0;

    }

    /**

     * stripQuotes - strip quotes from token if present. Quoted tokens kept

     * quotes to prevent search for redirects.

     * @param token token to strip

     * @return stripped token

     */

    private static String stripQuotes(String token) {

        if ((token.startsWith("\"") && token.endsWith("\"")) ||

             token.startsWith("\'") && token.endsWith("\'")) {

            token = token.substring(1, token.length() - 1);

        }

        return token;

    }

    /**

     * resolvePath - resolves a path against a current working directory.

     * @param cwd      current working directory

     * @param fileName name of file or directory

     * @return resolved Path to file

     */

    private static Path resolvePath(final String cwd, final String fileName) {

        return Paths.get(sanitizePath(cwd)).resolve(fileName).normalize();

    }

    /**

     * builtIn - checks to see if the command is a builtin and performs

     * appropriate action.

     * @param cmd current command

     * @param cwd current working directory

     * @return true if was a builtin command

     */

    private boolean builtIn(final List<String> cmd, final String cwd) {

        switch (cmd.get(0)) {

            // Set current working directory.

            case "cd":

                final boolean cygpath = IS_WINDOWS && cwd.startsWith(CYGDRIVE);

                // If zero args then use home directory as cwd else use first arg.

                final String newCWD = cmd.size() < 2 ? HOME_DIRECTORY : cmd.get(1);

                // Normalize the cwd

                final Path cwdPath = resolvePath(cwd, newCWD);

                // Check if is a directory.

                final File file = cwdPath.toFile();

                if (!file.exists()) {

                    reportError("file.not.exist", file.toString());

                    return true;

                } else if (!file.isDirectory()) {

                    reportError("not.directory", file.toString());

                    return true;

                }

                // Set PWD environment variable to be picked up as cwd.

                // Make sure Cygwin paths look like Unix paths.

                String scwd = cwdPath.toString();

                if (cygpath && scwd.length() >= 2 &&

                        Character.isLetter(scwd.charAt(0)) && scwd.charAt(1) == ':') {

                    scwd = CYGDRIVE + Character.toLowerCase(scwd.charAt(0)) + "/" + scwd.substring(2);

                }

                environment.put("PWD", scwd);

                return true;

            // Set an environment variable.

            case "setenv":

                if (3 <= cmd.size()) {

                    final String key = cmd.get(1);

                    final String value = cmd.get(2);

                    environment.put(key, value);

                }

                return true;

            // Unset an environment variable.

            case "unsetenv":

                if (2 <= cmd.size()) {

                    final String key = cmd.get(1);

                    environment.remove(key);

                }

                return true;

        }

        return false;

    }

    /**

     * preprocessCommand - scan the command for redirects, and sanitize the

     * executable path

     * @param tokens       command tokens

     * @param cwd          current working directory

     * @param redirectInfo redirection information

     * @return tokens remaining for actual command

     */

    private List<String>  preprocessCommand(final List<String> tokens,

            final String cwd, final RedirectInfo redirectInfo) {

        // Tokens remaining for actual command.

        final List<String> command = new ArrayList<>();

        // iterate through all tokens.

        final Iterator<String> iterator = tokens.iterator();

        while (iterator.hasNext()) {

            final String token = iterator.next();

            // Check if is a redirect.

            if (redirectInfo.check(token, iterator, cwd)) {

                // Don't add to the command.

                continue;

            }

            // Strip quotes and add to command.

            command.add(stripQuotes(token));

        }

        if (command.size() > 0) {

            command.set(0, sanitizePath(command.get(0)));

        }

        return command;

    }

    /**

     * Sanitize a path in case the underlying platform is Cygwin. In that case,

     * convert from the {@code /cygdrive/x} drive specification to the usual

     * Windows {@code X:} format.

     *

     * @param d a String representing a path

     * @return a String representing the same path in a form that can be

     *         processed by the underlying platform

     */

    private static String sanitizePath(final String d) {

        if (!IS_WINDOWS || (IS_WINDOWS && !d.startsWith(CYGDRIVE))) {

            return d;

        }

        final String pd = d.substring(CYGDRIVE.length());

        if (pd.length() >= 2 && pd.charAt(1) == '/') {

            // drive letter plus / -> convert /cygdrive/x/... to X:/...

            return pd.charAt(0) + ":" + pd.substring(1);

        } else if (pd.length() == 1) {

            // just drive letter -> convert /cygdrive/x to X:

            return pd.charAt(0) + ":";

        }