1 /*
2 * Copyright (c) 1999, 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 package sun.applet;
27
28 import java.io.BufferedInputStream;
29 import java.io.File;
30 import java.io.FileInputStream;
31 import java.io.FileOutputStream;
32 import java.io.IOException;
33 import java.net.URL;
34 import java.net.MalformedURLException;
35 import java.util.Enumeration;
36 import java.util.Properties;
37 import java.util.Vector;
38 import sun.net.www.ParseUtil;
39
40 /**
41 * The main entry point into AppletViewer.
42 *
43 * @deprecated The Applet API is deprecated. See the
44 * <a href="../../java/applet/package-summary.html"> java.applet package
45 * documentation</a> for further information.
46 */
47 @Deprecated(since = "9")
48 public class Main {
49 /**
50 * The file which contains all of the AppletViewer specific properties.
51 */
52 static File theUserPropertiesFile;
53
54 /**
55 * The default key/value pairs for the required user-specific properties.
56 */
57 static final String [][] avDefaultUserProps = {
58 // There's a bootstrapping problem here. If we don't have a proxyHost,
59 // then we will not be able to connect to a URL outside the firewall;
60 // however, there's no way for us to set the proxyHost without starting
61 // AppletViewer. This problem existed before the re-write.
62 {"http.proxyHost", ""},
63 {"http.proxyPort", "80"},
64 {"package.restrict.access.sun", "true"}
65 };
66
67 static {
68 File userHome = new File(System.getProperty("user.home"));
69 // make sure we can write to this location
70 userHome.canWrite();
71
72 theUserPropertiesFile = new File(userHome, ".appletviewer");
73 }
74
75 // i18n
76 private static AppletMessageHandler amh = new AppletMessageHandler("appletviewer");
77
78 /**
79 * Member variables set according to options passed in to AppletViewer.
80 */
81 private boolean helpFlag = false;
82 private String encoding = null;
83 private boolean noSecurityFlag = false;
84 private static boolean cmdLineTestFlag = false;
85
86 /**
87 * The list of valid URLs passed in to AppletViewer.
88 */
89 private static Vector<URL> urlList = new Vector<>(1);
90
91 // This is used in init(). Getting rid of this is desirable but depends
92 // on whether the property that uses it is necessary/standard.
93 public static final String theVersion = System.getProperty("java.version");
94
95 /**
96 * The main entry point into AppletViewer.
97 */
98 public static void main(String [] args) {
99 Main m = new Main();
100 int ret = m.run(args);
101
102 // Exit immediately if we got some sort of error along the way.
103 // For debugging purposes, if we have passed in "-XcmdLineTest" we
104 // force a premature exit.
105 if ((ret != 0) || (cmdLineTestFlag))
106 System.exit(ret);
107 }
108
109 private int run(String [] args) {
110 // DECODE ARGS
111 try {
112 System.err.println(lookup("deprecated"));
113 System.err.flush();
114 if (args.length == 0) {
115 usage();
116 return 0;
117 }
118 for (int i = 0; i < args.length; ) {
119 int j = decodeArg(args, i);
120 if (j == 0) {
121 throw new ParseException(lookup("main.err.unrecognizedarg",
122 args[i]));
123 }
124 i += j;
125 }
126 } catch (ParseException e) {
127 System.err.println(e.getMessage());
128 return 1;
129 }
130
131 // CHECK ARGUMENTS
132 if (helpFlag) {
133 usage();
134 return 0;
135 }
136
137 if (urlList.size() == 0) {
138 System.err.println(lookup("main.err.inputfile"));
139 return 1;
140 }
141
142 // INSTALL THE SECURITY MANAGER (if necessary)
143 if (!noSecurityFlag && (System.getSecurityManager() == null))
144 init();
145
146 // LAUNCH APPLETVIEWER FOR EACH URL
147 for (int i = 0; i < urlList.size(); i++) {
148 try {
149 // XXX 5/17 this parsing method should be changed/fixed so that
150 // it doesn't do both parsing of the html file and launching of
151 // the AppletPanel
152 AppletViewer.parse(urlList.elementAt(i), encoding);
153 } catch (IOException e) {
154 System.err.println(lookup("main.err.io", e.getMessage()));
155 return 1;
156 }
157 }
158 return 0;
159 }
160
161 private static void usage() {
162 System.out.println(lookup("usage"));
163 }
164
165 /**
166 * Decode a single argument in an array and return the number of elements
167 * used.
168 *
169 * @param args The array of arguments.
170 * @param i The argument to decode.
171 * @return The number of array elements used when the argument was
172 * decoded.
173 * @exception ParseException
174 * Thrown when there is a problem with something in the
175 * argument array.
176 */
177 private int decodeArg(String [] args, int i) throws ParseException {
178 String arg = args[i];
179 int argc = args.length;
180
181 if ("-help".equalsIgnoreCase(arg) || "-?".equals(arg)) {
182 helpFlag = true;
183 return 1;
184 } else if ("-encoding".equals(arg) && (i < argc - 1)) {
185 if (encoding != null)
186 throw new ParseException(lookup("main.err.dupoption", arg));
187 encoding = args[++i];
188 return 2;
189 } else if ("-Xnosecurity".equals(arg)) {
190 // This is an undocumented (and, in the future, unsupported)
191 // flag which prevents AppletViewer from installing its own
192 // SecurityManager.
193
194 System.err.println();
195 System.err.println(lookup("main.warn.nosecmgr"));
196 System.err.println();
197
198 noSecurityFlag = true;
199 return 1;
200 } else if ("-XcmdLineTest".equals(arg)) {
201 // This is an internal flag which should be used for command-line
202 // testing. It instructs AppletViewer to force a premature exit
203 // immediately after the applet has been launched.
204 cmdLineTestFlag = true;
205 return 1;
206 } else if (arg.startsWith("-")) {
207 throw new ParseException(lookup("main.err.unsupportedopt", arg));
208 } else {
209 // we found what we hope is a url
210 URL url = parseURL(arg);
211 if (url != null) {
212 urlList.addElement(url);
213 return 1;
214 }
215 }
216 return 0;
217 }
218
219 /**
220 * Following the relevant RFC, construct a valid URL based on the passed in
221 * string.
222 *
223 * @param url a string which represents either a relative or absolute URL.
224 * @return a URL when the passed in string can be interpreted according
225 * to the RFC, {@code null} otherwise.
226 * @exception ParseException
227 * Thrown when we are unable to construct a proper URL from the
228 * passed in string.
229 */
230 private URL parseURL(String url) throws ParseException {
231 URL u = null;
232 // prefix of the urls with 'file' scheme
233 String prefix = "file:";
234
235 try {
236 if (url.indexOf(':') <= 1)
237 {
238 // appletviewer accepts only unencoded filesystem paths
239 u = ParseUtil.fileToEncodedURL(new File(url));
240 } else if (url.startsWith(prefix) &&
241 url.length() != prefix.length() &&
242 !(new File(url.substring(prefix.length())).isAbsolute()))
243 {
244 // relative file URL, like this "file:index.html"
245 // ensure that this file URL is absolute
246 // ParseUtil.fileToEncodedURL should be done last (see 6329251)
247 String path = ParseUtil.fileToEncodedURL(new File(System.getProperty("user.dir"))).getPath() +
248 url.substring(prefix.length());
249 u = new URL("file", "", path);
250 } else {
251 // appletviewer accepts only encoded urls
252 u = new URL(url);
253 }
254 } catch (MalformedURLException e) {
255 throw new ParseException(lookup("main.err.badurl",
256 url, e.getMessage()));
257 }
258
259 return u;
260 }
261
262 private void init() {
263 // GET APPLETVIEWER USER-SPECIFIC PROPERTIES
264 Properties avProps = getAVProps();
265
266 // ADD OTHER RANDOM PROPERTIES
267 // XXX 5/18 need to revisit why these are here, is there some
268 // standard for what is available?
269
270 // Standard browser properties
271 avProps.put("browser", "sun.applet.AppletViewer");
272 avProps.put("browser.version", "1.06");
273 avProps.put("browser.vendor", "Oracle Corporation");
274 avProps.put("http.agent", "Java(tm) 2 SDK, Standard Edition v" + theVersion);
275
276 // Define which packages can be extended by applets
277 // XXX 5/19 probably not needed, not checked in AppletSecurity
278 avProps.put("package.restrict.definition.java", "true");
279 avProps.put("package.restrict.definition.sun", "true");
280
281 // Define which properties can be read by applets.
282 // A property named by "key" can be read only when its twin
283 // property "key.applet" is true. The following ten properties
284 // are open by default. Any other property can be explicitly
285 // opened up by the browser user by calling appletviewer with
286 // -J-Dkey.applet=true
287 avProps.put("java.version.applet", "true");
288 avProps.put("java.vendor.applet", "true");
289 avProps.put("java.vendor.url.applet", "true");
290 avProps.put("java.class.version.applet", "true");
291 avProps.put("os.name.applet", "true");
292 avProps.put("os.version.applet", "true");
293 avProps.put("os.arch.applet", "true");
294 avProps.put("file.separator.applet", "true");
295 avProps.put("path.separator.applet", "true");
296 avProps.put("line.separator.applet", "true");
297
298 // Read in the System properties. If something is going to be
299 // over-written, warn about it.
300 Properties sysProps = System.getProperties();
301 for (Enumeration<?> e = sysProps.propertyNames(); e.hasMoreElements(); ) {
302 String key = (String) e.nextElement();
303 String val = sysProps.getProperty(key);
304 String oldVal;
305 if ((oldVal = (String) avProps.setProperty(key, val)) != null)
306 System.err.println(lookup("main.warn.prop.overwrite", key,
307 oldVal, val));
308 }
309
310 // INSTALL THE PROPERTY LIST
311 System.setProperties(avProps);
312
313 // Create and install the security manager
314 if (!noSecurityFlag) {
315 System.setSecurityManager(new AppletSecurity());
316 } else {
317 System.err.println(lookup("main.nosecmgr"));
318 }
319
320 // REMIND: Create and install a socket factory!
321 }
322
323 /**
324 * Read the AppletViewer user-specific properties. Typically, these
325 * properties should reside in the file $USER/.appletviewer. If this file
326 * does not exist, one will be created. Information for this file will
327 * be gleaned from $USER/.hotjava/properties. If that file does not exist,
328 * then default values will be used.
329 *
330 * @return A Properties object containing all of the AppletViewer
331 * user-specific properties.
332 */
333 private Properties getAVProps() {
334 Properties avProps = new Properties();
335
336 File dotAV = theUserPropertiesFile;
337 if (dotAV.exists()) {
338 // we must have already done the conversion
339 if (dotAV.canRead()) {
340 // just read the file
341 avProps = getAVProps(dotAV);
342 } else {
343 // send out warning and use defaults
344 System.err.println(lookup("main.warn.cantreadprops",
345 dotAV.toString()));
346 avProps = setDefaultAVProps();
347 }
348 } else {
349 // create the $USER/.appletviewer file
350
351 // see if $USER/.hotjava/properties exists
352 File userHome = new File(System.getProperty("user.home"));
353 File dotHJ = new File(userHome, ".hotjava");
354 dotHJ = new File(dotHJ, "properties");
355 if (dotHJ.exists()) {
356 // just read the file
357 avProps = getAVProps(dotHJ);
358 } else {
359 // send out warning and use defaults
360 System.err.println(lookup("main.warn.cantreadprops",
361 dotHJ.toString()));
362 avProps = setDefaultAVProps();
363 }
364
365 // SAVE THE FILE
366 try (FileOutputStream out = new FileOutputStream(dotAV)) {
367 avProps.store(out, lookup("main.prop.store"));
368 } catch (IOException e) {
369 System.err.println(lookup("main.err.prop.cantsave",
370 dotAV.toString()));
371 }
372 }
373 return avProps;
374 }
375
376 /**
377 * Set the AppletViewer user-specific properties to be the default values.
378 *
379 * @return A Properties object containing all of the AppletViewer
380 * user-specific properties, set to the default values.
381 */
382 private Properties setDefaultAVProps() {
383 Properties avProps = new Properties();
384 for (int i = 0; i < avDefaultUserProps.length; i++) {
385 avProps.setProperty(avDefaultUserProps[i][0],
386 avDefaultUserProps[i][1]);
387 }
388 return avProps;
389 }
390
391 /**
392 * Given a file, find only the properties that are setable by AppletViewer.
393 *
394 * @param inFile A Properties file from which we select the properties of
395 * interest.
396 * @return A Properties object containing all of the AppletViewer
397 * user-specific properties.
398 */
399 private Properties getAVProps(File inFile) {
400 Properties avProps = new Properties();
401
402 // read the file
403 Properties tmpProps = new Properties();
404 try (FileInputStream in = new FileInputStream(inFile)) {
405 tmpProps.load(new BufferedInputStream(in));
406 } catch (IOException e) {
407 System.err.println(lookup("main.err.prop.cantread", inFile.toString()));
408 }
409
410 // pick off the properties we care about
411 for (int i = 0; i < avDefaultUserProps.length; i++) {
412 String value = tmpProps.getProperty(avDefaultUserProps[i][0]);
413 if (value != null) {
414 // the property exists in the file, so replace the default
415 avProps.setProperty(avDefaultUserProps[i][0], value);
416 } else {
417 // just use the default
418 avProps.setProperty(avDefaultUserProps[i][0],
419 avDefaultUserProps[i][1]);
420 }
421 }
422 return avProps;
423 }
424
425 /**
426 * Methods for easier i18n handling.
427 */
428
429 private static String lookup(String key) {
430 return amh.getMessage(key);
431 }
432
433 private static String lookup(String key, String arg0) {
434 return amh.getMessage(key, arg0);
435 }
436
437 private static String lookup(String key, String arg0, String arg1) {
438 return amh.getMessage(key, arg0, arg1);
439 }
440
441 private static String lookup(String key, String arg0, String arg1,
442 String arg2) {
443 return amh.getMessage(key, arg0, arg1, arg2);
444 }
445
446 @SuppressWarnings("serial") // JDK implementation class
447 class ParseException extends RuntimeException
448 {
449 public ParseException(String msg) {
450 super(msg);
451 }
452
453 public ParseException(Throwable t) {
454 super(t.getMessage());
455 this.t = t;
456 }
457
458 Throwable t = null;
459 }
460 }