jdk/src/windows/classes/java/lang/ProcessImpl.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1995, 2010, 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.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);
 }
	/*
	* Copyright (c) 1995, 2010, 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.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);
	}