Subversion Repositories scarts

// natWin32Process.cc - Native side of Win32 process code.

/* Copyright (C) 2003  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the

Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for

details.  */

#include <config.h>

#include <platform.h>

// Conflicts with the definition in "java/lang/reflect/Modifier.h"

#undef STRICT

#include <java/lang/ConcreteProcess.h>

#include <java/lang/IllegalThreadStateException.h>

#include <java/lang/InterruptedException.h>

#include <java/lang/NullPointerException.h>

#include <java/lang/Thread.h>

#include <java/io/File.h>

#include <java/io/FileDescriptor.h>

#include <java/io/FileInputStream.h>

#include <java/io/FileOutputStream.h>

#include <java/io/IOException.h>

#include <java/lang/OutOfMemoryError.h>

#include <gnu/java/nio/channels/FileChannelImpl.h>

using gnu::java::nio::channels::FileChannelImpl;

void

java::lang::ConcreteProcess::cleanup (void)

{

  // FIXME:

  // We used to close the input, output and

  // error streams here, but we can't do that

  // because the caller also has the right

  // to close these and FileInputStream and FileOutputStream

  // scream if you attempt to close() them twice. Presently,

  // we use _Jv_platform_close_on_exec, which is similar

  // to the POSIX approach.

  //

  // What I wanted to do is have private nested

  // classes in ConcreteProcess which extend FileInputStream

  // and FileOutputStream, respectively, but override

  // close() to permit multiple calls to close(). This

  // led to class header and platform configury issues

  // that I didn't feel like dealing with. However,

  // this approach could conceivably be a good multiplatform

  // one since delaying the pipe close until process

  // termination could be wasteful if many child processes

  // are spawned within the parent process' lifetime.

  inputStream = NULL;

  outputStream = NULL;

  errorStream = NULL;

  if (procHandle)

    {

      CloseHandle((HANDLE) procHandle);

      procHandle = (jint) INVALID_HANDLE_VALUE;

    }

}

void

java::lang::ConcreteProcess::destroy (void)

{

  if (! hasExited ())

    {

      // Kill it forcibly and assign an (arbitrary) exit code of 0.

      TerminateProcess ((HANDLE) procHandle, 0);

      exitCode = 0;

      cleanup ();

    }

}

jboolean

java::lang::ConcreteProcess::hasExited (void)

{

  DWORD exitStatus;

  if (GetExitCodeProcess ((HANDLE) procHandle, &exitStatus) != 0)

    {

      // NOTE: STILL_ACTIVE is defined as "259" by Win32 - if the

      // child actually exits with this return code, we have a

      // problem here. See MSDN documentation on GetExitCodeProcess( ).

      if (exitStatus == STILL_ACTIVE)

        return false;

      else

        {

          cleanup ();

          exitCode = exitStatus;

          return true;

        }

    }

  else

    return true;

}

jint

java::lang::ConcreteProcess::waitFor (void)

{

  if (! hasExited ())

    {

      DWORD exitStatus = 0UL;

      // Set up our waitable objects array

      // - 0: the handle to the process we just launched

      // - 1: our thread's interrupt event

      HANDLE arh[2];

      arh[0] = (HANDLE) procHandle;

      arh[1] = _Jv_Win32GetInterruptEvent ();

      DWORD rval = WaitForMultipleObjects (2, arh, 0, INFINITE);

      // Use the returned value from WaitForMultipleObjects

      // instead of our thread's interrupt_flag to test for

      // thread interruption. See the comment for

      // _Jv_Win32GetInterruptEvent().

      bool bInterrupted = rval == (WAIT_OBJECT_0 + 1);

      if (bInterrupted)

        {

          // Querying this forces a reset our thread's interrupt flag.

          Thread::interrupted();

          cleanup ();

          throw new InterruptedException ();

        }

      GetExitCodeProcess ((HANDLE) procHandle, &exitStatus);

      exitCode = exitStatus;

      cleanup ();

    }

  return exitCode;

}

// Helper class for creating and managing the pipes

// used for I/O redirection for child processes.

class ChildProcessPipe

{

public:

  // Indicates from the child process' point of view

  // whether the pipe is for reading or writing.

  enum EType {INPUT, OUTPUT};

  ChildProcessPipe(EType eType);

  ~ChildProcessPipe();

  // Returns a pipe handle suitable for use by the parent process

  HANDLE getParentHandle();

  // Returns a pipe handle suitable for use by the child process.

  HANDLE getChildHandle();

private:

  EType m_eType;

  HANDLE m_hRead, m_hWrite;

};

ChildProcessPipe::ChildProcessPipe(EType eType):

  m_eType(eType)

{

  SECURITY_ATTRIBUTES sAttrs;

  // Explicitly allow the handles to the pipes to be inherited.

  sAttrs.nLength = sizeof (SECURITY_ATTRIBUTES);

  sAttrs.bInheritHandle = 1;

  sAttrs.lpSecurityDescriptor = NULL;

  if (CreatePipe (&m_hRead, &m_hWrite, &sAttrs, 0) == 0)

    {

      DWORD dwErrorCode = GetLastError ();

      throw new java::io::IOException (

        _Jv_WinStrError (_T("Error creating pipe"), dwErrorCode));

    }

  // If this is the read end of the child, we need

  // to make the parent write end non-inheritable. Similarly,

  // if this is the write end of the child, we need to make

  // the parent read end non-inheritable. If we didn't

  // do this, the child would inherit these ends and we wouldn't

  // be able to close them from our end. For full details,

  // do a Google search on "Q190351".

  HANDLE& rhStd = m_eType==INPUT ? m_hWrite : m_hRead;

  _Jv_platform_close_on_exec (rhStd);

}

ChildProcessPipe::~ChildProcessPipe()

{

  // Close the parent end of the pipe. This

  // destructor is called after the child process

  // has been spawned.

  CloseHandle(getChildHandle());

}

HANDLE ChildProcessPipe::getParentHandle()

{

  return m_eType==INPUT ? m_hWrite : m_hRead;

}

HANDLE ChildProcessPipe::getChildHandle()

{

  return m_eType==INPUT ? m_hRead : m_hWrite;

}

void

java::lang::ConcreteProcess::startProcess (jstringArray progarray,

                                           jstringArray envp,

                                           java::io::File *dir)

{

  using namespace java::io;

  procHandle = (jint) INVALID_HANDLE_VALUE;

  // Reconstruct the command line.

  jstring *elts = elements (progarray);

  int cmdLineLen = 0;

  for (int i = 0; i < progarray->length; ++i)

    cmdLineLen += (elts[i]->length() + 1);

  LPTSTR cmdLine = (LPTSTR) _Jv_Malloc ((cmdLineLen + 1) * sizeof(TCHAR));

  LPTSTR cmdLineCurPos = cmdLine;

  for (int i = 0; i < progarray->length; ++i)

    {

      if (i > 0)

        *cmdLineCurPos++ = _T(' ');

      jint len = elts[i]->length();

      JV_TEMP_STRING_WIN32(thiselt, elts[i]);

      _tcscpy(cmdLineCurPos, thiselt);

      cmdLineCurPos += len;

    }

  *cmdLineCurPos = _T('\0');

  // Get the environment, if any.

  LPTSTR env = NULL;

  if (envp)

    {

      elts = elements (envp);

      int envLen = 0;

      for (int i = 0; i < envp->length; ++i)

        envLen += (elts[i]->length() + 1);

      env = (LPTSTR) _Jv_Malloc ((envLen + 1) * sizeof(TCHAR));

      int j = 0;

      for (int i = 0; i < envp->length; ++i)

        {

          jint len = elts[i]->length();

          JV_TEMP_STRING_WIN32(thiselt, elts[i]);

          _tcscpy(env + j, thiselt);

          j += len;

          // Skip past the null terminator that _tcscpy just inserted.

          j++;

        }

      *(env + j) = _T('\0');

    }

  // Get the working directory path, if specified.

  JV_TEMP_STRING_WIN32 (wdir, dir ? dir->getPath () : 0);

  errorStream = NULL;

  inputStream = NULL;

  outputStream = NULL;

  java::lang::Throwable *exc = NULL;

  try

    {

      // We create anonymous pipes to communicate with the child

      // on each of standard streams.

      ChildProcessPipe aChildStdIn(ChildProcessPipe::INPUT);

      ChildProcessPipe aChildStdOut(ChildProcessPipe::OUTPUT);

      ChildProcessPipe aChildStdErr(ChildProcessPipe::OUTPUT);

      outputStream = new FileOutputStream (new FileChannelImpl (

                           (jint) aChildStdIn.getParentHandle (),

                           FileChannelImpl::WRITE));

      inputStream = new FileInputStream (new FileChannelImpl (

                           (jint) aChildStdOut.getParentHandle (),

                           FileChannelImpl::READ));

      errorStream = new FileInputStream (new FileChannelImpl (

                           (jint) aChildStdErr.getParentHandle (),

                           FileChannelImpl::READ));

      // Now create the child process.

      PROCESS_INFORMATION pi;

      STARTUPINFO si;

      ZeroMemory (&pi, sizeof (PROCESS_INFORMATION));

      ZeroMemory (&si, sizeof (STARTUPINFO));

      si.cb = sizeof (STARTUPINFO);

      // Explicitly specify the handles to the standard streams.

      si.dwFlags |= STARTF_USESTDHANDLES;

      si.hStdInput = aChildStdIn.getChildHandle();

      si.hStdOutput = aChildStdOut.getChildHandle();

      si.hStdError = aChildStdErr.getChildHandle();

      // Spawn the process. CREATE_NO_WINDOW only applies when

      // starting a console application; it suppresses the

      // creation of a console window. This flag is ignored on

      // Win9X.

      if (CreateProcess (NULL,

                         cmdLine,

                         NULL,

                         NULL,

                         1,

                         CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT,

                         env,

                         wdir,

                         &si,

                         &pi) == 0)

        {

          DWORD dwErrorCode = GetLastError ();

          throw new IOException (

            _Jv_WinStrError (_T("Error creating child process"), dwErrorCode));

        }

      procHandle = (jint ) pi.hProcess;

      _Jv_Free (cmdLine);

      if (env != NULL)

        _Jv_Free (env);

    }

  catch (java::lang::Throwable *thrown)

    {

      cleanup ();

      exc = thrown;

    }

  if (exc != NULL)

    throw exc;

}