/*

 * Copyright (c) 1995, 2014, 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.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.Executors;

import java.util.concurrent.Executor;

import java.util.concurrent.ThreadFactory;

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)

 */

final class UNIXProcess extends Process {

    private static final sun.misc.JavaIOFileDescriptorAccess fdAccess

        = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();

    private final int pid;

    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;

    }

    /* this is for the reaping thread */

    private native int waitForProcessExit(int pid);

    /**

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

     *

     *  (4 - clone(2) and exec(2) - obsolete and currently disabled in native code)

     * </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;

    /**

     * The thread pool of "process reaper" daemon threads.

     */

    private static final Executor processReaperExecutor =

        doPrivileged((PrivilegedAction<Executor>) () -> {

            ThreadGroup tg = Thread.currentThread().getThreadGroup();

            while (tg.getParent() != null) tg = tg.getParent();

            ThreadGroup systemThreadGroup = tg;

            ThreadFactory threadFactory = grimReaper -> {

                // Our thread stack requirement is quite modest.

                Thread t = new Thread(systemThreadGroup, grimReaper,

                                      "process reaper", 32768);

                t.setDaemon(true);

                // A small attempt (probably futile) to avoid priority inversion

                t.setPriority(Thread.MAX_PRIORITY);

                return t;

            };

            return Executors.newCachedThreadPool(threadFactory);

        });

    UNIXProcess(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);

        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]);

                processReaperExecutor.execute(() -> {

                    int exitcode = waitForProcessExit(pid);

                    synchronized (this) {

                        this.exitcode = exitcode;

                        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();

                });

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

                 */

                processReaperExecutor.execute(() -> {

                    int exitcode = waitForProcessExit(pid);

                    synchronized (this) {

                        this.exitcode = exitcode;

                        this.hasExited = true;

                        this.notifyAll();

                    }

                });

                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]);

                processReaperExecutor.execute(() -> {

                    int exitcode = waitForProcessExit(pid);

                    synchronized (this) {

                        this.exitcode = exitcode;

                        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();

                });

                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

    {

        if (hasExited) return true;

        if (timeout <= 0) return false;

        return hasExited;

    }

    public synchronized int exitValue() {

        if (!hasExited) {

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

        }

        return exitcode;

    }

    private static native void destroyProcess(int pid, boolean force);

    private void destroy(boolean force) {

        switch (platform) {

            case LINUX:

            case BSD:

            case AIX:

                // There is a risk that pid will be recycled, causing us to

                // kill the wrong process!  So we only terminate processes

                // that appear to still be running.  Even with this check,

                // there is an unavoidable race condition here, but the window

                // is very small, and OSes try hard to not recycle pids too

                // soon, so this is quite safe.

                synchronized (this) {

                    if (!hasExited)

                        destroyProcess(pid, force);

                }

                try { stdin.close();  } catch (IOException ignored) {}

                try { stdout.close(); } catch (IOException ignored) {}

                try { stderr.close(); } catch (IOException ignored) {}

                break;

            case SOLARIS:

                // There is a risk that pid will be recycled, causing us to

                // kill the wrong process!  So we only terminate processes

                // that appear to still be running.  Even with this check,

                // there is an unavoidable race condition here, but the window

                // is very small, and OSes try hard to not recycle pids too

                // soon, so this is quite safe.

                synchronized (this) {

                    if (!hasExited)

                        destroyProcess(pid, force);

                    try {

                        stdin.close();

                        if (stdout_inner_stream != null)

                            stdout_inner_stream.closeDeferred(stdout);

                        if (stderr instanceof DeferredCloseInputStream)

                            ((DeferredCloseInputStream) stderr)

                                .closeDeferred(stderr);

                    } catch (IOException e) {

                        // ignore

                    }

                }

                break;

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

        }

    }

    public void destroy() {

        destroy(false);

    }

    @Override

    public Process destroyForcibly() {

        destroy(true);

        return this;

    }

    @Override

    public long getPid() {

        return pid;

    }