1 /*
2 * Copyright (c) 1998, 2011, 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 <dirent.h>
28 #include <dlfcn.h>
29 #include <fcntl.h>
30 #include <inttypes.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <stdlib.h>
34 #include <sys/stat.h>
35 #include <unistd.h>
36 #include <sys/types.h>
37 #include "manifest_info.h"
38 #include "version_comp.h"
39
40 #ifdef __linux__
41 #include <pthread.h>
42 #else
43 #include <thread.h>
44 #endif
45
46 #define JVM_DLL "libjvm.so"
47 #define JAVA_DLL "libjava.so"
48
49 /* help jettison the LD_LIBRARY_PATH settings in the future */
50 #ifndef SETENV_REQUIRED
51 #define SETENV_REQUIRED
52 #endif
53 /*
54 * If a processor / os combination has the ability to run binaries of
55 * two data models and cohabitation of jre/jdk bits with both data
56 * models is supported, then DUAL_MODE is defined. When DUAL_MODE is
57 * defined, the architecture names for the narrow and wide version of
58 * the architecture are defined in LIBARCH64NAME and LIBARCH32NAME.
59 * Currently only Solaris on sparc/sparcv9 and i586/amd64 is DUAL_MODE;
60 * linux i586/amd64 could be defined as DUAL_MODE but that is not the
61 * current policy.
62 */
63
64 #ifdef __solaris__
65 # define DUAL_MODE
66 # ifndef LIBARCH32NAME
67 # error "The macro LIBARCH32NAME was not defined on the compile line"
68 # endif
69 # ifndef LIBARCH64NAME
70 # error "The macro LIBARCH64NAME was not defined on the compile line"
71 # endif
72 # include <sys/systeminfo.h>
73 # include <sys/elf.h>
74 # include <stdio.h>
75 #endif
76
77 /* pointer to environment */
78 extern char **environ;
79
80 /*
81 * A collection of useful strings. One should think of these as #define
82 * entries, but actual strings can be more efficient (with many compilers).
83 */
84 #ifdef __linux__
85 static const char *system_dir = "/usr/java";
86 static const char *user_dir = "/java";
87 #else /* Solaris */
88 static const char *system_dir = "/usr/jdk";
89 static const char *user_dir = "/jdk";
90 #endif
91
92 /* Store the name of the executable once computed */
93 static char *execname = NULL;
94
95 /*
96 * Flowchart of launcher execs and options processing on unix
97 *
98 * The selection of the proper vm shared library to open depends on
99 * several classes of command line options, including vm "flavor"
100 * options (-client, -server) and the data model options, -d32 and
101 * -d64, as well as a version specification which may have come from
102 * the command line or from the manifest of an executable jar file.
103 * The vm selection options are not passed to the running
104 * virtual machine; they must be screened out by the launcher.
105 *
106 * The version specification (if any) is processed first by the
107 * platform independent routine SelectVersion. This may result in
108 * the exec of the specified launcher version.
109 *
110 * Previously the launcher modified the LD_LIBRARY_PATH appropriately for the
111 * desired data model path, regardless if data models matched or not. The
112 * launcher subsequently exec'ed the desired executable, in order to make the
113 * LD_LIBRARY_PATH path available, for the runtime linker.
114 *
115 * Now, in most cases,the launcher will dlopen the target libjvm.so. All
116 * required libraries are loaded by the runtime linker, using the
117 * $RPATH/$ORIGIN baked into the shared libraries at compile time. Therefore,
118 * in most cases, the launcher will only exec, if the data models are
119 * mismatched, and will not set any environment variables, regardless of the
120 * data models.
121 *
122 * However, if the environment contains a LD_LIBRARY_PATH, this will cause the
123 * launcher to inspect the LD_LIBRARY_PATH. The launcher will check
124 * a. if the LD_LIBRARY_PATH's first component is the the path to the desired
125 * libjvm.so
126 * b. if any other libjvm.so is found in any of the paths.
127 * If case b is true, then the launcher will set the LD_LIBRARY_PATH to the
128 * desired JRE and reexec, in order to propagate the environment.
129 *
130 * Main
131 * (incoming argv)
132 * |
133 * \|/
134 * SelectVersion
135 * (selects the JRE version, note: not data model)
136 * |
137 * \|/
138 * CreateExecutionEnvironment
139 * (determines desired data model)
140 * |
141 * |
142 * \|/
143 * Have Desired Model ? --> NO --> Is Dual-Mode ? --> NO --> Exit(with error)
144 * | |
145 * | |
146 * | \|/
147 * | YES
148 * | |
149 * | |
150 * | \|/
151 * | CheckJvmType
152 * | (removes -client, -server etc.)
153 * | |
154 * | |
155 * \|/ \|/
156 * YES Find the desired executable/library
157 * | |
158 * | |
159 * \|/ \|/
160 * CheckJvmType RequiresSetenv
161 * (removes -client, -server, etc.)
162 * |
163 * |
164 * \|/
165 * TranslateDashJArgs...
166 * (Prepare to pass args to vm)
167 * |
168 * |
169 * \|/
170 * ParseArguments
171 * (removes -d32 and -d64 if any,
172 * processes version options,
173 * creates argument list for vm,
174 * etc.)
175 * |
176 * |
177 * \|/
178 * RequiresSetenv
179 * Is LD_LIBRARY_PATH
180 * and friends set ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
181 * YES YES --> Continue
182 * |
183 * |
184 * \|/
185 * Path is desired JRE ? YES --> Have Desired Model ? NO --> Re-exec --> Main
186 * NO YES --> Continue
187 * |
188 * |
189 * \|/
190 * Paths have well known
191 * jvm paths ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
192 * YES YES --> Continue
193 * |
194 * |
195 * \|/
196 * Does libjvm.so exit
197 * in any of them ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
198 * YES YES --> Continue
199 * |
200 * |
201 * \|/
202 * Set the LD_LIBRARY_PATH
203 * |
204 * |
205 * \|/
206 * Re-exec
207 * |
208 * |
209 * \|/
210 * Main
211 */
212
213 static const char * SetExecname(char **argv);
214 static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
215 char *jvmpath, jint jvmpathsize, const char * arch);
216 static jboolean GetJREPath(char *path, jint pathsize, const char * arch, jboolean speculative);
217
218
219 #define GetArch() GetArchPath(CURRENT_DATA_MODEL)
220
221 const char *
222 GetArchPath(int nbits)
223 {
224 switch(nbits) {
225 #ifdef DUAL_MODE
226 case 32:
227 return LIBARCH32NAME;
228 case 64:
229 return LIBARCH64NAME;
230 #endif /* DUAL_MODE */
231 default:
232 return LIBARCHNAME;
233 }
234 }
235
236 #ifdef SETENV_REQUIRED
237 static jboolean
238 JvmExists(const char *path) {
239 char tmp[PATH_MAX + 1];
240 struct stat statbuf;
241 JLI_Snprintf(tmp, PATH_MAX, "%s/%s", path, JVM_DLL);
242 if (stat(tmp, &statbuf) == 0) {
243 return JNI_TRUE;
244 }
245 return JNI_FALSE;
246 }
247 /*
248 * contains a lib/$LIBARCH/{server,client}/libjvm.so ?
249 */
250 static jboolean
251 ContainsLibJVM(int wanted, const char *env) {
252 char clientPattern[PATH_MAX + 1];
253 char serverPattern[PATH_MAX + 1];
254 char *envpath;
255 char *path;
256 jboolean clientPatternFound;
257 jboolean serverPatternFound;
258
259 /* fastest path */
260 if (env == NULL) {
261 return JNI_FALSE;
262 }
263
264 /* the usual suspects */
265 JLI_Snprintf(clientPattern, PATH_MAX, "lib/%s/client", GetArchPath(wanted));
266 JLI_Snprintf(serverPattern, PATH_MAX, "lib/%s/server", GetArchPath(wanted));
267
268 /* to optimize for time, test if any of our usual suspects are present. */
269 clientPatternFound = JLI_StrStr(env, clientPattern) != NULL;
270 serverPatternFound = JLI_StrStr(env, serverPattern) != NULL;
271 if (clientPatternFound == JNI_FALSE && serverPatternFound == JNI_FALSE) {
272 return JNI_FALSE;
273 }
274
275 /*
276 * we have a suspicious path component, check if it contains a libjvm.so
277 */
278 envpath = JLI_StringDup(env);
279 for (path = JLI_StrTok(envpath, ":"); path != NULL; path = JLI_StrTok(NULL, ":")) {
280 if (clientPatternFound && JLI_StrStr(path, clientPattern) != NULL) {
281 if (JvmExists(path)) {
282 JLI_MemFree(envpath);
283 return JNI_TRUE;
284 }
285 }
286 if (serverPatternFound && JLI_StrStr(path, serverPattern) != NULL) {
287 if (JvmExists(path)) {
288 JLI_MemFree(envpath);
289 return JNI_TRUE;
290 }
291 }
292 }
293 JLI_MemFree(envpath);
294 return JNI_FALSE;
295 }
296
297 /*
298 * Test whether the environment variable needs to be set, see flowchart.
299 */
300 static jboolean
301 RequiresSetenv(int wanted, const char *jvmpath) {
302 char jpath[PATH_MAX + 1];
303 char *llp;
304 char *dmllp = NULL;
305 char *p; /* a utility pointer */
306
307 llp = getenv("LD_LIBRARY_PATH");
308 #ifdef __solaris__
309 dmllp = (CURRENT_DATA_MODEL == 32)
310 ? getenv("LD_LIBRARY_PATH_32")
311 : getenv("LD_LIBRARY_PATH_64");
312 #endif /* __solaris__ */
313 /* no environment variable is a good environment variable */
314 if (llp == NULL && dmllp == NULL) {
315 return JNI_FALSE;
316 }
317 #ifdef __linux
318 /*
319 * On linux, if a binary is running as sgid or suid, glibc sets
320 * LD_LIBRARY_PATH to the empty string for security purposes. (In contrast,
321 * on Solaris the LD_LIBRARY_PATH variable for a privileged binary does not
322 * lose its settings; but the dynamic linker does apply more scrutiny to the
323 * path.) The launcher uses the value of LD_LIBRARY_PATH to prevent an exec
324 * loop, here and further downstream. Therefore, if we are running sgid or
325 * suid, this function's setting of LD_LIBRARY_PATH will be ineffective and
326 * we should case a return from the calling function. Getting the right
327 * libraries will be handled by the RPATH. In reality, this check is
328 * redundant, as the previous check for a non-null LD_LIBRARY_PATH will
329 * return back to the calling function forthwith, it is left here to safe
330 * guard against any changes, in the glibc's existing security policy.
331 */
332 if ((getgid() != getegid()) || (getuid() != geteuid())) {
333 return JNI_FALSE;
334 }
335 #endif /* __linux */
336
337 /*
338 * Prevent recursions. Since LD_LIBRARY_PATH is the one which will be set by
339 * previous versions of the JRE, thus it is the only path that matters here.
340 * So we check to see if the desired JRE is set.
341 */
342 JLI_StrNCpy(jpath, jvmpath, PATH_MAX);
343 p = JLI_StrRChr(jpath, '/');
344 *p = '\0';
345 if (llp != NULL && JLI_StrNCmp(llp, jpath, JLI_StrLen(jpath)) == 0) {
346 return JNI_FALSE;
347 }
348
349 /* scrutinize all the paths further */
350 if (llp != NULL && ContainsLibJVM(wanted, llp)) {
351 return JNI_TRUE;
352 }
353 if (dmllp != NULL && ContainsLibJVM(wanted, dmllp)) {
354 return JNI_TRUE;
355 }
356 return JNI_FALSE;
357 }
358 #endif /* SETENV_REQUIRED */
359
360 void
361 CreateExecutionEnvironment(int *pargc, char ***pargv,
362 char jrepath[], jint so_jrepath,
363 char jvmpath[], jint so_jvmpath) {
364 /*
365 * First, determine if we are running the desired data model. If we
366 * are running the desired data model, all the error messages
367 * associated with calling GetJREPath, ReadKnownVMs, etc. should be
368 * output. However, if we are not running the desired data model,
369 * some of the errors should be suppressed since it is more
370 * informative to issue an error message based on whether or not the
371 * os/processor combination has dual mode capabilities.
372 */
373 jboolean jvmpathExists;
374
375 /* Compute/set the name of the executable */
376 SetExecname(*pargv);
377
378 /* Check data model flags, and exec process, if needed */
379 {
380 char *arch = (char *)GetArch(); /* like sparc or sparcv9 */
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 #ifdef SETENV_REQUIRED
391 jboolean mustsetenv = JNI_FALSE;
392 char *runpath = NULL; /* existing effective LD_LIBRARY_PATH setting */
393 char* new_runpath = NULL; /* desired new LD_LIBRARY_PATH string */
394 char* newpath = NULL; /* path on new LD_LIBRARY_PATH */
395 char* lastslash = NULL;
396 char** newenvp = NULL; /* current environment */
397 #ifdef __solaris__
398 char* dmpath = NULL; /* data model specific LD_LIBRARY_PATH,
399 Solaris only */
400 #endif /* __solaris__ */
401 #endif /* SETENV_REQUIRED */
402
403 char** newargv = NULL;
404 int newargc = 0;
405
406 /*
407 * Starting in 1.5, all unix platforms accept the -d32 and -d64
408 * options. On platforms where only one data-model is supported
409 * (e.g. ia-64 Linux), using the flag for the other data model is
410 * an error and will terminate the program.
411 */
412
413 { /* open new scope to declare local variables */
414 int i;
415
416 newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(char*));
417 newargv[newargc++] = argv[0];
418
419 /* scan for data model arguments and remove from argument list;
420 last occurrence determines desired data model */
421 for (i=1; i < argc; i++) {
422
423 if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) {
424 wanted = 64;
425 continue;
426 }
427 if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) {
428 wanted = 32;
429 continue;
430 }
431 newargv[newargc++] = argv[i];
432
433 if (IsJavaArgs()) {
434 if (argv[i][0] != '-') continue;
435 } else {
436 if (JLI_StrCmp(argv[i], "-classpath") == 0 || JLI_StrCmp(argv[i], "-cp") == 0) {
437 i++;
438 if (i >= argc) break;
439 newargv[newargc++] = argv[i];
440 continue;
441 }
442 if (argv[i][0] != '-') { i++; break; }
443 }
444 }
445
446 /* copy rest of args [i .. argc) */
447 while (i < argc) {
448 newargv[newargc++] = argv[i++];
449 }
450 newargv[newargc] = NULL;
451
452 /*
453 * newargv has all proper arguments here
454 */
455
456 argc = newargc;
457 argv = newargv;
458 }
459
460 /* If the data model is not changing, it is an error if the
461 jvmpath does not exist */
462 if (wanted == running) {
463 /* Find out where the JRE is that we will be using. */
464 if (!GetJREPath(jrepath, so_jrepath, arch, JNI_FALSE) ) {
465 JLI_ReportErrorMessage(JRE_ERROR1);
466 exit(2);
467 }
468
469 /* Find the specified JVM type */
470 if (ReadKnownVMs(jrepath, arch, JNI_FALSE) < 1) {
471 JLI_ReportErrorMessage(CFG_ERROR7);
472 exit(1);
473 }
474
475 jvmpath[0] = '\0';
476 jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE);
477 if (JLI_StrCmp(jvmtype, "ERROR") == 0) {
478 JLI_ReportErrorMessage(CFG_ERROR9);
479 exit(4);
480 }
481
482 if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, arch )) {
483 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath);
484 exit(4);
485 }
486 /*
487 * we seem to have everything we need, so without further ado
488 * we return back, otherwise proceed to set the environment.
489 */
490 #ifdef SETENV_REQUIRED
491 mustsetenv = RequiresSetenv(wanted, jvmpath);
492 JLI_TraceLauncher("mustsetenv: %s\n", mustsetenv ? "TRUE" : "FALSE");
493
494 if (mustsetenv == JNI_FALSE) {
495 return;
496 }
497 #else
498 return;
499 #endif /* SETENV_REQUIRED */
500 } else { /* do the same speculatively or exit */
501 #ifdef DUAL_MODE
502 if (running != wanted) {
503 /* Find out where the JRE is that we will be using. */
504 if (!GetJREPath(jrepath, so_jrepath, GetArchPath(wanted), JNI_TRUE)) {
505 /* give up and let other code report error message */
506 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
507 exit(1);
508 }
509
510 /*
511 * Read in jvm.cfg for target data model and process vm
512 * selection options.
513 */
514 if (ReadKnownVMs(jrepath, GetArchPath(wanted), JNI_TRUE) < 1) {
515 /* give up and let other code report error message */
516 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
517 exit(1);
518 }
519 jvmpath[0] = '\0';
520 jvmtype = CheckJvmType(pargc, pargv, JNI_TRUE);
521 if (JLI_StrCmp(jvmtype, "ERROR") == 0) {
522 JLI_ReportErrorMessage(CFG_ERROR9);
523 exit(4);
524 }
525
526 /* exec child can do error checking on the existence of the path */
527 jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, GetArchPath(wanted));
528 #ifdef SETENV_REQUIRED
529 mustsetenv = RequiresSetenv(wanted, jvmpath);
530 #endif /* SETENV_REQUIRED */
531 }
532 #else
533 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
534 exit(1);
535 #endif
536 }
537 #ifdef SETENV_REQUIRED
538 if (mustsetenv) {
539 /*
540 * We will set the LD_LIBRARY_PATH as follows:
541 *
542 * o $JVMPATH (directory portion only)
543 * o $JRE/lib/$LIBARCHNAME
544 * o $JRE/../lib/$LIBARCHNAME
545 *
546 * followed by the user's previous effective LD_LIBRARY_PATH, if
547 * any.
548 */
549
550 #ifdef __solaris__
551 /*
552 * Starting in Solaris 7, ld.so.1 supports three LD_LIBRARY_PATH
553 * variables:
554 *
555 * 1. LD_LIBRARY_PATH -- used for 32 and 64 bit searches if
556 * data-model specific variables are not set.
557 *
558 * 2. LD_LIBRARY_PATH_64 -- overrides and replaces LD_LIBRARY_PATH
559 * for 64-bit binaries.
560 *
561 * 3. LD_LIBRARY_PATH_32 -- overrides and replaces LD_LIBRARY_PATH
562 * for 32-bit binaries.
563 *
564 * The vm uses LD_LIBRARY_PATH to set the java.library.path system
565 * property. To shield the vm from the complication of multiple
566 * LD_LIBRARY_PATH variables, if the appropriate data model
567 * specific variable is set, we will act as if LD_LIBRARY_PATH had
568 * the value of the data model specific variant and the data model
569 * specific variant will be unset. Note that the variable for the
570 * *wanted* data model must be used (if it is set), not simply the
571 * current running data model.
572 */
573
574 switch (wanted) {
575 case 0:
576 if (running == 32) {
577 dmpath = getenv("LD_LIBRARY_PATH_32");
578 wanted = 32;
579 } else {
580 dmpath = getenv("LD_LIBRARY_PATH_64");
581 wanted = 64;
582 }
583 break;
584
585 case 32:
586 dmpath = getenv("LD_LIBRARY_PATH_32");
587 break;
588
589 case 64:
590 dmpath = getenv("LD_LIBRARY_PATH_64");
591 break;
592
593 default:
594 JLI_ReportErrorMessage(JRE_ERROR3, __LINE__);
595 exit(1); /* unknown value in wanted */
596 break;
597 }
598
599 /*
600 * If dmpath is NULL, the relevant data model specific variable is
601 * not set and normal LD_LIBRARY_PATH should be used.
602 */
603 if (dmpath == NULL) {
604 runpath = getenv("LD_LIBRARY_PATH");
605 } else {
606 runpath = dmpath;
607 }
608 #else
609 /*
610 * If not on Solaris, assume only a single LD_LIBRARY_PATH
611 * variable.
612 */
613 runpath = getenv("LD_LIBRARY_PATH");
614 #endif /* __solaris__ */
615
616 /* runpath contains current effective LD_LIBRARY_PATH setting */
617
618 jvmpath = JLI_StringDup(jvmpath);
619 new_runpath = JLI_MemAlloc(((runpath != NULL) ? JLI_StrLen(runpath) : 0) +
620 2 * JLI_StrLen(jrepath) + 2 * JLI_StrLen(arch) +
621 JLI_StrLen(jvmpath) + 52);
622 newpath = new_runpath + JLI_StrLen("LD_LIBRARY_PATH=");
623
624
625 /*
626 * Create desired LD_LIBRARY_PATH value for target data model.
627 */
628 {
629 /* remove the name of the .so from the JVM path */
630 lastslash = JLI_StrRChr(jvmpath, '/');
631 if (lastslash)
632 *lastslash = '\0';
633
634 sprintf(new_runpath, "LD_LIBRARY_PATH="
635 "%s:"
636 "%s/lib/%s:"
637 "%s/../lib/%s",
638 jvmpath,
639 #ifdef DUAL_MODE
640 jrepath, GetArchPath(wanted),
641 jrepath, GetArchPath(wanted)
642 #else
643 jrepath, arch,
644 jrepath, arch
645 #endif
646 );
647
648
649 /*
650 * Check to make sure that the prefix of the current path is the
651 * desired environment variable setting, though the RequiresSetenv
652 * checks if the desired runpath exists, this logic does a more
653 * comprehensive check.
654 */
655 if (runpath != NULL &&
656 JLI_StrNCmp(newpath, runpath, JLI_StrLen(newpath)) == 0 &&
657 (runpath[JLI_StrLen(newpath)] == 0 || runpath[JLI_StrLen(newpath)] == ':') &&
658 (running == wanted) /* data model does not have to be changed */
659 #ifdef __solaris__
660 && (dmpath == NULL) /* data model specific variables not set */
661 #endif
662 ) {
663
664 return;
665
666 }
667 }
668
669 /*
670 * Place the desired environment setting onto the prefix of
671 * LD_LIBRARY_PATH. Note that this prevents any possible infinite
672 * loop of execv() because we test for the prefix, above.
673 */
674 if (runpath != 0) {
675 JLI_StrCat(new_runpath, ":");
676 JLI_StrCat(new_runpath, runpath);
677 }
678
679 if (putenv(new_runpath) != 0) {
680 exit(1); /* problem allocating memory; LD_LIBRARY_PATH not set
681 properly */
682 }
683
684 /*
685 * Unix systems document that they look at LD_LIBRARY_PATH only
686 * once at startup, so we have to re-exec the current executable
687 * to get the changed environment variable to have an effect.
688 */
689
690 #ifdef __solaris__
691 /*
692 * If dmpath is not NULL, remove the data model specific string
693 * in the environment for the exec'ed child.
694 */
695 if (dmpath != NULL)
696 (void)UnsetEnv((wanted == 32) ? "LD_LIBRARY_PATH_32" : "LD_LIBRARY_PATH_64");
697 #endif
698
699 newenvp = environ;
700 }
701 #endif /* SETENV_REQUIRED */
702 {
703 char *newexec = execname;
704 #ifdef DUAL_MODE
705 /*
706 * If the data model is being changed, the path to the
707 * executable must be updated accordingly; the executable name
708 * and directory the executable resides in are separate. In the
709 * case of 32 => 64, the new bits are assumed to reside in, e.g.
710 * "olddir/LIBARCH64NAME/execname"; in the case of 64 => 32,
711 * the bits are assumed to be in "olddir/../execname". For example,
712 *
713 * olddir/sparcv9/execname
714 * olddir/amd64/execname
715 *
716 * for Solaris SPARC and Linux amd64, respectively.
717 */
718
719 if (running != wanted) {
720 char *oldexec = JLI_StrCpy(JLI_MemAlloc(JLI_StrLen(execname) + 1), execname);
721 char *olddir = oldexec;
722 char *oldbase = JLI_StrRChr(oldexec, '/');
723
724
725 newexec = JLI_MemAlloc(JLI_StrLen(execname) + 20);
726 *oldbase++ = 0;
727 sprintf(newexec, "%s/%s/%s", olddir,
728 ((wanted == 64) ? LIBARCH64NAME : ".."), oldbase);
729 argv[0] = newexec;
730 }
731 #endif /* DUAL_MODE */
732 JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n");
733 (void) fflush(stdout);
734 (void) fflush(stderr);
735 #ifdef SETENV_REQUIRED
736 if (mustsetenv) {
737 execve(newexec, argv, newenvp);
738 } else {
739 execv(newexec, argv);
740 }
741 #else
742 execv(newexec, argv);
743 #endif /* SETENV_REQUIRED */
744 JLI_ReportErrorMessageSys(JRE_ERROR4, newexec);
745
746 #ifdef DUAL_MODE
747 if (running != wanted) {
748 JLI_ReportErrorMessage(JRE_ERROR5, wanted, running);
749 #ifdef __solaris__
750 #ifdef __sparc
751 JLI_ReportErrorMessage(JRE_ERROR6);
752 #else
753 JLI_ReportErrorMessage(JRE_ERROR7);
754 #endif /* __sparc */
755 }
756 #endif /* __solaris__ */
757 #endif /* DUAL_MODE */
758
759 }
760 exit(1);
761 }
762 }
763
764 /*
765 * On Solaris VM choosing is done by the launcher (java.c).
766 */
767 static jboolean
768 GetJVMPath(const char *jrepath, const char *jvmtype,
769 char *jvmpath, jint jvmpathsize, const char * arch)
770 {
771 struct stat s;
772
773 if (JLI_StrChr(jvmtype, '/')) {
774 JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype);
775 } else {
776 JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/%s/" JVM_DLL, jrepath, arch, jvmtype);
777 }
778
779 JLI_TraceLauncher("Does `%s' exist ... ", jvmpath);
780
781 if (stat(jvmpath, &s) == 0) {
782 JLI_TraceLauncher("yes.\n");
783 return JNI_TRUE;
784 } else {
785 JLI_TraceLauncher("no.\n");
786 return JNI_FALSE;
787 }
788 }
789
790 /*
791 * Find path to JRE based on .exe's location or registry settings.
792 */
793 static jboolean
794 GetJREPath(char *path, jint pathsize, const char * arch, jboolean speculative)
795 {
796 char libjava[MAXPATHLEN];
797
798 if (GetApplicationHome(path, pathsize)) {
799 /* Is JRE co-located with the application? */
800 JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/%s/" JAVA_DLL, path, arch);
801 if (access(libjava, F_OK) == 0) {
802 JLI_TraceLauncher("JRE path is %s\n", path);
803 return JNI_TRUE;
804 }
805
806 /* Does the app ship a private JRE in <apphome>/jre directory? */
807 JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/%s/" JAVA_DLL, path, arch);
808 if (access(libjava, F_OK) == 0) {
809 JLI_StrCat(path, "/jre");
810 JLI_TraceLauncher("JRE path is %s\n", path);
811 return JNI_TRUE;
812 }
813 }
814
815 if (!speculative)
816 JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL);
817 return JNI_FALSE;
818 }
819
820 jboolean
821 LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
822 {
823 void *libjvm;
824
825 JLI_TraceLauncher("JVM path is %s\n", jvmpath);
826
827 libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);
828 if (libjvm == NULL) {
829 #if defined(__solaris__) && defined(__sparc) && !defined(_LP64) /* i.e. 32-bit sparc */
830 FILE * fp;
831 Elf32_Ehdr elf_head;
832 int count;
833 int location;
834
835 fp = fopen(jvmpath, "r");
836 if (fp == NULL) {
837 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
838 return JNI_FALSE;
839 }
840
841 /* read in elf header */
842 count = fread((void*)(&elf_head), sizeof(Elf32_Ehdr), 1, fp);
843 fclose(fp);
844 if (count < 1) {
845 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
846 return JNI_FALSE;
847 }
848
849 /*
850 * Check for running a server vm (compiled with -xarch=v8plus)
851 * on a stock v8 processor. In this case, the machine type in
852 * the elf header would not be included the architecture list
853 * provided by the isalist command, which is turn is gotten from
854 * sysinfo. This case cannot occur on 64-bit hardware and thus
855 * does not have to be checked for in binaries with an LP64 data
856 * model.
857 */
858 if (elf_head.e_machine == EM_SPARC32PLUS) {
859 char buf[257]; /* recommended buffer size from sysinfo man
860 page */
861 long length;
862 char* location;
863
864 length = sysinfo(SI_ISALIST, buf, 257);
865 if (length > 0) {
866 location = JLI_StrStr(buf, "sparcv8plus ");
867 if (location == NULL) {
868 JLI_ReportErrorMessage(JVM_ERROR3);
869 return JNI_FALSE;
870 }
871 }
872 }
873 #endif
874 JLI_ReportErrorMessage(DLL_ERROR1, __LINE__);
875 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
876 return JNI_FALSE;
877 }
878
879 ifn->CreateJavaVM = (CreateJavaVM_t)
880 dlsym(libjvm, "JNI_CreateJavaVM");
881 if (ifn->CreateJavaVM == NULL) {
882 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
883 return JNI_FALSE;
884 }
885
886 ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)
887 dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");
888 if (ifn->GetDefaultJavaVMInitArgs == NULL) {
889 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror());
890 return JNI_FALSE;
891 }
892
893 return JNI_TRUE;
894 }
895
896 /*
897 * If app is "/foo/bin/javac", or "/foo/bin/sparcv9/javac" then put
898 * "/foo" into buf.
899 */
900 jboolean
901 GetApplicationHome(char *buf, jint bufsize)
902 {
903 if (execname != NULL) {
904 JLI_Snprintf(buf, bufsize, "%s", execname);
905 buf[bufsize-1] = '\0';
906 } else {
907 return JNI_FALSE;
908 }
909
910 if (JLI_StrRChr(buf, '/') == 0) {
911 buf[0] = '\0';
912 return JNI_FALSE;
913 }
914 *(JLI_StrRChr(buf, '/')) = '\0'; /* executable file */
915 if (JLI_StrLen(buf) < 4 || JLI_StrRChr(buf, '/') == 0) {
916 buf[0] = '\0';
917 return JNI_FALSE;
918 }
919 if (JLI_StrCmp("/bin", buf + JLI_StrLen(buf) - 4) != 0)
920 *(JLI_StrRChr(buf, '/')) = '\0'; /* sparcv9 or amd64 */
921 if (JLI_StrLen(buf) < 4 || JLI_StrCmp("/bin", buf + JLI_StrLen(buf) - 4) != 0) {
922 buf[0] = '\0';
923 return JNI_FALSE;
924 }
925 *(JLI_StrRChr(buf, '/')) = '\0'; /* bin */
926
927 return JNI_TRUE;
928 }
929
930
931 /*
932 * Return true if the named program exists
933 */
934 static int
935 ProgramExists(char *name)
936 {
937 struct stat sb;
938 if (stat(name, &sb) != 0) return 0;
939 if (S_ISDIR(sb.st_mode)) return 0;
940 return (sb.st_mode & S_IEXEC) != 0;
941 }
942
943
944 /*
945 * Find a command in a directory, returning the path.
946 */
947 static char *
948 Resolve(char *indir, char *cmd)
949 {
950 char name[PATH_MAX + 2], *real;
951
952 if ((JLI_StrLen(indir) + JLI_StrLen(cmd) + 1) > PATH_MAX) return 0;
953 JLI_Snprintf(name, sizeof(name), "%s%c%s", indir, FILE_SEPARATOR, cmd);
954 if (!ProgramExists(name)) return 0;
955 real = JLI_MemAlloc(PATH_MAX + 2);
956 if (!realpath(name, real))
957 JLI_StrCpy(real, name);
958 return real;
959 }
960
961
962 /*
963 * Find a path for the executable
964 */
965 static char *
966 FindExecName(char *program)
967 {
968 char cwdbuf[PATH_MAX+2];
969 char *path;
970 char *tmp_path;
971 char *f;
972 char *result = NULL;
973
974 /* absolute path? */
975 if (*program == FILE_SEPARATOR ||
976 (FILE_SEPARATOR=='\\' && JLI_StrRChr(program, ':')))
977 return Resolve("", program+1);
978
979 /* relative path? */
980 if (JLI_StrRChr(program, FILE_SEPARATOR) != 0) {
981 char buf[PATH_MAX+2];
982 return Resolve(getcwd(cwdbuf, sizeof(cwdbuf)), program);
983 }
984
985 /* from search path? */
986 path = getenv("PATH");
987 if (!path || !*path) path = ".";
988 tmp_path = JLI_MemAlloc(JLI_StrLen(path) + 2);
989 JLI_StrCpy(tmp_path, path);
990
991 for (f=tmp_path; *f && result==0; ) {
992 char *s = f;
993 while (*f && (*f != PATH_SEPARATOR)) ++f;
994 if (*f) *f++ = 0;
995 if (*s == FILE_SEPARATOR)
996 result = Resolve(s, program);
997 else {
998 /* relative path element */
999 char dir[2*PATH_MAX];
1000 JLI_Snprintf(dir, sizeof(dir), "%s%c%s", getcwd(cwdbuf, sizeof(cwdbuf)),
1001 FILE_SEPARATOR, s);
1002 result = Resolve(dir, program);
1003 }
1004 if (result != 0) break;
1005 }
1006
1007 JLI_MemFree(tmp_path);
1008 return result;
1009 }
1010
1011
1012
1013 /*
1014 * Compute the name of the executable
1015 *
1016 * In order to re-exec securely we need the absolute path of the
1017 * executable. On Solaris getexecname(3c) may not return an absolute
1018 * path so we use dladdr to get the filename of the executable and
1019 * then use realpath to derive an absolute path. From Solaris 9
1020 * onwards the filename returned in DL_info structure from dladdr is
1021 * an absolute pathname so technically realpath isn't required.
1022 * On Linux we read the executable name from /proc/self/exe.
1023 * As a fallback, and for platforms other than Solaris and Linux,
1024 * we use FindExecName to compute the executable name.
1025 */
1026 static const char*
1027 SetExecname(char **argv)
1028 {
1029 char* exec_path = NULL;
1030 #if defined(__solaris__)
1031 {
1032 Dl_info dlinfo;
1033 int (*fptr)();
1034
1035 fptr = (int (*)())dlsym(RTLD_DEFAULT, "main");
1036 if (fptr == NULL) {
1037 JLI_ReportErrorMessage(DLL_ERROR3, dlerror());
1038 return JNI_FALSE;
1039 }
1040
1041 if (dladdr((void*)fptr, &dlinfo)) {
1042 char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1);
1043 if (resolved != NULL) {
1044 exec_path = realpath(dlinfo.dli_fname, resolved);
1045 if (exec_path == NULL) {
1046 JLI_MemFree(resolved);
1047 }
1048 }
1049 }
1050 }
1051 #elif defined(__linux__)
1052 {
1053 const char* self = "/proc/self/exe";
1054 char buf[PATH_MAX+1];
1055 int len = readlink(self, buf, PATH_MAX);
1056 if (len >= 0) {
1057 buf[len] = '\0'; /* readlink doesn't nul terminate */
1058 exec_path = JLI_StringDup(buf);
1059 }
1060 }
1061 #else /* !__solaris__ && !__linux */
1062 {
1063 /* Not implemented */
1064 }
1065 #endif
1066
1067 if (exec_path == NULL) {
1068 exec_path = FindExecName(argv[0]);
1069 }
1070 execname = exec_path;
1071 return exec_path;
1072 }
1073
1074 void JLI_ReportErrorMessage(const char* fmt, ...) {
1075 va_list vl;
1076 va_start(vl, fmt);
1077 vfprintf(stderr, fmt, vl);
1078 fprintf(stderr, "\n");
1079 va_end(vl);
1080 }
1081
1082 void JLI_ReportErrorMessageSys(const char* fmt, ...) {
1083 va_list vl;
1084 char *emsg;
1085
1086 /*
1087 * TODO: its safer to use strerror_r but is not available on
1088 * Solaris 8. Until then....
1089 */
1090 emsg = strerror(errno);
1091 if (emsg != NULL) {
1092 fprintf(stderr, "%s\n", emsg);
1093 }
1094
1095 va_start(vl, fmt);
1096 vfprintf(stderr, fmt, vl);
1097 fprintf(stderr, "\n");
1098 va_end(vl);
1099 }
1100
1101 void JLI_ReportExceptionDescription(JNIEnv * env) {
1102 (*env)->ExceptionDescribe(env);
1103 }
1104
1105 /*
1106 * Since using the file system as a registry is a bit risky, perform
1107 * additional sanity checks on the identified directory to validate
1108 * it as a valid jre/sdk.
1109 *
1110 * Return 0 if the tests fail; otherwise return non-zero (true).
1111 *
1112 * Note that checking for anything more than the existence of an
1113 * executable object at bin/java relative to the path being checked
1114 * will break the regression tests.
1115 */
1116 static int
1117 CheckSanity(char *path, char *dir)
1118 {
1119 char buffer[PATH_MAX];
1120
1121 if (JLI_StrLen(path) + JLI_StrLen(dir) + 11 > PATH_MAX)
1122 return (0); /* Silently reject "impossibly" long paths */
1123
1124 JLI_Snprintf(buffer, sizeof(buffer), "%s/%s/bin/java", path, dir);
1125 return ((access(buffer, X_OK) == 0) ? 1 : 0);
1126 }
1127
1128 /*
1129 * Determine if there is an acceptable JRE in the directory dirname.
1130 * Upon locating the "best" one, return a fully qualified path to
1131 * it. "Best" is defined as the most advanced JRE meeting the
1132 * constraints contained in the manifest_info. If no JRE in this
1133 * directory meets the constraints, return NULL.
1134 *
1135 * Note that we don't check for errors in reading the directory
1136 * (which would be done by checking errno). This is because it
1137 * doesn't matter if we get an error reading the directory, or
1138 * we just don't find anything interesting in the directory. We
1139 * just return NULL in either case.
1140 *
1141 * The historical names of j2sdk and j2re were changed to jdk and
1142 * jre respecively as part of the 1.5 rebranding effort. Since the
1143 * former names are legacy on Linux, they must be recognized for
1144 * all time. Fortunately, this is a minor cost.
1145 */
1146 static char
1147 *ProcessDir(manifest_info *info, char *dirname)
1148 {
1149 DIR *dirp;
1150 struct dirent *dp;
1151 char *best = NULL;
1152 int offset;
1153 int best_offset = 0;
1154 char *ret_str = NULL;
1155 char buffer[PATH_MAX];
1156
1157 if ((dirp = opendir(dirname)) == NULL)
1158 return (NULL);
1159
1160 do {
1161 if ((dp = readdir(dirp)) != NULL) {
1162 offset = 0;
1163 if ((JLI_StrNCmp(dp->d_name, "jre", 3) == 0) ||
1164 (JLI_StrNCmp(dp->d_name, "jdk", 3) == 0))
1165 offset = 3;
1166 else if (JLI_StrNCmp(dp->d_name, "j2re", 4) == 0)
1167 offset = 4;
1168 else if (JLI_StrNCmp(dp->d_name, "j2sdk", 5) == 0)
1169 offset = 5;
1170 if (offset > 0) {
1171 if ((JLI_AcceptableRelease(dp->d_name + offset,
1172 info->jre_version)) && CheckSanity(dirname, dp->d_name))
1173 if ((best == NULL) || (JLI_ExactVersionId(
1174 dp->d_name + offset, best + best_offset) > 0)) {
1175 if (best != NULL)
1176 JLI_MemFree(best);
1177 best = JLI_StringDup(dp->d_name);
1178 best_offset = offset;
1179 }
1180 }
1181 }
1182 } while (dp != NULL);
1183 (void) closedir(dirp);
1184 if (best == NULL)
1185 return (NULL);
1186 else {
1187 ret_str = JLI_MemAlloc(JLI_StrLen(dirname) + JLI_StrLen(best) + 2);
1188 sprintf(ret_str, "%s/%s", dirname, best);
1189 JLI_MemFree(best);
1190 return (ret_str);
1191 }
1192 }
1193
1194 /*
1195 * This is the global entry point. It examines the host for the optimal
1196 * JRE to be used by scanning a set of directories. The set of directories
1197 * is platform dependent and can be overridden by the environment
1198 * variable JAVA_VERSION_PATH.
1199 *
1200 * This routine itself simply determines the set of appropriate
1201 * directories before passing control onto ProcessDir().
1202 */
1203 char*
1204 LocateJRE(manifest_info* info)
1205 {
1206 char *path;
1207 char *home;
1208 char *target = NULL;
1209 char *dp;
1210 char *cp;
1211
1212 /*
1213 * Start by getting JAVA_VERSION_PATH
1214 */
1215 if (info->jre_restrict_search) {
1216 path = JLI_StringDup(system_dir);
1217 } else if ((path = getenv("JAVA_VERSION_PATH")) != NULL) {
1218 path = JLI_StringDup(path);
1219 } else {
1220 if ((home = getenv("HOME")) != NULL) {
1221 path = (char *)JLI_MemAlloc(JLI_StrLen(home) + \
1222 JLI_StrLen(system_dir) + JLI_StrLen(user_dir) + 2);
1223 sprintf(path, "%s%s:%s", home, user_dir, system_dir);
1224 } else {
1225 path = JLI_StringDup(system_dir);
1226 }
1227 }
1228
1229 /*
1230 * Step through each directory on the path. Terminate the scan with
1231 * the first directory with an acceptable JRE.
1232 */
1233 cp = dp = path;
1234 while (dp != NULL) {
1235 cp = JLI_StrChr(dp, (int)':');
1236 if (cp != NULL)
1237 *cp = '\0';
1238 if ((target = ProcessDir(info, dp)) != NULL)
1239 break;
1240 dp = cp;
1241 if (dp != NULL)
1242 dp++;
1243 }
1244 JLI_MemFree(path);
1245 return (target);
1246 }
1247
1248 /*
1249 * Given a path to a jre to execute, this routine checks if this process
1250 * is indeed that jre. If not, it exec's that jre.
1251 *
1252 * We want to actually check the paths rather than just the version string
1253 * built into the executable, so that given version specification (and
1254 * JAVA_VERSION_PATH) will yield the exact same Java environment, regardless
1255 * of the version of the arbitrary launcher we start with.
1256 */
1257 void
1258 ExecJRE(char *jre, char **argv)
1259 {
1260 char wanted[PATH_MAX];
1261 const char* progname = GetProgramName();
1262
1263 /*
1264 * Resolve the real path to the directory containing the selected JRE.
1265 */
1266 if (realpath(jre, wanted) == NULL) {
1267 JLI_ReportErrorMessage(JRE_ERROR9, jre);
1268 exit(1);
1269 }
1270
1271 /*
1272 * Resolve the real path to the currently running launcher.
1273 */
1274 SetExecname(argv);
1275 if (execname == NULL) {
1276 JLI_ReportErrorMessage(JRE_ERROR10);
1277 exit(1);
1278 }
1279
1280 /*
1281 * If the path to the selected JRE directory is a match to the initial
1282 * portion of the path to the currently executing JRE, we have a winner!
1283 * If so, just return.
1284 */
1285 if (JLI_StrNCmp(wanted, execname, JLI_StrLen(wanted)) == 0)
1286 return; /* I am the droid you were looking for */
1287
1288
1289 /*
1290 * This should never happen (because of the selection code in SelectJRE),
1291 * but check for "impossibly" long path names just because buffer overruns
1292 * can be so deadly.
1293 */
1294 if (JLI_StrLen(wanted) + JLI_StrLen(progname) + 6 > PATH_MAX) {
1295 JLI_ReportErrorMessage(JRE_ERROR11);
1296 exit(1);
1297 }
1298
1299 /*
1300 * Construct the path and exec it.
1301 */
1302 (void)JLI_StrCat(JLI_StrCat(wanted, "/bin/"), progname);
1303 argv[0] = JLI_StringDup(progname);
1304 if (JLI_IsTraceLauncher()) {
1305 int i;
1306 printf("ReExec Command: %s (%s)\n", wanted, argv[0]);
1307 printf("ReExec Args:");
1308 for (i = 1; argv[i] != NULL; i++)
1309 printf(" %s", argv[i]);
1310 printf("\n");
1311 }
1312 JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n");
1313 (void)fflush(stdout);
1314 (void)fflush(stderr);
1315 execv(wanted, argv);
1316 JLI_ReportErrorMessageSys(JRE_ERROR12, wanted);
1317 exit(1);
1318 }
1319
1320 /*
1321 * "Borrowed" from Solaris 10 where the unsetenv() function is being added
1322 * to libc thanks to SUSv3 (Standard Unix Specification, version 3). As
1323 * such, in the fullness of time this will appear in libc on all relevant
1324 * Solaris/Linux platforms and maybe even the Windows platform. At that
1325 * time, this stub can be removed.
1326 *
1327 * This implementation removes the environment locking for multithreaded
1328 * applications. (We don't have access to these mutexes within libc and
1329 * the launcher isn't multithreaded.) Note that what remains is platform
1330 * independent, because it only relies on attributes that a POSIX environment
1331 * defines.
1332 *
1333 * Returns 0 on success, -1 on failure.
1334 *
1335 * Also removed was the setting of errno. The only value of errno set
1336 * was EINVAL ("Invalid Argument").
1337 */
1338
1339 /*
1340 * s1(environ) is name=value
1341 * s2(name) is name(not the form of name=value).
1342 * if names match, return value of 1, else return 0
1343 */
1344 static int
1345 match_noeq(const char *s1, const char *s2)
1346 {
1347 while (*s1 == *s2++) {
1348 if (*s1++ == '=')
1349 return (1);
1350 }
1351 if (*s1 == '=' && s2[-1] == '\0')
1352 return (1);
1353 return (0);
1354 }
1355
1356 /*
1357 * added for SUSv3 standard
1358 *
1359 * Delete entry from environ.
1360 * Do not free() memory! Other threads may be using it.
1361 * Keep it around forever.
1362 */
1363 static int
1364 borrowed_unsetenv(const char *name)
1365 {
1366 long idx; /* index into environ */
1367
1368 if (name == NULL || *name == '\0' ||
1369 JLI_StrChr(name, '=') != NULL) {
1370 return (-1);
1371 }
1372
1373 for (idx = 0; environ[idx] != NULL; idx++) {
1374 if (match_noeq(environ[idx], name))
1375 break;
1376 }
1377 if (environ[idx] == NULL) {
1378 /* name not found but still a success */
1379 return (0);
1380 }
1381 /* squeeze up one entry */
1382 do {
1383 environ[idx] = environ[idx+1];
1384 } while (environ[++idx] != NULL);
1385
1386 return (0);
1387 }
1388 /* --- End of "borrowed" code --- */
1389
1390 /*
1391 * Wrapper for unsetenv() function.
1392 */
1393 int
1394 UnsetEnv(char *name)
1395 {
1396 return(borrowed_unsetenv(name));
1397 }
1398
1399 /* --- Splash Screen shared library support --- */
1400
1401 static const char* SPLASHSCREEN_SO = "libsplashscreen.so";
1402
1403 static void* hSplashLib = NULL;
1404
1405 void* SplashProcAddress(const char* name) {
1406 if (!hSplashLib) {
1407 hSplashLib = dlopen(SPLASHSCREEN_SO, RTLD_LAZY | RTLD_GLOBAL);
1408 }
1409 if (hSplashLib) {
1410 void* sym = dlsym(hSplashLib, name);
1411 return sym;
1412 } else {
1413 return NULL;
1414 }
1415 }
1416
1417 void SplashFreeLibrary() {
1418 if (hSplashLib) {
1419 dlclose(hSplashLib);
1420 hSplashLib = NULL;
1421 }
1422 }
1423
1424 const char *
1425 jlong_format_specifier() {
1426 return "%lld";
1427 }
1428
1429
1430
1431 /*
1432 * Block current thread and continue execution in a new thread
1433 */
1434 int
1435 ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
1436 int rslt;
1437 #ifdef __linux__
1438 pthread_t tid;
1439 pthread_attr_t attr;
1440 pthread_attr_init(&attr);
1441 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1442
1443 if (stack_size > 0) {
1444 pthread_attr_setstacksize(&attr, stack_size);
1445 }
1446
1447 if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
1448 void * tmp;
1449 pthread_join(tid, &tmp);
1450 rslt = (int)tmp;
1451 } else {
1452 /*
1453 * Continue execution in current thread if for some reason (e.g. out of
1454 * memory/LWP) a new thread can't be created. This will likely fail
1455 * later in continuation as JNI_CreateJavaVM needs to create quite a
1456 * few new threads, anyway, just give it a try..
1457 */
1458 rslt = continuation(args);
1459 }
1460
1461 pthread_attr_destroy(&attr);
1462 #else
1463 thread_t tid;
1464 long flags = 0;
1465 if (thr_create(NULL, stack_size, (void *(*)(void *))continuation, args, flags, &tid) == 0) {
1466 void * tmp;
1467 thr_join(tid, NULL, &tmp);
1468 rslt = (int)tmp;
1469 } else {
1470 /* See above. Continue in current thread if thr_create() failed */
1471 rslt = continuation(args);
1472 }
1473 #endif
1474 return rslt;
1475 }
1476
1477 /* Coarse estimation of number of digits assuming the worst case is a 64-bit pid. */
1478 #define MAX_PID_STR_SZ 20
1479
1480 void SetJavaLauncherPlatformProps() {
1481 /* Linux only */
1482 #ifdef __linux__
1483 const char *substr = "-Dsun.java.launcher.pid=";
1484 char *pid_prop_str = (char *)JLI_MemAlloc(JLI_StrLen(substr) + MAX_PID_STR_SZ + 1);
1485 sprintf(pid_prop_str, "%s%d", substr, getpid());
1486 AddOption(pid_prop_str, NULL);
1487 #endif
1488 }
1489
1490 jboolean
1491 IsJavaw()
1492 {
1493 /* noop on UNIX */
1494 return JNI_FALSE;
1495 }
1496
1497 void
1498 InitLauncher(jboolean javaw)
1499 {
1500 JLI_SetTraceLauncher();
1501 }
1502
1503 /*
1504 * The implementation for finding classes from the bootstrap
1505 * class loader, refer to java.h
1506 */
1507 static FindClassFromBootLoader_t *findBootClass = NULL;
1508
1509 jclass
1510 FindBootStrapClass(JNIEnv *env, const char* classname)
1511 {
1512 if (findBootClass == NULL) {
1513 findBootClass = (FindClassFromBootLoader_t *)dlsym(RTLD_DEFAULT,
1514 "JVM_FindClassFromBootLoader");
1515 if (findBootClass == NULL) {
1516 JLI_ReportErrorMessage(DLL_ERROR4,
1517 "JVM_FindClassFromBootLoader");
1518 return NULL;
1519 }
1520 }
1521 return findBootClass(env, classname);
1522 }