1 /*

     2  * Copyright (c) 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 sun.nio.fs;

    27 

    28 import java.io.IOException;

    29 import java.nio.charset.Charset;

    30 import java.nio.file.Files;

    31 import java.nio.file.Path;

    32 import java.security.AccessController;

    33 import java.security.PrivilegedAction;

    34 import java.util.Collections;

    35 import java.util.HashMap;

    36 import java.util.List;

    37 import java.util.Map;

    38 import java.util.regex.Matcher;

    39 import java.util.regex.Pattern;

    40 

    41 /**

    42  * File type detector that uses a file extension to look up its MIME type

    43  * based on a mime.types file.

    44  */

    45 

    46 class MimeTypesFileTypeDetector extends AbstractFileTypeDetector {

    47 

    48     // path to mime.types file

    49     private final Path mimeTypesFile;

    50 

    51     // map of extension to MIME type

    52     private Map<String,String> mimeTypeMap;

    53 

    54     // set to true when file loaded

    55     private volatile boolean loaded = false;

    56 

    57     public MimeTypesFileTypeDetector(Path filePath) {

    58         mimeTypesFile = filePath;

    59     }

    60 

    61     @Override

    62     protected String implProbeContentType(Path path) {

    63         Path fn = path.getFileName();

    64         if (fn == null)

    65             return null;  // no file name

    66 

    67         String ext = getExtension(fn.toString());

    68         if (ext.isEmpty())

    69             return null;  // no extension

    70 

    71         loadMimeTypes();

    72         if (mimeTypeMap == null || mimeTypeMap.isEmpty())

    73             return null;

    74 

    75         // Case-sensitive search

    76         String mimeType;

    77         do {

    78             mimeType = mimeTypeMap.get(ext);

    79             if (mimeType == null)

    80                 ext = getExtension(ext);

    81         } while (mimeType == null && !ext.isEmpty());

    82 

    83         return mimeType;

    84     }

    85 

    86     // Get the extension of a file name.

    87     private static String getExtension(String name) {

    88         String ext = "";

    89         if (name != null && !name.isEmpty()) {

    90             int dot = name.indexOf('.');

    91             if ((dot >= 0) && (dot < name.length() - 1)) {

    92                 ext = name.substring(dot + 1);

    93             }

    94         }

    95         return ext;

    96     }

    97 

    98     /**

    99      * Parse the mime types file, and store the type-extension mappings into

   100      * mimeTypeMap. The mime types file is not loaded until the first probe

   101      * to achieve the lazy initialization. It adopts double-checked locking

   102      * optimization to reduce the locking overhead.

   103      */

   104     private void loadMimeTypes() {

   105         if (!loaded) {

   106             synchronized (this) {

   107                 if (!loaded) {

   108                     List<String> lines = AccessController.doPrivileged(

   109                         new PrivilegedAction<List<String>>() {

   110                             @Override

   111                             public List<String> run() {

   112                                 try {

   113                                     return Files.readAllLines(mimeTypesFile,

   114                                                               Charset.defaultCharset());

   115                                 } catch (IOException ignore) {

   116                                     return Collections.emptyList();

   117                                 }

   118                             }

   119                         });

   120 

   121                     mimeTypeMap = new HashMap<>(lines.size());

   122                     String entry = "";

   123                     for (String line : lines) {

   124                         entry += line;

   125                         if (entry.endsWith("\\")) {

   126                             entry = entry.substring(0, entry.length() - 1);

   127                             continue;

   128                         }

   129                         parseMimeEntry(entry);

   130                         entry = "";

   131                     }

   132                     if (!entry.isEmpty()) {

   133                         parseMimeEntry(entry);

   134                     }

   135                     loaded = true;

   136                 }

   137             }

   138         }

   139     }

   140 

   141     /**

   142      * Parse a mime-types entry, which can have the following formats.

   143      * 1) Simple space-delimited format

   144      * image/jpeg   jpeg jpg jpe JPG

   145      *

   146      * 2) Netscape key-value pair format

   147      * type=application/x-java-jnlp-file desc="Java Web Start" exts="jnlp"

   148      * or

   149      * type=text/html exts=htm,html

   150      */

   151     private void parseMimeEntry(String entry) {

   152         entry = entry.trim();

   153         if (entry.isEmpty() || entry.charAt(0) == '#')

   154             return;

   155 

   156         entry = entry.replaceAll("\\s*#.*", "");

   157         int equalIdx = entry.indexOf('=');

   158         if (equalIdx > 0) {

   159             // Parse a mime-types command having the key-value pair format

   160             final String TYPEEQUAL = "type=";

   161             String typeRegex = "\\b" + TYPEEQUAL +

   162                     "(\"\\p{Graph}+?/\\p{Graph}+?\"|\\p{Graph}+/\\p{Graph}+\\b)";

   163             Pattern typePattern = Pattern.compile(typeRegex);

   164             Matcher typeMatcher = typePattern.matcher(entry);

   165 

   166             if (typeMatcher.find()) {

   167                 String type = typeMatcher.group().substring(TYPEEQUAL.length());

   168                 if (type.charAt(0) == '"') {

   169                     type = type.substring(1, type.length() - 1);

   170                 }

   171 

   172                 final String EXTEQUAL = "exts=";

   173                 String extRegex = "\\b" + EXTEQUAL +

   174                         "(\"[\\p{Graph}|\\p{Blank}]+?\"|\\p{Graph}+\\b)";

   175                 Pattern extPattern = Pattern.compile(extRegex);

   176                 Matcher extMatcher = extPattern.matcher(entry);

   177 

   178                 if (extMatcher.find()) {

   179                     String exts =

   180                             extMatcher.group().substring(EXTEQUAL.length());

   181                     if (exts.charAt(0) == '"') {

   182                         exts = exts.substring(1, exts.length() - 1);

   183                     }

   184                     String[] extList = exts.split("[\\p{Blank}|\\p{Punct}]+");

   185                     for (String ext : extList) {

   186                         putIfAbsent(ext, type);

   187                     }

   188                 }

   189             }

   190         } else {

   191             // Parse a mime-types command having the space-delimited format

   192             String[] elements = entry.split("\\s+");

   193             int i = 1;

   194             while (i < elements.length) {

   195                 putIfAbsent(elements[i++], elements[0]);

   196             }

   197         }

   198     }

   199 

   200     private void putIfAbsent(String key, String value) {

   201         if (key != null && !key.isEmpty() &&

   202             value != null && !value.isEmpty() &&

   203             !mimeTypeMap.containsKey(key))

   204         {

   205             mimeTypeMap.put(key, value);

   206         }

   207     }

   208 }