/*

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

import java.io.File;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileDescriptor;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.lang.ProcessBuilder.Redirect;

import java.security.AccessController;

import java.security.PrivilegedAction;

/* This class is for the exclusive use of ProcessBuilder.start() to

 * create new processes.

 *

 * @author Martin Buchholz

 * @since   1.5

 */

final class ProcessImpl extends Process {

    private static final sun.misc.JavaIOFileDescriptorAccess fdAccess

        = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();

    /**

     * Open a file for writing. If {@code append} is {@code true} then the file

     * is opened for atomic append directly and a FileOutputStream constructed

     * with the resulting handle. This is because a FileOutputStream created

     * to append to a file does not open the file in a manner that guarantees

     * that writes by the child process will be atomic.

     */

    private static FileOutputStream newFileOutputStream(File f, boolean append)

        throws IOException

    {

        if (append) {

            SecurityManager sm = System.getSecurityManager();

            if (sm != null)

                sm.checkWrite(f.getPath());

            long handle = openForAtomicAppend(f.getPath());

            final FileDescriptor fd = new FileDescriptor();

            fdAccess.setHandle(fd, handle);

            return AccessController.doPrivileged(

                new PrivilegedAction<FileOutputStream>() {

                    public FileOutputStream run() {

                        return new FileOutputStream(fd);

                    }

                }

            );

        } else {

            return new FileOutputStream(f);

        }

    }

    // System-dependent portion of ProcessBuilder.start()

    static Process start(String cmdarray[],

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

                         String dir,

                         ProcessBuilder.Redirect[] redirects,

                         boolean redirectErrorStream)

        throws IOException

    {

        String envblock = ProcessEnvironment.toEnvironmentBlock(environment);

        FileInputStream  f0 = null;

        FileOutputStream f1 = null;

        FileOutputStream f2 = null;

        try {

            long[] stdHandles;

            if (redirects == null) {

                stdHandles = new long[] { -1L, -1L, -1L };

            } else {

                stdHandles = new long[3];

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

                    stdHandles[0] = -1L;

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

                    stdHandles[0] = fdAccess.getHandle(FileDescriptor.in);

                else {

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

                    stdHandles[0] = fdAccess.getHandle(f0.getFD());

                }

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

                    stdHandles[1] = -1L;

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

                    stdHandles[1] = fdAccess.getHandle(FileDescriptor.out);

                else {

                    f1 = newFileOutputStream(redirects[1].file(),

                                             redirects[1].append());

                    stdHandles[1] = fdAccess.getHandle(f1.getFD());

                }

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

                    stdHandles[2] = -1L;

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

                    stdHandles[2] = fdAccess.getHandle(FileDescriptor.err);

                else {

                    f2 = newFileOutputStream(redirects[2].file(),

                                             redirects[2].append());

                    stdHandles[2] = fdAccess.getHandle(f2.getFD());

                }

            }

            return new ProcessImpl(cmdarray, envblock, dir,

                                   stdHandles, 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(); }

            }

        }

    }

    private long handle = 0;

    private OutputStream stdin_stream;

    private InputStream stdout_stream;

    private InputStream stderr_stream;

    private ProcessImpl(final String cmd[],

                        final String envblock,

                        final String path,

                        final long[] stdHandles,

                        final boolean redirectErrorStream)

        throws IOException

    {

        // Win32 CreateProcess requires cmd[0] to be normalized

        cmd[0] = new File(cmd[0]).getPath();

        StringBuilder cmdbuf = new StringBuilder(80);

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

            if (i > 0) {

                cmdbuf.append(' ');

            }

            String s = cmd[i];

            if (s.indexOf(' ') >= 0 || s.indexOf('\t') >= 0) {

                if (s.charAt(0) != '"') {

                    cmdbuf.append('"');

                    cmdbuf.append(s);

                    if (s.endsWith("\\")) {

                        cmdbuf.append("\\");

                    }

                    cmdbuf.append('"');

                } else if (s.endsWith("\"")) {

                    /* The argument has already been quoted. */

                    cmdbuf.append(s);

                } else {

                    /* Unmatched quote for the argument. */

                    throw new IllegalArgumentException();

                }

            } else {

                cmdbuf.append(s);

            }

        }

        String cmdstr = cmdbuf.toString();

        handle = create(cmdstr, envblock, path,

                        stdHandles, redirectErrorStream);

        java.security.AccessController.doPrivileged(

        new java.security.PrivilegedAction<Void>() {

        public Void run() {

            if (stdHandles[0] == -1L)

                stdin_stream = ProcessBuilder.NullOutputStream.INSTANCE;

            else {

                FileDescriptor stdin_fd = new FileDescriptor();

                fdAccess.setHandle(stdin_fd, stdHandles[0]);

                stdin_stream = new BufferedOutputStream(

                    new FileOutputStream(stdin_fd));

            }

            if (stdHandles[1] == -1L)

                stdout_stream = ProcessBuilder.NullInputStream.INSTANCE;

            else {

                FileDescriptor stdout_fd = new FileDescriptor();

                fdAccess.setHandle(stdout_fd, stdHandles[1]);

                stdout_stream = new BufferedInputStream(

                    new FileInputStream(stdout_fd));

            }

            if (stdHandles[2] == -1L)

                stderr_stream = ProcessBuilder.NullInputStream.INSTANCE;

            else {

                FileDescriptor stderr_fd = new FileDescriptor();

                fdAccess.setHandle(stderr_fd, stdHandles[2]);

                stderr_stream = new FileInputStream(stderr_fd);

            }

            return null; }});

    }

    public OutputStream getOutputStream() {

        return stdin_stream;

    }

    public InputStream getInputStream() {

        return stdout_stream;

    }

    public InputStream getErrorStream() {

        return stderr_stream;

    }

    public void finalize() {

        closeHandle(handle);

    }

    private static final int STILL_ACTIVE = getStillActive();

    private static native int getStillActive();

    public int exitValue() {

        int exitCode = getExitCodeProcess(handle);

        if (exitCode == STILL_ACTIVE)

            throw new IllegalThreadStateException("process has not exited");

        return exitCode;

    }

    private static native int getExitCodeProcess(long handle);

    public int waitFor() throws InterruptedException {

        waitForInterruptibly(handle);

        if (Thread.interrupted())

            throw new InterruptedException();

        return exitValue();

    }

    private static native void waitForInterruptibly(long handle);

    public void destroy() { terminateProcess(handle); }

    private static native void terminateProcess(long handle);

    /**

     * Create a process using the win32 function CreateProcess.

     *

     * @param cmdstr the Windows commandline

     * @param envblock NUL-separated, double-NUL-terminated list of

     *        environment strings in VAR=VALUE form

     * @param dir the working directory of the process, or null if

     *        inheriting the current directory from the parent process

     * @param stdHandles array of windows HANDLEs.  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 handle 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.

     * @param redirectErrorStream redirectErrorStream attribute

     * @return the native subprocess HANDLE returned by CreateProcess

     */

    private static native long create(String cmdstr,

                                      String envblock,

                                      String dir,

                                      long[] stdHandles,

                                      boolean redirectErrorStream)

        throws IOException;

    /**

     * Opens a file for atomic append. The file is created if it doesn't

     * already exist.

     *

     * @param file the file to open or create

     * @return the native HANDLE

     */

    private static native long openForAtomicAppend(String path)

        throws IOException;

    private static native boolean closeHandle(long handle);

}