libjava/java/lang/natWin32Process.cc

   1 // natWin32Process.cc - Native side of Win32 process code.
   2
   3 /* Copyright (C) 2003  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #include <config.h>
  12 #include <platform.h>
  13
  14 // Conflicts with the definition in "java/lang/reflect/Modifier.h"
  15 #undef STRICT
  16
  17 #include <java/lang/ConcreteProcess.h>
  18 #include <java/lang/IllegalThreadStateException.h>
  19 #include <java/lang/InterruptedException.h>
  20 #include <java/lang/NullPointerException.h>
  21 #include <java/lang/Thread.h>
  22 #include <java/io/File.h>
  23 #include <java/io/FileDescriptor.h>
  24 #include <java/io/FileInputStream.h>
  25 #include <java/io/FileOutputStream.h>
  26 #include <java/io/IOException.h>
  27 #include <java/lang/OutOfMemoryError.h>
  28
  29 void
  30 java::lang::ConcreteProcess::cleanup (void)
  31 {
  32   // FIXME:
  33   // We used to close the input, output and
  34   // error streams here, but we can't do that
  35   // because the caller also has the right
  36   // to close these and FileInputStream and FileOutputStream
  37   // scream if you attempt to close() them twice. Presently,
  38   // we use _Jv_platform_close_on_exec, which is similar
  39   // to the POSIX approach.
  40   //
  41   // What I wanted to do is have private nested
  42   // classes in ConcreteProcess which extend FileInputStream
  43   // and FileOutputStream, respectively, but override
  44   // close() to permit multiple calls to close(). This
  45   // led to class header and platform configury issues
  46   // that I didn't feel like dealing with. However,
  47   // this approach could conceivably be a good multiplatform
  48   // one since delaying the pipe close until process
  49   // termination could be wasteful if many child processes
  50   // are spawned within the parent process' lifetime.
  51   inputStream = NULL;
  52   outputStream = NULL;
  53   errorStream = NULL;
  54
  55   if (procHandle)
  56     {
  57       CloseHandle((HANDLE) procHandle);
  58       procHandle = (jint) INVALID_HANDLE_VALUE;
  59     }
  60 }
  61
  62 void
  63 java::lang::ConcreteProcess::destroy (void)
  64 {
  65   if (! hasExited ())
  66     {
  67       // Kill it forcibly and assign an (arbitrary) exit code of 0.
  68       TerminateProcess ((HANDLE) procHandle, 0);
  69       exitCode = 0;
  70
  71       cleanup ();
  72     }
  73 }
  74
  75 jboolean
  76 java::lang::ConcreteProcess::hasExited (void)
  77 {
  78   DWORD exitStatus;
  79
  80   if (GetExitCodeProcess ((HANDLE) procHandle, &exitStatus) != 0)
  81     {
  82       // NOTE: STILL_ACTIVE is defined as "259" by Win32 - if the
  83       // child actually exits with this return code, we have a
  84       // problem here. See MSDN documentation on GetExitCodeProcess( ).
  85
  86       if (exitStatus == STILL_ACTIVE)
  87         return false;
  88       else
  89         {
  90           cleanup ();
  91           exitCode = exitStatus;
  92           return true;
  93         }
  94     }
  95   else
  96     return true;
  97 }
  98
  99 jint
 100 java::lang::ConcreteProcess::waitFor (void)
 101 {
 102   if (! hasExited ())
 103     {
 104       DWORD exitStatus = 0UL;
 105
 106       // Set up our waitable objects array
 107       // - 0: the handle to the process we just launched
 108       // - 1: our thread's interrupt event
 109       HANDLE arh[2];
 110       arh[0] = (HANDLE) procHandle;
 111       arh[1] = _Jv_Win32GetInterruptEvent ();
 112       DWORD rval = WaitForMultipleObjects (2, arh, 0, INFINITE);
 113
 114       // Use the returned value from WaitForMultipleObjects
 115       // instead of our thread's interrupt_flag to test for
 116       // thread interruption. See the comment for
 117       // _Jv_Win32GetInterruptEvent().
 118       bool bInterrupted = rval == (WAIT_OBJECT_0 + 1);
 119
 120       if (bInterrupted)
 121         {
 122           // Querying this forces a reset our thread's interrupt flag.
 123           Thread::interrupted();
 124
 125           cleanup ();
 126           throw new InterruptedException ();
 127         }
 128
 129       GetExitCodeProcess ((HANDLE) procHandle, &exitStatus);
 130       exitCode = exitStatus;
 131
 132       cleanup ();
 133     }
 134
 135   return exitCode;
 136 }
 137
 138
 139 // Helper class for creating and managing the pipes
 140 // used for I/O redirection for child processes.
 141 class ChildProcessPipe
 142 {
 143 public:
 144   // Indicates from the child process' point of view
 145   // whether the pipe is for reading or writing.
 146   enum EType {INPUT, OUTPUT};
 147
 148   ChildProcessPipe(EType eType);
 149   ~ChildProcessPipe();
 150
 151   // Returns a pipe handle suitable for use by the parent process
 152   HANDLE getParentHandle();
 153
 154   // Returns a pipe handle suitable for use by the child process.
 155   HANDLE getChildHandle();
 156
 157 private:
 158   EType m_eType;
 159   HANDLE m_hRead, m_hWrite;
 160 };
 161
 162 ChildProcessPipe::ChildProcessPipe(EType eType):
 163   m_eType(eType)
 164 {
 165   SECURITY_ATTRIBUTES sAttrs;
 166
 167   // Explicitly allow the handles to the pipes to be inherited.
 168   sAttrs.nLength = sizeof (SECURITY_ATTRIBUTES);
 169   sAttrs.bInheritHandle = 1;
 170   sAttrs.lpSecurityDescriptor = NULL;
 171
 172   if (CreatePipe (&m_hRead, &m_hWrite, &sAttrs, 0) == 0)
 173     {
 174       DWORD dwErrorCode = GetLastError ();
 175       throw new java::io::IOException (
 176         _Jv_WinStrError (_T("Error creating pipe"), dwErrorCode));
 177     }
 178
 179   // If this is the read end of the child, we need
 180   // to make the parent write end non-inheritable. Similarly,
 181   // if this is the write end of the child, we need to make
 182   // the parent read end non-inheritable. If we didn't
 183   // do this, the child would inherit these ends and we wouldn't
 184   // be able to close them from our end. For full details,
 185   // do a Google search on "Q190351".
 186   HANDLE& rhStd = m_eType==INPUT ? m_hWrite : m_hRead;
 187   _Jv_platform_close_on_exec (rhStd);
 188 }
 189
 190 ChildProcessPipe::~ChildProcessPipe()
 191 {
 192   // Close the parent end of the pipe. This
 193   // destructor is called after the child process
 194   // has been spawned.
 195   CloseHandle(getChildHandle());
 196 }
 197
 198 HANDLE ChildProcessPipe::getParentHandle()
 199 {
 200   return m_eType==INPUT ? m_hWrite : m_hRead;
 201 }
 202
 203 HANDLE ChildProcessPipe::getChildHandle()
 204 {
 205   return m_eType==INPUT ? m_hRead : m_hWrite;
 206 }
 207
 208 void
 209 java::lang::ConcreteProcess::startProcess (jstringArray progarray,
 210                                            jstringArray envp,
 211                                            java::io::File *dir)
 212 {
 213   using namespace java::io;
 214
 215   procHandle = (jint) INVALID_HANDLE_VALUE;
 216
 217   // Reconstruct the command line.
 218   jstring *elts = elements (progarray);
 219
 220   int cmdLineLen = 0;
 221
 222   for (int i = 0; i < progarray->length; ++i)
 223     cmdLineLen += (elts[i]->length() + 1);
 224
 225   LPTSTR cmdLine = (LPTSTR) _Jv_Malloc ((cmdLineLen + 1) * sizeof(TCHAR));
 226   LPTSTR cmdLineCurPos = cmdLine;
 227
 228   for (int i = 0; i < progarray->length; ++i)
 229     {
 230       if (i > 0)
 231         *cmdLineCurPos++ = _T(' ');
 232
 233       jint len = elts[i]->length();
 234       JV_TEMP_STRING_WIN32(thiselt, elts[i]);
 235       _tcscpy(cmdLineCurPos, thiselt);
 236       cmdLineCurPos += len;
 237     }
 238   *cmdLineCurPos = _T('\0');
 239
 240   // Get the environment, if any.
 241   LPTSTR env = NULL;
 242   if (envp)
 243     {
 244       elts = elements (envp);
 245
 246       int envLen = 0;
 247       for (int i = 0; i < envp->length; ++i)
 248         envLen += (elts[i]->length() + 1);
 249
 250       env = (LPTSTR) _Jv_Malloc ((envLen + 1) * sizeof(TCHAR));
 251
 252       int j = 0;
 253       for (int i = 0; i < envp->length; ++i)
 254         {
 255           jint len = elts[i]->length();
 256
 257           JV_TEMP_STRING_WIN32(thiselt, elts[i]);
 258           _tcscpy(env + j, thiselt);
 259
 260           j += len;
 261
 262           // Skip past the null terminator that _tcscpy just inserted.
 263           j++;
 264         }
 265       *(env + j) = _T('\0');
 266     }
 267
 268   // Get the working directory path, if specified.
 269   JV_TEMP_STRING_WIN32 (wdir, dir ? dir->getPath () : 0);
 270
 271   errorStream = NULL;
 272   inputStream = NULL;
 273   outputStream = NULL;
 274
 275   java::lang::Throwable *exc = NULL;
 276
 277   try
 278     {
 279       // We create anonymous pipes to communicate with the child
 280       // on each of standard streams.
 281       ChildProcessPipe aChildStdIn(ChildProcessPipe::INPUT);
 282       ChildProcessPipe aChildStdOut(ChildProcessPipe::OUTPUT);
 283       ChildProcessPipe aChildStdErr(ChildProcessPipe::OUTPUT);
 284
 285       outputStream = new FileOutputStream (new FileDescriptor (
 286                            (jint) aChildStdIn.getParentHandle ()));
 287       inputStream = new FileInputStream (new FileDescriptor (
 288                            (jint) aChildStdOut.getParentHandle ()));
 289       errorStream = new FileInputStream (new FileDescriptor (
 290                            (jint) aChildStdErr.getParentHandle ()));
 291
 292       // Now create the child process.
 293       PROCESS_INFORMATION pi;
 294       STARTUPINFO si;
 295
 296       ZeroMemory (&pi, sizeof (PROCESS_INFORMATION));
 297
 298       ZeroMemory (&si, sizeof (STARTUPINFO));
 299       si.cb = sizeof (STARTUPINFO);
 300
 301       // Explicitly specify the handles to the standard streams.
 302       si.dwFlags |= STARTF_USESTDHANDLES;
 303
 304       si.hStdInput = aChildStdIn.getChildHandle();
 305       si.hStdOutput = aChildStdOut.getChildHandle();
 306       si.hStdError = aChildStdErr.getChildHandle();
 307
 308       // Spawn the process. CREATE_NO_WINDOW only applies when
 309       // starting a console application; it suppresses the
 310       // creation of a console window. This flag is ignored on
 311       // Win9X.
 312
 313       if (CreateProcess (NULL,
 314                          cmdLine,
 315                          NULL,
 316                          NULL,
 317                          1,
 318                          CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT,
 319                          env,
 320                          wdir,
 321                          &si,
 322                          &pi) == 0)
 323         {
 324           DWORD dwErrorCode = GetLastError ();
 325           throw new IOException (
 326             _Jv_WinStrError (_T("Error creating child process"), dwErrorCode));
 327         }
 328
 329       procHandle = (jint ) pi.hProcess;
 330
 331       _Jv_Free (cmdLine);
 332       if (env != NULL)
 333         _Jv_Free (env);
 334     }
 335   catch (java::lang::Throwable *thrown)
 336     {
 337       cleanup ();
 338       exc = thrown;
 339     }
 340
 341   if (exc != NULL)
 342     throw exc;
 343 }