1 /* 2 * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include <windows.h> 27 #include <io.h> 28 #include <process.h> 29 #include <stdlib.h> 30 #include <stdio.h> 31 #include <stdarg.h> 32 #include <string.h> 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <wtypes.h> 36 #include <commctrl.h> 37 #include <assert.h> 38 39 #include <jni.h> 40 #include "java.h" 41 42 #define JVM_DLL "jvm.dll" 43 #define JAVA_DLL "java.dll" 44 45 /* 46 * Prototypes. 47 */ 48 static jboolean GetJVMPath(const char *jrepath, const char *jvmtype, 49 char *jvmpath, jint jvmpathsize); 50 static jboolean GetJREPath(char *path, jint pathsize); 51 52 #ifdef USE_REGISTRY_LOOKUP 53 jboolean GetPublicJREHome(char *buf, jint bufsize); 54 #endif 55 56 /* We supports warmup for UI stack that is performed in parallel 57 * to VM initialization. 58 * This helps to improve startup of UI application as warmup phase 59 * might be long due to initialization of OS or hardware resources. 60 * It is not CPU bound and therefore it does not interfere with VM init. 61 * Obviously such warmup only has sense for UI apps and therefore it needs 62 * to be explicitly requested by passing -Dsun.awt.warmup=true property 63 * (this is always the case for plugin/javaws). 64 * 65 * Implementation launches new thread after VM starts and use it to perform 66 * warmup code (platform dependent). 67 * This thread is later reused as AWT toolkit thread as graphics toolkit 68 * often assume that they are used from the same thread they were launched on. 69 * 70 * At the moment we only support warmup for D3D. It only possible on windows 71 * and only if other flags do not prohibit this (e.g. OpenGL support requested). 72 */ 73 #undef ENABLE_AWT_PRELOAD 74 #ifndef JAVA_ARGS /* turn off AWT preloading for javac, jar, etc */ 75 /* CR6999872: fastdebug crashes if awt library is loaded before JVM is 76 * initialized*/ 77 #if !defined(DEBUG) 78 #define ENABLE_AWT_PRELOAD 79 #endif 80 #endif 81 82 #ifdef ENABLE_AWT_PRELOAD 83 /* "AWT was preloaded" flag; 84 * turned on by AWTPreload(). 85 */ 86 int awtPreloaded = 0; 87 88 /* Calls a function with the name specified 89 * the function must be int(*fn)(void). 90 */ 91 int AWTPreload(const char *funcName); 92 /* stops AWT preloading */ 93 void AWTPreloadStop(); 94 95 /* D3D preloading */ 96 /* -1: not initialized; 0: OFF, 1: ON */ 97 int awtPreloadD3D = -1; 98 /* command line parameter to swith D3D preloading on */ 99 #define PARAM_PRELOAD_D3D "-Dsun.awt.warmup" 100 /* D3D/OpenGL management parameters */ 101 #define PARAM_NODDRAW "-Dsun.java2d.noddraw" 102 #define PARAM_D3D "-Dsun.java2d.d3d" 103 #define PARAM_OPENGL "-Dsun.java2d.opengl" 104 /* funtion in awt.dll (src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp) */ 105 #define D3D_PRELOAD_FUNC "preloadD3D" 106 107 /* Extracts value of a parameter with the specified name 108 * from command line argument (returns pointer in the argument). 109 * Returns NULL if the argument does not contains the parameter. 110 * e.g.: 111 * GetParamValue("theParam", "theParam=value") returns pointer to "value". 112 */ 113 const char * GetParamValue(const char *paramName, const char *arg) { 114 size_t nameLen = JLI_StrLen(paramName); 115 if (JLI_StrNCmp(paramName, arg, nameLen) == 0) { 116 /* arg[nameLen] is valid (may contain final NULL) */ 117 if (arg[nameLen] == '=') { 118 return arg + nameLen + 1; 119 } 120 } 121 return NULL; 122 } 123 124 /* Checks if commandline argument contains property specified 125 * and analyze it as boolean property (true/false). 126 * Returns -1 if the argument does not contain the parameter; 127 * Returns 1 if the argument contains the parameter and its value is "true"; 128 * Returns 0 if the argument contains the parameter and its value is "false". 129 */ 130 int GetBoolParamValue(const char *paramName, const char *arg) { 131 const char * paramValue = GetParamValue(paramName, arg); 132 if (paramValue != NULL) { 133 if (JLI_StrCaseCmp(paramValue, "true") == 0) { 134 return 1; 135 } 136 if (JLI_StrCaseCmp(paramValue, "false") == 0) { 137 return 0; 138 } 139 } 140 return -1; 141 } 142 #endif /* ENABLE_AWT_PRELOAD */ 143 144 145 static jboolean _isjavaw = JNI_FALSE; 146 147 148 jboolean 149 IsJavaw() 150 { 151 return _isjavaw; 152 } 153 154 /* 155 * 156 */ 157 void 158 CreateExecutionEnvironment(int *pargc, char ***pargv, 159 char *jrepath, jint so_jrepath, 160 char *jvmpath, jint so_jvmpath, 161 char *jvmcfg, jint so_jvmcfg) { 162 163 char *jvmtype; 164 int i = 0; 165 char** argv = *pargv; 166 167 /* Find out where the JRE is that we will be using. */ 168 if (!GetJREPath(jrepath, so_jrepath)) { 169 JLI_ReportErrorMessage(JRE_ERROR1); 170 exit(2); 171 } 172 173 JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%sjvm.cfg", 174 jrepath, FILESEP, FILESEP); 175 176 /* Find the specified JVM type */ 177 if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) { 178 JLI_ReportErrorMessage(CFG_ERROR7); 179 exit(1); 180 } 181 182 jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE); 183 if (JLI_StrCmp(jvmtype, "ERROR") == 0) { 184 JLI_ReportErrorMessage(CFG_ERROR9); 185 exit(4); 186 } 187 188 jvmpath[0] = '\0'; 189 if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath)) { 190 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath); 191 exit(4); 192 } 193 /* If we got here, jvmpath has been correctly initialized. */ 194 195 /* Check if we need preload AWT */ 196 #ifdef ENABLE_AWT_PRELOAD 197 argv = *pargv; 198 for (i = 0; i < *pargc ; i++) { 199 /* Tests the "turn on" parameter only if not set yet. */ 200 if (awtPreloadD3D < 0) { 201 if (GetBoolParamValue(PARAM_PRELOAD_D3D, argv[i]) == 1) { 202 awtPreloadD3D = 1; 203 } 204 } 205 /* Test parameters which can disable preloading if not already disabled. */ 206 if (awtPreloadD3D != 0) { 207 if (GetBoolParamValue(PARAM_NODDRAW, argv[i]) == 1 208 || GetBoolParamValue(PARAM_D3D, argv[i]) == 0 209 || GetBoolParamValue(PARAM_OPENGL, argv[i]) == 1) 210 { 211 awtPreloadD3D = 0; 212 /* no need to test the rest of the parameters */ 213 break; 214 } 215 } 216 } 217 #endif /* ENABLE_AWT_PRELOAD */ 218 } 219 220 221 static jboolean 222 LoadMSVCRT() 223 { 224 // Only do this once 225 static int loaded = 0; 226 char crtpath[MAXPATHLEN]; 227 228 if (!loaded) { 229 /* 230 * The Microsoft C Runtime Library needs to be loaded first. A copy is 231 * assumed to be present in the "JRE path" directory. If it is not found 232 * there (or "JRE path" fails to resolve), skip the explicit load and let 233 * nature take its course, which is likely to be a failure to execute. 234 * The makefiles will provide the correct lib contained in quotes in the 235 * macro MSVCR_DLL_NAME. 236 */ 237 #ifdef MSVCR_DLL_NAME 238 if (GetJREPath(crtpath, MAXPATHLEN)) { 239 if (JLI_StrLen(crtpath) + JLI_StrLen("\\bin\\") + 240 JLI_StrLen(MSVCR_DLL_NAME) >= MAXPATHLEN) { 241 JLI_ReportErrorMessage(JRE_ERROR11); 242 return JNI_FALSE; 243 } 244 (void)JLI_StrCat(crtpath, "\\bin\\" MSVCR_DLL_NAME); /* Add crt dll */ 245 JLI_TraceLauncher("CRT path is %s\n", crtpath); 246 if (_access(crtpath, 0) == 0) { 247 if (LoadLibrary(crtpath) == 0) { 248 JLI_ReportErrorMessage(DLL_ERROR4, crtpath); 249 return JNI_FALSE; 250 } 251 } 252 } 253 #endif /* MSVCR_DLL_NAME */ 254 #ifdef MSVCP_DLL_NAME 255 if (GetJREPath(crtpath, MAXPATHLEN)) { 256 if (JLI_StrLen(crtpath) + JLI_StrLen("\\bin\\") + 257 JLI_StrLen(MSVCP_DLL_NAME) >= MAXPATHLEN) { 258 JLI_ReportErrorMessage(JRE_ERROR11); 259 return JNI_FALSE; 260 } 261 (void)JLI_StrCat(crtpath, "\\bin\\" MSVCP_DLL_NAME); /* Add prt dll */ 262 JLI_TraceLauncher("PRT path is %s\n", crtpath); 263 if (_access(crtpath, 0) == 0) { 264 if (LoadLibrary(crtpath) == 0) { 265 JLI_ReportErrorMessage(DLL_ERROR4, crtpath); 266 return JNI_FALSE; 267 } 268 } 269 } 270 #endif /* MSVCP_DLL_NAME */ 271 loaded = 1; 272 } 273 return JNI_TRUE; 274 } 275 276 277 /* 278 * Find path to JRE based on .exe's location or registry settings. 279 */ 280 jboolean 281 GetJREPath(char *path, jint pathsize) 282 { 283 char javadll[MAXPATHLEN]; 284 struct stat s; 285 286 if (GetApplicationHome(path, pathsize)) { 287 /* Is JRE co-located with the application? */ 288 JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path); 289 if (stat(javadll, &s) == 0) { 290 JLI_TraceLauncher("JRE path is %s\n", path); 291 return JNI_TRUE; 292 } 293 /* ensure storage for path + \jre + NULL */ 294 if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) { 295 JLI_TraceLauncher("Insufficient space to store JRE path\n"); 296 return JNI_FALSE; 297 } 298 /* Does this app ship a private JRE in <apphome>\jre directory? */ 299 JLI_Snprintf(javadll, sizeof (javadll), "%s\\jre\\bin\\" JAVA_DLL, path); 300 if (stat(javadll, &s) == 0) { 301 JLI_StrCat(path, "\\jre"); 302 JLI_TraceLauncher("JRE path is %s\n", path); 303 return JNI_TRUE; 304 } 305 } 306 307 /* Try getting path to JRE from path to JLI.DLL */ 308 if (GetApplicationHomeFromDll(path, pathsize)) { 309 JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path); 310 if (stat(javadll, &s) == 0) { 311 JLI_TraceLauncher("JRE path is %s\n", path); 312 return JNI_TRUE; 313 } 314 } 315 316 #ifdef USE_REGISTRY_LOOKUP 317 /* Lookup public JRE using Windows registry. */ 318 if (GetPublicJREHome(path, pathsize)) { 319 JLI_TraceLauncher("JRE path is %s\n", path); 320 return JNI_TRUE; 321 } 322 #endif 323 324 JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL); 325 return JNI_FALSE; 326 } 327 328 /* 329 * Given a JRE location and a JVM type, construct what the name the 330 * JVM shared library will be. Return true, if such a library 331 * exists, false otherwise. 332 */ 333 static jboolean 334 GetJVMPath(const char *jrepath, const char *jvmtype, 335 char *jvmpath, jint jvmpathsize) 336 { 337 struct stat s; 338 if (JLI_StrChr(jvmtype, '/') || JLI_StrChr(jvmtype, '\\')) { 339 JLI_Snprintf(jvmpath, jvmpathsize, "%s\\" JVM_DLL, jvmtype); 340 } else { 341 JLI_Snprintf(jvmpath, jvmpathsize, "%s\\bin\\%s\\" JVM_DLL, 342 jrepath, jvmtype); 343 } 344 if (stat(jvmpath, &s) == 0) { 345 return JNI_TRUE; 346 } else { 347 return JNI_FALSE; 348 } 349 } 350 351 /* 352 * Load a jvm from "jvmpath" and initialize the invocation functions. 353 */ 354 jboolean 355 LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn) 356 { 357 HINSTANCE handle; 358 359 JLI_TraceLauncher("JVM path is %s\n", jvmpath); 360 361 /* 362 * The Microsoft C Runtime Library needs to be loaded first. A copy is 363 * assumed to be present in the "JRE path" directory. If it is not found 364 * there (or "JRE path" fails to resolve), skip the explicit load and let 365 * nature take its course, which is likely to be a failure to execute. 366 * 367 */ 368 LoadMSVCRT(); 369 370 /* Load the Java VM DLL */ 371 if ((handle = LoadLibrary(jvmpath)) == 0) { 372 JLI_ReportErrorMessage(DLL_ERROR4, (char *)jvmpath); 373 return JNI_FALSE; 374 } 375 376 /* Now get the function addresses */ 377 ifn->CreateJavaVM = 378 (void *)GetProcAddress(handle, "JNI_CreateJavaVM"); 379 ifn->GetDefaultJavaVMInitArgs = 380 (void *)GetProcAddress(handle, "JNI_GetDefaultJavaVMInitArgs"); 381 if (ifn->CreateJavaVM == 0 || ifn->GetDefaultJavaVMInitArgs == 0) { 382 JLI_ReportErrorMessage(JNI_ERROR1, (char *)jvmpath); 383 return JNI_FALSE; 384 } 385 386 return JNI_TRUE; 387 } 388 389 /* 390 * Removes the trailing file name and one sub-folder from a path. 391 * If buf is "c:\foo\bin\javac", then put "c:\foo" into buf. 392 */ 393 jboolean 394 TruncatePath(char *buf) 395 { 396 char *cp; 397 *JLI_StrRChr(buf, '\\') = '\0'; /* remove .exe file name */ 398 if ((cp = JLI_StrRChr(buf, '\\')) == 0) { 399 /* This happens if the application is in a drive root, and 400 * there is no bin directory. */ 401 buf[0] = '\0'; 402 return JNI_FALSE; 403 } 404 *cp = '\0'; /* remove the bin\ part */ 405 return JNI_TRUE; 406 } 407 408 /* 409 * Retrieves the path to the JRE home by locating the executable file 410 * of the current process and then truncating the path to the executable 411 */ 412 jboolean 413 GetApplicationHome(char *buf, jint bufsize) 414 { 415 GetModuleFileName(NULL, buf, bufsize); 416 return TruncatePath(buf); 417 } 418 419 /* 420 * Retrieves the path to the JRE home by locating JLI.DLL and 421 * then truncating the path to JLI.DLL 422 */ 423 jboolean 424 GetApplicationHomeFromDll(char *buf, jint bufsize) 425 { 426 HMODULE module; 427 DWORD flags = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | 428 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT; 429 430 if (GetModuleHandleEx(flags, (LPCSTR)&GetJREPath, &module) != 0) { 431 if (GetModuleFileName(module, buf, bufsize) != 0) { 432 return TruncatePath(buf); 433 } 434 } 435 return JNI_FALSE; 436 } 437 438 /* 439 * Support for doing cheap, accurate interval timing. 440 */ 441 static jboolean counterAvailable = JNI_FALSE; 442 static jboolean counterInitialized = JNI_FALSE; 443 static LARGE_INTEGER counterFrequency; 444 445 jlong CounterGet() 446 { 447 LARGE_INTEGER count; 448 449 if (!counterInitialized) { 450 counterAvailable = QueryPerformanceFrequency(&counterFrequency); 451 counterInitialized = JNI_TRUE; 452 } 453 if (!counterAvailable) { 454 return 0; 455 } 456 QueryPerformanceCounter(&count); 457 return (jlong)(count.QuadPart); 458 } 459 460 jlong Counter2Micros(jlong counts) 461 { 462 if (!counterAvailable || !counterInitialized) { 463 return 0; 464 } 465 return (counts * 1000 * 1000)/counterFrequency.QuadPart; 466 } 467 /* 468 * windows snprintf does not guarantee a null terminator in the buffer, 469 * if the computed size is equal to or greater than the buffer size, 470 * as well as error conditions. This function guarantees a null terminator 471 * under all these conditions. An unreasonable buffer or size will return 472 * an error value. Under all other conditions this function will return the 473 * size of the bytes actually written minus the null terminator, similar 474 * to ansi snprintf api. Thus when calling this function the caller must 475 * ensure storage for the null terminator. 476 */ 477 int 478 JLI_Snprintf(char* buffer, size_t size, const char* format, ...) { 479 int rc; 480 va_list vl; 481 if (size == 0 || buffer == NULL) 482 return -1; 483 buffer[0] = '\0'; 484 va_start(vl, format); 485 rc = vsnprintf(buffer, size, format, vl); 486 va_end(vl); 487 /* force a null terminator, if something is amiss */ 488 if (rc < 0) { 489 /* apply ansi semantics */ 490 buffer[size - 1] = '\0'; 491 return (int)size; 492 } else if (rc == size) { 493 /* force a null terminator */ 494 buffer[size - 1] = '\0'; 495 } 496 return rc; 497 } 498 499 static errno_t convert_to_unicode(const char* path, const wchar_t* prefix, wchar_t** wpath) { 500 int unicode_path_len; 501 size_t prefix_len, wpath_len; 502 503 /* 504 * Get required buffer size to convert to Unicode. 505 * The return value includes the terminating null character. 506 */ 507 unicode_path_len = MultiByteToWideChar(CP_THREAD_ACP, MB_ERR_INVALID_CHARS, 508 path, -1, NULL, 0); 509 if (unicode_path_len == 0) { 510 return EINVAL; 511 } 512 513 prefix_len = wcslen(prefix); 514 wpath_len = prefix_len + unicode_path_len; 515 *wpath = (wchar_t*)JLI_MemAlloc(wpath_len * sizeof(wchar_t)); 516 if (*wpath == NULL) { 517 return ENOMEM; 518 } 519 520 wcsncpy(*wpath, prefix, prefix_len); 521 MultiByteToWideChar(CP_THREAD_ACP, MB_ERR_INVALID_CHARS, 522 path, -1, &((*wpath)[prefix_len]), (int)wpath_len); 523 524 return ERROR_SUCCESS; 525 } 526 527 /* taken from hotspot and slightly adjusted for jli lib; 528 * creates a UNC/ELP path from input 'path' 529 * the return buffer is allocated in C heap and needs to be freed using 530 * JLI_MemFree by the caller. 531 */ 532 static wchar_t* create_unc_path(const char* path, errno_t* err) { 533 wchar_t* wpath = NULL; 534 size_t converted_chars = 0; 535 size_t path_len = strlen(path) + 1; /* includes the terminating NULL */ 536 if (path[0] == '\\' && path[1] == '\\') { 537 if (path[2] == '?' && path[3] == '\\') { 538 /* if it already has a \\?\ don't do the prefix */ 539 *err = convert_to_unicode(path, L"", &wpath); 540 } else { 541 /* only UNC pathname includes double slashes here */ 542 *err = convert_to_unicode(path, L"\\\\?\\UNC", &wpath); 543 } 544 } else { 545 *err = convert_to_unicode(path, L"\\\\?\\", &wpath); 546 } 547 return wpath; 548 } 549 550 int JLI_Open(const char* name, int flags) { 551 int fd; 552 if (strlen(name) < MAX_PATH) { 553 fd = _open(name, flags); 554 } else { 555 errno_t err = ERROR_SUCCESS; 556 wchar_t* wpath = create_unc_path(name, &err); 557 if (err != ERROR_SUCCESS) { 558 if (wpath != NULL) JLI_MemFree(wpath); 559 errno = err; 560 return -1; 561 } 562 fd = _wopen(wpath, flags); 563 if (fd == -1) { 564 errno = GetLastError(); 565 } 566 JLI_MemFree(wpath); 567 } 568 return fd; 569 } 570 571 JNIEXPORT void JNICALL 572 JLI_ReportErrorMessage(const char* fmt, ...) { 573 va_list vl; 574 va_start(vl,fmt); 575 576 if (IsJavaw()) { 577 char *message; 578 579 /* get the length of the string we need */ 580 int n = _vscprintf(fmt, vl); 581 582 message = (char *)JLI_MemAlloc(n + 1); 583 _vsnprintf(message, n, fmt, vl); 584 message[n]='\0'; 585 MessageBox(NULL, message, "Java Virtual Machine Launcher", 586 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 587 JLI_MemFree(message); 588 } else { 589 vfprintf(stderr, fmt, vl); 590 fprintf(stderr, "\n"); 591 } 592 va_end(vl); 593 } 594 595 /* 596 * Just like JLI_ReportErrorMessage, except that it concatenates the system 597 * error message if any, its upto the calling routine to correctly 598 * format the separation of the messages. 599 */ 600 JNIEXPORT void JNICALL 601 JLI_ReportErrorMessageSys(const char *fmt, ...) 602 { 603 va_list vl; 604 605 int save_errno = errno; 606 DWORD errval; 607 jboolean freeit = JNI_FALSE; 608 char *errtext = NULL; 609 610 va_start(vl, fmt); 611 612 if ((errval = GetLastError()) != 0) { /* Platform SDK / DOS Error */ 613 int n = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM| 614 FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_ALLOCATE_BUFFER, 615 NULL, errval, 0, (LPTSTR)&errtext, 0, NULL); 616 if (errtext == NULL || n == 0) { /* Paranoia check */ 617 errtext = ""; 618 n = 0; 619 } else { 620 freeit = JNI_TRUE; 621 if (n > 2) { /* Drop final CR, LF */ 622 if (errtext[n - 1] == '\n') n--; 623 if (errtext[n - 1] == '\r') n--; 624 errtext[n] = '\0'; 625 } 626 } 627 } else { /* C runtime error that has no corresponding DOS error code */ 628 errtext = strerror(save_errno); 629 } 630 631 if (IsJavaw()) { 632 char *message; 633 int mlen; 634 /* get the length of the string we need */ 635 int len = mlen = _vscprintf(fmt, vl) + 1; 636 if (freeit) { 637 mlen += (int)JLI_StrLen(errtext); 638 } 639 640 message = (char *)JLI_MemAlloc(mlen); 641 _vsnprintf(message, len, fmt, vl); 642 message[len]='\0'; 643 644 if (freeit) { 645 JLI_StrCat(message, errtext); 646 } 647 648 MessageBox(NULL, message, "Java Virtual Machine Launcher", 649 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 650 651 JLI_MemFree(message); 652 } else { 653 vfprintf(stderr, fmt, vl); 654 if (freeit) { 655 fprintf(stderr, "%s", errtext); 656 } 657 } 658 if (freeit) { 659 (void)LocalFree((HLOCAL)errtext); 660 } 661 va_end(vl); 662 } 663 664 JNIEXPORT void JNICALL 665 JLI_ReportExceptionDescription(JNIEnv * env) { 666 if (IsJavaw()) { 667 /* 668 * This code should be replaced by code which opens a window with 669 * the exception detail message, for now atleast put a dialog up. 670 */ 671 MessageBox(NULL, "A Java Exception has occurred.", "Java Virtual Machine Launcher", 672 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 673 } else { 674 (*env)->ExceptionDescribe(env); 675 } 676 } 677 678 /* 679 * Wrapper for platform dependent unsetenv function. 680 */ 681 int 682 UnsetEnv(char *name) 683 { 684 int ret; 685 char *buf = JLI_MemAlloc(JLI_StrLen(name) + 2); 686 buf = JLI_StrCat(JLI_StrCpy(buf, name), "="); 687 ret = _putenv(buf); 688 JLI_MemFree(buf); 689 return (ret); 690 } 691 692 /* --- Splash Screen shared library support --- */ 693 694 static const char* SPLASHSCREEN_SO = "\\bin\\splashscreen.dll"; 695 696 static HMODULE hSplashLib = NULL; 697 698 void* SplashProcAddress(const char* name) { 699 char libraryPath[MAXPATHLEN]; /* some extra space for JLI_StrCat'ing SPLASHSCREEN_SO */ 700 701 if (!GetJREPath(libraryPath, MAXPATHLEN)) { 702 return NULL; 703 } 704 if (JLI_StrLen(libraryPath)+JLI_StrLen(SPLASHSCREEN_SO) >= MAXPATHLEN) { 705 return NULL; 706 } 707 JLI_StrCat(libraryPath, SPLASHSCREEN_SO); 708 709 if (!hSplashLib) { 710 hSplashLib = LoadLibrary(libraryPath); 711 } 712 if (hSplashLib) { 713 return GetProcAddress(hSplashLib, name); 714 } else { 715 return NULL; 716 } 717 } 718 719 /* 720 * Signature adapter for _beginthreadex(). 721 */ 722 static unsigned __stdcall ThreadJavaMain(void* args) { 723 return (unsigned)JavaMain(args); 724 } 725 726 /* 727 * Block current thread and continue execution in a new thread. 728 */ 729 int 730 CallJavaMainInNewThread(jlong stack_size, void* args) { 731 int rslt = 0; 732 unsigned thread_id; 733 734 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION 735 #define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000) 736 #endif 737 738 /* 739 * STACK_SIZE_PARAM_IS_A_RESERVATION is what we want, but it's not 740 * supported on older version of Windows. Try first with the flag; and 741 * if that fails try again without the flag. See MSDN document or HotSpot 742 * source (os_win32.cpp) for details. 743 */ 744 HANDLE thread_handle = 745 (HANDLE)_beginthreadex(NULL, 746 (unsigned)stack_size, 747 ThreadJavaMain, 748 args, 749 STACK_SIZE_PARAM_IS_A_RESERVATION, 750 &thread_id); 751 if (thread_handle == NULL) { 752 thread_handle = 753 (HANDLE)_beginthreadex(NULL, 754 (unsigned)stack_size, 755 ThreadJavaMain, 756 args, 757 0, 758 &thread_id); 759 } 760 761 /* AWT preloading (AFTER main thread start) */ 762 #ifdef ENABLE_AWT_PRELOAD 763 /* D3D preloading */ 764 if (awtPreloadD3D != 0) { 765 char *envValue; 766 /* D3D routines checks env.var J2D_D3D if no appropriate 767 * command line params was specified 768 */ 769 envValue = getenv("J2D_D3D"); 770 if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) { 771 awtPreloadD3D = 0; 772 } 773 /* Test that AWT preloading isn't disabled by J2D_D3D_PRELOAD env.var */ 774 envValue = getenv("J2D_D3D_PRELOAD"); 775 if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) { 776 awtPreloadD3D = 0; 777 } 778 if (awtPreloadD3D < 0) { 779 /* If awtPreloadD3D is still undefined (-1), test 780 * if it is turned on by J2D_D3D_PRELOAD env.var. 781 * By default it's turned OFF. 782 */ 783 awtPreloadD3D = 0; 784 if (envValue != NULL && JLI_StrCaseCmp(envValue, "true") == 0) { 785 awtPreloadD3D = 1; 786 } 787 } 788 } 789 if (awtPreloadD3D) { 790 AWTPreload(D3D_PRELOAD_FUNC); 791 } 792 #endif /* ENABLE_AWT_PRELOAD */ 793 794 if (thread_handle) { 795 WaitForSingleObject(thread_handle, INFINITE); 796 GetExitCodeThread(thread_handle, &rslt); 797 CloseHandle(thread_handle); 798 } else { 799 rslt = JavaMain(args); 800 } 801 802 #ifdef ENABLE_AWT_PRELOAD 803 if (awtPreloaded) { 804 AWTPreloadStop(); 805 } 806 #endif /* ENABLE_AWT_PRELOAD */ 807 808 return rslt; 809 } 810 811 /* 812 * The implementation for finding classes from the bootstrap 813 * class loader, refer to java.h 814 */ 815 static FindClassFromBootLoader_t *findBootClass = NULL; 816 817 jclass FindBootStrapClass(JNIEnv *env, const char *classname) 818 { 819 HMODULE hJvm; 820 821 if (findBootClass == NULL) { 822 hJvm = GetModuleHandle(JVM_DLL); 823 if (hJvm == NULL) return NULL; 824 /* need to use the demangled entry point */ 825 findBootClass = (FindClassFromBootLoader_t *)GetProcAddress(hJvm, 826 "JVM_FindClassFromBootLoader"); 827 if (findBootClass == NULL) { 828 JLI_ReportErrorMessage(DLL_ERROR4, "JVM_FindClassFromBootLoader"); 829 return NULL; 830 } 831 } 832 return findBootClass(env, classname); 833 } 834 835 void 836 InitLauncher(boolean javaw) 837 { 838 INITCOMMONCONTROLSEX icx; 839 840 /* 841 * Required for javaw mode MessageBox output as well as for 842 * HotSpot -XX:+ShowMessageBoxOnError in java mode, an empty 843 * flag field is sufficient to perform the basic UI initialization. 844 */ 845 memset(&icx, 0, sizeof(INITCOMMONCONTROLSEX)); 846 icx.dwSize = sizeof(INITCOMMONCONTROLSEX); 847 InitCommonControlsEx(&icx); 848 _isjavaw = javaw; 849 JLI_SetTraceLauncher(); 850 } 851 852 853 /* ============================== */ 854 /* AWT preloading */ 855 #ifdef ENABLE_AWT_PRELOAD 856 857 typedef int FnPreloadStart(void); 858 typedef void FnPreloadStop(void); 859 static FnPreloadStop *fnPreloadStop = NULL; 860 static HMODULE hPreloadAwt = NULL; 861 862 /* 863 * Starts AWT preloading 864 */ 865 int AWTPreload(const char *funcName) 866 { 867 int result = -1; 868 /* load AWT library once (if several preload function should be called) */ 869 if (hPreloadAwt == NULL) { 870 /* awt.dll is not loaded yet */ 871 char libraryPath[MAXPATHLEN]; 872 size_t jrePathLen = 0; 873 HMODULE hJava = NULL; 874 HMODULE hVerify = NULL; 875 876 while (1) { 877 /* awt.dll depends on jvm.dll & java.dll; 878 * jvm.dll is already loaded, so we need only java.dll; 879 * java.dll depends on MSVCRT lib & verify.dll. 880 */ 881 if (!GetJREPath(libraryPath, MAXPATHLEN)) { 882 break; 883 } 884 885 /* save path length */ 886 jrePathLen = JLI_StrLen(libraryPath); 887 888 if (jrePathLen + JLI_StrLen("\\bin\\verify.dll") >= MAXPATHLEN) { 889 /* jre path is too long, the library path will not fit there; 890 * report and abort preloading 891 */ 892 JLI_ReportErrorMessage(JRE_ERROR11); 893 break; 894 } 895 896 /* load msvcrt 1st */ 897 LoadMSVCRT(); 898 899 /* load verify.dll */ 900 JLI_StrCat(libraryPath, "\\bin\\verify.dll"); 901 hVerify = LoadLibrary(libraryPath); 902 if (hVerify == NULL) { 903 break; 904 } 905 906 /* restore jrePath */ 907 libraryPath[jrePathLen] = 0; 908 /* load java.dll */ 909 JLI_StrCat(libraryPath, "\\bin\\" JAVA_DLL); 910 hJava = LoadLibrary(libraryPath); 911 if (hJava == NULL) { 912 break; 913 } 914 915 /* restore jrePath */ 916 libraryPath[jrePathLen] = 0; 917 /* load awt.dll */ 918 JLI_StrCat(libraryPath, "\\bin\\awt.dll"); 919 hPreloadAwt = LoadLibrary(libraryPath); 920 if (hPreloadAwt == NULL) { 921 break; 922 } 923 924 /* get "preloadStop" func ptr */ 925 fnPreloadStop = (FnPreloadStop *)GetProcAddress(hPreloadAwt, "preloadStop"); 926 927 break; 928 } 929 } 930 931 if (hPreloadAwt != NULL) { 932 FnPreloadStart *fnInit = (FnPreloadStart *)GetProcAddress(hPreloadAwt, funcName); 933 if (fnInit != NULL) { 934 /* don't forget to stop preloading */ 935 awtPreloaded = 1; 936 937 result = fnInit(); 938 } 939 } 940 941 return result; 942 } 943 944 /* 945 * Terminates AWT preloading 946 */ 947 void AWTPreloadStop() { 948 if (fnPreloadStop != NULL) { 949 fnPreloadStop(); 950 } 951 } 952 953 #endif /* ENABLE_AWT_PRELOAD */ 954 955 int 956 JVMInit(InvocationFunctions* ifn, jlong threadStackSize, 957 int argc, char **argv, 958 int mode, char *what, int ret) 959 { 960 ShowSplashScreen(); 961 return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); 962 } 963 964 void 965 PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) 966 { 967 // stubbed out for windows and *nixes. 968 } 969 970 void 971 RegisterThread() 972 { 973 // stubbed out for windows and *nixes. 974 } 975 976 /* 977 * on windows, we return a false to indicate this option is not applicable 978 */ 979 jboolean 980 ProcessPlatformOption(const char *arg) 981 { 982 return JNI_FALSE; 983 } 984 985 /* 986 * At this point we have the arguments to the application, and we need to 987 * check with original stdargs in order to compare which of these truly 988 * needs expansion. cmdtoargs will specify this if it finds a bare 989 * (unquoted) argument containing a glob character(s) ie. * or ? 990 */ 991 jobjectArray 992 CreateApplicationArgs(JNIEnv *env, char **strv, int argc) 993 { 994 int i, j, idx; 995 size_t tlen; 996 jobjectArray outArray, inArray; 997 char *arg, **nargv; 998 jboolean needs_expansion = JNI_FALSE; 999 jmethodID mid; 1000 int stdargc; 1001 StdArg *stdargs; 1002 int *appArgIdx; 1003 int isTool; 1004 jclass cls = GetLauncherHelperClass(env); 1005 NULL_CHECK0(cls); 1006 1007 if (argc == 0) { 1008 return NewPlatformStringArray(env, strv, argc); 1009 } 1010 // the holy grail we need to compare with. 1011 stdargs = JLI_GetStdArgs(); 1012 stdargc = JLI_GetStdArgc(); 1013 1014 // sanity check, this should never happen 1015 if (argc > stdargc) { 1016 JLI_TraceLauncher("Warning: app args is larger than the original, %d %d\n", argc, stdargc); 1017 JLI_TraceLauncher("passing arguments as-is.\n"); 1018 return NewPlatformStringArray(env, strv, argc); 1019 } 1020 1021 // sanity check, match the args we have, to the holy grail 1022 idx = JLI_GetAppArgIndex(); 1023 1024 // First arg index is NOT_FOUND 1025 if (idx < 0) { 1026 // The only allowed value should be NOT_FOUND (-1) unless another change introduces 1027 // a different negative index 1028 assert (idx == -1); 1029 JLI_TraceLauncher("Warning: first app arg index not found, %d\n", idx); 1030 JLI_TraceLauncher("passing arguments as-is.\n"); 1031 return NewPlatformStringArray(env, strv, argc); 1032 } 1033 1034 isTool = (idx == 0); 1035 if (isTool) { idx++; } // skip tool name 1036 JLI_TraceLauncher("AppArgIndex: %d points to %s\n", idx, stdargs[idx].arg); 1037 1038 appArgIdx = calloc(argc, sizeof(int)); 1039 for (i = idx, j = 0; i < stdargc; i++) { 1040 if (isTool) { // filter -J used by tools to pass JVM options 1041 arg = stdargs[i].arg; 1042 if (arg[0] == '-' && arg[1] == 'J') { 1043 continue; 1044 } 1045 } 1046 appArgIdx[j++] = i; 1047 } 1048 // sanity check, ensure same number of arguments for application 1049 if (j != argc) { 1050 JLI_TraceLauncher("Warning: app args count doesn't match, %d %d\n", j, argc); 1051 JLI_TraceLauncher("passing arguments as-is.\n"); 1052 JLI_MemFree(appArgIdx); 1053 return NewPlatformStringArray(env, strv, argc); 1054 } 1055 1056 // make a copy of the args which will be expanded in java if required. 1057 nargv = (char **)JLI_MemAlloc(argc * sizeof(char*)); 1058 for (i = 0; i < argc; i++) { 1059 jboolean arg_expand; 1060 j = appArgIdx[i]; 1061 arg_expand = (JLI_StrCmp(stdargs[j].arg, strv[i]) == 0) 1062 ? stdargs[j].has_wildcard 1063 : JNI_FALSE; 1064 if (needs_expansion == JNI_FALSE) 1065 needs_expansion = arg_expand; 1066 1067 // indicator char + String + NULL terminator, the java method will strip 1068 // out the first character, the indicator character, so no matter what 1069 // we add the indicator 1070 tlen = 1 + JLI_StrLen(strv[i]) + 1; 1071 nargv[i] = (char *) JLI_MemAlloc(tlen); 1072 if (JLI_Snprintf(nargv[i], tlen, "%c%s", arg_expand ? 'T' : 'F', 1073 strv[i]) < 0) { 1074 return NULL; 1075 } 1076 JLI_TraceLauncher("%s\n", nargv[i]); 1077 } 1078 1079 if (!needs_expansion) { 1080 // clean up any allocated memory and return back the old arguments 1081 for (i = 0 ; i < argc ; i++) { 1082 JLI_MemFree(nargv[i]); 1083 } 1084 JLI_MemFree(nargv); 1085 JLI_MemFree(appArgIdx); 1086 return NewPlatformStringArray(env, strv, argc); 1087 } 1088 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, 1089 "expandArgs", 1090 "([Ljava/lang/String;)[Ljava/lang/String;")); 1091 1092 // expand the arguments that require expansion, the java method will strip 1093 // out the indicator character. 1094 NULL_CHECK0(inArray = NewPlatformStringArray(env, nargv, argc)); 1095 outArray = (*env)->CallStaticObjectMethod(env, cls, mid, inArray); 1096 for (i = 0; i < argc; i++) { 1097 JLI_MemFree(nargv[i]); 1098 } 1099 JLI_MemFree(nargv); 1100 JLI_MemFree(appArgIdx); 1101 return outArray; 1102 }