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.concurrent.Executors;

import java.util.concurrent.Executor;

import java.util.concurrent.ThreadFactory;

import java.security.AccessController;

import static java.security.AccessController.doPrivileged;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

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;

/* this is for the reaping thread */

private native int waitForProcessExit(int pid);

/**

private native int forkAndExec(byte[] prog,

byte[] argBlock, int argc,

byte[] envBlock, int envc,

byte[] dir,

int[] fds,

boolean redirectErrorStream)

throws IOException;

/**

private static class ProcessReaperThreadFactory implements ThreadFactory {

private final static ThreadGroup group = getRootThreadGroup();

private static ThreadGroup getRootThreadGroup() {

return doPrivileged(new PrivilegedAction<ThreadGroup> () {

public ThreadGroup run() {

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

while (root.getParent() != null)

root = root.getParent();

return root;

}});

}

public Thread newThread(Runnable grimReaper) {

// Our thread stack requirement is quite modest.

Thread t = new Thread(group, grimReaper, "process reaper", 32768);

t.setDaemon(true);

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

t.setPriority(Thread.MAX_PRIORITY);

return t;

}

}

/**

private static final Executor processReaperExecutor =

doPrivileged(new PrivilegedAction<Executor>() {

public Executor run() {

return Executors.newCachedThreadPool

(new ProcessReaperThreadFactory());

}});

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(prog,

argBlock, argc,

envBlock, envc,

dir,

fds,

redirectErrorStream);

try {

doPrivileged(new PrivilegedExceptionAction<Void>() {

public Void run() throws IOException {

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 {

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(new Runnable() {

public void run() {

int exitcode = waitForProcessExit(pid);

UNIXProcess.this.processExited(exitcode);

}});

}

void processExited(int exitcode) {

synchronized (this) {

this.exitcode = exitcode;

hasExited = true;

notifyAll();

}

if (stdout instanceof ProcessPipeInputStream)

((ProcessPipeInputStream) stdout).processExited();

if (stderr instanceof ProcessPipeInputStream)

((ProcessPipeInputStream) stderr).processExited();

if (stdin instanceof ProcessPipeOutputStream)

((ProcessPipeOutputStream) stdin).processExited();

}

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;

}

public synchronized int exitValue() {

if (!hasExited) {

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

}

return exitcode;

}

private static native void destroyProcess(int pid);

public void destroy() {

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

}

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

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

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

}

/* This routine initializes JNI field offsets for the class */

private static native void initIDs();

static {

initIDs();

}

/**

static class ProcessPipeInputStream extends BufferedInputStream {

ProcessPipeInputStream(int fd) {

super(new FileInputStream(newFileDescriptor(fd)));

}

private static byte[] drainInputStream(InputStream in)

throws IOException {

if (in == null) return null;

int n = 0;

int j;

byte[] a = null;

while ((j = in.available()) > 0) {

a = (a == null) ? new byte[j] : Arrays.copyOf(a, n + j);

n += in.read(a, n, j);

}

return (a == null || n == a.length) ? a : Arrays.copyOf(a, n);

}

/** Called by the process reaper thread when the process exits. */

synchronized void processExited() {

// Most BufferedInputStream methods are synchronized, but close()

// is not, and so we have to handle concurrent racing close().

try {

InputStream in = this.in;

if (in != null) {

byte[] stragglers = drainInputStream(in);

in.close();

this.in = (stragglers == null) ?

ProcessBuilder.NullInputStream.INSTANCE :

new ByteArrayInputStream(stragglers);

if (buf == null) // asynchronous close()?

this.in = null;

}

} catch (IOException ignored) {

// probably an asynchronous close().

}

}

}

/**

static class ProcessPipeOutputStream extends BufferedOutputStream {

ProcessPipeOutputStream(int fd) {

super(new FileOutputStream(newFileDescriptor(fd)));

}

/** Called by the process reaper thread when the process exits. */

synchronized void processExited() {

OutputStream out = this.out;

if (out != null) {

try {

out.close();

} catch (IOException ignored) {

// We know of no reason to get an IOException, but if

// we do, there's nothing else to do but carry on.

}

this.out = ProcessBuilder.NullOutputStream.INSTANCE;

}

}

}

}