/*

 * Copyright (c) 2003, 2015, 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 java.lang;

import java.lang.ProcessBuilder.Redirect;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.FileDescriptor;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.Locale;

import java.util.Set;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.TimeUnit;

import java.security.AccessController;

import static java.security.AccessController.doPrivileged;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

/**

 * java.lang.Process subclass in the UNIX environment.

 *

 * @author Mario Wolczko and Ross Knippel.

 * @author Konstantin Kladko (ported to Linux and Bsd)

 * @author Martin Buchholz

 * @author Volker Simonis (ported to AIX)

 * @since   1.5

 */

final class ProcessImpl extends Process {

    private static final sun.misc.JavaIOFileDescriptorAccess fdAccess

        = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();

    // Linux platforms support a normal (non-forcible) kill signal.

    static final boolean SUPPORTS_NORMAL_TERMINATION = true;

    private final int pid;

    private final ProcessHandle processHandle;

    private int exitcode;

    private boolean hasExited;

    private /* final */ OutputStream stdin;

    private /* final */ InputStream  stdout;

    private /* final */ InputStream  stderr;

    // only used on Solaris

    private /* final */ DeferredCloseInputStream stdout_inner_stream;

    private static enum LaunchMechanism {

        // order IS important!

        FORK,

        POSIX_SPAWN,

        VFORK

    }

    private static enum Platform {

        LINUX(LaunchMechanism.VFORK, LaunchMechanism.FORK),

        BSD(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK),

        SOLARIS(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK),

        AIX(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK);

        final LaunchMechanism defaultLaunchMechanism;

        final Set<LaunchMechanism> validLaunchMechanisms;

        Platform(LaunchMechanism ... launchMechanisms) {

            this.defaultLaunchMechanism = launchMechanisms[0];

            this.validLaunchMechanisms =

                EnumSet.copyOf(Arrays.asList(launchMechanisms));

        }

        @SuppressWarnings("fallthrough")

        private String helperPath(String javahome, String osArch) {

            switch (this) {

                case SOLARIS:

                    if (osArch.equals("x86")) { osArch = "i386"; }

                    else if (osArch.equals("x86_64")) { osArch = "amd64"; }

                    // fall through...

                case LINUX:

                case AIX:

                    return javahome + "/lib/" + osArch + "/jspawnhelper";

                case BSD:

                    return javahome + "/lib/jspawnhelper";

                default:

                    throw new AssertionError("Unsupported platform: " + this);

            }

        }

        String helperPath() {

            return AccessController.doPrivileged(

                (PrivilegedAction<String>) () ->

                    helperPath(System.getProperty("java.home"),

                               System.getProperty("os.arch"))

            );

        }

        LaunchMechanism launchMechanism() {

            return AccessController.doPrivileged(

                (PrivilegedAction<LaunchMechanism>) () -> {

                    String s = System.getProperty(

                        "jdk.lang.Process.launchMechanism");

                    LaunchMechanism lm;

                    if (s == null) {

                        lm = defaultLaunchMechanism;

                        s = lm.name().toLowerCase(Locale.ENGLISH);

                    } else {

                        try {

                            lm = LaunchMechanism.valueOf(

                                s.toUpperCase(Locale.ENGLISH));

                        } catch (IllegalArgumentException e) {

                            lm = null;

                        }

                    }

                    if (lm == null || !validLaunchMechanisms.contains(lm)) {

                        throw new Error(

                            s + " is not a supported " +

                            "process launch mechanism on this platform."

                        );

                    }

                    return lm;

                }

            );

        }

        static Platform get() {

            String osName = AccessController.doPrivileged(

                (PrivilegedAction<String>) () -> System.getProperty("os.name")

            );

            if (osName.equals("Linux")) { return LINUX; }

            if (osName.contains("OS X")) { return BSD; }

            if (osName.equals("SunOS")) { return SOLARIS; }

            if (osName.equals("AIX")) { return AIX; }

            throw new Error(osName + " is not a supported OS platform.");

        }

    }

    private static final Platform platform = Platform.get();

    private static final LaunchMechanism launchMechanism = platform.launchMechanism();

    private static final byte[] helperpath = toCString(platform.helperPath());

    private static byte[] toCString(String s) {

        if (s == null)

            return null;

        byte[] bytes = s.getBytes();

        byte[] result = new byte[bytes.length + 1];

        System.arraycopy(bytes, 0,

                         result, 0,

                         bytes.length);

        result[result.length-1] = (byte)0;

        return result;

    }

    // Only for use by ProcessBuilder.start()

    static Process start(String[] cmdarray,

                         java.util.Map<String,String> environment,

                         String dir,

                         ProcessBuilder.Redirect[] redirects,

                         boolean redirectErrorStream)

            throws IOException

    {

        assert cmdarray != null && cmdarray.length > 0;

        // Convert arguments to a contiguous block; it's easier to do

        // memory management in Java than in C.

        byte[][] args = new byte[cmdarray.length-1][];

        int size = args.length; // For added NUL bytes

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

            args[i] = cmdarray[i+1].getBytes();

            size += args[i].length;

        }

        byte[] argBlock = new byte[size];

        int i = 0;

        for (byte[] arg : args) {

            System.arraycopy(arg, 0, argBlock, i, arg.length);

            i += arg.length + 1;

            // No need to write NUL bytes explicitly

        }

        int[] envc = new int[1];

        byte[] envBlock = ProcessEnvironment.toEnvironmentBlock(environment, envc);

        int[] std_fds;

        FileInputStream  f0 = null;

        FileOutputStream f1 = null;

        FileOutputStream f2 = null;

        try {

            if (redirects == null) {

                std_fds = new int[] { -1, -1, -1 };

            } else {

                std_fds = new int[3];

                if (redirects[0] == Redirect.PIPE)

                    std_fds[0] = -1;

                else if (redirects[0] == Redirect.INHERIT)

                    std_fds[0] = 0;

                else {

                    f0 = new FileInputStream(redirects[0].file());

                    std_fds[0] = fdAccess.get(f0.getFD());

                }

                if (redirects[1] == Redirect.PIPE)

                    std_fds[1] = -1;

                else if (redirects[1] == Redirect.INHERIT)

                    std_fds[1] = 1;

                else {

                    f1 = new FileOutputStream(redirects[1].file(),

                            redirects[1].append());

                    std_fds[1] = fdAccess.get(f1.getFD());

                }

                if (redirects[2] == Redirect.PIPE)

                    std_fds[2] = -1;

                else if (redirects[2] == Redirect.INHERIT)

                    std_fds[2] = 2;

                else {

                    f2 = new FileOutputStream(redirects[2].file(),

                            redirects[2].append());

                    std_fds[2] = fdAccess.get(f2.getFD());

                }

            }

            return new ProcessImpl

                    (toCString(cmdarray[0]),

                            argBlock, args.length,

                            envBlock, envc[0],

                            toCString(dir),

                            std_fds,

                            redirectErrorStream);

        } finally {

            // In theory, close() can throw IOException

            // (although it is rather unlikely to happen here)

            try { if (f0 != null) f0.close(); }

            finally {

                try { if (f1 != null) f1.close(); }

                finally { if (f2 != null) f2.close(); }

            }

        }

    }

    /**

     * Creates a process. Depending on the {@code mode} flag, this is done by

     * one of the following mechanisms:

     * <pre>

     *   1 - fork(2) and exec(2)

     *   2 - posix_spawn(3P)

     *   3 - vfork(2) and exec(2)

     * </pre>

     * @param fds an array of three file descriptors.

     *        Indexes 0, 1, and 2 correspond to standard input,

     *        standard output and standard error, respectively.  On

     *        input, a value of -1 means to create a pipe to connect

     *        child and parent processes.  On output, a value which

     *        is not -1 is the parent pipe fd corresponding to the

     *        pipe which has been created.  An element of this array

     *        is -1 on input if and only if it is <em>not</em> -1 on

     *        output.

     * @return the pid of the subprocess

     */

    private native int forkAndExec(int mode, byte[] helperpath,

                                   byte[] prog,

                                   byte[] argBlock, int argc,

                                   byte[] envBlock, int envc,

                                   byte[] dir,

                                   int[] fds,

                                   boolean redirectErrorStream)

        throws IOException;

    private ProcessImpl(final byte[] prog,

                final byte[] argBlock, final int argc,

                final byte[] envBlock, final int envc,

                final byte[] dir,

                final int[] fds,

                final boolean redirectErrorStream)

            throws IOException {

        pid = forkAndExec(launchMechanism.ordinal() + 1,

                          helperpath,

                          prog,

                          argBlock, argc,

                          envBlock, envc,

                          dir,

                          fds,

                          redirectErrorStream);

        processHandle = ProcessHandleImpl.getUnchecked(pid);

        try {

            doPrivileged((PrivilegedExceptionAction<Void>) () -> {

                initStreams(fds);

                return null;

            });

        } catch (PrivilegedActionException ex) {

            throw (IOException) ex.getException();

        }

    }

    static FileDescriptor newFileDescriptor(int fd) {

        FileDescriptor fileDescriptor = new FileDescriptor();

        fdAccess.set(fileDescriptor, fd);

        return fileDescriptor;

    }

    void initStreams(int[] fds) throws IOException {

        switch (platform) {

            case LINUX:

            case BSD:

                stdin = (fds[0] == -1) ?

                        ProcessBuilder.NullOutputStream.INSTANCE :

                        new ProcessPipeOutputStream(fds[0]);

                stdout = (fds[1] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new ProcessPipeInputStream(fds[1]);

                stderr = (fds[2] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new ProcessPipeInputStream(fds[2]);

                ProcessHandleImpl.completion(pid, true).handle((exitcode, throwable) -> {

                    synchronized (this) {

                        this.exitcode = (exitcode == null) ? -1 : exitcode.intValue();

                        this.hasExited = true;

                        this.notifyAll();

                    }

                    if (stdout instanceof ProcessPipeInputStream)

                        ((ProcessPipeInputStream) stdout).processExited();

                    if (stderr instanceof ProcessPipeInputStream)

                        ((ProcessPipeInputStream) stderr).processExited();

                    if (stdin instanceof ProcessPipeOutputStream)

                        ((ProcessPipeOutputStream) stdin).processExited();

                    return null;

                });

                break;

            case SOLARIS:

                stdin = (fds[0] == -1) ?

                        ProcessBuilder.NullOutputStream.INSTANCE :

                        new BufferedOutputStream(

                            new FileOutputStream(newFileDescriptor(fds[0])));

                stdout = (fds[1] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new BufferedInputStream(

                             stdout_inner_stream =

                                 new DeferredCloseInputStream(

                                     newFileDescriptor(fds[1])));

                stderr = (fds[2] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new DeferredCloseInputStream(newFileDescriptor(fds[2]));

                /*

                 * For each subprocess forked a corresponding reaper task

                 * is submitted.  That task is the only thread which waits

                 * for the subprocess to terminate and it doesn't hold any

                 * locks while doing so.  This design allows waitFor() and

                 * exitStatus() to be safely executed in parallel (and they

                 * need no native code).

                 */

                ProcessHandleImpl.completion(pid, true).handle((exitcode, throwable) -> {

                    synchronized (this) {

                        this.exitcode = (exitcode == null) ? -1 : exitcode.intValue();

                        this.hasExited = true;

                        this.notifyAll();

                    }

                    return null;

                });

                break;

            case AIX:

                stdin = (fds[0] == -1) ?

                        ProcessBuilder.NullOutputStream.INSTANCE :

                        new ProcessPipeOutputStream(fds[0]);

                stdout = (fds[1] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new DeferredCloseProcessPipeInputStream(fds[1]);

                stderr = (fds[2] == -1) ?

                         ProcessBuilder.NullInputStream.INSTANCE :

                         new DeferredCloseProcessPipeInputStream(fds[2]);

                ProcessHandleImpl.completion(pid, true).handle((exitcode, throwable) -> {

                    synchronized (this) {

                        this.exitcode = (exitcode == null) ? -1 : exitcode.intValue();

                        this.hasExited = true;

                        this.notifyAll();

                    }

                    if (stdout instanceof DeferredCloseProcessPipeInputStream)

                        ((DeferredCloseProcessPipeInputStream) stdout).processExited();

                    if (stderr instanceof DeferredCloseProcessPipeInputStream)

                        ((DeferredCloseProcessPipeInputStream) stderr).processExited();

                    if (stdin instanceof ProcessPipeOutputStream)

                        ((ProcessPipeOutputStream) stdin).processExited();

                    return null;

                });

                break;

            default: throw new AssertionError("Unsupported platform: " + platform);

        }

    }

    public OutputStream getOutputStream() {

        return stdin;

    }

    public InputStream getInputStream() {

        return stdout;

    }

    public InputStream getErrorStream() {

        return stderr;

    }

    public synchronized int waitFor() throws InterruptedException {

        while (!hasExited) {

            wait();

        }

        return exitcode;

    }

    @Override

    public synchronized boolean waitFor(long timeout, TimeUnit unit)

        throws InterruptedException

    {

        long remainingNanos = unit.toNanos(timeout);    // throw NPE before other conditions

        if (hasExited) return true;

        if (timeout <= 0) return false;

        long deadline = System.nanoTime() + remainingNanos;

        do {

            // Round up to next millisecond

            wait(TimeUnit.NANOSECONDS.toMillis(remainingNanos + 999_999L));

            if (hasExited) {

                return true;

            }

            remainingNanos = deadline - System.nanoTime();

        } while (remainingNanos > 0);

        return hasExited;

    }

    public synchronized int exitValue() {

        if (!hasExited) {

            throw new IllegalThreadStateException("process hasn't exited");

        }

        return exitcode;

    }