activation/registries/MimeTypeFile.java

/*
 * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.activation.registries;

import java.io.*;
import java.util.*;

public class MimeTypeFile {
    private String fname = null;
    private Hashtable type_hash = new Hashtable();

    /**
     * The construtor that takes a filename as an argument.
     *
     * @param new_fname The file name of the mime types file.
     */
    public MimeTypeFile(String new_fname) throws IOException {
        File mime_file = null;
        FileReader fr = null;

        fname = new_fname; // remember the file name

        mime_file = new File(fname); // get a file object

        fr = new FileReader(mime_file);

        try {
            parse(new BufferedReader(fr));
        } finally {
            try {
                fr.close(); // close it
            } catch (IOException e) {
                // ignore it
            }
        }
    }

    public MimeTypeFile(InputStream is) throws IOException {
        parse(new BufferedReader(new InputStreamReader(is, "iso-8859-1")));
    }

    /**
     * Creates an empty DB.
     */
    public MimeTypeFile() {
    }

    /**
     * get the MimeTypeEntry based on the file extension
     */
    public MimeTypeEntry getMimeTypeEntry(String file_ext) {
        return (MimeTypeEntry)type_hash.get((Object)file_ext);
    }

    /**
     * Get the MIME type string corresponding to the file extension.
     */
    public String getMIMETypeString(String file_ext) {
        MimeTypeEntry entry = this.getMimeTypeEntry(file_ext);

        if (entry != null)
            return entry.getMIMEType();
        else
            return null;
    }

    /**
     * Appends string of entries to the types registry, must be valid
     * .mime.types format.
     * A mime.types entry is one of two forms:
     *
     *  type/subtype    ext1 ext2 ...
     * or
     *  type=type/subtype desc="description of type" exts=ext1,ext2,...
     *
     * Example:
     * # this is a test
     * audio/basic            au
     * text/plain             txt text
     * type=application/postscript exts=ps,eps
     */
    public void appendToRegistry(String mime_types) {
        try {
            parse(new BufferedReader(new StringReader(mime_types)));
        } catch (IOException ex) {
            // can't happen
        }
    }

    /**
     * Parse a stream of mime.types entries.
     */
    private void parse(BufferedReader buf_reader) throws IOException {
        String line = null, prev = null;

        while ((line = buf_reader.readLine()) != null) {
            if (prev == null)
                prev = line;
            else
                prev += line;
            int end = prev.length();
            if (prev.length() > 0 && prev.charAt(end - 1) == '\\') {
                prev = prev.substring(0, end - 1);
                continue;
            }
            this.parseEntry(prev);
            prev = null;
        }
        if (prev != null)
            this.parseEntry(prev);
    }

    /**
     * Parse single mime.types entry.
     */
    private void parseEntry(String line) {
        String mime_type = null;
        String file_ext = null;
        line = line.trim();

        if (line.length() == 0) // empty line...
            return; // BAIL!

        // check to see if this is a comment line?
        if (line.charAt(0) == '#')
            return; // then we are done!

        // is it a new format line or old format?
        if (line.indexOf('=') > 0) {
            // new format
            LineTokenizer lt = new LineTokenizer(line);
            while (lt.hasMoreTokens()) {
                String name = lt.nextToken();
                String value = null;
                if (lt.hasMoreTokens() && lt.nextToken().equals("=") &&
                                                        lt.hasMoreTokens())
                    value = lt.nextToken();
                if (value == null) {
                    if (LogSupport.isLoggable())
                        LogSupport.log("Bad .mime.types entry: " + line);
                    return;
                }
                if (name.equals("type"))
                    mime_type = value;
                else if (name.equals("exts")) {
                    StringTokenizer st = new StringTokenizer(value, ",");
                    while (st.hasMoreTokens()) {
                        file_ext = st.nextToken();
                        MimeTypeEntry entry =
                                new MimeTypeEntry(mime_type, file_ext);
                        type_hash.put(file_ext, entry);
                        if (LogSupport.isLoggable())
                            LogSupport.log("Added: " + entry.toString());
                    }
                }
            }
        } else {
            // old format
            // count the tokens
            StringTokenizer strtok = new StringTokenizer(line);
            int num_tok = strtok.countTokens();

            if (num_tok == 0) // empty line
                return;

            mime_type = strtok.nextToken(); // get the MIME type

            while (strtok.hasMoreTokens()) {
                MimeTypeEntry entry = null;

                file_ext = strtok.nextToken();
                entry = new MimeTypeEntry(mime_type, file_ext);
                type_hash.put(file_ext, entry);
                if (LogSupport.isLoggable())
                    LogSupport.log("Added: " + entry.toString());
            }
        }
    }

    // for debugging
    /*
    public static void main(String[] argv) throws Exception {
        MimeTypeFile mf = new MimeTypeFile(argv[0]);
        System.out.println("ext " + argv[1] + " type " +
                                                mf.getMIMETypeString(argv[1]));
        System.exit(0);
    }
    */
}

class LineTokenizer {
    private int currentPosition;
    private int maxPosition;
    private String str;
    private Vector stack = new Vector();
    private static final String singles = "=";  // single character tokens

    /**
     * Constructs a tokenizer for the specified string.
     * <p>
     *
     * @param   str            a string to be parsed.
     */
    public LineTokenizer(String str) {
        currentPosition = 0;
        this.str = str;
        maxPosition = str.length();
    }

    /**
     * Skips white space.
     */
    private void skipWhiteSpace() {
        while ((currentPosition < maxPosition) &&
               Character.isWhitespace(str.charAt(currentPosition))) {
            currentPosition++;
        }
    }

    /**
     * Tests if there are more tokens available from this tokenizer's string.
     *
     * @return  <code>true</code> if there are more tokens available from this
     *          tokenizer's string; <code>false</code> otherwise.
     */
    public boolean hasMoreTokens() {
        if (stack.size() > 0)
            return true;
        skipWhiteSpace();
        return (currentPosition < maxPosition);
    }

    /**
     * Returns the next token from this tokenizer.
     *
     * @return     the next token from this tokenizer.
     * @exception  NoSuchElementException  if there are no more tokens in this
     *               tokenizer's string.
     */
    public String nextToken() {
        int size = stack.size();
        if (size > 0) {
            String t = (String)stack.elementAt(size - 1);
            stack.removeElementAt(size - 1);
            return t;
        }
        skipWhiteSpace();

        if (currentPosition >= maxPosition) {
            throw new NoSuchElementException();
        }

        int start = currentPosition;
        char c = str.charAt(start);
        if (c == '"') {
            currentPosition++;
            boolean filter = false;
            while (currentPosition < maxPosition) {
                c = str.charAt(currentPosition++);
                if (c == '\\') {
                    currentPosition++;
                    filter = true;
                } else if (c == '"') {
                    String s;

                    if (filter) {
                        StringBuffer sb = new StringBuffer();
                        for (int i = start + 1; i < currentPosition - 1; i++) {
                            c = str.charAt(i);
                            if (c != '\\')
                                sb.append(c);
                        }
                        s = sb.toString();
                    } else
                        s = str.substring(start + 1, currentPosition - 1);
                    return s;
                }
            }
        } else if (singles.indexOf(c) >= 0) {
            currentPosition++;
        } else {
            while ((currentPosition < maxPosition) &&
                   singles.indexOf(str.charAt(currentPosition)) < 0 &&
                   !Character.isWhitespace(str.charAt(currentPosition))) {
                currentPosition++;
            }
        }
        return str.substring(start, currentPosition);
    }

    public void pushToken(String token) {
        stack.addElement(token);
    }
}