* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

import java.lang.ProcessBuilder.Redirect;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.FileDescriptor;

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;

 * This java.lang.Process subclass in the UNIX environment is for the exclusive use of

 * ProcessBuilder.start() to create new processes.

 * @author Mario Wolczko and Ross Knippel.

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

 * @author Volker Simonis (ported to AIX)

final class ProcessImpl extends Process {

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

    /* this is for the reaping thread */

    private native int waitForProcessExit(int pid);

                result, 0,

                bytes.length);

            throws IOException

                            redirects[1].append());

                            redirects[2].append());

            return new ProcessImpl

                    (toCString(cmdarray[0]),

                            argBlock, args.length,

                            envBlock, envc[0],

                            toCString(dir),

                            std_fds,

                            redirectErrorStream);

    /**

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

            });

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

        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