1 /*
2 * Copyright (c) 2007, 2017, 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 package sun.launcher;
27
28 /*
29 *
30 * <p><b>This is NOT part of any API supported by Sun Microsystems.
31 * If you write code that depends on this, you do so at your own
32 * risk. This code and its internal interfaces are subject to change
33 * or deletion without notice.</b>
34 *
35 */
36
37 /**
38 * A utility package for the java(1), javaw(1) launchers.
39 * The following are helper methods that the native launcher uses
40 * to perform checks etc. using JNI, see src/share/bin/java.c
41 */
42 import java.io.File;
43 import java.io.IOException;
44 import java.io.PrintStream;
45 import java.io.UnsupportedEncodingException;
46 import java.lang.module.ModuleFinder;
47 import java.lang.module.ModuleReference;
48 import java.lang.module.ModuleDescriptor;
49 import java.lang.module.ModuleDescriptor.Requires;
50 import java.lang.module.ModuleDescriptor.Exports;
51 import java.lang.module.ModuleDescriptor.Opens;
52 import java.lang.module.ModuleDescriptor.Provides;
53 import java.lang.reflect.Layer;
54 import java.lang.reflect.Method;
55 import java.lang.reflect.Modifier;
56 import java.lang.reflect.Module;
57 import java.math.BigDecimal;
58 import java.math.RoundingMode;
59 import java.net.URI;
60 import java.nio.charset.Charset;
61 import java.nio.file.DirectoryStream;
62 import java.nio.file.Files;
63 import java.nio.file.Path;
64 import java.text.Normalizer;
65 import java.text.MessageFormat;
66 import java.util.ArrayList;
67 import java.util.Collection;
68 import java.util.Collections;
69 import java.util.Comparator;
70 import java.util.HashSet;
71 import java.util.Iterator;
72 import java.util.List;
73 import java.util.Locale;
74 import java.util.Locale.Category;
75 import java.util.Map;
76 import java.util.Optional;
77 import java.util.Properties;
78 import java.util.ResourceBundle;
79 import java.util.Set;
80 import java.util.TreeSet;
81 import java.util.jar.Attributes;
82 import java.util.jar.JarFile;
83 import java.util.jar.Manifest;
84 import java.util.stream.Collectors;
85 import java.util.stream.Stream;
86
87 import jdk.internal.misc.VM;
88 import jdk.internal.module.IllegalAccessLogger;
89 import jdk.internal.module.Modules;
90
91
92 public final class LauncherHelper {
93
94 // No instantiation
95 private LauncherHelper() {}
96
97 // used to identify JavaFX applications
98 private static final String JAVAFX_APPLICATION_MARKER =
99 "JavaFX-Application-Class";
100 private static final String JAVAFX_APPLICATION_CLASS_NAME =
101 "javafx.application.Application";
102 private static final String JAVAFX_FXHELPER_CLASS_NAME_SUFFIX =
103 "sun.launcher.LauncherHelper$FXHelper";
104 private static final String MAIN_CLASS = "Main-Class";
105 private static final String ADD_EXPORTS = "Add-Exports";
106 private static final String ADD_OPENS = "Add-Opens";
107
108 private static StringBuilder outBuf = new StringBuilder();
109
110 private static final String INDENT = " ";
111 private static final String VM_SETTINGS = "VM settings:";
112 private static final String PROP_SETTINGS = "Property settings:";
113 private static final String LOCALE_SETTINGS = "Locale settings:";
114
115 // sync with java.c and jdk.internal.misc.VM
116 private static final String diagprop = "sun.java.launcher.diag";
117 static final boolean trace = VM.getSavedProperty(diagprop) != null;
118
119 private static final String defaultBundleName =
120 "sun.launcher.resources.launcher";
121 private static class ResourceBundleHolder {
122 private static final ResourceBundle RB =
123 ResourceBundle.getBundle(defaultBundleName);
124 }
125 private static PrintStream ostream;
126 private static Class<?> appClass; // application class, for GUI/reporting purposes
127
128 /*
129 * A method called by the launcher to print out the standard settings,
130 * by default -XshowSettings is equivalent to -XshowSettings:all,
131 * Specific information may be gotten by using suboptions with possible
132 * values vm, properties and locale.
133 *
134 * printToStderr: choose between stdout and stderr
135 *
136 * optionFlag: specifies which options to print default is all other
137 * possible values are vm, properties, locale.
138 *
139 * initialHeapSize: in bytes, as set by the launcher, a zero-value indicates
140 * this code should determine this value, using a suitable method or
141 * the line could be omitted.
142 *
143 * maxHeapSize: in bytes, as set by the launcher, a zero-value indicates
144 * this code should determine this value, using a suitable method.
145 *
146 * stackSize: in bytes, as set by the launcher, a zero-value indicates
147 * this code determine this value, using a suitable method or omit the
148 * line entirely.
149 */
150 static void showSettings(boolean printToStderr, String optionFlag,
151 long initialHeapSize, long maxHeapSize, long stackSize) {
152
153 initOutput(printToStderr);
154 String opts[] = optionFlag.split(":");
155 String optStr = (opts.length > 1 && opts[1] != null)
156 ? opts[1].trim()
157 : "all";
158 switch (optStr) {
159 case "vm":
160 printVmSettings(initialHeapSize, maxHeapSize, stackSize);
161 break;
162 case "properties":
163 printProperties();
164 break;
165 case "locale":
166 printLocale();
167 break;
168 default:
169 printVmSettings(initialHeapSize, maxHeapSize, stackSize);
170 printProperties();
171 printLocale();
172 break;
173 }
174 }
175
176 /*
177 * prints the main vm settings subopt/section
178 */
179 private static void printVmSettings(
180 long initialHeapSize, long maxHeapSize,
181 long stackSize) {
182
183 ostream.println(VM_SETTINGS);
184 if (stackSize != 0L) {
185 ostream.println(INDENT + "Stack Size: " +
186 SizePrefix.scaleValue(stackSize));
187 }
188 if (initialHeapSize != 0L) {
189 ostream.println(INDENT + "Min. Heap Size: " +
190 SizePrefix.scaleValue(initialHeapSize));
191 }
192 if (maxHeapSize != 0L) {
193 ostream.println(INDENT + "Max. Heap Size: " +
194 SizePrefix.scaleValue(maxHeapSize));
195 } else {
196 ostream.println(INDENT + "Max. Heap Size (Estimated): "
197 + SizePrefix.scaleValue(Runtime.getRuntime().maxMemory()));
198 }
199 ostream.println(INDENT + "Using VM: "
200 + System.getProperty("java.vm.name"));
201 ostream.println();
202 }
203
204 /*
205 * prints the properties subopt/section
206 */
207 private static void printProperties() {
208 Properties p = System.getProperties();
209 ostream.println(PROP_SETTINGS);
210 List<String> sortedPropertyKeys = new ArrayList<>();
211 sortedPropertyKeys.addAll(p.stringPropertyNames());
212 Collections.sort(sortedPropertyKeys);
213 for (String x : sortedPropertyKeys) {
214 printPropertyValue(x, p.getProperty(x));
215 }
216 ostream.println();
217 }
218
219 private static boolean isPath(String key) {
220 return key.endsWith(".dirs") || key.endsWith(".path");
221 }
222
223 private static void printPropertyValue(String key, String value) {
224 ostream.print(INDENT + key + " = ");
225 if (key.equals("line.separator")) {
226 for (byte b : value.getBytes()) {
227 switch (b) {
228 case 0xd:
229 ostream.print("\\r ");
230 break;
231 case 0xa:
232 ostream.print("\\n ");
233 break;
234 default:
235 // print any bizzare line separators in hex, but really
236 // shouldn't happen.
237 ostream.printf("0x%02X", b & 0xff);
238 break;
239 }
240 }
241 ostream.println();
242 return;
243 }
244 if (!isPath(key)) {
245 ostream.println(value);
246 return;
247 }
248 String[] values = value.split(System.getProperty("path.separator"));
249 boolean first = true;
250 for (String s : values) {
251 if (first) { // first line treated specially
252 ostream.println(s);
253 first = false;
254 } else { // following lines prefix with indents
255 ostream.println(INDENT + INDENT + s);
256 }
257 }
258 }
259
260 /*
261 * prints the locale subopt/section
262 */
263 private static void printLocale() {
264 Locale locale = Locale.getDefault();
265 ostream.println(LOCALE_SETTINGS);
266 ostream.println(INDENT + "default locale = " +
267 locale.getDisplayLanguage());
268 ostream.println(INDENT + "default display locale = " +
269 Locale.getDefault(Category.DISPLAY).getDisplayName());
270 ostream.println(INDENT + "default format locale = " +
271 Locale.getDefault(Category.FORMAT).getDisplayName());
272 printLocales();
273 ostream.println();
274 }
275
276 private static void printLocales() {
277 Locale[] tlocales = Locale.getAvailableLocales();
278 final int len = tlocales == null ? 0 : tlocales.length;
279 if (len < 1 ) {
280 return;
281 }
282 // Locale does not implement Comparable so we convert it to String
283 // and sort it for pretty printing.
284 Set<String> sortedSet = new TreeSet<>();
285 for (Locale l : tlocales) {
286 sortedSet.add(l.toString());
287 }
288
289 ostream.print(INDENT + "available locales = ");
290 Iterator<String> iter = sortedSet.iterator();
291 final int last = len - 1;
292 for (int i = 0 ; iter.hasNext() ; i++) {
293 String s = iter.next();
294 ostream.print(s);
295 if (i != last) {
296 ostream.print(", ");
297 }
298 // print columns of 8
299 if ((i + 1) % 8 == 0) {
300 ostream.println();
301 ostream.print(INDENT + INDENT);
302 }
303 }
304 }
305
306 private enum SizePrefix {
307
308 KILO(1024, "K"),
309 MEGA(1024 * 1024, "M"),
310 GIGA(1024 * 1024 * 1024, "G"),
311 TERA(1024L * 1024L * 1024L * 1024L, "T");
312 long size;
313 String abbrev;
314
315 SizePrefix(long size, String abbrev) {
316 this.size = size;
317 this.abbrev = abbrev;
318 }
319
320 private static String scale(long v, SizePrefix prefix) {
321 return BigDecimal.valueOf(v).divide(BigDecimal.valueOf(prefix.size),
322 2, RoundingMode.HALF_EVEN).toPlainString() + prefix.abbrev;
323 }
324 /*
325 * scale the incoming values to a human readable form, represented as
326 * K, M, G and T, see java.c parse_size for the scaled values and
327 * suffixes. The lowest possible scaled value is Kilo.
328 */
329 static String scaleValue(long v) {
330 if (v < MEGA.size) {
331 return scale(v, KILO);
332 } else if (v < GIGA.size) {
333 return scale(v, MEGA);
334 } else if (v < TERA.size) {
335 return scale(v, GIGA);
336 } else {
337 return scale(v, TERA);
338 }
339 }
340 }
341
342 /**
343 * A private helper method to get a localized message and also
344 * apply any arguments that we might pass.
345 */
346 private static String getLocalizedMessage(String key, Object... args) {
347 String msg = ResourceBundleHolder.RB.getString(key);
348 return (args != null) ? MessageFormat.format(msg, args) : msg;
349 }
350
351 /**
352 * The java -help message is split into 3 parts, an invariant, followed
353 * by a set of platform dependent variant messages, finally an invariant
354 * set of lines.
355 * This method initializes the help message for the first time, and also
356 * assembles the invariant header part of the message.
357 */
358 static void initHelpMessage(String progname) {
359 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.header",
360 (progname == null) ? "java" : progname ));
361 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.datamodel",
362 32));
363 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.datamodel",
364 64));
365 }
366
367 /**
368 * Appends the vm selection messages to the header, already created.
369 * initHelpSystem must already be called.
370 */
371 static void appendVmSelectMessage(String vm1, String vm2) {
372 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.vmselect",
373 vm1, vm2));
374 }
375
376 /**
377 * Appends the vm synoym message to the header, already created.
378 * initHelpSystem must be called before using this method.
379 */
380 static void appendVmSynonymMessage(String vm1, String vm2) {
381 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.hotspot",
382 vm1, vm2));
383 }
384
385 /**
386 * Appends the last invariant part to the previously created messages,
387 * and finishes up the printing to the desired output stream.
388 * initHelpSystem must be called before using this method.
389 */
390 static void printHelpMessage(boolean printToStderr) {
391 initOutput(printToStderr);
392 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.footer",
393 File.pathSeparator));
394 ostream.println(outBuf.toString());
395 }
396
397 /**
398 * Prints the Xusage text to the desired output stream.
399 */
400 static void printXUsageMessage(boolean printToStderr) {
401 initOutput(printToStderr);
402 ostream.println(getLocalizedMessage("java.launcher.X.usage",
403 File.pathSeparator));
404 if (System.getProperty("os.name").contains("OS X")) {
405 ostream.println(getLocalizedMessage("java.launcher.X.macosx.usage",
406 File.pathSeparator));
407 }
408 }
409
410 static void initOutput(boolean printToStderr) {
411 ostream = (printToStderr) ? System.err : System.out;
412 }
413
414 static String getMainClassFromJar(String jarname) {
415 String mainValue = null;
416 try (JarFile jarFile = new JarFile(jarname)) {
417 Manifest manifest = jarFile.getManifest();
418 if (manifest == null) {
419 abort(null, "java.launcher.jar.error2", jarname);
420 }
421 Attributes mainAttrs = manifest.getMainAttributes();
422 if (mainAttrs == null) {
423 abort(null, "java.launcher.jar.error3", jarname);
424 }
425
426 // Main-Class
427 mainValue = mainAttrs.getValue(MAIN_CLASS);
428 if (mainValue == null) {
429 abort(null, "java.launcher.jar.error3", jarname);
430 }
431
432 // Add-Exports and Add-Opens to allow illegal access
433 String exports = mainAttrs.getValue(ADD_EXPORTS);
434 if (exports != null) {
435 String warn = getLocalizedMessage("java.launcher.permitaccess.warning",
436 jarname, ADD_EXPORTS);
437 System.err.println(warn);
438 addExportsOrOpens(exports, false, ADD_EXPORTS);
439 }
440 String opens = mainAttrs.getValue(ADD_OPENS);
441 if (opens != null) {
442 String warn = getLocalizedMessage("java.launcher.permitaccess.warning",
443 jarname, ADD_OPENS);
444 System.err.println(warn);
445 addExportsOrOpens(opens, true, ADD_OPENS);
446 }
447
448 /*
449 * Hand off to FXHelper if it detects a JavaFX application
450 * This must be done after ensuring a Main-Class entry
451 * exists to enforce compliance with the jar specification
452 */
453 if (mainAttrs.containsKey(
454 new Attributes.Name(JAVAFX_APPLICATION_MARKER))) {
455 FXHelper.setFXLaunchParameters(jarname, LM_JAR);
456 return FXHelper.class.getName();
457 }
458
459 return mainValue.trim();
460 } catch (IOException ioe) {
461 abort(ioe, "java.launcher.jar.error1", jarname);
462 }
463 return null;
464 }
465
466 /**
467 * Process the Add-Exports or Add-Opens value. The value is
468 * {@code <module>/<package> ( <module>/<package>)*}.
469 */
470 static void addExportsOrOpens(String value, boolean open, String how) {
471 IllegalAccessLogger.Builder builder;
472 IllegalAccessLogger logger = IllegalAccessLogger.illegalAccessLogger();
473 if (logger == null) {
474 builder = new IllegalAccessLogger.Builder();
475 } else {
476 builder = logger.toBuilder();
477 }
478
479 for (String moduleAndPackage : value.split(" ")) {
480 String[] s = moduleAndPackage.trim().split("/");
481 if (s.length == 2) {
482 String mn = s[0];
483 String pn = s[1];
484
485 Layer.boot().findModule(mn).ifPresent(m -> {
486 if (m.getDescriptor().packages().contains(pn)) {
487 if (open) {
488 builder.logAccessToOpenPackage(m, pn, how);
489 Modules.addOpensToAllUnnamed(m, pn);
490 } else {
491 builder.logAccessToExportedPackage(m, pn, how);
492 Modules.addExportsToAllUnnamed(m, pn);
493 }
494 }
495 });
496 }
497 }
498
499 IllegalAccessLogger.setIllegalAccessLogger(builder.build());
500 }
501
502 // From src/share/bin/java.c:
503 // enum LaunchMode { LM_UNKNOWN = 0, LM_CLASS, LM_JAR, LM_MODULE }
504
505 private static final int LM_UNKNOWN = 0;
506 private static final int LM_CLASS = 1;
507 private static final int LM_JAR = 2;
508 private static final int LM_MODULE = 3;
509
510 static void abort(Throwable t, String msgKey, Object... args) {
511 if (msgKey != null) {
512 ostream.println(getLocalizedMessage(msgKey, args));
513 }
514 if (trace) {
515 if (t != null) {
516 t.printStackTrace();
517 } else {
518 Thread.dumpStack();
519 }
520 }
521 System.exit(1);
522 }
523
524 /**
525 * This method:
526 * 1. Loads the main class from the module or class path
527 * 2. Checks the public static void main method.
528 * 3. If the main class extends FX Application then call on FXHelper to
529 * perform the launch.
530 *
531 * @param printToStderr if set, all output will be routed to stderr
532 * @param mode LaunchMode as determined by the arguments passed on the
533 * command line
534 * @param what the module name[/class], JAR file, or the main class
535 * depending on the mode
536 *
537 * @return the application's main class
538 */
539 public static Class<?> checkAndLoadMain(boolean printToStderr,
540 int mode,
541 String what) {
542 initOutput(printToStderr);
543
544 Class<?> mainClass = (mode == LM_MODULE) ? loadModuleMainClass(what)
545 : loadMainClass(mode, what);
546
547 // record the real main class for UI purposes
548 // neither method above can return null, they will abort()
549 appClass = mainClass;
550
551 /*
552 * Check if FXHelper can launch it using the FX launcher. In an FX app,
553 * the main class may or may not have a main method, so do this before
554 * validating the main class.
555 */
556 if (JAVAFX_FXHELPER_CLASS_NAME_SUFFIX.equals(mainClass.getName()) ||
557 doesExtendFXApplication(mainClass)) {
558 // Will abort() if there are problems with FX runtime
559 FXHelper.setFXLaunchParameters(what, mode);
560 mainClass = FXHelper.class;
561 }
562
563 validateMainClass(mainClass);
564
565 return mainClass;
566 }
567
568 /**
569 * Returns the main class for a module. The query is either a module name
570 * or module-name/main-class. For the former then the module's main class
571 * is obtained from the module descriptor (MainClass attribute).
572 */
573 private static Class<?> loadModuleMainClass(String what) {
574 int i = what.indexOf('/');
575 String mainModule;
576 String mainClass;
577 if (i == -1) {
578 mainModule = what;
579 mainClass = null;
580 } else {
581 mainModule = what.substring(0, i);
582 mainClass = what.substring(i+1);
583 }
584
585 // main module is in the boot layer
586 Layer layer = Layer.boot();
587 Optional<Module> om = layer.findModule(mainModule);
588 if (!om.isPresent()) {
589 // should not happen
590 throw new InternalError("Module " + mainModule + " not in boot Layer");
591 }
592 Module m = om.get();
593
594 // get main class
595 if (mainClass == null) {
596 Optional<String> omc = m.getDescriptor().mainClass();
597 if (!omc.isPresent()) {
598 abort(null, "java.launcher.module.error1", mainModule);
599 }
600 mainClass = omc.get();
601 }
602
603 // load the class from the module
604 Class<?> c = null;
605 try {
606 c = Class.forName(m, mainClass);
607 if (c == null && System.getProperty("os.name", "").contains("OS X")
608 && Normalizer.isNormalized(mainClass, Normalizer.Form.NFD)) {
609
610 String cn = Normalizer.normalize(mainClass, Normalizer.Form.NFC);
611 c = Class.forName(m, cn);
612 }
613 } catch (LinkageError le) {
614 abort(null, "java.launcher.module.error3", mainClass, m.getName(),
615 le.getClass().getName() + ": " + le.getLocalizedMessage());
616 }
617 if (c == null) {
618 abort(null, "java.launcher.module.error2", mainClass, mainModule);
619 }
620
621 System.setProperty("jdk.module.main.class", c.getName());
622 return c;
623 }
624
625 /**
626 * Loads the main class from the class path (LM_CLASS or LM_JAR).
627 */
628 private static Class<?> loadMainClass(int mode, String what) {
629 // get the class name
630 String cn;
631 switch (mode) {
632 case LM_CLASS:
633 cn = what;
634 break;
635 case LM_JAR:
636 cn = getMainClassFromJar(what);
637 break;
638 default:
639 // should never happen
640 throw new InternalError("" + mode + ": Unknown launch mode");
641 }
642
643 // load the main class
644 cn = cn.replace('/', '.');
645 Class<?> mainClass = null;
646 ClassLoader scl = ClassLoader.getSystemClassLoader();
647 try {
648 try {
649 mainClass = Class.forName(cn, false, scl);
650 } catch (NoClassDefFoundError | ClassNotFoundException cnfe) {
651 if (System.getProperty("os.name", "").contains("OS X")
652 && Normalizer.isNormalized(cn, Normalizer.Form.NFD)) {
653 try {
654 // On Mac OS X since all names with diacritical marks are
655 // given as decomposed it is possible that main class name
656 // comes incorrectly from the command line and we have
657 // to re-compose it
658 String ncn = Normalizer.normalize(cn, Normalizer.Form.NFC);
659 mainClass = Class.forName(ncn, false, scl);
660 } catch (NoClassDefFoundError | ClassNotFoundException cnfe1) {
661 abort(cnfe1, "java.launcher.cls.error1", cn,
662 cnfe1.getClass().getCanonicalName(), cnfe1.getMessage());
663 }
664 } else {
665 abort(cnfe, "java.launcher.cls.error1", cn,
666 cnfe.getClass().getCanonicalName(), cnfe.getMessage());
667 }
668 }
669 } catch (LinkageError le) {
670 abort(le, "java.launcher.cls.error6", cn,
671 le.getClass().getName() + ": " + le.getLocalizedMessage());
672 }
673 return mainClass;
674 }
675
676 /*
677 * Accessor method called by the launcher after getting the main class via
678 * checkAndLoadMain(). The "application class" is the class that is finally
679 * executed to start the application and in this case is used to report
680 * the correct application name, typically for UI purposes.
681 */
682 public static Class<?> getApplicationClass() {
683 return appClass;
684 }
685
686 /*
687 * Check if the given class is a JavaFX Application class. This is done
688 * in a way that does not cause the Application class to load or throw
689 * ClassNotFoundException if the JavaFX runtime is not available.
690 */
691 private static boolean doesExtendFXApplication(Class<?> mainClass) {
692 for (Class<?> sc = mainClass.getSuperclass(); sc != null;
693 sc = sc.getSuperclass()) {
694 if (sc.getName().equals(JAVAFX_APPLICATION_CLASS_NAME)) {
695 return true;
696 }
697 }
698 return false;
699 }
700
701 // Check the existence and signature of main and abort if incorrect
702 static void validateMainClass(Class<?> mainClass) {
703 Method mainMethod;
704 try {
705 mainMethod = mainClass.getMethod("main", String[].class);
706 } catch (NoSuchMethodException nsme) {
707 // invalid main or not FX application, abort with an error
708 abort(null, "java.launcher.cls.error4", mainClass.getName(),
709 JAVAFX_APPLICATION_CLASS_NAME);
710 return; // Avoid compiler issues
711 }
712
713 /*
714 * getMethod (above) will choose the correct method, based
715 * on its name and parameter type, however, we still have to
716 * ensure that the method is static and returns a void.
717 */
718 int mod = mainMethod.getModifiers();
719 if (!Modifier.isStatic(mod)) {
720 abort(null, "java.launcher.cls.error2", "static",
721 mainMethod.getDeclaringClass().getName());
722 }
723 if (mainMethod.getReturnType() != java.lang.Void.TYPE) {
724 abort(null, "java.launcher.cls.error3",
725 mainMethod.getDeclaringClass().getName());
726 }
727 }
728
729 private static final String encprop = "sun.jnu.encoding";
730 private static String encoding = null;
731 private static boolean isCharsetSupported = false;
732
733 /*
734 * converts a c or a byte array to a platform specific string,
735 * previously implemented as a native method in the launcher.
736 */
737 static String makePlatformString(boolean printToStderr, byte[] inArray) {
738 initOutput(printToStderr);
739 if (encoding == null) {
740 encoding = System.getProperty(encprop);
741 isCharsetSupported = Charset.isSupported(encoding);
742 }
743 try {
744 String out = isCharsetSupported
745 ? new String(inArray, encoding)
746 : new String(inArray);
747 return out;
748 } catch (UnsupportedEncodingException uee) {
749 abort(uee, null);
750 }
751 return null; // keep the compiler happy
752 }
753
754 static String[] expandArgs(String[] argArray) {
755 List<StdArg> aList = new ArrayList<>();
756 for (String x : argArray) {
757 aList.add(new StdArg(x));
758 }
759 return expandArgs(aList);
760 }
761
762 static String[] expandArgs(List<StdArg> argList) {
763 ArrayList<String> out = new ArrayList<>();
764 if (trace) {
765 System.err.println("Incoming arguments:");
766 }
767 for (StdArg a : argList) {
768 if (trace) {
769 System.err.println(a);
770 }
771 if (a.needsExpansion) {
772 File x = new File(a.arg);
773 File parent = x.getParentFile();
774 String glob = x.getName();
775 if (parent == null) {
776 parent = new File(".");
777 }
778 try (DirectoryStream<Path> dstream =
779 Files.newDirectoryStream(parent.toPath(), glob)) {
780 int entries = 0;
781 for (Path p : dstream) {
782 out.add(p.normalize().toString());
783 entries++;
784 }
785 if (entries == 0) {
786 out.add(a.arg);
787 }
788 } catch (Exception e) {
789 out.add(a.arg);
790 if (trace) {
791 System.err.println("Warning: passing argument as-is " + a);
792 System.err.print(e);
793 }
794 }
795 } else {
796 out.add(a.arg);
797 }
798 }
799 String[] oarray = new String[out.size()];
800 out.toArray(oarray);
801
802 if (trace) {
803 System.err.println("Expanded arguments:");
804 for (String x : oarray) {
805 System.err.println(x);
806 }
807 }
808 return oarray;
809 }
810
811 /* duplicate of the native StdArg struct */
812 private static class StdArg {
813 final String arg;
814 final boolean needsExpansion;
815 StdArg(String arg, boolean expand) {
816 this.arg = arg;
817 this.needsExpansion = expand;
818 }
819 // protocol: first char indicates whether expansion is required
820 // 'T' = true ; needs expansion
821 // 'F' = false; needs no expansion
822 StdArg(String in) {
823 this.arg = in.substring(1);
824 needsExpansion = in.charAt(0) == 'T';
825 }
826 public String toString() {
827 return "StdArg{" + "arg=" + arg + ", needsExpansion=" + needsExpansion + '}';
828 }
829 }
830
831 static final class FXHelper {
832
833 private static final String JAVAFX_GRAPHICS_MODULE_NAME =
834 "javafx.graphics";
835
836 private static final String JAVAFX_LAUNCHER_CLASS_NAME =
837 "com.sun.javafx.application.LauncherImpl";
838
839 /*
840 * The launch method used to invoke the JavaFX launcher. These must
841 * match the strings used in the launchApplication method.
842 *
843 * Command line JavaFX-App-Class Launch mode FX Launch mode
844 * java -cp fxapp.jar FXClass N/A LM_CLASS "LM_CLASS"
845 * java -cp somedir FXClass N/A LM_CLASS "LM_CLASS"
846 * java -jar fxapp.jar Present LM_JAR "LM_JAR"
847 * java -jar fxapp.jar Not Present LM_JAR "LM_JAR"
848 * java -m module/class [1] N/A LM_MODULE "LM_MODULE"
849 * java -m module N/A LM_MODULE "LM_MODULE"
850 *
851 * [1] - JavaFX-Application-Class is ignored when modular args are used, even
852 * if present in a modular jar
853 */
854 private static final String JAVAFX_LAUNCH_MODE_CLASS = "LM_CLASS";
855 private static final String JAVAFX_LAUNCH_MODE_JAR = "LM_JAR";
856 private static final String JAVAFX_LAUNCH_MODE_MODULE = "LM_MODULE";
857
858 /*
859 * FX application launcher and launch method, so we can launch
860 * applications with no main method.
861 */
862 private static String fxLaunchName = null;
863 private static String fxLaunchMode = null;
864
865 private static Class<?> fxLauncherClass = null;
866 private static Method fxLauncherMethod = null;
867
868 /*
869 * Set the launch params according to what was passed to LauncherHelper
870 * so we can use the same launch mode for FX. Abort if there is any
871 * issue with loading the FX runtime or with the launcher method.
872 */
873 private static void setFXLaunchParameters(String what, int mode) {
874
875 // find the module with the FX launcher
876 Optional<Module> om = Layer.boot().findModule(JAVAFX_GRAPHICS_MODULE_NAME);
877 if (!om.isPresent()) {
878 abort(null, "java.launcher.cls.error5");
879 }
880
881 // load the FX launcher class
882 fxLauncherClass = Class.forName(om.get(), JAVAFX_LAUNCHER_CLASS_NAME);
883 if (fxLauncherClass == null) {
884 abort(null, "java.launcher.cls.error5");
885 }
886
887 try {
888 /*
889 * signature must be:
890 * public static void launchApplication(String launchName,
891 * String launchMode, String[] args);
892 */
893 fxLauncherMethod = fxLauncherClass.getMethod("launchApplication",
894 String.class, String.class, String[].class);
895
896 // verify launcher signature as we do when validating the main method
897 int mod = fxLauncherMethod.getModifiers();
898 if (!Modifier.isStatic(mod)) {
899 abort(null, "java.launcher.javafx.error1");
900 }
901 if (fxLauncherMethod.getReturnType() != java.lang.Void.TYPE) {
902 abort(null, "java.launcher.javafx.error1");
903 }
904 } catch (NoSuchMethodException ex) {
905 abort(ex, "java.launcher.cls.error5", ex);
906 }
907
908 fxLaunchName = what;
909 switch (mode) {
910 case LM_CLASS:
911 fxLaunchMode = JAVAFX_LAUNCH_MODE_CLASS;
912 break;
913 case LM_JAR:
914 fxLaunchMode = JAVAFX_LAUNCH_MODE_JAR;
915 break;
916 case LM_MODULE:
917 fxLaunchMode = JAVAFX_LAUNCH_MODE_MODULE;
918 break;
919 default:
920 // should not have gotten this far...
921 throw new InternalError(mode + ": Unknown launch mode");
922 }
923 }
924
925 public static void main(String... args) throws Exception {
926 if (fxLauncherMethod == null
927 || fxLaunchMode == null
928 || fxLaunchName == null) {
929 throw new RuntimeException("Invalid JavaFX launch parameters");
930 }
931 // launch appClass via fxLauncherMethod
932 fxLauncherMethod.invoke(null,
933 new Object[] {fxLaunchName, fxLaunchMode, args});
934 }
935 }
936
937 private static void formatCommaList(PrintStream out,
938 String prefix,
939 Collection<?> list)
940 {
941 if (list.isEmpty())
942 return;
943 out.format("%s", prefix);
944 boolean first = true;
945 for (Object ob : list) {
946 if (first) {
947 out.format(" %s", ob);
948 first = false;
949 } else {
950 out.format(", %s", ob);
951 }
952 }
953 out.format("%n");
954 }
955
956 /**
957 * Called by the launcher to list the observable modules.
958 * If called without any sub-options then the output is a simple list of
959 * the modules. If called with sub-options then the sub-options are the
960 * names of the modules to list (-listmods:java.base,java.desktop for
961 * example).
962 */
963 static void listModules(boolean printToStderr, String optionFlag)
964 throws IOException, ClassNotFoundException
965 {
966 initOutput(printToStderr);
967
968 ModuleFinder finder = jdk.internal.module.ModuleBootstrap.finder();
969
970 int colon = optionFlag.indexOf('=');
971 if (colon == -1) {
972 finder.findAll().stream()
973 .sorted(Comparator.comparing(ModuleReference::descriptor))
974 .forEach(md -> {
975 ostream.println(midAndLocation(md.descriptor(),
976 md.location()));
977 });
978 } else {
979 String[] names = optionFlag.substring(colon+1).split(",");
980 for (String name: names) {
981 ModuleReference mref = finder.find(name).orElse(null);
982 if (mref == null) {
983 System.err.format("%s not observable!%n", name);
984 continue;
985 }
986
987 ModuleDescriptor md = mref.descriptor();
988 if (md.isOpen())
989 ostream.print("open ");
990 if (md.isAutomatic())
991 ostream.print("automatic ");
992 if (md.modifiers().contains(ModuleDescriptor.Modifier.SYNTHETIC))
993 ostream.print("synthetic ");
994 if (md.modifiers().contains(ModuleDescriptor.Modifier.MANDATED))
995 ostream.print("mandated ");
996 ostream.println("module " + midAndLocation(md, mref.location()));
997
998 // unqualified exports (sorted by package)
999 Set<Exports> exports = new TreeSet<>(Comparator.comparing(Exports::source));
1000 md.exports().stream().filter(e -> !e.isQualified()).forEach(exports::add);
1001 for (Exports e : exports) {
1002 String modsAndSource = Stream.concat(toStringStream(e.modifiers()),
1003 Stream.of(e.source()))
1004 .collect(Collectors.joining(" "));
1005 ostream.format(" exports %s%n", modsAndSource);
1006 }
1007
1008 for (Requires d : md.requires()) {
1009 ostream.format(" requires %s%n", d);
1010 }
1011 for (String s : md.uses()) {
1012 ostream.format(" uses %s%n", s);
1013 }
1014
1015 for (Provides ps : md.provides()) {
1016 ostream.format(" provides %s with %s%n", ps.service(),
1017 ps.providers().stream().collect(Collectors.joining(", ")));
1018 }
1019
1020 // qualified exports
1021 for (Exports e : md.exports()) {
1022 if (e.isQualified()) {
1023 String modsAndSource = Stream.concat(toStringStream(e.modifiers()),
1024 Stream.of(e.source()))
1025 .collect(Collectors.joining(" "));
1026 ostream.format(" exports %s", modsAndSource);
1027 formatCommaList(ostream, " to", e.targets());
1028 }
1029 }
1030
1031 // open packages
1032 for (Opens obj: md.opens()) {
1033 String modsAndSource = Stream.concat(toStringStream(obj.modifiers()),
1034 Stream.of(obj.source()))
1035 .collect(Collectors.joining(" "));
1036 ostream.format(" opens %s", modsAndSource);
1037 if (obj.isQualified())
1038 formatCommaList(ostream, " to", obj.targets());
1039 else
1040 ostream.println();
1041 }
1042
1043 // non-exported/non-open packages
1044 Set<String> concealed = new TreeSet<>(md.packages());
1045 md.exports().stream().map(Exports::source).forEach(concealed::remove);
1046 md.opens().stream().map(Opens::source).forEach(concealed::remove);
1047 concealed.forEach(p -> ostream.format(" contains %s%n", p));
1048 }
1049 }
1050 }
1051
1052 static <T> String toString(Set<T> s) {
1053 return toStringStream(s).collect(Collectors.joining(" "));
1054 }
1055
1056 static <T> Stream<String> toStringStream(Set<T> s) {
1057 return s.stream().map(e -> e.toString().toLowerCase());
1058 }
1059
1060 static String midAndLocation(ModuleDescriptor md, Optional<URI> location ) {
1061 URI loc = location.orElse(null);
1062 if (loc == null || loc.getScheme().equalsIgnoreCase("jrt"))
1063 return md.toNameAndVersion();
1064 else
1065 return md.toNameAndVersion() + " (" + loc + ")";
1066 }
1067 }