1 /*
2 * Copyright (c) 2012, 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 <sys/time.h>
39
40 #include "manifest_info.h"
41
42 /* Support Cocoa event loop on the main thread */
43 #include <Cocoa/Cocoa.h>
44 #include <objc/objc-runtime.h>
45 #include <objc/objc-auto.h>
46
47 #include <errno.h>
48 #include <spawn.h>
49
50 struct NSAppArgs {
51 int argc;
52 char **argv;
53 };
54
55 #define JVM_DLL "libjvm.dylib"
56 #define JAVA_DLL "libjava.dylib"
57 /* FALLBACK avoids naming conflicts with system libraries
58 * (eg, ImageIO's libJPEG.dylib) */
59 #define LD_LIBRARY_PATH "DYLD_FALLBACK_LIBRARY_PATH"
60
61 /*
62 * If a processor / os combination has the ability to run binaries of
63 * two data models and cohabitation of jre/jdk bits with both data
64 * models is supported, then DUAL_MODE is defined. MacOSX is a hybrid
65 * system in that, the universal library can contain all types of libraries
66 * 32/64 and client/server, thus the spawn is capable of linking with the
67 * appropriate library as requested.
68 *
69 * Notes:
70 * 1. VM. DUAL_MODE is disabled, and not supported, however, it is left here in
71 * for experimentation and perhaps enable it in the future.
72 * 2. At the time of this writing, the universal library contains only
73 * a server 64-bit server JVM.
74 * 3. "-client" command line option is supported merely as a command line flag,
75 * for, compatibility reasons, however, a server VM will be launched.
76 */
77
78 /*
79 * Flowchart of launcher execs and options processing on unix
80 *
81 * The selection of the proper vm shared library to open depends on
82 * several classes of command line options, including vm "flavor"
83 * options (-client, -server) and the data model options, -d32 and
84 * -d64, as well as a version specification which may have come from
85 * the command line or from the manifest of an executable jar file.
86 * The vm selection options are not passed to the running
87 * virtual machine; they must be screened out by the launcher.
88 *
89 * The version specification (if any) is processed first by the
90 * platform independent routine SelectVersion. This may result in
91 * the exec of the specified launcher version.
92 *
93 * Now, in most cases,the launcher will dlopen the target libjvm.so. All
94 * required libraries are loaded by the runtime linker, using the known paths
95 * baked into the shared libraries at compile time. Therefore,
96 * in most cases, the launcher will only exec, if the data models are
97 * mismatched, and will not set any environment variables, regardless of the
98 * data models.
99 *
100 *
101 *
102 * Main
103 * (incoming argv)
104 * |
105 * \|/
106 * CreateExecutionEnvironment
107 * (determines desired data model)
108 * |
109 * |
110 * \|/
111 * Have Desired Model ? --> NO --> Is Dual-Mode ? --> NO --> Exit(with error)
112 * | |
113 * | |
114 * | \|/
115 * | YES
116 * | |
117 * | |
118 * | \|/
119 * | CheckJvmType
120 * | (removes -client, -server etc.)
121 * | |
122 * | |
123 * \|/ \|/
124 * YES Find the desired executable/library
125 * | |
126 * | |
127 * \|/ \|/
128 * CheckJvmType POINT A
129 * (removes -client, -server, etc.)
130 * |
131 * |
132 * \|/
133 * TranslateDashJArgs...
134 * (Prepare to pass args to vm)
135 * |
136 * |
137 * \|/
138 * ParseArguments
139 * (removes -d32 and -d64 if any,
140 * processes version options,
141 * creates argument list for vm,
142 * etc.)
143 * |
144 * |
145 * \|/
146 * POINT A
147 * |
148 * |
149 * \|/
150 * Path is desired JRE ? YES --> Have Desired Model ? NO --> Re-exec --> Main
151 * NO YES --> Continue
152 * |
153 * |
154 * \|/
155 * Paths have well known
156 * jvm paths ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
157 * YES YES --> Continue
158 * |
159 * |
160 * \|/
161 * Does libjvm.so exist
162 * in any of them ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
163 * YES YES --> Continue
164 * |
165 * |
166 * \|/
167 * Re-exec / Spawn
168 * |
169 * |
170 * \|/
171 * Main
172 */
173
174 /* Store the name of the executable once computed */
175 static char *execname = NULL;
176
177 /*
178 * execname accessor from other parts of platform dependent logic
179 */
180 const char *
181 GetExecName() {
182 return execname;
183 }
184
185 /*
186 * Exports the JNI interface from libjli
187 *
188 * This allows client code to link against the .jre/.jdk bundles,
189 * and not worry about trying to pick a HotSpot to link against.
190 *
191 * Switching architectures is unsupported, since client code has
192 * made that choice before the JVM was requested.
193 */
194
195 static InvocationFunctions *sExportedJNIFunctions = NULL;
196 static char *sPreferredJVMType = NULL;
197
198 static InvocationFunctions *GetExportedJNIFunctions() {
199 if (sExportedJNIFunctions != NULL) return sExportedJNIFunctions;
200
201 char jrePath[PATH_MAX];
202 jboolean gotJREPath = GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE);
203 if (!gotJREPath) {
204 JLI_ReportErrorMessage("Failed to GetJREPath()");
205 return NULL;
206 }
207
208 char *preferredJVM = sPreferredJVMType;
209 if (preferredJVM == NULL) {
210 #if defined(__i386__)
211 preferredJVM = "client";
212 #elif defined(__x86_64__)
213 preferredJVM = "server";
214 #else
215 #error "Unknown architecture - needs definition"
216 #endif
217 }
218
219 char jvmPath[PATH_MAX];
220 jboolean gotJVMPath = GetJVMPath(jrePath, preferredJVM, jvmPath, sizeof(jvmPath), CURRENT_DATA_MODEL);
221 if (!gotJVMPath) {
222 JLI_ReportErrorMessage("Failed to GetJVMPath()");
223 return NULL;
224 }
225
226 InvocationFunctions *fxns = malloc(sizeof(InvocationFunctions));
227 jboolean vmLoaded = LoadJavaVM(jvmPath, fxns);
228 if (!vmLoaded) {
229 JLI_ReportErrorMessage("Failed to LoadJavaVM()");
230 return NULL;
231 }
232
233 return sExportedJNIFunctions = fxns;
234 }
235
236 #ifndef STATIC_BUILD
237
238 JNIEXPORT jint JNICALL
239 JNI_GetDefaultJavaVMInitArgs(void *args) {
240 InvocationFunctions *ifn = GetExportedJNIFunctions();
241 if (ifn == NULL) return JNI_ERR;
242 return ifn->GetDefaultJavaVMInitArgs(args);
243 }
244
245 JNIEXPORT jint JNICALL
246 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) {
247 InvocationFunctions *ifn = GetExportedJNIFunctions();
248 if (ifn == NULL) return JNI_ERR;
249 return ifn->CreateJavaVM(pvm, penv, args);
250 }
251
252 JNIEXPORT jint JNICALL
253 JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs) {
254 InvocationFunctions *ifn = GetExportedJNIFunctions();
255 if (ifn == NULL) return JNI_ERR;
256 return ifn->GetCreatedJavaVMs(vmBuf, bufLen, nVMs);
257 }
258 #endif
259
260 /*
261 * Allow JLI-aware launchers to specify a client/server preference
262 */
263 JNIEXPORT void JNICALL
264 JLI_SetPreferredJVM(const char *prefJVM) {
265 if (sPreferredJVMType != NULL) {
266 free(sPreferredJVMType);
267 sPreferredJVMType = NULL;
268 }
269
270 if (prefJVM == NULL) return;
271 sPreferredJVMType = strdup(prefJVM);
272 }
273
274 static BOOL awtLoaded = NO;
275 static pthread_mutex_t awtLoaded_mutex = PTHREAD_MUTEX_INITIALIZER;
276 static pthread_cond_t awtLoaded_cv = PTHREAD_COND_INITIALIZER;
277
278 JNIEXPORT void JNICALL
279 JLI_NotifyAWTLoaded()
280 {
281 pthread_mutex_lock(&awtLoaded_mutex);
282 awtLoaded = YES;
283 pthread_cond_signal(&awtLoaded_cv);
284 pthread_mutex_unlock(&awtLoaded_mutex);
285 }
286
287 static int (*main_fptr)(int argc, char **argv) = NULL;
288
289 /*
290 * Unwrap the arguments and re-run main()
291 */
292 static void *apple_main (void *arg)
293 {
294 objc_registerThreadWithCollector();
295
296 if (main_fptr == NULL) {
297 #ifdef STATIC_BUILD
298 extern int main(int argc, char **argv);
299 main_fptr = &main;
300 #else
301 main_fptr = (int (*)())dlsym(RTLD_DEFAULT, "main");
302 #endif
303 if (main_fptr == NULL) {
304 JLI_ReportErrorMessageSys("error locating main entrypoint\n");
305 exit(1);
306 }
307 }
308
309 struct NSAppArgs *args = (struct NSAppArgs *) arg;
310 exit(main_fptr(args->argc, args->argv));
311 }
312
313 static void dummyTimer(CFRunLoopTimerRef timer, void *info) {}
314
315 static void ParkEventLoop() {
316 // RunLoop needs at least one source, and 1e20 is pretty far into the future
317 CFRunLoopTimerRef t = CFRunLoopTimerCreate(kCFAllocatorDefault, 1.0e20, 0.0, 0, 0, dummyTimer, NULL);
318 CFRunLoopAddTimer(CFRunLoopGetCurrent(), t, kCFRunLoopDefaultMode);
319 CFRelease(t);
320
321 // Park this thread in the main run loop.
322 int32_t result;
323 do {
324 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, false);
325 } while (result != kCFRunLoopRunFinished);
326 }
327
328 /*
329 * Mac OS X mandates that the GUI event loop run on very first thread of
330 * an application. This requires that we re-call Java's main() on a new
331 * thread, reserving the 'main' thread for Cocoa.
332 */
333 static void MacOSXStartup(int argc, char *argv[]) {
334 // Thread already started?
335 static jboolean started = false;
336 if (started) {
337 return;
338 }
339 started = true;
340
341 // Hand off arguments
342 struct NSAppArgs args;
343 args.argc = argc;
344 args.argv = argv;
345
346 // Fire up the main thread
347 pthread_t main_thr;
348 if (pthread_create(&main_thr, NULL, &apple_main, &args) != 0) {
349 JLI_ReportErrorMessageSys("Could not create main thread: %s\n", strerror(errno));
350 exit(1);
351 }
352 if (pthread_detach(main_thr)) {
353 JLI_ReportErrorMessageSys("pthread_detach() failed: %s\n", strerror(errno));
354 exit(1);
355 }
356
357 ParkEventLoop();
358 }
359
360 void
361 CreateExecutionEnvironment(int *pargc, char ***pargv,
362 char jrepath[], jint so_jrepath,
363 char jvmpath[], jint so_jvmpath,
364 char jvmcfg[], jint so_jvmcfg) {
365 /*
366 * First, determine if we are running the desired data model. If we
367 * are running the desired data model, all the error messages
368 * associated with calling GetJREPath, ReadKnownVMs, etc. should be
369 * output. However, if we are not running the desired data model,
370 * some of the errors should be suppressed since it is more
371 * informative to issue an error message based on whether or not the
372 * os/processor combination has dual mode capabilities.
373 */
374 jboolean jvmpathExists;
375
376 /* Compute/set the name of the executable */
377 SetExecname(*pargv);
378
379 /* Check data model flags, and exec process, if needed */
380 {
381 char * jvmtype = NULL;
382 int argc = *pargc;
383 char **argv = *pargv;
384 int running = CURRENT_DATA_MODEL;
385
386 int wanted = running; /* What data mode is being
387 asked for? Current model is
388 fine unless another model
389 is asked for */
390
391 char** newargv = NULL;
392 int newargc = 0;
393
394 /*
395 * Starting in 1.5, all unix platforms accept the -d32 and -d64
396 * options. On platforms where only one data-model is supported
397 * (e.g. ia-64 Linux), using the flag for the other data model is
398 * an error and will terminate the program.
399 */
400
401 { /* open new scope to declare local variables */
402 int i;
403
404 newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(char*));
405 newargv[newargc++] = argv[0];
406
407 /* scan for data model arguments and remove from argument list;
408 last occurrence determines desired data model */
409 for (i=1; i < argc; i++) {
410
411 if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) {
412 wanted = 64;
413 continue;
414 }
415 if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) {
416 wanted = 32;
417 continue;
418 }
419 newargv[newargc++] = argv[i];
420
421 if (IsJavaArgs()) {
422 if (argv[i][0] != '-') continue;
423 } else {
424 if (JLI_StrCmp(argv[i], "-classpath") == 0 || JLI_StrCmp(argv[i], "-cp") == 0) {
425 i++;
426 if (i >= argc) break;
427 newargv[newargc++] = argv[i];
428 continue;
429 }
430 if (argv[i][0] != '-') { i++; break; }
431 }
432 }
433
434 /* copy rest of args [i .. argc) */
435 while (i < argc) {
436 newargv[newargc++] = argv[i++];
437 }
438 newargv[newargc] = NULL;
439
440 /*
441 * newargv has all proper arguments here
442 */
443
444 argc = newargc;
445 argv = newargv;
446 }
447
448 /* If the data model is not changing, it is an error if the
449 jvmpath does not exist */
450 if (wanted == running) {
451 /* Find out where the JRE is that we will be using. */
452 if (!GetJREPath(jrepath, so_jrepath, JNI_FALSE) ) {
453 JLI_ReportErrorMessage(JRE_ERROR1);
454 exit(2);
455 }
456 JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg",
457 jrepath, FILESEP, FILESEP, "", "");
458 /* Find the specified JVM type */
459 if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) {
460 JLI_ReportErrorMessage(CFG_ERROR7);
461 exit(1);
462 }
463
464 jvmpath[0] = '\0';
465 jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE);
466 if (JLI_StrCmp(jvmtype, "ERROR") == 0) {
467 JLI_ReportErrorMessage(CFG_ERROR9);
468 exit(4);
469 }
470
471 if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, wanted)) {
472 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath);
473 exit(4);
474 }
475
476 /*
477 * Mac OS X requires the Cocoa event loop to be run on the "main"
478 * thread. Spawn off a new thread to run main() and pass
479 * this thread off to the Cocoa event loop.
480 */
481 MacOSXStartup(argc, argv);
482
483 /*
484 * we seem to have everything we need, so without further ado
485 * we return back, otherwise proceed to set the environment.
486 */
487 return;
488 } else { /* do the same speculatively or exit */
489 #if defined(DUAL_MODE)
490 if (running != wanted) {
491 /* Find out where the JRE is that we will be using. */
492 if (!GetJREPath(jrepath, so_jrepath, JNI_TRUE)) {
493 /* give up and let other code report error message */
494 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
495 exit(1);
496 }
497 JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg",
498 jrepath, FILESEP, FILESEP, "", "");
499 /*
500 * Read in jvm.cfg for target data model and process vm
501 * selection options.
502 */
503 if (ReadKnownVMs(jvmcfg, JNI_TRUE) < 1) {
504 /* give up and let other code report error message */
505 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
506 exit(1);
507 }
508 jvmpath[0] = '\0';
509 jvmtype = CheckJvmType(pargc, pargv, JNI_TRUE);
510 if (JLI_StrCmp(jvmtype, "ERROR") == 0) {
511 JLI_ReportErrorMessage(CFG_ERROR9);
512 exit(4);
513 }
514
515 /* exec child can do error checking on the existence of the path */
516 jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, wanted);
517 }
518 #else /* ! DUAL_MODE */
519 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
520 exit(1);
521 #endif /* DUAL_MODE */
522 }
523 {
524 char *newexec = execname;
525 JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n");
526 (void) fflush(stdout);
527 (void) fflush(stderr);
528 /*
529 * Use posix_spawn() instead of execv() on Mac OS X.
530 * This allows us to choose which architecture the child process
531 * should run as.
532 */
533 {
534 posix_spawnattr_t attr;
535 size_t unused_size;
536 pid_t unused_pid;
537
538 #if defined(__i386__) || defined(__x86_64__)
539 cpu_type_t cpu_type[] = { (wanted == 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86,
540 (running== 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86 };
541 #else
542 cpu_type_t cpu_type[] = { CPU_TYPE_ANY };
543 #endif /* __i386 .. */
544
545 posix_spawnattr_init(&attr);
546 posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETEXEC);
547 posix_spawnattr_setbinpref_np(&attr, sizeof(cpu_type) / sizeof(cpu_type_t),
548 cpu_type, &unused_size);
549
550 posix_spawn(&unused_pid, newexec, NULL, &attr, argv, environ);
551 }
552 JLI_ReportErrorMessageSys(JRE_ERROR4, newexec);
553
554 #if defined(DUAL_MODE)
555 if (running != wanted) {
556 JLI_ReportErrorMessage(JRE_ERROR5, wanted, running);
557 }
558 #endif /* DUAL_MODE */
559 }
560 exit(1);
561 }
562 }
563
564 /*
565 * VM choosing is done by the launcher (java.c).
566 */
567 static jboolean
568 GetJVMPath(const char *jrepath, const char *jvmtype,
569 char *jvmpath, jint jvmpathsize, int bitsWanted)
570 {
571 struct stat s;
572
573 if (JLI_StrChr(jvmtype, '/')) {
574 JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype);
575 } else {
576 /*
577 * macosx client library is built thin, i386 only.
578 * 64 bit client requests must load server library
579 */
580 const char *jvmtypeUsed = ((bitsWanted == 64) && (strcmp(jvmtype, "client") == 0)) ? "server" : jvmtype;
581 JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/" JVM_DLL, jrepath, jvmtypeUsed);
582 }
583
584 JLI_TraceLauncher("Does `%s' exist ... ", jvmpath);
585
586 #ifdef STATIC_BUILD
587 return JNI_TRUE;
588 #else
589 if (stat(jvmpath, &s) == 0) {
590 JLI_TraceLauncher("yes.\n");
591 return JNI_TRUE;
592 } else {
593 JLI_TraceLauncher("no.\n");
594 return JNI_FALSE;
595 }
596 #endif
597 }
598
599 /*
600 * Find path to JRE based on .exe's location or registry settings.
601 */
602 static jboolean
603 GetJREPath(char *path, jint pathsize, jboolean speculative)
604 {
605 char libjava[MAXPATHLEN];
606
607 if (GetApplicationHome(path, pathsize)) {
608 /* Is JRE co-located with the application? */
609 #ifdef STATIC_BUILD
610 char jvm_cfg[MAXPATHLEN];
611 JLI_Snprintf(jvm_cfg, sizeof(jvm_cfg), "%s/lib/jvm.cfg", path);
612 if (access(jvm_cfg, F_OK) == 0) {
613 return JNI_TRUE;
614 }
615 #else
616 JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path);
617 if (access(libjava, F_OK) == 0) {
618 return JNI_TRUE;
619 }
620 #endif
621 /* ensure storage for path + /jre + NULL */
622 if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) {
623 JLI_TraceLauncher("Insufficient space to store JRE path\n");
624 return JNI_FALSE;
625 }
626 /* Does the app ship a private JRE in <apphome>/jre directory? */
627 JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/" JAVA_DLL, path);
628 if (access(libjava, F_OK) == 0) {
629 JLI_StrCat(path, "/jre");
630 JLI_TraceLauncher("JRE path is %s\n", path);
631 return JNI_TRUE;
632 }
633 }
634
635 /* try to find ourselves instead */
636 Dl_info selfInfo;
637 dladdr(&GetJREPath, &selfInfo);
638
639 #ifdef STATIC_BUILD
640 char jvm_cfg[MAXPATHLEN];
641 char *p = NULL;
642 strncpy(jvm_cfg, selfInfo.dli_fname, MAXPATHLEN);
643 p = strrchr(jvm_cfg, '/'); *p = '\0';
644 p = strrchr(jvm_cfg, '/');
645 if (strcmp(p, "/.") == 0) {
646 *p = '\0';
647 p = strrchr(jvm_cfg, '/'); *p = '\0';
648 }
649 else *p = '\0';
650 strncpy(path, jvm_cfg, pathsize);
651 strncat(jvm_cfg, "/lib/jvm.cfg", MAXPATHLEN);
652 if (access(jvm_cfg, F_OK) == 0) {
653 return JNI_TRUE;
654 }
655 #endif
656
657 char *realPathToSelf = realpath(selfInfo.dli_fname, path);
658 if (realPathToSelf != path) {
659 return JNI_FALSE;
660 }
661
662 size_t pathLen = strlen(realPathToSelf);
663 if (pathLen == 0) {
664 return JNI_FALSE;
665 }
666
667 const char lastPathComponent[] = "/lib/jli/libjli.dylib";
668 size_t sizeOfLastPathComponent = sizeof(lastPathComponent) - 1;
669 if (pathLen < sizeOfLastPathComponent) {
670 return JNI_FALSE;
671 }
672
673 size_t indexOfLastPathComponent = pathLen - sizeOfLastPathComponent;
674 if (0 == strncmp(realPathToSelf + indexOfLastPathComponent, lastPathComponent, sizeOfLastPathComponent - 1)) {
675 realPathToSelf[indexOfLastPathComponent + 1] = '\0';
676 return JNI_TRUE;
677 }
678
679 if (!speculative)
680 JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL);
681 return JNI_FALSE;
682 }
683
684 jboolean
685 LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
686 {
687 Dl_info dlinfo;
688 void *libjvm;
689
690 JLI_TraceLauncher("JVM path is %s\n", jvmpath);
691
692 #ifndef STATIC_BUILD
693 libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);
694 #else
695 libjvm = dlopen(NULL, RTLD_FIRST);
696 #endif
697 if (libjvm == NULL) {
698 JLI_ReportErrorMessage(DLL_ERROR1, __LINE__);
699 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
700 return JNI_FALSE;
701 }
702
703 ifn->CreateJavaVM = (CreateJavaVM_t)
704 dlsym(libjvm, "JNI_CreateJavaVM");
705 if (ifn->CreateJavaVM == NULL) {
706 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
707 return JNI_FALSE;
708 }
709
710 ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)
711 dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");
712 if (ifn->GetDefaultJavaVMInitArgs == NULL) {
713 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
714 return JNI_FALSE;
715 }
716
717 ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t)
718 dlsym(libjvm, "JNI_GetCreatedJavaVMs");
719 if (ifn->GetCreatedJavaVMs == NULL) {
720 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
721 return JNI_FALSE;
722 }
723
724 return JNI_TRUE;
725 }
726
727 /*
728 * Compute the name of the executable
729 *
730 * In order to re-exec securely we need the absolute path of the
731 * executable. On Solaris getexecname(3c) may not return an absolute
732 * path so we use dladdr to get the filename of the executable and
733 * then use realpath to derive an absolute path. From Solaris 9
734 * onwards the filename returned in DL_info structure from dladdr is
735 * an absolute pathname so technically realpath isn't required.
736 * On Linux we read the executable name from /proc/self/exe.
737 * As a fallback, and for platforms other than Solaris and Linux,
738 * we use FindExecName to compute the executable name.
739 */
740 const char*
741 SetExecname(char **argv)
742 {
743 char* exec_path = NULL;
744 {
745 Dl_info dlinfo;
746
747 #ifdef STATIC_BUILD
748 void *fptr;
749 fptr = (void *)&SetExecname;
750 #else
751 int (*fptr)();
752 fptr = (int (*)())dlsym(RTLD_DEFAULT, "main");
753 #endif
754 if (fptr == NULL) {
755 JLI_ReportErrorMessage(DLL_ERROR3, dlerror());
756 return JNI_FALSE;
757 }
758
759 if (dladdr((void*)fptr, &dlinfo)) {
760 char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1);
761 if (resolved != NULL) {
762 exec_path = realpath(dlinfo.dli_fname, resolved);
763 if (exec_path == NULL) {
764 JLI_MemFree(resolved);
765 }
766 }
767 }
768 }
769 if (exec_path == NULL) {
770 exec_path = FindExecName(argv[0]);
771 }
772 execname = exec_path;
773 return exec_path;
774 }
775
776 /*
777 * BSD's implementation of CounterGet()
778 */
779 int64_t
780 CounterGet()
781 {
782 struct timeval tv;
783 gettimeofday(&tv, NULL);
784 return (tv.tv_sec * 1000) + tv.tv_usec;
785 }
786
787
788 /* --- Splash Screen shared library support --- */
789
790 static JavaVM* SetJavaVMValue()
791 {
792 JavaVM * jvm = NULL;
793
794 // The handle is good for both the launcher and the libosxapp.dylib
795 void * handle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
796 if (handle) {
797 typedef JavaVM* (*JLI_GetJavaVMInstance_t)();
798
799 JLI_GetJavaVMInstance_t JLI_GetJavaVMInstance =
800 (JLI_GetJavaVMInstance_t)dlsym(handle,
801 "JLI_GetJavaVMInstance");
802 if (JLI_GetJavaVMInstance) {
803 jvm = JLI_GetJavaVMInstance();
804 }
805
806 if (jvm) {
807 typedef void (*OSXAPP_SetJavaVM_t)(JavaVM*);
808
809 OSXAPP_SetJavaVM_t OSXAPP_SetJavaVM =
810 (OSXAPP_SetJavaVM_t)dlsym(handle, "OSXAPP_SetJavaVM");
811 if (OSXAPP_SetJavaVM) {
812 OSXAPP_SetJavaVM(jvm);
813 } else {
814 jvm = NULL;
815 }
816 }
817
818 dlclose(handle);
819 }
820
821 return jvm;
822 }
823
824 static const char* SPLASHSCREEN_SO = JNI_LIB_NAME("splashscreen");
825
826 static void* hSplashLib = NULL;
827
828 void* SplashProcAddress(const char* name) {
829 if (!hSplashLib) {
830 char jrePath[PATH_MAX];
831 if (!GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE)) {
832 JLI_ReportErrorMessage(JRE_ERROR1);
833 return NULL;
834 }
835
836 char splashPath[PATH_MAX];
837 const int ret = JLI_Snprintf(splashPath, sizeof(splashPath),
838 "%s/lib/%s", jrePath, SPLASHSCREEN_SO);
839 if (ret >= (int)sizeof(splashPath)) {
840 JLI_ReportErrorMessage(JRE_ERROR11);
841 return NULL;
842 }
843 if (ret < 0) {
844 JLI_ReportErrorMessage(JRE_ERROR13);
845 return NULL;
846 }
847
848 hSplashLib = dlopen(splashPath, RTLD_LAZY | RTLD_GLOBAL);
849 // It's OK if dlopen() fails. The splash screen library binary file
850 // might have been stripped out from the JRE image to reduce its size
851 // (e.g. on embedded platforms).
852
853 if (hSplashLib) {
854 if (!SetJavaVMValue()) {
855 dlclose(hSplashLib);
856 hSplashLib = NULL;
857 }
858 }
859 }
860 if (hSplashLib) {
861 void* sym = dlsym(hSplashLib, name);
862 return sym;
863 } else {
864 return NULL;
865 }
866 }
867
868 void SplashFreeLibrary() {
869 if (hSplashLib) {
870 dlclose(hSplashLib);
871 hSplashLib = NULL;
872 }
873 }
874
875 /*
876 * Block current thread and continue execution in a new thread
877 */
878 int
879 ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
880 int rslt;
881 pthread_t tid;
882 pthread_attr_t attr;
883 pthread_attr_init(&attr);
884 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
885
886 if (stack_size > 0) {
887 pthread_attr_setstacksize(&attr, stack_size);
888 }
889
890 if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
891 void * tmp;
892 pthread_join(tid, &tmp);
893 rslt = (int)(intptr_t)tmp;
894 } else {
895 /*
896 * Continue execution in current thread if for some reason (e.g. out of
897 * memory/LWP) a new thread can't be created. This will likely fail
898 * later in continuation as JNI_CreateJavaVM needs to create quite a
899 * few new threads, anyway, just give it a try..
900 */
901 rslt = continuation(args);
902 }
903
904 pthread_attr_destroy(&attr);
905 return rslt;
906 }
907
908 void SetJavaLauncherPlatformProps() {
909 /* Linux only */
910 }
911
912 static JavaVM* jvmInstance = NULL;
913 static jboolean sameThread = JNI_FALSE; /* start VM in current thread */
914
915 /*
916 * Note there is a callback on this function from the splashscreen logic,
917 * this as well SetJavaVMValue() needs to be simplified.
918 */
919 JavaVM*
920 JLI_GetJavaVMInstance()
921 {
922 return jvmInstance;
923 }
924
925 void
926 RegisterThread()
927 {
928 objc_registerThreadWithCollector();
929 }
930
931 static void
932 SetXDockArgForAWT(const char *arg)
933 {
934 char envVar[80];
935 if (strstr(arg, "-Xdock:name=") == arg) {
936 /*
937 * The APP_NAME_<pid> environment variable is used to pass
938 * an application name as specified with the -Xdock:name command
939 * line option from Java launcher code to the AWT code in order
940 * to assign this name to the app's dock tile on the Mac.
941 * The _<pid> part is added to avoid collisions with child processes.
942 *
943 * WARNING: This environment variable is an implementation detail and
944 * isn't meant for use outside of the core platform. The mechanism for
945 * passing this information from Java launcher to other modules may
946 * change drastically between update release, and it may even be
947 * removed or replaced with another mechanism.
948 *
949 * NOTE: It is used by SWT, and JavaFX.
950 */
951 snprintf(envVar, sizeof(envVar), "APP_NAME_%d", getpid());
952 setenv(envVar, (arg + 12), 1);
953 }
954
955 if (strstr(arg, "-Xdock:icon=") == arg) {
956 /*
957 * The APP_ICON_<pid> environment variable is used to pass
958 * an application icon as specified with the -Xdock:icon command
959 * line option from Java launcher code to the AWT code in order
960 * to assign this icon to the app's dock tile on the Mac.
961 * The _<pid> part is added to avoid collisions with child processes.
962 *
963 * WARNING: This environment variable is an implementation detail and
964 * isn't meant for use outside of the core platform. The mechanism for
965 * passing this information from Java launcher to other modules may
966 * change drastically between update release, and it may even be
967 * removed or replaced with another mechanism.
968 *
969 * NOTE: It is used by SWT, and JavaFX.
970 */
971 snprintf(envVar, sizeof(envVar), "APP_ICON_%d", getpid());
972 setenv(envVar, (arg + 12), 1);
973 }
974 }
975
976 static void
977 SetMainClassForAWT(JNIEnv *env, jclass mainClass) {
978 jclass classClass = NULL;
979 NULL_CHECK(classClass = FindBootStrapClass(env, "java/lang/Class"));
980
981 jmethodID getCanonicalNameMID = NULL;
982 NULL_CHECK(getCanonicalNameMID = (*env)->GetMethodID(env, classClass, "getCanonicalName", "()Ljava/lang/String;"));
983
984 jstring mainClassString = (*env)->CallObjectMethod(env, mainClass, getCanonicalNameMID);
985 if ((*env)->ExceptionCheck(env)) {
986 /*
987 * Clears all errors caused by getCanonicalName() on the mainclass and
988 * leaves the JAVA_MAIN_CLASS__<pid> empty.
989 */
990 (*env)->ExceptionClear(env);
991 return;
992 }
993
994 const char *mainClassName = NULL;
995 NULL_CHECK(mainClassName = (*env)->GetStringUTFChars(env, mainClassString, NULL));
996
997 char envVar[80];
998 /*
999 * The JAVA_MAIN_CLASS_<pid> environment variable is used to pass
1000 * the name of a Java class whose main() method is invoked by
1001 * the Java launcher code to start the application, to the AWT code
1002 * in order to assign the name to the Apple menu bar when the app
1003 * is active on the Mac.
1004 * The _<pid> part is added to avoid collisions with child processes.
1005 *
1006 * WARNING: This environment variable is an implementation detail and
1007 * isn't meant for use outside of the core platform. The mechanism for
1008 * passing this information from Java launcher to other modules may
1009 * change drastically between update release, and it may even be
1010 * removed or replaced with another mechanism.
1011 *
1012 * NOTE: It is used by SWT, and JavaFX.
1013 */
1014 snprintf(envVar, sizeof(envVar), "JAVA_MAIN_CLASS_%d", getpid());
1015 setenv(envVar, mainClassName, 1);
1016
1017 (*env)->ReleaseStringUTFChars(env, mainClassString, mainClassName);
1018 }
1019
1020 void
1021 SetXStartOnFirstThreadArg()
1022 {
1023 // XXX: BEGIN HACK
1024 // short circuit hack for <https://bugs.eclipse.org/bugs/show_bug.cgi?id=211625>
1025 // need a way to get AWT/Swing apps launched when spawned from Eclipse,
1026 // which currently has no UI to not pass the -XstartOnFirstThread option
1027 if (getenv("HACK_IGNORE_START_ON_FIRST_THREAD") != NULL) return;
1028 // XXX: END HACK
1029
1030 sameThread = JNI_TRUE;
1031 // Set a variable that tells us we started on the main thread.
1032 // This is used by the AWT during startup. (See LWCToolkit.m)
1033 char envVar[80];
1034 snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid());
1035 setenv(envVar, "1", 1);
1036 }
1037
1038 // MacOSX we may continue in the same thread
1039 int
1040 JVMInit(InvocationFunctions* ifn, jlong threadStackSize,
1041 int argc, char **argv,
1042 int mode, char *what, int ret) {
1043 if (sameThread) {
1044 JLI_TraceLauncher("In same thread\n");
1045 // need to block this thread against the main thread
1046 // so signals get caught correctly
1047 __block int rslt = 0;
1048 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
1049 {
1050 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock: ^{
1051 JavaMainArgs args;
1052 args.argc = argc;
1053 args.argv = argv;
1054 args.mode = mode;
1055 args.what = what;
1056 args.ifn = *ifn;
1057 rslt = JavaMain(&args);
1058 }];
1059
1060 /*
1061 * We cannot use dispatch_sync here, because it blocks the main dispatch queue.
1062 * Using the main NSRunLoop allows the dispatch queue to run properly once
1063 * SWT (or whatever toolkit this is needed for) kicks off it's own NSRunLoop
1064 * and starts running.
1065 */
1066 [op performSelectorOnMainThread:@selector(start) withObject:nil waitUntilDone:YES];
1067 }
1068 [pool drain];
1069 return rslt;
1070 } else {
1071 return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret);
1072 }
1073 }
1074
1075 /*
1076 * Note the jvmInstance must be initialized first before entering into
1077 * ShowSplashScreen, as there is a callback into the JLI_GetJavaVMInstance.
1078 */
1079 void PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) {
1080 jvmInstance = vm;
1081 SetMainClassForAWT(env, mainClass);
1082 CHECK_EXCEPTION_RETURN();
1083 ShowSplashScreen();
1084 }
1085
1086 jboolean
1087 ProcessPlatformOption(const char* arg)
1088 {
1089 if (JLI_StrCmp(arg, "-XstartOnFirstThread") == 0) {
1090 SetXStartOnFirstThreadArg();
1091 return JNI_TRUE;
1092 } else if (JLI_StrCCmp(arg, "-Xdock:") == 0) {
1093 SetXDockArgForAWT(arg);
1094 return JNI_TRUE;
1095 }
1096 // arguments we know not
1097 return JNI_FALSE;
1098 }