1 /*
2 * Copyright (c) 1997, 2012, 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 com.sun.activation.registries;
27
28 import java.io.*;
29 import java.util.*;
30
31 public class MailcapFile {
32
33 /**
34 * A Map indexed by MIME type (string) that references
35 * a Map of commands for each type. The comand Map
36 * is indexed by the command name and references a List of
37 * class names (strings) for each command.
38 */
39 private Map type_hash = new HashMap();
40
41 /**
42 * Another Map like above, but for fallback entries.
43 */
44 private Map fallback_hash = new HashMap();
45
46 /**
47 * A Map indexed by MIME type (string) that references
48 * a List of native commands (string) corresponding to the type.
49 */
50 private Map native_commands = new HashMap();
51
52 private static boolean addReverse = false;
53
54 static {
55 try {
56 addReverse = Boolean.getBoolean("javax.activation.addreverse");
57 } catch (Throwable t) {
58 // ignore any errors
59 }
60 }
61
62 /**
63 * The constructor that takes a filename as an argument.
64 *
65 * @param new_fname The file name of the mailcap file.
66 */
67 public MailcapFile(String new_fname) throws IOException {
68 if (LogSupport.isLoggable())
69 LogSupport.log("new MailcapFile: file " + new_fname);
70 FileReader reader = null;
71 try {
72 reader = new FileReader(new_fname);
73 parse(new BufferedReader(reader));
74 } finally {
75 if (reader != null) {
76 try {
77 reader.close();
78 } catch (IOException ex) { }
79 }
80 }
81 }
82
83 /**
84 * The constructor that takes an input stream as an argument.
85 *
86 * @param is the input stream
87 */
88 public MailcapFile(InputStream is) throws IOException {
89 if (LogSupport.isLoggable())
90 LogSupport.log("new MailcapFile: InputStream");
91 parse(new BufferedReader(new InputStreamReader(is, "iso-8859-1")));
92 }
93
94 /**
95 * Mailcap file default constructor.
96 */
97 public MailcapFile() {
98 if (LogSupport.isLoggable())
99 LogSupport.log("new MailcapFile: default");
100 }
101
102 /**
103 * Get the Map of MailcapEntries based on the MIME type.
104 *
105 * <p>
106 * <strong>Semantics:</strong> First check for the literal mime type,
107 * if that fails looks for wildcard <type>/\* and return that. Return the
108 * list of all that hit.
109 */
110 public Map getMailcapList(String mime_type) {
111 Map search_result = null;
112 Map wildcard_result = null;
113
114 // first try the literal
115 search_result = (Map)type_hash.get(mime_type);
116
117 // ok, now try the wildcard
118 int separator = mime_type.indexOf('/');
119 String subtype = mime_type.substring(separator + 1);
120 if (!subtype.equals("*")) {
121 String type = mime_type.substring(0, separator + 1) + "*";
122 wildcard_result = (Map)type_hash.get(type);
123
124 if (wildcard_result != null) { // damn, we have to merge!!!
125 if (search_result != null)
126 search_result =
127 mergeResults(search_result, wildcard_result);
128 else
129 search_result = wildcard_result;
130 }
131 }
132 return search_result;
133 }
134
135 /**
136 * Get the Map of fallback MailcapEntries based on the MIME type.
137 *
138 * <p>
139 * <strong>Semantics:</strong> First check for the literal mime type,
140 * if that fails looks for wildcard <type>/\* and return that. Return the
141 * list of all that hit.
142 */
143 public Map getMailcapFallbackList(String mime_type) {
144 Map search_result = null;
145 Map wildcard_result = null;
146
147 // first try the literal
148 search_result = (Map)fallback_hash.get(mime_type);
149
150 // ok, now try the wildcard
151 int separator = mime_type.indexOf('/');
152 String subtype = mime_type.substring(separator + 1);
153 if (!subtype.equals("*")) {
154 String type = mime_type.substring(0, separator + 1) + "*";
155 wildcard_result = (Map)fallback_hash.get(type);
156
157 if (wildcard_result != null) { // damn, we have to merge!!!
158 if (search_result != null)
159 search_result =
160 mergeResults(search_result, wildcard_result);
161 else
162 search_result = wildcard_result;
163 }
164 }
165 return search_result;
166 }
167
168 /**
169 * Return all the MIME types known to this mailcap file.
170 */
171 public String[] getMimeTypes() {
172 Set types = new HashSet(type_hash.keySet());
173 types.addAll(fallback_hash.keySet());
174 types.addAll(native_commands.keySet());
175 String[] mts = new String[types.size()];
176 mts = (String[])types.toArray(mts);
177 return mts;
178 }
179
180 /**
181 * Return all the native comands for the given MIME type.
182 */
183 public String[] getNativeCommands(String mime_type) {
184 String[] cmds = null;
185 List v =
186 (List)native_commands.get(mime_type.toLowerCase(Locale.ENGLISH));
187 if (v != null) {
188 cmds = new String[v.size()];
189 cmds = (String[])v.toArray(cmds);
190 }
191 return cmds;
192 }
193
194 /**
195 * Merge the first hash into the second.
196 * This merge will only effect the hashtable that is
197 * returned, we don't want to touch the one passed in since
198 * its integrity must be maintained.
199 */
200 private Map mergeResults(Map first, Map second) {
201 Iterator verb_enum = second.keySet().iterator();
202 Map clonedHash = new HashMap(first);
203
204 // iterate through the verbs in the second map
205 while (verb_enum.hasNext()) {
206 String verb = (String)verb_enum.next();
207 List cmdVector = (List)clonedHash.get(verb);
208 if (cmdVector == null) {
209 clonedHash.put(verb, second.get(verb));
210 } else {
211 // merge the two
212 List oldV = (List)second.get(verb);
213 cmdVector = new ArrayList(cmdVector);
214 cmdVector.addAll(oldV);
215 clonedHash.put(verb, cmdVector);
216 }
217 }
218 return clonedHash;
219 }
220
221 /**
222 * appendToMailcap: Append to this Mailcap DB, use the mailcap
223 * format:
224 * Comment == "# <i>comment string</i>
225 * Entry == "mimetype; javabeanclass<nl>
226 *
227 * Example:
228 * # this is a comment
229 * image/gif jaf.viewers.ImageViewer
230 */
231 public void appendToMailcap(String mail_cap) {
232 if (LogSupport.isLoggable())
233 LogSupport.log("appendToMailcap: " + mail_cap);
234 try {
235 parse(new StringReader(mail_cap));
236 } catch (IOException ex) {
237 // can't happen
238 }
239 }
240
241 /**
242 * parse file into a hash table of MC Type Entry Obj
243 */
244 private void parse(Reader reader) throws IOException {
245 BufferedReader buf_reader = new BufferedReader(reader);
246 String line = null;
247 String continued = null;
248
249 while ((line = buf_reader.readLine()) != null) {
250 // LogSupport.log("parsing line: " + line);
251
252 line = line.trim();
253
254 try {
255 if (line.charAt(0) == '#')
256 continue;
257 if (line.charAt(line.length() - 1) == '\\') {
258 if (continued != null)
259 continued += line.substring(0, line.length() - 1);
260 else
261 continued = line.substring(0, line.length() - 1);
262 } else if (continued != null) {
263 // handle the two strings
264 continued = continued + line;
265 // LogSupport.log("parse: " + continued);
266 try {
267 parseLine(continued);
268 } catch (MailcapParseException e) {
269 //e.printStackTrace();
270 }
271 continued = null;
272 }
273 else {
274 // LogSupport.log("parse: " + line);
275 try {
276 parseLine(line);
277 // LogSupport.log("hash.size = " + type_hash.size());
278 } catch (MailcapParseException e) {
279 //e.printStackTrace();
280 }
281 }
282 } catch (StringIndexOutOfBoundsException e) {}
283 }
284 }
285
286 /**
287 * A routine to parse individual entries in a Mailcap file.
288 *
289 * Note that this routine does not handle line continuations.
290 * They should have been handled prior to calling this routine.
291 */
292 protected void parseLine(String mailcapEntry)
293 throws MailcapParseException, IOException {
294 MailcapTokenizer tokenizer = new MailcapTokenizer(mailcapEntry);
295 tokenizer.setIsAutoquoting(false);
296
297 if (LogSupport.isLoggable())
298 LogSupport.log("parse: " + mailcapEntry);
299 // parse the primary type
300 int currentToken = tokenizer.nextToken();
301 if (currentToken != MailcapTokenizer.STRING_TOKEN) {
302 reportParseError(MailcapTokenizer.STRING_TOKEN, currentToken,
303 tokenizer.getCurrentTokenValue());
304 }
305 String primaryType =
306 tokenizer.getCurrentTokenValue().toLowerCase(Locale.ENGLISH);
307 String subType = "*";
308
309 // parse the '/' between primary and sub
310 // if it's not present that's ok, we just don't have a subtype
311 currentToken = tokenizer.nextToken();
312 if ((currentToken != MailcapTokenizer.SLASH_TOKEN) &&
313 (currentToken != MailcapTokenizer.SEMICOLON_TOKEN)) {
314 reportParseError(MailcapTokenizer.SLASH_TOKEN,
315 MailcapTokenizer.SEMICOLON_TOKEN, currentToken,
316 tokenizer.getCurrentTokenValue());
317 }
318
319 // only need to look for a sub type if we got a '/'
320 if (currentToken == MailcapTokenizer.SLASH_TOKEN) {
321 // parse the sub type
322 currentToken = tokenizer.nextToken();
323 if (currentToken != MailcapTokenizer.STRING_TOKEN) {
324 reportParseError(MailcapTokenizer.STRING_TOKEN,
325 currentToken, tokenizer.getCurrentTokenValue());
326 }
327 subType =
328 tokenizer.getCurrentTokenValue().toLowerCase(Locale.ENGLISH);
329
330 // get the next token to simplify the next step
331 currentToken = tokenizer.nextToken();
332 }
333
334 String mimeType = primaryType + "/" + subType;
335
336 if (LogSupport.isLoggable())
337 LogSupport.log(" Type: " + mimeType);
338
339 // now setup the commands hashtable
340 Map commands = new LinkedHashMap(); // keep commands in order found
341
342 // parse the ';' that separates the type from the parameters
343 if (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) {
344 reportParseError(MailcapTokenizer.SEMICOLON_TOKEN,
345 currentToken, tokenizer.getCurrentTokenValue());
346 }
347 // eat it
348
349 // parse the required view command
350 tokenizer.setIsAutoquoting(true);
351 currentToken = tokenizer.nextToken();
352 tokenizer.setIsAutoquoting(false);
353 if ((currentToken != MailcapTokenizer.STRING_TOKEN) &&
354 (currentToken != MailcapTokenizer.SEMICOLON_TOKEN)) {
355 reportParseError(MailcapTokenizer.STRING_TOKEN,
356 MailcapTokenizer.SEMICOLON_TOKEN, currentToken,
357 tokenizer.getCurrentTokenValue());
358 }
359
360 if (currentToken == MailcapTokenizer.STRING_TOKEN) {
361 // have a native comand, save the entire mailcap entry
362 //String nativeCommand = tokenizer.getCurrentTokenValue();
363 List v = (List)native_commands.get(mimeType);
364 if (v == null) {
365 v = new ArrayList();
366 v.add(mailcapEntry);
367 native_commands.put(mimeType, v);
368 } else {
369 // XXX - check for duplicates?
370 v.add(mailcapEntry);
371 }
372 }
373
374 // only have to get the next token if the current one isn't a ';'
375 if (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) {
376 currentToken = tokenizer.nextToken();
377 }
378
379 // look for a ';' which will indicate whether
380 // a parameter list is present or not
381 if (currentToken == MailcapTokenizer.SEMICOLON_TOKEN) {
382 boolean isFallback = false;
383 do {
384 // eat the ';'
385
386 // parse the parameter name
387 currentToken = tokenizer.nextToken();
388 if (currentToken != MailcapTokenizer.STRING_TOKEN) {
389 reportParseError(MailcapTokenizer.STRING_TOKEN,
390 currentToken, tokenizer.getCurrentTokenValue());
391 }
392 String paramName = tokenizer.getCurrentTokenValue().
393 toLowerCase(Locale.ENGLISH);
394
395 // parse the '=' which separates the name from the value
396 currentToken = tokenizer.nextToken();
397 if ((currentToken != MailcapTokenizer.EQUALS_TOKEN) &&
398 (currentToken != MailcapTokenizer.SEMICOLON_TOKEN) &&
399 (currentToken != MailcapTokenizer.EOI_TOKEN)) {
400 reportParseError(MailcapTokenizer.EQUALS_TOKEN,
401 MailcapTokenizer.SEMICOLON_TOKEN,
402 MailcapTokenizer.EOI_TOKEN,
403 currentToken, tokenizer.getCurrentTokenValue());
404 }
405
406 // we only have a useful command if it is named
407 if (currentToken == MailcapTokenizer.EQUALS_TOKEN) {
408 // eat it
409
410 // parse the parameter value (which is autoquoted)
411 tokenizer.setIsAutoquoting(true);
412 currentToken = tokenizer.nextToken();
413 tokenizer.setIsAutoquoting(false);
414 if (currentToken != MailcapTokenizer.STRING_TOKEN) {
415 reportParseError(MailcapTokenizer.STRING_TOKEN,
416 currentToken, tokenizer.getCurrentTokenValue());
417 }
418 String paramValue =
419 tokenizer.getCurrentTokenValue();
420
421 // add the class to the list iff it is one we care about
422 if (paramName.startsWith("x-java-")) {
423 String commandName = paramName.substring(7);
424 // 7 == "x-java-".length
425
426 if (commandName.equals("fallback-entry") &&
427 paramValue.equalsIgnoreCase("true")) {
428 isFallback = true;
429 } else {
430
431 // setup the class entry list
432 if (LogSupport.isLoggable())
433 LogSupport.log(" Command: " + commandName +
434 ", Class: " + paramValue);
435 List classes = (List)commands.get(commandName);
436 if (classes == null) {
437 classes = new ArrayList();
438 commands.put(commandName, classes);
439 }
440 if (addReverse)
441 classes.add(0, paramValue);
442 else
443 classes.add(paramValue);
444 }
445 }
446
447 // set up the next iteration
448 currentToken = tokenizer.nextToken();
449 }
450 } while (currentToken == MailcapTokenizer.SEMICOLON_TOKEN);
451
452 Map masterHash = isFallback ? fallback_hash : type_hash;
453 Map curcommands =
454 (Map)masterHash.get(mimeType);
455 if (curcommands == null) {
456 masterHash.put(mimeType, commands);
457 } else {
458 if (LogSupport.isLoggable())
459 LogSupport.log("Merging commands for type " + mimeType);
460 // have to merge current and new commands
461 // first, merge list of classes for commands already known
462 Iterator cn = curcommands.keySet().iterator();
463 while (cn.hasNext()) {
464 String cmdName = (String)cn.next();
465 List ccv = (List)curcommands.get(cmdName);
466 List cv = (List)commands.get(cmdName);
467 if (cv == null)
468 continue;
469 // add everything in cv to ccv, if it's not already there
470 Iterator cvn = cv.iterator();
471 while (cvn.hasNext()) {
472 String clazz = (String)cvn.next();
473 if (!ccv.contains(clazz))
474 if (addReverse)
475 ccv.add(0, clazz);
476 else
477 ccv.add(clazz);
478 }
479 }
480 // now, add commands not previously known
481 cn = commands.keySet().iterator();
482 while (cn.hasNext()) {
483 String cmdName = (String)cn.next();
484 if (curcommands.containsKey(cmdName))
485 continue;
486 List cv = (List)commands.get(cmdName);
487 curcommands.put(cmdName, cv);
488 }
489 }
490 } else if (currentToken != MailcapTokenizer.EOI_TOKEN) {
491 reportParseError(MailcapTokenizer.EOI_TOKEN,
492 MailcapTokenizer.SEMICOLON_TOKEN,
493 currentToken, tokenizer.getCurrentTokenValue());
494 }
495 }
496
497 protected static void reportParseError(int expectedToken, int actualToken,
498 String actualTokenValue) throws MailcapParseException {
499 throw new MailcapParseException("Encountered a " +
500 MailcapTokenizer.nameForToken(actualToken) + " token (" +
501 actualTokenValue + ") while expecting a " +
502 MailcapTokenizer.nameForToken(expectedToken) + " token.");
503 }
504
505 protected static void reportParseError(int expectedToken,
506 int otherExpectedToken, int actualToken, String actualTokenValue)
507 throws MailcapParseException {
508 throw new MailcapParseException("Encountered a " +
509 MailcapTokenizer.nameForToken(actualToken) + " token (" +
510 actualTokenValue + ") while expecting a " +
511 MailcapTokenizer.nameForToken(expectedToken) + " or a " +
512 MailcapTokenizer.nameForToken(otherExpectedToken) + " token.");
513 }
514
515 protected static void reportParseError(int expectedToken,
516 int otherExpectedToken, int anotherExpectedToken, int actualToken,
517 String actualTokenValue) throws MailcapParseException {
518 if (LogSupport.isLoggable())
519 LogSupport.log("PARSE ERROR: " + "Encountered a " +
520 MailcapTokenizer.nameForToken(actualToken) + " token (" +
521 actualTokenValue + ") while expecting a " +
522 MailcapTokenizer.nameForToken(expectedToken) + ", a " +
523 MailcapTokenizer.nameForToken(otherExpectedToken) + ", or a " +
524 MailcapTokenizer.nameForToken(anotherExpectedToken) + " token.");
525 throw new MailcapParseException("Encountered a " +
526 MailcapTokenizer.nameForToken(actualToken) + " token (" +
527 actualTokenValue + ") while expecting a " +
528 MailcapTokenizer.nameForToken(expectedToken) + ", a " +
529 MailcapTokenizer.nameForToken(otherExpectedToken) + ", or a " +
530 MailcapTokenizer.nameForToken(anotherExpectedToken) + " token.");
531 }
532
533 /** for debugging
534 public static void main(String[] args) throws Exception {
535 Map masterHash = new HashMap();
536 for (int i = 0; i < args.length; ++i) {
537 System.out.println("Entry " + i + ": " + args[i]);
538 parseLine(args[i], masterHash);
539 }
540
541 Enumeration types = masterHash.keys();
542 while (types.hasMoreElements()) {
543 String key = (String)types.nextElement();
544 System.out.println("MIME Type: " + key);
545
546 Map commandHash = (Map)masterHash.get(key);
547 Enumeration commands = commandHash.keys();
548 while (commands.hasMoreElements()) {
549 String command = (String)commands.nextElement();
550 System.out.println(" Command: " + command);
551
552 Vector classes = (Vector)commandHash.get(command);
553 for (int i = 0; i < classes.size(); ++i) {
554 System.out.println(" Class: " +
555 (String)classes.elementAt(i));
556 }
557 }
558
559 System.out.println("");
560 }
561 }
562 */
563 }