1 /* 2 * Copyright (c) 1998, 2016, 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 "java.h" 27 #include "jvm_md.h" 28 #include <dirent.h> 29 #include <dlfcn.h> 30 #include <fcntl.h> 31 #include <inttypes.h> 32 #include <stdio.h> 33 #include <string.h> 34 #include <stdlib.h> 35 #include <sys/stat.h> 36 #include <unistd.h> 37 #include <sys/types.h> 38 #include "manifest_info.h" 39 40 41 #define JVM_DLL "libjvm.so" 42 #define JAVA_DLL "libjava.so" 43 #ifdef AIX 44 #define LD_LIBRARY_PATH "LIBPATH" 45 #else 46 #define LD_LIBRARY_PATH "LD_LIBRARY_PATH" 47 #endif 48 49 /* help jettison the LD_LIBRARY_PATH settings in the future */ 50 #ifndef SETENV_REQUIRED 51 #define SETENV_REQUIRED 52 #endif 53 54 #ifdef __solaris__ 55 # ifndef LIBARCHNAME 56 # error "The macro LIBARCHNAME was not defined on the compile line" 57 # endif 58 # include <sys/systeminfo.h> 59 # include <sys/elf.h> 60 # include <stdio.h> 61 #endif 62 63 /* 64 * Flowchart of launcher execs and options processing on unix 65 * 66 * The selection of the proper vm shared library to open depends on 67 * several classes of command line options, including vm "flavor" 68 * options (-client, -server) and the data model options, -d32 and 69 * -d64, as well as a version specification which may have come from 70 * the command line or from the manifest of an executable jar file. 71 * The vm selection options are not passed to the running 72 * virtual machine; they must be screened out by the launcher. 73 * 74 * The version specification (if any) is processed first by the 75 * platform independent routine SelectVersion. This may result in 76 * the exec of the specified launcher version. 77 * 78 * Previously the launcher modified the LD_LIBRARY_PATH appropriately for the 79 * desired data model path, regardless if data models matched or not. The 80 * launcher subsequently exec'ed the desired executable, in order to make the 81 * LD_LIBRARY_PATH path available, for the runtime linker. 82 * 83 * Now, in most cases,the launcher will dlopen the target libjvm.so. All 84 * required libraries are loaded by the runtime linker, using the 85 * $RPATH/$ORIGIN baked into the shared libraries at compile time. Therefore, 86 * in most cases, the launcher will only exec, if the data models are 87 * mismatched, and will not set any environment variables, regardless of the 88 * data models. 89 * 90 * However, if the environment contains a LD_LIBRARY_PATH, this will cause the 91 * launcher to inspect the LD_LIBRARY_PATH. The launcher will check 92 * a. if the LD_LIBRARY_PATH's first component is the path to the desired 93 * libjvm.so 94 * b. if any other libjvm.so is found in any of the paths. 95 * If case b is true, then the launcher will set the LD_LIBRARY_PATH to the 96 * desired JRE and reexec, in order to propagate the environment. 97 * 98 * Main 99 * (incoming argv) 100 * | 101 * \|/ 102 * CreateExecutionEnvironment 103 * (determines desired data model) 104 * | 105 * | 106 * \|/ 107 * Have Desired Model ? --> NO --> Exit(with error) 108 * | 109 * | 110 * \|/ 111 * YES 112 * | 113 * | 114 * \|/ 115 * CheckJvmType 116 * (removes -client, -server, etc.) 117 * | 118 * | 119 * \|/ 120 * TranslateDashJArgs... 121 * (Prepare to pass args to vm) 122 * | 123 * | 124 * \|/ 125 * ParseArguments 126 * (removes -d32 and -d64 if any, 127 * processes version options, 128 * creates argument list for vm, 129 * etc.) 130 * | 131 * | 132 * \|/ 133 * RequiresSetenv 134 * Is LD_LIBRARY_PATH 135 * and friends set ? --> NO --> Have Desired Model ? NO --> Error/Exit 136 * YES YES --> Continue 137 * | 138 * | 139 * \|/ 140 * Path is desired JRE ? YES --> Have Desired Model ? NO --> Error/Exit 141 * NO YES --> Continue 142 * | 143 * | 144 * \|/ 145 * Paths have well known 146 * jvm paths ? --> NO --> Have Desired Model ? NO --> Error/Exit 147 * YES YES --> Continue 148 * | 149 * | 150 * \|/ 151 * Does libjvm.so exit 152 * in any of them ? --> NO --> Have Desired Model ? NO --> Error/Exit 153 * YES YES --> Continue 154 * | 155 * | 156 * \|/ 157 * Set the LD_LIBRARY_PATH 158 * | 159 * | 160 * \|/ 161 * Re-exec 162 * | 163 * | 164 * \|/ 165 * Main 166 */ 167 168 /* Store the name of the executable once computed */ 169 static char *execname = NULL; 170 171 /* 172 * execname accessor from other parts of platform dependent logic 173 */ 174 const char * 175 GetExecName() { 176 return execname; 177 } 178 179 #ifdef SETENV_REQUIRED 180 static jboolean 181 JvmExists(const char *path) { 182 char tmp[PATH_MAX + 1]; 183 struct stat statbuf; 184 JLI_Snprintf(tmp, PATH_MAX, "%s/%s", path, JVM_DLL); 185 if (stat(tmp, &statbuf) == 0) { 186 return JNI_TRUE; 187 } 188 return JNI_FALSE; 189 } 190 /* 191 * contains a lib/$LIBARCHNAME/{server,client}/libjvm.so ? 192 */ 193 static jboolean 194 ContainsLibJVM(const char *env) { 195 char clientPattern[PATH_MAX + 1]; 196 char serverPattern[PATH_MAX + 1]; 197 char *envpath; 198 char *path; 199 jboolean clientPatternFound; 200 jboolean serverPatternFound; 201 202 /* fastest path */ 203 if (env == NULL) { 204 return JNI_FALSE; 205 } 206 207 /* the usual suspects */ 208 JLI_Snprintf(clientPattern, PATH_MAX, "lib/%s/client", LIBARCHNAME); 209 JLI_Snprintf(serverPattern, PATH_MAX, "lib/%s/server", LIBARCHNAME); 210 211 /* to optimize for time, test if any of our usual suspects are present. */ 212 clientPatternFound = JLI_StrStr(env, clientPattern) != NULL; 213 serverPatternFound = JLI_StrStr(env, serverPattern) != NULL; 214 if (clientPatternFound == JNI_FALSE && serverPatternFound == JNI_FALSE) { 215 return JNI_FALSE; 216 } 217 218 /* 219 * we have a suspicious path component, check if it contains a libjvm.so 220 */ 221 envpath = JLI_StringDup(env); 222 for (path = JLI_StrTok(envpath, ":"); path != NULL; path = JLI_StrTok(NULL, ":")) { 223 if (clientPatternFound && JLI_StrStr(path, clientPattern) != NULL) { 224 if (JvmExists(path)) { 225 JLI_MemFree(envpath); 226 return JNI_TRUE; 227 } 228 } 229 if (serverPatternFound && JLI_StrStr(path, serverPattern) != NULL) { 230 if (JvmExists(path)) { 231 JLI_MemFree(envpath); 232 return JNI_TRUE; 233 } 234 } 235 } 236 JLI_MemFree(envpath); 237 return JNI_FALSE; 238 } 239 240 /* 241 * Test whether the environment variable needs to be set, see flowchart. 242 */ 243 static jboolean 244 RequiresSetenv(const char *jvmpath) { 245 char jpath[PATH_MAX + 1]; 246 char *llp; 247 char *dmllp = NULL; 248 char *p; /* a utility pointer */ 249 250 #ifdef AIX 251 /* We always have to set the LIBPATH on AIX because ld doesn't support $ORIGIN. */ 252 return JNI_TRUE; 253 #endif 254 255 llp = getenv("LD_LIBRARY_PATH"); 256 #ifdef __solaris__ 257 dmllp = getenv("LD_LIBRARY_PATH_64"); 258 #endif /* __solaris__ */ 259 /* no environment variable is a good environment variable */ 260 if (llp == NULL && dmllp == NULL) { 261 return JNI_FALSE; 262 } 263 #ifdef __linux 264 /* 265 * On linux, if a binary is running as sgid or suid, glibc sets 266 * LD_LIBRARY_PATH to the empty string for security purposes. (In contrast, 267 * on Solaris the LD_LIBRARY_PATH variable for a privileged binary does not 268 * lose its settings; but the dynamic linker does apply more scrutiny to the 269 * path.) The launcher uses the value of LD_LIBRARY_PATH to prevent an exec 270 * loop, here and further downstream. Therefore, if we are running sgid or 271 * suid, this function's setting of LD_LIBRARY_PATH will be ineffective and 272 * we should case a return from the calling function. Getting the right 273 * libraries will be handled by the RPATH. In reality, this check is 274 * redundant, as the previous check for a non-null LD_LIBRARY_PATH will 275 * return back to the calling function forthwith, it is left here to safe 276 * guard against any changes, in the glibc's existing security policy. 277 */ 278 if ((getgid() != getegid()) || (getuid() != geteuid())) { 279 return JNI_FALSE; 280 } 281 #endif /* __linux */ 282 283 /* 284 * Prevent recursions. Since LD_LIBRARY_PATH is the one which will be set by 285 * previous versions of the JRE, thus it is the only path that matters here. 286 * So we check to see if the desired JRE is set. 287 */ 288 JLI_StrNCpy(jpath, jvmpath, PATH_MAX); 289 p = JLI_StrRChr(jpath, '/'); 290 *p = '\0'; 291 if (llp != NULL && JLI_StrNCmp(llp, jpath, JLI_StrLen(jpath)) == 0) { 292 return JNI_FALSE; 293 } 294 295 /* scrutinize all the paths further */ 296 if (llp != NULL && ContainsLibJVM(llp)) { 297 return JNI_TRUE; 298 } 299 if (dmllp != NULL && ContainsLibJVM(dmllp)) { 300 return JNI_TRUE; 301 } 302 return JNI_FALSE; 303 } 304 #endif /* SETENV_REQUIRED */ 305 306 void 307 CreateExecutionEnvironment(int *pargc, char ***pargv, 308 char jrepath[], jint so_jrepath, 309 char jvmpath[], jint so_jvmpath, 310 char jvmcfg[], jint so_jvmcfg) { 311 /* 312 * First, determine if we are running the desired data model. If we 313 * are running the desired data model, all the error messages 314 * associated with calling GetJREPath, ReadKnownVMs, etc. should be 315 * output, otherwise we simply exit with an error, as we no longer 316 * support dual data models. 317 */ 318 jboolean jvmpathExists; 319 320 /* Compute/set the name of the executable */ 321 SetExecname(*pargv); 322 323 /* Check data model flags, and exec process, if needed */ 324 { 325 char *arch = LIBARCHNAME; /* like sparc or sparcv9 */ 326 char * jvmtype = NULL; 327 int argc = *pargc; 328 char **argv = *pargv; 329 int running = CURRENT_DATA_MODEL; 330 /* 331 * As of jdk9, there is no support for dual mode operations, however 332 * for legacy error reporting purposes and until -d options are supported 333 * we need this. 334 */ 335 int wanted = running; 336 #ifdef SETENV_REQUIRED 337 jboolean mustsetenv = JNI_FALSE; 338 char *runpath = NULL; /* existing effective LD_LIBRARY_PATH setting */ 339 char* new_runpath = NULL; /* desired new LD_LIBRARY_PATH string */ 340 char* newpath = NULL; /* path on new LD_LIBRARY_PATH */ 341 char* lastslash = NULL; 342 char** newenvp = NULL; /* current environment */ 343 size_t new_runpath_size; 344 #ifdef __solaris__ 345 char* dmpath = NULL; /* data model specific LD_LIBRARY_PATH, 346 Solaris only */ 347 #endif /* __solaris__ */ 348 #endif /* SETENV_REQUIRED */ 349 350 char** newargv = NULL; 351 int newargc = 0; 352 353 /* 354 * Starting in 1.5, all unix platforms accept the -d32 and -d64 355 * options. On platforms where only one data-model is supported 356 * (e.g. ia-64 Linux), using the flag for the other data model is 357 * an error and will terminate the program. 358 */ 359 360 { /* open new scope to declare local variables */ 361 int i; 362 363 newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(char*)); 364 newargv[newargc++] = argv[0]; 365 366 /* scan for data model arguments and remove from argument list; 367 last occurrence determines desired data model */ 368 for (i=1; i < argc; i++) { 369 370 if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) { 371 wanted = 64; 372 continue; 373 } 374 if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) { 375 wanted = 32; 376 continue; 377 } 378 newargv[newargc++] = argv[i]; 379 380 if (IsJavaArgs()) { 381 if (argv[i][0] != '-') continue; 382 } else { 383 if (JLI_StrCmp(argv[i], "-classpath") == 0 || JLI_StrCmp(argv[i], "-cp") == 0) { 384 i++; 385 if (i >= argc) break; 386 newargv[newargc++] = argv[i]; 387 continue; 388 } 389 if (argv[i][0] != '-') { i++; break; } 390 } 391 } 392 393 /* copy rest of args [i .. argc) */ 394 while (i < argc) { 395 newargv[newargc++] = argv[i++]; 396 } 397 newargv[newargc] = NULL; 398 399 /* 400 * newargv has all proper arguments here 401 */ 402 403 argc = newargc; 404 argv = newargv; 405 } 406 407 /* If the data model is not changing, it is an error if the 408 jvmpath does not exist */ 409 if (wanted == running) { 410 /* Find out where the JRE is that we will be using. */ 411 if (!GetJREPath(jrepath, so_jrepath, arch, JNI_FALSE) ) { 412 JLI_ReportErrorMessage(JRE_ERROR1); 413 exit(2); 414 } 415 JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg", 416 jrepath, FILESEP, FILESEP, arch, FILESEP); 417 /* Find the specified JVM type */ 418 if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) { 419 JLI_ReportErrorMessage(CFG_ERROR7); 420 exit(1); 421 } 422 423 jvmpath[0] = '\0'; 424 jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE); 425 if (JLI_StrCmp(jvmtype, "ERROR") == 0) { 426 JLI_ReportErrorMessage(CFG_ERROR9); 427 exit(4); 428 } 429 430 if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, arch, 0 )) { 431 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath); 432 exit(4); 433 } 434 /* 435 * we seem to have everything we need, so without further ado 436 * we return back, otherwise proceed to set the environment. 437 */ 438 #ifdef SETENV_REQUIRED 439 mustsetenv = RequiresSetenv(jvmpath); 440 JLI_TraceLauncher("mustsetenv: %s\n", mustsetenv ? "TRUE" : "FALSE"); 441 442 if (mustsetenv == JNI_FALSE) { 443 JLI_MemFree(newargv); 444 return; 445 } 446 #else 447 JLI_MemFree(newargv); 448 return; 449 #endif /* SETENV_REQUIRED */ 450 } else { /* do the same speculatively or exit */ 451 JLI_ReportErrorMessage(JRE_ERROR2, wanted); 452 exit(1); 453 } 454 #ifdef SETENV_REQUIRED 455 if (mustsetenv) { 456 /* 457 * We will set the LD_LIBRARY_PATH as follows: 458 * 459 * o $JVMPATH (directory portion only) 460 * o $JRE/lib/$LIBARCHNAME 461 * o $JRE/../lib/$LIBARCHNAME 462 * 463 * followed by the user's previous effective LD_LIBRARY_PATH, if 464 * any. 465 */ 466 467 #ifdef __solaris__ 468 /* 469 * Starting in Solaris 7, ld.so.1 supports three LD_LIBRARY_PATH 470 * variables: 471 * 472 * 1. LD_LIBRARY_PATH -- used for 32 and 64 bit searches if 473 * data-model specific variables are not set. 474 * 475 * 2. LD_LIBRARY_PATH_64 -- overrides and replaces LD_LIBRARY_PATH 476 * for 64-bit binaries. 477 * The vm uses LD_LIBRARY_PATH to set the java.library.path system 478 * property. To shield the vm from the complication of multiple 479 * LD_LIBRARY_PATH variables, if the appropriate data model 480 * specific variable is set, we will act as if LD_LIBRARY_PATH had 481 * the value of the data model specific variant and the data model 482 * specific variant will be unset. Note that the variable for the 483 * *wanted* data model must be used (if it is set), not simply the 484 * current running data model. 485 */ 486 487 switch (wanted) { 488 case 0: 489 case 64: 490 dmpath = getenv("LD_LIBRARY_PATH_64"); 491 wanted = 64; 492 break; 493 494 default: 495 JLI_ReportErrorMessage(JRE_ERROR3, __LINE__); 496 exit(1); /* unknown value in wanted */ 497 break; 498 } 499 500 /* 501 * If dmpath is NULL, the relevant data model specific variable is 502 * not set and normal LD_LIBRARY_PATH should be used. 503 */ 504 if (dmpath == NULL) { 505 runpath = getenv("LD_LIBRARY_PATH"); 506 } else { 507 runpath = dmpath; 508 } 509 #else /* ! __solaris__ */ 510 /* 511 * If not on Solaris, assume only a single LD_LIBRARY_PATH 512 * variable. 513 */ 514 runpath = getenv(LD_LIBRARY_PATH); 515 #endif /* __solaris__ */ 516 517 /* runpath contains current effective LD_LIBRARY_PATH setting */ 518 519 char *new_jvmpath = JLI_StringDup(jvmpath); 520 new_runpath_size = ((runpath != NULL) ? JLI_StrLen(runpath) : 0) + 521 2 * JLI_StrLen(jrepath) + 2 * JLI_StrLen(arch) + 522 #ifdef AIX 523 /* On AIX we additionally need 'jli' in the path because ld doesn't support $ORIGIN. */ 524 JLI_StrLen(jrepath) + JLI_StrLen(arch) + JLI_StrLen("/lib/jli:") + 525 #endif 526 JLI_StrLen(new_jvmpath) + 52; 527 new_runpath = JLI_MemAlloc(new_runpath_size); 528 newpath = new_runpath + JLI_StrLen(LD_LIBRARY_PATH "="); 529 530 531 /* 532 * Create desired LD_LIBRARY_PATH value for target data model. 533 */ 534 { 535 /* remove the name of the .so from the JVM path */ 536 lastslash = JLI_StrRChr(new_jvmpath, '/'); 537 if (lastslash) 538 *lastslash = '\0'; 539 540 sprintf(new_runpath, LD_LIBRARY_PATH "=" 541 "%s:" 542 "%s/lib/%s:" 543 #ifdef AIX 544 "%s/lib/%s/jli:" /* Needed on AIX because ld doesn't support $ORIGIN. */ 545 #endif 546 "%s/../lib/%s", 547 new_jvmpath, 548 jrepath, arch, 549 #ifdef AIX 550 jrepath, arch, 551 #endif 552 jrepath, arch 553 ); 554 555 JLI_MemFree(new_jvmpath); 556 557 /* 558 * Check to make sure that the prefix of the current path is the 559 * desired environment variable setting, though the RequiresSetenv 560 * checks if the desired runpath exists, this logic does a more 561 * comprehensive check. 562 */ 563 if (runpath != NULL && 564 JLI_StrNCmp(newpath, runpath, JLI_StrLen(newpath)) == 0 && 565 (runpath[JLI_StrLen(newpath)] == 0 || runpath[JLI_StrLen(newpath)] == ':') && 566 (running == wanted) /* data model does not have to be changed */ 567 #ifdef __solaris__ 568 && (dmpath == NULL) /* data model specific variables not set */ 569 #endif /* __solaris__ */ 570 ) { 571 JLI_MemFree(newargv); 572 JLI_MemFree(new_runpath); 573 return; 574 } 575 } 576 577 /* 578 * Place the desired environment setting onto the prefix of 579 * LD_LIBRARY_PATH. Note that this prevents any possible infinite 580 * loop of execv() because we test for the prefix, above. 581 */ 582 if (runpath != 0) { 583 /* ensure storage for runpath + colon + NULL */ 584 if ((JLI_StrLen(runpath) + 1 + 1) > new_runpath_size) { 585 JLI_ReportErrorMessageSys(JRE_ERROR11); 586 exit(1); 587 } 588 JLI_StrCat(new_runpath, ":"); 589 JLI_StrCat(new_runpath, runpath); 590 } 591 592 if (putenv(new_runpath) != 0) { 593 exit(1); /* problem allocating memory; LD_LIBRARY_PATH not set 594 properly */ 595 } 596 597 /* 598 * Unix systems document that they look at LD_LIBRARY_PATH only 599 * once at startup, so we have to re-exec the current executable 600 * to get the changed environment variable to have an effect. 601 */ 602 603 #ifdef __solaris__ 604 /* 605 * If dmpath is not NULL, remove the data model specific string 606 * in the environment for the exec'ed child. 607 */ 608 if (dmpath != NULL) 609 (void)UnsetEnv("LD_LIBRARY_PATH_64"); 610 #endif /* __solaris */ 611 612 newenvp = environ; 613 } 614 #endif /* SETENV_REQUIRED */ 615 { 616 char *newexec = execname; 617 JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n"); 618 (void) fflush(stdout); 619 (void) fflush(stderr); 620 #ifdef SETENV_REQUIRED 621 if (mustsetenv) { 622 execve(newexec, argv, newenvp); 623 } else { 624 execv(newexec, argv); 625 } 626 #else /* !SETENV_REQUIRED */ 627 execv(newexec, argv); 628 #endif /* SETENV_REQUIRED */ 629 JLI_ReportErrorMessageSys(JRE_ERROR4, newexec); 630 } 631 exit(1); 632 } 633 } 634 635 /* 636 * On Solaris VM choosing is done by the launcher (java.c), 637 * bitsWanted is used by MacOSX, on Solaris and Linux this. 638 * parameter is unused. 639 */ 640 static jboolean 641 GetJVMPath(const char *jrepath, const char *jvmtype, 642 char *jvmpath, jint jvmpathsize, const char * arch, int bitsWanted) 643 { 644 struct stat s; 645 646 if (JLI_StrChr(jvmtype, '/')) { 647 JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype); 648 } else { 649 JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/%s/" JVM_DLL, jrepath, arch, jvmtype); 650 } 651 652 JLI_TraceLauncher("Does `%s' exist ... ", jvmpath); 653 654 if (stat(jvmpath, &s) == 0) { 655 JLI_TraceLauncher("yes.\n"); 656 return JNI_TRUE; 657 } else { 658 JLI_TraceLauncher("no.\n"); 659 return JNI_FALSE; 660 } 661 } 662 663 /* 664 * Find path to JRE based on .exe's location or registry settings. 665 */ 666 static jboolean 667 GetJREPath(char *path, jint pathsize, const char * arch, jboolean speculative) 668 { 669 char libjava[MAXPATHLEN]; 670 struct stat s; 671 672 if (GetApplicationHome(path, pathsize)) { 673 /* Is JRE co-located with the application? */ 674 JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/%s/" JAVA_DLL, path, arch); 675 if (access(libjava, F_OK) == 0) { 676 JLI_TraceLauncher("JRE path is %s\n", path); 677 return JNI_TRUE; 678 } 679 /* ensure storage for path + /jre + NULL */ 680 if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) { 681 JLI_TraceLauncher("Insufficient space to store JRE path\n"); 682 return JNI_FALSE; 683 } 684 /* Does the app ship a private JRE in <apphome>/jre directory? */ 685 JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/%s/" JAVA_DLL, path, arch); 686 if (access(libjava, F_OK) == 0) { 687 JLI_StrCat(path, "/jre"); 688 JLI_TraceLauncher("JRE path is %s\n", path); 689 return JNI_TRUE; 690 } 691 } 692 693 if (GetApplicationHomeFromDll(path, pathsize)) { 694 JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/%s/" JAVA_DLL, path, arch); 695 if (stat(libjava, &s) == 0) { 696 JLI_TraceLauncher("JRE path is %s\n", path); 697 return JNI_TRUE; 698 } 699 } 700 701 if (!speculative) 702 JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL); 703 return JNI_FALSE; 704 } 705 706 jboolean 707 LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn) 708 { 709 void *libjvm; 710 711 JLI_TraceLauncher("JVM path is %s\n", jvmpath); 712 713 libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL); 714 if (libjvm == NULL) { 715 #if defined(__solaris__) && defined(__sparc) && !defined(_LP64) /* i.e. 32-bit sparc */ 716 FILE * fp; 717 Elf32_Ehdr elf_head; 718 int count; 719 int location; 720 721 fp = fopen(jvmpath, "r"); 722 if (fp == NULL) { 723 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 724 return JNI_FALSE; 725 } 726 727 /* read in elf header */ 728 count = fread((void*)(&elf_head), sizeof(Elf32_Ehdr), 1, fp); 729 fclose(fp); 730 if (count < 1) { 731 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 732 return JNI_FALSE; 733 } 734 735 /* 736 * Check for running a server vm (compiled with -xarch=v8plus) 737 * on a stock v8 processor. In this case, the machine type in 738 * the elf header would not be included the architecture list 739 * provided by the isalist command, which is turn is gotten from 740 * sysinfo. This case cannot occur on 64-bit hardware and thus 741 * does not have to be checked for in binaries with an LP64 data 742 * model. 743 */ 744 if (elf_head.e_machine == EM_SPARC32PLUS) { 745 char buf[257]; /* recommended buffer size from sysinfo man 746 page */ 747 long length; 748 char* location; 749 750 length = sysinfo(SI_ISALIST, buf, 257); 751 if (length > 0) { 752 location = JLI_StrStr(buf, "sparcv8plus "); 753 if (location == NULL) { 754 JLI_ReportErrorMessage(JVM_ERROR3); 755 return JNI_FALSE; 756 } 757 } 758 } 759 #endif 760 JLI_ReportErrorMessage(DLL_ERROR1, __LINE__); 761 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 762 return JNI_FALSE; 763 } 764 765 ifn->CreateJavaVM = (CreateJavaVM_t) 766 dlsym(libjvm, "JNI_CreateJavaVM"); 767 if (ifn->CreateJavaVM == NULL) { 768 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 769 return JNI_FALSE; 770 } 771 772 ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t) 773 dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs"); 774 if (ifn->GetDefaultJavaVMInitArgs == NULL) { 775 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 776 return JNI_FALSE; 777 } 778 779 ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t) 780 dlsym(libjvm, "JNI_GetCreatedJavaVMs"); 781 if (ifn->GetCreatedJavaVMs == NULL) { 782 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 783 return JNI_FALSE; 784 } 785 786 return JNI_TRUE; 787 } 788 789 /* 790 * Compute the name of the executable 791 * 792 * In order to re-exec securely we need the absolute path of the 793 * executable. On Solaris getexecname(3c) may not return an absolute 794 * path so we use dladdr to get the filename of the executable and 795 * then use realpath to derive an absolute path. From Solaris 9 796 * onwards the filename returned in DL_info structure from dladdr is 797 * an absolute pathname so technically realpath isn't required. 798 * On Linux we read the executable name from /proc/self/exe. 799 * As a fallback, and for platforms other than Solaris and Linux, 800 * we use FindExecName to compute the executable name. 801 */ 802 const char* 803 SetExecname(char **argv) 804 { 805 char* exec_path = NULL; 806 #if defined(__solaris__) 807 { 808 Dl_info dlinfo; 809 int (*fptr)(); 810 811 fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); 812 if (fptr == NULL) { 813 JLI_ReportErrorMessage(DLL_ERROR3, dlerror()); 814 return JNI_FALSE; 815 } 816 817 if (dladdr((void*)fptr, &dlinfo)) { 818 char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1); 819 if (resolved != NULL) { 820 exec_path = realpath(dlinfo.dli_fname, resolved); 821 if (exec_path == NULL) { 822 JLI_MemFree(resolved); 823 } 824 } 825 } 826 } 827 #elif defined(__linux__) 828 { 829 const char* self = "/proc/self/exe"; 830 char buf[PATH_MAX+1]; 831 int len = readlink(self, buf, PATH_MAX); 832 if (len >= 0) { 833 buf[len] = '\0'; /* readlink(2) doesn't NUL terminate */ 834 exec_path = JLI_StringDup(buf); 835 } 836 } 837 #else /* !__solaris__ && !__linux__ */ 838 { 839 /* Not implemented */ 840 } 841 #endif 842 843 if (exec_path == NULL) { 844 exec_path = FindExecName(argv[0]); 845 } 846 execname = exec_path; 847 return exec_path; 848 } 849 850 /* --- Splash Screen shared library support --- */ 851 static const char* SPLASHSCREEN_SO = JNI_LIB_NAME("splashscreen"); 852 static void* hSplashLib = NULL; 853 854 void* SplashProcAddress(const char* name) { 855 if (!hSplashLib) { 856 int ret; 857 char jrePath[MAXPATHLEN]; 858 char splashPath[MAXPATHLEN]; 859 860 if (!GetJREPath(jrePath, sizeof(jrePath), LIBARCHNAME, JNI_FALSE)) { 861 JLI_ReportErrorMessage(JRE_ERROR1); 862 return NULL; 863 } 864 ret = JLI_Snprintf(splashPath, sizeof(splashPath), "%s/lib/%s/%s", 865 jrePath, LIBARCHNAME, SPLASHSCREEN_SO); 866 867 if (ret >= (int) sizeof(splashPath)) { 868 JLI_ReportErrorMessage(JRE_ERROR11); 869 return NULL; 870 } 871 if (ret < 0) { 872 JLI_ReportErrorMessage(JRE_ERROR13); 873 return NULL; 874 } 875 hSplashLib = dlopen(splashPath, RTLD_LAZY | RTLD_GLOBAL); 876 JLI_TraceLauncher("Info: loaded %s\n", splashPath); 877 } 878 if (hSplashLib) { 879 void* sym = dlsym(hSplashLib, name); 880 return sym; 881 } else { 882 return NULL; 883 } 884 } 885 886 void SplashFreeLibrary() { 887 if (hSplashLib) { 888 dlclose(hSplashLib); 889 hSplashLib = NULL; 890 } 891 } 892 893 /* 894 * Block current thread and continue execution in a new thread 895 */ 896 int 897 ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) { 898 int rslt; 899 #ifndef __solaris__ 900 pthread_t tid; 901 pthread_attr_t attr; 902 pthread_attr_init(&attr); 903 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 904 905 if (stack_size > 0) { 906 pthread_attr_setstacksize(&attr, stack_size); 907 } 908 909 if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) { 910 void * tmp; 911 pthread_join(tid, &tmp); 912 rslt = (int)(intptr_t)tmp; 913 } else { 914 /* 915 * Continue execution in current thread if for some reason (e.g. out of 916 * memory/LWP) a new thread can't be created. This will likely fail 917 * later in continuation as JNI_CreateJavaVM needs to create quite a 918 * few new threads, anyway, just give it a try.. 919 */ 920 rslt = continuation(args); 921 } 922 923 pthread_attr_destroy(&attr); 924 #else /* __solaris__ */ 925 thread_t tid; 926 long flags = 0; 927 if (thr_create(NULL, stack_size, (void *(*)(void *))continuation, args, flags, &tid) == 0) { 928 void * tmp; 929 thr_join(tid, NULL, &tmp); 930 rslt = (int)(intptr_t)tmp; 931 } else { 932 /* See above. Continue in current thread if thr_create() failed */ 933 rslt = continuation(args); 934 } 935 #endif /* !__solaris__ */ 936 return rslt; 937 } 938 939 /* Coarse estimation of number of digits assuming the worst case is a 64-bit pid. */ 940 #define MAX_PID_STR_SZ 20 941 942 void SetJavaLauncherPlatformProps() { 943 /* Linux only */ 944 #ifdef __linux__ 945 const char *substr = "-Dsun.java.launcher.pid="; 946 char *pid_prop_str = (char *)JLI_MemAlloc(JLI_StrLen(substr) + MAX_PID_STR_SZ + 1); 947 sprintf(pid_prop_str, "%s%d", substr, getpid()); 948 AddOption(pid_prop_str, NULL); 949 #endif /* __linux__ */ 950 } 951 952 int 953 JVMInit(InvocationFunctions* ifn, jlong threadStackSize, 954 int argc, char **argv, 955 int mode, char *what, int ret) 956 { 957 ShowSplashScreen(); 958 return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); 959 } 960 961 void 962 PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) 963 { 964 // stubbed out for windows and *nixes. 965 } 966 967 void 968 RegisterThread() 969 { 970 // stubbed out for windows and *nixes. 971 } 972 973 /* 974 * on unix, we return a false to indicate this option is not applicable 975 */ 976 jboolean 977 ProcessPlatformOption(const char *arg) 978 { 979 return JNI_FALSE; 980 }