src/windows/native/java/lang/ProcessImpl_md.c

Print this page

        

@@ -38,24 +38,74 @@
  * deadlock.  Windows 2000 inexplicably appears to need an extra 24
  * bytes of slop to avoid deadlock.
  */
 #define PIPE_SIZE (4096+24)
 
+/* We have THREE locales in action: 
+ * 1. Thread default locale - dictates UNICODE-to-8bit conversion
+ * 2. System locale that defines the message localization
+ * 3. The file name locale
+ * Each locale could be an extended locale, that means that text cannot be
+ * mapped to 8bit sequence without multibyte encoding.
+ * VM is ready for that, if text is UTF-8.
+ * Here we make the work right from the beginning.
+ */
+size_t os_error_message(int errnum, WCHAR* utf16_OSErrorMsg, size_t maxMsgLength) {
+    size_t n = (size_t)FormatMessageW(
+            FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            (DWORD)errnum,
+            0,
+            utf16_OSErrorMsg,
+            (DWORD)maxMsgLength,
+            NULL);
+    if (n > 3) {
+        // Drop final '.', CR, LF
+        if (utf16_OSErrorMsg[n - 1] == L'\n') --n;
+        if (utf16_OSErrorMsg[n - 1] == L'\r') --n;
+        if (utf16_OSErrorMsg[n - 1] == L'.') --n;
+        utf16_OSErrorMsg[n] = L'\0';
+    }
+    return n;
+}
+
+#define MESSAGE_LENGTH (256 + 100)
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(*x))
+
 static void
-win32Error(JNIEnv *env, const char *functionName)
+win32Error(JNIEnv *env, const WCHAR *functionName)
 {
-    static const char * const format = "%s error=%d, %s";
-    static const char * const fallbackFormat = "%s failed, error=%d";
-    char buf[256];
-    char errmsg[sizeof(buf) + 100];
-    const int errnum = GetLastError();
-    const int n = JVM_GetLastErrorString(buf, sizeof(buf));
-    if (n > 0)
-        sprintf(errmsg, format, functionName, errnum, buf);
-    else
-        sprintf(errmsg, fallbackFormat, functionName, errnum);
-    JNU_ThrowIOException(env, errmsg);
+    WCHAR utf16_OSErrorMsg[MESSAGE_LENGTH - 100];
+    WCHAR utf16_javaMessage[MESSAGE_LENGTH];
+    /*Good suggestion about 2-bytes-per-symbol in localized error reports*/
+    char  utf8_javaMessage[MESSAGE_LENGTH*2];
+    const int errnum = (int)GetLastError();
+    int n = os_error_message(errnum, utf16_OSErrorMsg, ARRAY_SIZE(utf16_OSErrorMsg));
+    n = (n > 0)
+        ? swprintf(utf16_javaMessage, MESSAGE_LENGTH, L"%s error=%d, %s", functionName, errnum, utf16_OSErrorMsg)
+        : swprintf(utf16_javaMessage, MESSAGE_LENGTH, L"%s failed, error=%d", functionName, errnum);
+
+    if (n > 0) /*terminate '\0' is not a part of conversion procedure*/
+        n = WideCharToMultiByte(
+            CP_UTF8,
+            0,
+            utf16_javaMessage,
+            n, /*by creation n <= MESSAGE_LENGTH*/
+            utf8_javaMessage,
+            MESSAGE_LENGTH*2,
+            NULL,
+            NULL);
+
+    /*no way to die*/
+    {
+        const char *errorMessage = "Secondary error while OS message extraction";
+        if (n > 0) {
+            utf8_javaMessage[min(MESSAGE_LENGTH*2 - 1, n)] = '\0';
+            errorMessage = utf8_javaMessage;
+        }
+        JNU_ThrowIOException(env, errorMessage);
+    }
 }
 
 static void
 closeSafely(HANDLE handle)
 {

@@ -114,11 +164,11 @@
     if (handles[0] != (jlong) -1) {
         si.hStdInput = (HANDLE) handles[0];
         handles[0] = (jlong) -1;
     } else {
         if (! CreatePipe(&inRead,  &inWrite,  &sa, PIPE_SIZE)) {
-            win32Error(env, "CreatePipe");
+            win32Error(env, L"CreatePipe");
             goto Catch;
         }
         si.hStdInput = inRead;
         SetHandleInformation(inWrite, HANDLE_FLAG_INHERIT, 0);
         handles[0] = (jlong) inWrite;

@@ -130,11 +180,11 @@
     if (handles[1] != (jlong) -1) {
         si.hStdOutput = (HANDLE) handles[1];
         handles[1] = (jlong) -1;
     } else {
         if (! CreatePipe(&outRead, &outWrite, &sa, PIPE_SIZE)) {
-            win32Error(env, "CreatePipe");
+            win32Error(env, L"CreatePipe");
             goto Catch;
         }
         si.hStdOutput = outWrite;
         SetHandleInformation(outRead, HANDLE_FLAG_INHERIT, 0);
         handles[1] = (jlong) outRead;

@@ -149,11 +199,11 @@
     } else if (handles[2] != (jlong) -1) {
         si.hStdError = (HANDLE) handles[2];
         handles[2] = (jlong) -1;
     } else {
         if (! CreatePipe(&errRead, &errWrite, &sa, PIPE_SIZE)) {
-            win32Error(env, "CreatePipe");
+            win32Error(env, L"CreatePipe");
             goto Catch;
         }
         si.hStdError = errWrite;
         SetHandleInformation(errRead, HANDLE_FLAG_INHERIT, 0);
         handles[2] = (jlong) errRead;

@@ -172,11 +222,11 @@
                          (LPVOID)penvBlock,/* environment block */
                          (LPCWSTR)pdir,    /* change to the new current directory */
                          &si,              /* (in)  startup information */
                          &pi);             /* (out) process information */
     if (!ret) {
-        win32Error(env, "CreateProcess");
+        win32Error(env, L"CreateProcess");
         goto Catch;
     }
 
     CloseHandle(pi.hThread);
     ret = (jlong)pi.hProcess;

@@ -208,11 +258,11 @@
 JNIEXPORT jint JNICALL
 Java_java_lang_ProcessImpl_getExitCodeProcess(JNIEnv *env, jclass ignored, jlong handle)
 {
     DWORD exit_code;
     if (GetExitCodeProcess((HANDLE) handle, &exit_code) == 0)
-        win32Error(env, "GetExitCodeProcess");
+        win32Error(env, L"GetExitCodeProcess");
     return exit_code;
 }
 
 JNIEXPORT jint JNICALL
 Java_java_lang_ProcessImpl_getStillActive(JNIEnv *env, jclass ignored)

@@ -229,11 +279,11 @@
 
     if (WaitForMultipleObjects(sizeof(events)/sizeof(events[0]), events,
                                FALSE,    /* Wait for ANY event */
                                INFINITE)  /* Wait forever */
         == WAIT_FAILED)
-        win32Error(env, "WaitForMultipleObjects");
+        win32Error(env, L"WaitForMultipleObjects");
 }
 
 JNIEXPORT void JNICALL
 Java_java_lang_ProcessImpl_waitForTimeoutInterruptibly(JNIEnv *env,
                                                        jclass ignored,

@@ -248,11 +298,11 @@
     result = WaitForMultipleObjects(sizeof(events)/sizeof(events[0]), events,
                                     FALSE,    /* Wait for ANY event */
                                     dwTimeout);  /* Wait for dwTimeout */
 
     if (result == WAIT_FAILED)
-        win32Error(env, "WaitForMultipleObjects");
+        win32Error(env, L"WaitForMultipleObjects");
 }
 
 JNIEXPORT void JNICALL
 Java_java_lang_ProcessImpl_terminateProcess(JNIEnv *env, jclass ignored, jlong handle)
 {

@@ -261,11 +311,11 @@
 
 JNIEXPORT jboolean JNICALL
 Java_java_lang_ProcessImpl_isProcessAlive(JNIEnv *env, jclass ignored, jlong handle)
 {
     DWORD dwExitStatus;
-    GetExitCodeProcess(handle, &dwExitStatus);
+    GetExitCodeProcess((HANDLE) handle, &dwExitStatus);
     return dwExitStatus == STILL_ACTIVE;
 }
 
 JNIEXPORT jboolean JNICALL
 Java_java_lang_ProcessImpl_closeHandle(JNIEnv *env, jclass ignored, jlong handle)