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 if (MultiByteToWideChar(CP_THREAD_ACP, MB_ERR_INVALID_CHARS, 522 path, -1, &((*wpath)[prefix_len]), (int)wpath_len) == 0) { 523 JLI_MemFree(*wpath); 524 return EINVAL; 525 } 526 527 return ERROR_SUCCESS; 528 } 529 530 /* taken from hotspot and slightly adjusted for jli lib; 531 * creates a UNC/ELP path from input 'path' 532 * the return buffer is allocated in C heap and needs to be freed using 533 * JLI_MemFree by the caller. 534 */ 535 static wchar_t* create_unc_path(const char* path, errno_t* err) { 536 wchar_t* wpath = NULL; 537 size_t converted_chars = 0; 538 size_t path_len = strlen(path) + 1; /* includes the terminating NULL */ 539 if (path[0] == '\\' && path[1] == '\\') { 540 if (path[2] == '?' && path[3] == '\\') { 541 /* if it already has a \\?\ don't do the prefix */ 542 *err = convert_to_unicode(path, L"", &wpath); 543 } else { 544 /* only UNC pathname includes double slashes here */ 545 *err = convert_to_unicode(path, L"\\\\?\\UNC", &wpath); 546 } 547 } else { 548 *err = convert_to_unicode(path, L"\\\\?\\", &wpath); 549 } 550 return wpath; 551 } 552 553 int JLI_Open(const char* name, int flags) { 554 int fd; 555 if (strlen(name) < MAX_PATH) { 556 fd = _open(name, flags); 557 } else { 558 errno_t err = ERROR_SUCCESS; 559 wchar_t* wpath = create_unc_path(name, &err); 560 if (err != ERROR_SUCCESS) { 561 if (wpath != NULL) JLI_MemFree(wpath); 562 errno = err; 563 return -1; 564 } 565 fd = _wopen(wpath, flags); 566 if (fd == -1) { 567 errno = GetLastError(); 568 } 569 JLI_MemFree(wpath); 570 } 571 return fd; 572 } 573 574 JNIEXPORT void JNICALL 575 JLI_ReportErrorMessage(const char* fmt, ...) { 576 va_list vl; 577 va_start(vl,fmt); 578 579 if (IsJavaw()) { 580 char *message; 581 582 /* get the length of the string we need */ 583 int n = _vscprintf(fmt, vl); 584 585 message = (char *)JLI_MemAlloc(n + 1); 586 _vsnprintf(message, n, fmt, vl); 587 message[n]='\0'; 588 MessageBox(NULL, message, "Java Virtual Machine Launcher", 589 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 590 JLI_MemFree(message); 591 } else { 592 vfprintf(stderr, fmt, vl); 593 fprintf(stderr, "\n"); 594 } 595 va_end(vl); 596 } 597 598 /* 599 * Just like JLI_ReportErrorMessage, except that it concatenates the system 600 * error message if any, its upto the calling routine to correctly 601 * format the separation of the messages. 602 */ 603 JNIEXPORT void JNICALL 604 JLI_ReportErrorMessageSys(const char *fmt, ...) 605 { 606 va_list vl; 607 608 int save_errno = errno; 609 DWORD errval; 610 jboolean freeit = JNI_FALSE; 611 char *errtext = NULL; 612 613 va_start(vl, fmt); 614 615 if ((errval = GetLastError()) != 0) { /* Platform SDK / DOS Error */ 616 int n = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM| 617 FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_ALLOCATE_BUFFER, 618 NULL, errval, 0, (LPTSTR)&errtext, 0, NULL); 619 if (errtext == NULL || n == 0) { /* Paranoia check */ 620 errtext = ""; 621 n = 0; 622 } else { 623 freeit = JNI_TRUE; 624 if (n > 2) { /* Drop final CR, LF */ 625 if (errtext[n - 1] == '\n') n--; 626 if (errtext[n - 1] == '\r') n--; 627 errtext[n] = '\0'; 628 } 629 } 630 } else { /* C runtime error that has no corresponding DOS error code */ 631 errtext = strerror(save_errno); 632 } 633 634 if (IsJavaw()) { 635 char *message; 636 int mlen; 637 /* get the length of the string we need */ 638 int len = mlen = _vscprintf(fmt, vl) + 1; 639 if (freeit) { 640 mlen += (int)JLI_StrLen(errtext); 641 } 642 643 message = (char *)JLI_MemAlloc(mlen); 644 _vsnprintf(message, len, fmt, vl); 645 message[len]='\0'; 646 647 if (freeit) { 648 JLI_StrCat(message, errtext); 649 } 650 651 MessageBox(NULL, message, "Java Virtual Machine Launcher", 652 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 653 654 JLI_MemFree(message); 655 } else { 656 vfprintf(stderr, fmt, vl); 657 if (freeit) { 658 fprintf(stderr, "%s", errtext); 659 } 660 } 661 if (freeit) { 662 (void)LocalFree((HLOCAL)errtext); 663 } 664 va_end(vl); 665 } 666 667 JNIEXPORT void JNICALL 668 JLI_ReportExceptionDescription(JNIEnv * env) { 669 if (IsJavaw()) { 670 /* 671 * This code should be replaced by code which opens a window with 672 * the exception detail message, for now atleast put a dialog up. 673 */ 674 MessageBox(NULL, "A Java Exception has occurred.", "Java Virtual Machine Launcher", 675 (MB_OK|MB_ICONSTOP|MB_APPLMODAL)); 676 } else { 677 (*env)->ExceptionDescribe(env); 678 } 679 } 680 681 /* 682 * Wrapper for platform dependent unsetenv function. 683 */ 684 int 685 UnsetEnv(char *name) 686 { 687 int ret; 688 char *buf = JLI_MemAlloc(JLI_StrLen(name) + 2); 689 buf = JLI_StrCat(JLI_StrCpy(buf, name), "="); 690 ret = _putenv(buf); 691 JLI_MemFree(buf); 692 return (ret); 693 } 694 695 /* --- Splash Screen shared library support --- */ 696 697 static const char* SPLASHSCREEN_SO = "\\bin\\splashscreen.dll"; 698 699 static HMODULE hSplashLib = NULL; 700 701 void* SplashProcAddress(const char* name) { 702 char libraryPath[MAXPATHLEN]; /* some extra space for JLI_StrCat'ing SPLASHSCREEN_SO */ 703 704 if (!GetJREPath(libraryPath, MAXPATHLEN)) { 705 return NULL; 706 } 707 if (JLI_StrLen(libraryPath)+JLI_StrLen(SPLASHSCREEN_SO) >= MAXPATHLEN) { 708 return NULL; 709 } 710 JLI_StrCat(libraryPath, SPLASHSCREEN_SO); 711 712 if (!hSplashLib) { 713 hSplashLib = LoadLibrary(libraryPath); 714 } 715 if (hSplashLib) { 716 return GetProcAddress(hSplashLib, name); 717 } else { 718 return NULL; 719 } 720 } 721 722 /* 723 * Signature adapter for _beginthreadex(). 724 */ 725 static unsigned __stdcall ThreadJavaMain(void* args) { 726 return (unsigned)JavaMain(args); 727 } 728 729 /* 730 * Block current thread and continue execution in a new thread. 731 */ 732 int 733 CallJavaMainInNewThread(jlong stack_size, void* args) { 734 int rslt = 0; 735 unsigned thread_id; 736 737 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION 738 #define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000) 739 #endif 740 741 /* 742 * STACK_SIZE_PARAM_IS_A_RESERVATION is what we want, but it's not 743 * supported on older version of Windows. Try first with the flag; and 744 * if that fails try again without the flag. See MSDN document or HotSpot 745 * source (os_win32.cpp) for details. 746 */ 747 HANDLE thread_handle = 748 (HANDLE)_beginthreadex(NULL, 749 (unsigned)stack_size, 750 ThreadJavaMain, 751 args, 752 STACK_SIZE_PARAM_IS_A_RESERVATION, 753 &thread_id); 754 if (thread_handle == NULL) { 755 thread_handle = 756 (HANDLE)_beginthreadex(NULL, 757 (unsigned)stack_size, 758 ThreadJavaMain, 759 args, 760 0, 761 &thread_id); 762 } 763 764 /* AWT preloading (AFTER main thread start) */ 765 #ifdef ENABLE_AWT_PRELOAD 766 /* D3D preloading */ 767 if (awtPreloadD3D != 0) { 768 char *envValue; 769 /* D3D routines checks env.var J2D_D3D if no appropriate 770 * command line params was specified 771 */ 772 envValue = getenv("J2D_D3D"); 773 if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) { 774 awtPreloadD3D = 0; 775 } 776 /* Test that AWT preloading isn't disabled by J2D_D3D_PRELOAD env.var */ 777 envValue = getenv("J2D_D3D_PRELOAD"); 778 if (envValue != NULL && JLI_StrCaseCmp(envValue, "false") == 0) { 779 awtPreloadD3D = 0; 780 } 781 if (awtPreloadD3D < 0) { 782 /* If awtPreloadD3D is still undefined (-1), test 783 * if it is turned on by J2D_D3D_PRELOAD env.var. 784 * By default it's turned OFF. 785 */ 786 awtPreloadD3D = 0; 787 if (envValue != NULL && JLI_StrCaseCmp(envValue, "true") == 0) { 788 awtPreloadD3D = 1; 789 } 790 } 791 } 792 if (awtPreloadD3D) { 793 AWTPreload(D3D_PRELOAD_FUNC); 794 } 795 #endif /* ENABLE_AWT_PRELOAD */ 796 797 if (thread_handle) { 798 WaitForSingleObject(thread_handle, INFINITE); 799 GetExitCodeThread(thread_handle, &rslt); 800 CloseHandle(thread_handle); 801 } else { 802 rslt = JavaMain(args); 803 } 804 805 #ifdef ENABLE_AWT_PRELOAD 806 if (awtPreloaded) { 807 AWTPreloadStop(); 808 } 809 #endif /* ENABLE_AWT_PRELOAD */ 810 811 return rslt; 812 } 813 814 /* 815 * The implementation for finding classes from the bootstrap 816 * class loader, refer to java.h 817 */ 818 static FindClassFromBootLoader_t *findBootClass = NULL; 819 820 jclass FindBootStrapClass(JNIEnv *env, const char *classname) 821 { 822 HMODULE hJvm; 823 824 if (findBootClass == NULL) { 825 hJvm = GetModuleHandle(JVM_DLL); 826 if (hJvm == NULL) return NULL; 827 /* need to use the demangled entry point */ 828 findBootClass = (FindClassFromBootLoader_t *)GetProcAddress(hJvm, 829 "JVM_FindClassFromBootLoader"); 830 if (findBootClass == NULL) { 831 JLI_ReportErrorMessage(DLL_ERROR4, "JVM_FindClassFromBootLoader"); 832 return NULL; 833 } 834 } 835 return findBootClass(env, classname); 836 } 837 838 void 839 InitLauncher(boolean javaw) 840 { 841 INITCOMMONCONTROLSEX icx; 842 843 /* 844 * Required for javaw mode MessageBox output as well as for 845 * HotSpot -XX:+ShowMessageBoxOnError in java mode, an empty 846 * flag field is sufficient to perform the basic UI initialization. 847 */ 848 memset(&icx, 0, sizeof(INITCOMMONCONTROLSEX)); 849 icx.dwSize = sizeof(INITCOMMONCONTROLSEX); 850 InitCommonControlsEx(&icx); 851 _isjavaw = javaw; 852 JLI_SetTraceLauncher(); 853 } 854 855 856 /* ============================== */ 857 /* AWT preloading */ 858 #ifdef ENABLE_AWT_PRELOAD 859 860 typedef int FnPreloadStart(void); 861 typedef void FnPreloadStop(void); 862 static FnPreloadStop *fnPreloadStop = NULL; 863 static HMODULE hPreloadAwt = NULL; 864 865 /* 866 * Starts AWT preloading 867 */ 868 int AWTPreload(const char *funcName) 869 { 870 int result = -1; 871 /* load AWT library once (if several preload function should be called) */ 872 if (hPreloadAwt == NULL) { 873 /* awt.dll is not loaded yet */ 874 char libraryPath[MAXPATHLEN]; 875 size_t jrePathLen = 0; 876 HMODULE hJava = NULL; 877 HMODULE hVerify = NULL; 878 879 while (1) { 880 /* awt.dll depends on jvm.dll & java.dll; 881 * jvm.dll is already loaded, so we need only java.dll; 882 * java.dll depends on MSVCRT lib & verify.dll. 883 */ 884 if (!GetJREPath(libraryPath, MAXPATHLEN)) { 885 break; 886 } 887 888 /* save path length */ 889 jrePathLen = JLI_StrLen(libraryPath); 890 891 if (jrePathLen + JLI_StrLen("\\bin\\verify.dll") >= MAXPATHLEN) { 892 /* jre path is too long, the library path will not fit there; 893 * report and abort preloading 894 */ 895 JLI_ReportErrorMessage(JRE_ERROR11); 896 break; 897 } 898 899 /* load msvcrt 1st */ 900 LoadMSVCRT(); 901 902 /* load verify.dll */ 903 JLI_StrCat(libraryPath, "\\bin\\verify.dll"); 904 hVerify = LoadLibrary(libraryPath); 905 if (hVerify == NULL) { 906 break; 907 } 908 909 /* restore jrePath */ 910 libraryPath[jrePathLen] = 0; 911 /* load java.dll */ 912 JLI_StrCat(libraryPath, "\\bin\\" JAVA_DLL); 913 hJava = LoadLibrary(libraryPath); 914 if (hJava == NULL) { 915 break; 916 } 917 918 /* restore jrePath */ 919 libraryPath[jrePathLen] = 0; 920 /* load awt.dll */ 921 JLI_StrCat(libraryPath, "\\bin\\awt.dll"); 922 hPreloadAwt = LoadLibrary(libraryPath); 923 if (hPreloadAwt == NULL) { 924 break; 925 } 926 927 /* get "preloadStop" func ptr */ 928 fnPreloadStop = (FnPreloadStop *)GetProcAddress(hPreloadAwt, "preloadStop"); 929 930 break; 931 } 932 } 933 934 if (hPreloadAwt != NULL) { 935 FnPreloadStart *fnInit = (FnPreloadStart *)GetProcAddress(hPreloadAwt, funcName); 936 if (fnInit != NULL) { 937 /* don't forget to stop preloading */ 938 awtPreloaded = 1; 939 940 result = fnInit(); 941 } 942 } 943 944 return result; 945 } 946 947 /* 948 * Terminates AWT preloading 949 */ 950 void AWTPreloadStop() { 951 if (fnPreloadStop != NULL) { 952 fnPreloadStop(); 953 } 954 } 955 956 #endif /* ENABLE_AWT_PRELOAD */ 957 958 int 959 JVMInit(InvocationFunctions* ifn, jlong threadStackSize, 960 int argc, char **argv, 961 int mode, char *what, int ret) 962 { 963 ShowSplashScreen(); 964 return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); 965 } 966 967 void 968 PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) 969 { 970 // stubbed out for windows and *nixes. 971 } 972 973 void 974 RegisterThread() 975 { 976 // stubbed out for windows and *nixes. 977 } 978 979 /* 980 * on windows, we return a false to indicate this option is not applicable 981 */ 982 jboolean 983 ProcessPlatformOption(const char *arg) 984 { 985 return JNI_FALSE; 986 } 987 988 /* 989 * At this point we have the arguments to the application, and we need to 990 * check with original stdargs in order to compare which of these truly 991 * needs expansion. cmdtoargs will specify this if it finds a bare 992 * (unquoted) argument containing a glob character(s) ie. * or ? 993 */ 994 jobjectArray 995 CreateApplicationArgs(JNIEnv *env, char **strv, int argc) 996 { 997 int i, j, idx; 998 size_t tlen; 999 jobjectArray outArray, inArray; 1000 char *arg, **nargv; 1001 jboolean needs_expansion = JNI_FALSE; 1002 jmethodID mid; 1003 int stdargc; 1004 StdArg *stdargs; 1005 int *appArgIdx; 1006 int isTool; 1007 jclass cls = GetLauncherHelperClass(env); 1008 NULL_CHECK0(cls); 1009 1010 if (argc == 0) { 1011 return NewPlatformStringArray(env, strv, argc); 1012 } 1013 // the holy grail we need to compare with. 1014 stdargs = JLI_GetStdArgs(); 1015 stdargc = JLI_GetStdArgc(); 1016 1017 // sanity check, this should never happen 1018 if (argc > stdargc) { 1019 JLI_TraceLauncher("Warning: app args is larger than the original, %d %d\n", argc, stdargc); 1020 JLI_TraceLauncher("passing arguments as-is.\n"); 1021 return NewPlatformStringArray(env, strv, argc); 1022 } 1023 1024 // sanity check, match the args we have, to the holy grail 1025 idx = JLI_GetAppArgIndex(); 1026 1027 // First arg index is NOT_FOUND 1028 if (idx < 0) { 1029 // The only allowed value should be NOT_FOUND (-1) unless another change introduces 1030 // a different negative index 1031 assert (idx == -1); 1032 JLI_TraceLauncher("Warning: first app arg index not found, %d\n", idx); 1033 JLI_TraceLauncher("passing arguments as-is.\n"); 1034 return NewPlatformStringArray(env, strv, argc); 1035 } 1036 1037 isTool = (idx == 0); 1038 if (isTool) { idx++; } // skip tool name 1039 JLI_TraceLauncher("AppArgIndex: %d points to %s\n", idx, stdargs[idx].arg); 1040 1041 appArgIdx = calloc(argc, sizeof(int)); 1042 for (i = idx, j = 0; i < stdargc; i++) { 1043 if (isTool) { // filter -J used by tools to pass JVM options 1044 arg = stdargs[i].arg; 1045 if (arg[0] == '-' && arg[1] == 'J') { 1046 continue; 1047 } 1048 } 1049 appArgIdx[j++] = i; 1050 } 1051 // sanity check, ensure same number of arguments for application 1052 if (j != argc) { 1053 JLI_TraceLauncher("Warning: app args count doesn't match, %d %d\n", j, argc); 1054 JLI_TraceLauncher("passing arguments as-is.\n"); 1055 JLI_MemFree(appArgIdx); 1056 return NewPlatformStringArray(env, strv, argc); 1057 } 1058 1059 // make a copy of the args which will be expanded in java if required. 1060 nargv = (char **)JLI_MemAlloc(argc * sizeof(char*)); 1061 for (i = 0; i < argc; i++) { 1062 jboolean arg_expand; 1063 j = appArgIdx[i]; 1064 arg_expand = (JLI_StrCmp(stdargs[j].arg, strv[i]) == 0) 1065 ? stdargs[j].has_wildcard 1066 : JNI_FALSE; 1067 if (needs_expansion == JNI_FALSE) 1068 needs_expansion = arg_expand; 1069 1070 // indicator char + String + NULL terminator, the java method will strip 1071 // out the first character, the indicator character, so no matter what 1072 // we add the indicator 1073 tlen = 1 + JLI_StrLen(strv[i]) + 1; 1074 nargv[i] = (char *) JLI_MemAlloc(tlen); 1075 if (JLI_Snprintf(nargv[i], tlen, "%c%s", arg_expand ? 'T' : 'F', 1076 strv[i]) < 0) { 1077 return NULL; 1078 } 1079 JLI_TraceLauncher("%s\n", nargv[i]); 1080 } 1081 1082 if (!needs_expansion) { 1083 // clean up any allocated memory and return back the old arguments 1084 for (i = 0 ; i < argc ; i++) { 1085 JLI_MemFree(nargv[i]); 1086 } 1087 JLI_MemFree(nargv); 1088 JLI_MemFree(appArgIdx); 1089 return NewPlatformStringArray(env, strv, argc); 1090 } 1091 NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, 1092 "expandArgs", 1093 "([Ljava/lang/String;)[Ljava/lang/String;")); 1094 1095 // expand the arguments that require expansion, the java method will strip 1096 // out the indicator character. 1097 NULL_CHECK0(inArray = NewPlatformStringArray(env, nargv, argc)); 1098 outArray = (*env)->CallStaticObjectMethod(env, cls, mid, inArray); 1099 for (i = 0; i < argc; i++) { 1100 JLI_MemFree(nargv[i]); 1101 } 1102 JLI_MemFree(nargv); 1103 JLI_MemFree(appArgIdx); 1104 return outArray; 1105 }