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 javax.activation;
27
28 import java.io.*;
29 import java.net.*;
30 import java.util.*;
31 import com.sun.activation.registries.MimeTypeFile;
32 import com.sun.activation.registries.LogSupport;
33
34 /**
35 * This class extends FileTypeMap and provides data typing of files
36 * via their file extension. It uses the {@code .mime.types} format. <p>
37 *
38 * <b>MIME types file search order:</b><p>
39 * The MimetypesFileTypeMap looks in various places in the user's
40 * system for MIME types file entries. When requests are made
41 * to search for MIME types in the MimetypesFileTypeMap, it searches
42 * MIME types files in the following order:
43 * <ol>
44 * <li> Programmatically added entries to the MimetypesFileTypeMap instance.
45 * <li> The file {@code .mime.types} in the user's home directory.
46 * <li> The file {@literal <}<i>java.home</i>{@literal >}{@code /lib/mime.types}.
47 * <li> The file or resources named {@code META-INF/mime.types}.
48 * <li> The file or resource named {@code META-INF/mimetypes.default}
49 * (usually found only in the {@code activation.jar} file).
50 * </ol>
51 * <p>
52 * <b>MIME types file format:</b>
53 *
54 * <pre>{@code
55 * # comments begin with a '#'
56 * # the format is <mime type> <space separated file extensions>
57 * # for example:
58 * text/plain txt text TXT
59 * # this would map file.txt, file.text, and file.TXT to
60 * # the mime type "text/plain"
61 * }</pre>
62 *
63 * @author Bart Calder
64 * @author Bill Shannon
65 *
66 * @since 1.6
67 */
68 public class MimetypesFileTypeMap extends FileTypeMap {
69 /*
70 * We manage a collection of databases, searched in order.
71 */
72 private MimeTypeFile[] DB;
73 private static final int PROG = 0; // programmatically added entries
74
75 private static String defaultType = "application/octet-stream";
76
77 /**
78 * The default constructor.
79 */
80 public MimetypesFileTypeMap() {
81 Vector dbv = new Vector(5); // usually 5 or less databases
82 MimeTypeFile mf = null;
83 dbv.addElement(null); // place holder for PROG entry
84
85 LogSupport.log("MimetypesFileTypeMap: load HOME");
86 try {
87 String user_home = System.getProperty("user.home");
88
89 if (user_home != null) {
90 String path = user_home + File.separator + ".mime.types";
91 mf = loadFile(path);
92 if (mf != null)
93 dbv.addElement(mf);
94 }
95 } catch (SecurityException ex) {}
96
97 LogSupport.log("MimetypesFileTypeMap: load SYS");
98 try {
99 // check system's home
100 String system_mimetypes = System.getProperty("java.home") +
101 File.separator + "lib" + File.separator + "mime.types";
102 mf = loadFile(system_mimetypes);
103 if (mf != null)
104 dbv.addElement(mf);
105 } catch (SecurityException ex) {}
106
107 LogSupport.log("MimetypesFileTypeMap: load JAR");
108 // load from the app's jar file
109 loadAllResources(dbv, "META-INF/mime.types");
110
111 LogSupport.log("MimetypesFileTypeMap: load DEF");
112 mf = loadResource("/META-INF/mimetypes.default");
113
114 if (mf != null)
115 dbv.addElement(mf);
116
117 DB = new MimeTypeFile[dbv.size()];
118 dbv.copyInto(DB);
119 }
120
121 /**
122 * Load from the named resource.
123 */
124 private MimeTypeFile loadResource(String name) {
222
223 /**
224 * Load the named file.
225 */
226 private MimeTypeFile loadFile(String name) {
227 MimeTypeFile mtf = null;
228
229 try {
230 mtf = new MimeTypeFile(name);
231 } catch (IOException e) {
232 // e.printStackTrace();
233 }
234 return mtf;
235 }
236
237 /**
238 * Construct a MimetypesFileTypeMap with programmatic entries
239 * added from the named file.
240 *
241 * @param mimeTypeFileName the file name
242 */
243 public MimetypesFileTypeMap(String mimeTypeFileName) throws IOException {
244 this();
245 DB[PROG] = new MimeTypeFile(mimeTypeFileName);
246 }
247
248 /**
249 * Construct a MimetypesFileTypeMap with programmatic entries
250 * added from the InputStream.
251 *
252 * @param is the input stream to read from
253 */
254 public MimetypesFileTypeMap(InputStream is) {
255 this();
256 try {
257 DB[PROG] = new MimeTypeFile(is);
258 } catch (IOException ex) {
259 // XXX - really should throw it
260 }
261 }
281 * @param f the file
282 * @return the file's MIME type
283 */
284 public String getContentType(File f) {
285 return this.getContentType(f.getName());
286 }
287
288 /**
289 * Return the MIME type based on the specified file name.
290 * The MIME type entries are searched as described above under
291 * <i>MIME types file search order</i>.
292 * If no entry is found, the type "application/octet-stream" is returned.
293 *
294 * @param filename the file name
295 * @return the file's MIME type
296 */
297 public synchronized String getContentType(String filename) {
298 int dot_pos = filename.lastIndexOf("."); // period index
299
300 if (dot_pos < 0)
301 return defaultType;
302
303 String file_ext = filename.substring(dot_pos + 1);
304 if (file_ext.length() == 0)
305 return defaultType;
306
307 for (int i = 0; i < DB.length; i++) {
308 if (DB[i] == null)
309 continue;
310 String result = DB[i].getMIMETypeString(file_ext);
311 if (result != null)
312 return result;
313 }
314 return defaultType;
315 }
316
317 /**
318 * for debugging...
319 *
320 public static void main(String[] argv) throws Exception {
321 MimetypesFileTypeMap map = new MimetypesFileTypeMap();
322 System.out.println("File " + argv[0] + " has MIME type " +
323 map.getContentType(argv[0]));
324 System.exit(0);
325 }
326 */
327 }
|
1 /*
2 * Copyright (c) 1997, 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 javax.activation;
27
28 import java.io.*;
29 import java.net.*;
30 import java.util.*;
31 import java.security.AccessController;
32 import java.security.PrivilegedAction;
33 import com.sun.activation.registries.MimeTypeFile;
34 import com.sun.activation.registries.LogSupport;
35
36 /**
37 * This class extends FileTypeMap and provides data typing of files
38 * via their file extension. It uses the {@code .mime.types} format. <p>
39 *
40 * <b>MIME types file search order:</b><p>
41 * The MimetypesFileTypeMap looks in various places in the user's
42 * system for MIME types file entries. When requests are made
43 * to search for MIME types in the MimetypesFileTypeMap, it searches
44 * MIME types files in the following order:
45 * <ol>
46 * <li> Programmatically added entries to the MimetypesFileTypeMap instance.
47 * <li> The file {@code .mime.types} in the user's home directory.
48 * <li> The file {@code mime.types} in the Java runtime.
49 * <li> The file or resources named {@code META-INF/mime.types}.
50 * <li> The file or resource named {@code META-INF/mimetypes.default}
51 * (usually found only in the {@code activation.jar} file).
52 * </ol>
53 * <p>
54 * The current implementation looks for the {@code mime.types} file
55 * in the Java runtime in the directory <i>java.home</i>{@code /conf}
56 * if it exists, and otherwise in the directory
57 * <i>java.home</i>{@code /lib}, where <i>java.home</i> is the value
58 * of the "java.home" System property. Note that the "conf" directory was
59 * introduced in JDK 9.
60 * <p>
61 * <b>MIME types file format:</b>
62 *
63 * <pre>{@code
64 * # comments begin with a '#'
65 * # the format is <mime type> <space separated file extensions>
66 * # for example:
67 * text/plain txt text TXT
68 * # this would map file.txt, file.text, and file.TXT to
69 * # the mime type "text/plain"
70 * }</pre>
71 *
72 * @author Bart Calder
73 * @author Bill Shannon
74 *
75 * @since 1.6
76 */
77 public class MimetypesFileTypeMap extends FileTypeMap {
78 /*
79 * We manage a collection of databases, searched in order.
80 */
81 private MimeTypeFile[] DB;
82 private static final int PROG = 0; // programmatically added entries
83
84 private static final String DEFAULT_TYPE = "application/octet-stream";
85
86 private static final String CONF_DIR;
87
88 static {
89 String dir = null;
90 try {
91 dir = (String)AccessController.doPrivileged(
92 new PrivilegedAction() {
93 public Object run() {
94 String home = System.getProperty("java.home");
95 String newdir = home + File.separator + "conf";
96 File conf = new File(newdir);
97 if (conf.exists())
98 return newdir + File.separator;
99 else
100 return home + File.separator + "lib" + File.separator;
101 }
102 });
103 } catch (Exception ex) {
104 // ignore any exceptions
105 }
106 CONF_DIR = dir;
107 }
108
109 /**
110 * The default constructor.
111 */
112 public MimetypesFileTypeMap() {
113 Vector dbv = new Vector(5); // usually 5 or less databases
114 MimeTypeFile mf = null;
115 dbv.addElement(null); // place holder for PROG entry
116
117 LogSupport.log("MimetypesFileTypeMap: load HOME");
118 try {
119 String user_home = System.getProperty("user.home");
120
121 if (user_home != null) {
122 String path = user_home + File.separator + ".mime.types";
123 mf = loadFile(path);
124 if (mf != null)
125 dbv.addElement(mf);
126 }
127 } catch (SecurityException ex) {}
128
129 LogSupport.log("MimetypesFileTypeMap: load SYS");
130 try {
131 // check system's home
132 if (CONF_DIR != null) {
133 mf = loadFile(CONF_DIR + "mime.types");
134 if (mf != null)
135 dbv.addElement(mf);
136 }
137 } catch (SecurityException ex) {}
138
139 LogSupport.log("MimetypesFileTypeMap: load JAR");
140 // load from the app's jar file
141 loadAllResources(dbv, "META-INF/mime.types");
142
143 LogSupport.log("MimetypesFileTypeMap: load DEF");
144 mf = loadResource("/META-INF/mimetypes.default");
145
146 if (mf != null)
147 dbv.addElement(mf);
148
149 DB = new MimeTypeFile[dbv.size()];
150 dbv.copyInto(DB);
151 }
152
153 /**
154 * Load from the named resource.
155 */
156 private MimeTypeFile loadResource(String name) {
254
255 /**
256 * Load the named file.
257 */
258 private MimeTypeFile loadFile(String name) {
259 MimeTypeFile mtf = null;
260
261 try {
262 mtf = new MimeTypeFile(name);
263 } catch (IOException e) {
264 // e.printStackTrace();
265 }
266 return mtf;
267 }
268
269 /**
270 * Construct a MimetypesFileTypeMap with programmatic entries
271 * added from the named file.
272 *
273 * @param mimeTypeFileName the file name
274 * @exception IOException for errors reading the file
275 */
276 public MimetypesFileTypeMap(String mimeTypeFileName) throws IOException {
277 this();
278 DB[PROG] = new MimeTypeFile(mimeTypeFileName);
279 }
280
281 /**
282 * Construct a MimetypesFileTypeMap with programmatic entries
283 * added from the InputStream.
284 *
285 * @param is the input stream to read from
286 */
287 public MimetypesFileTypeMap(InputStream is) {
288 this();
289 try {
290 DB[PROG] = new MimeTypeFile(is);
291 } catch (IOException ex) {
292 // XXX - really should throw it
293 }
294 }
314 * @param f the file
315 * @return the file's MIME type
316 */
317 public String getContentType(File f) {
318 return this.getContentType(f.getName());
319 }
320
321 /**
322 * Return the MIME type based on the specified file name.
323 * The MIME type entries are searched as described above under
324 * <i>MIME types file search order</i>.
325 * If no entry is found, the type "application/octet-stream" is returned.
326 *
327 * @param filename the file name
328 * @return the file's MIME type
329 */
330 public synchronized String getContentType(String filename) {
331 int dot_pos = filename.lastIndexOf("."); // period index
332
333 if (dot_pos < 0)
334 return DEFAULT_TYPE;
335
336 String file_ext = filename.substring(dot_pos + 1);
337 if (file_ext.length() == 0)
338 return DEFAULT_TYPE;
339
340 for (int i = 0; i < DB.length; i++) {
341 if (DB[i] == null)
342 continue;
343 String result = DB[i].getMIMETypeString(file_ext);
344 if (result != null)
345 return result;
346 }
347 return DEFAULT_TYPE;
348 }
349
350 /**
351 * for debugging...
352 *
353 public static void main(String[] argv) throws Exception {
354 MimetypesFileTypeMap map = new MimetypesFileTypeMap();
355 System.out.println("File " + argv[0] + " has MIME type " +
356 map.getContentType(argv[0]));
357 System.exit(0);
358 }
359 */
360 }
|