File Types

package librarian.util.mimetype;

import java.util.HashSet;
import java.util.Set;

import librarian.util.StringUtils;

public class MimeType{
private String mimeType;
private HashSet extensions = new HashSet();
private String description;
private String browserContentType;
private String magicBytes; // as hexstring
private boolean isArchive;

public String getBrowserContentType() {
  return browserContentType;
}

public void setBrowserContentType(String 
browserContentType) {
  this.browserContentType = browserContentType;
}

public String getDescription() {
  return description;
}

public void setDescription(String description) {
  this.description = description;
}

public Set getExtensions() {
  return extensions;
}

public void addExtension(String extension){
  if (!StringUtils.isEmptyWithTrim(extension)){
    extensions.add(extension.trim());
  }
}

public String getMagicBytes() {
  return magicBytes;
}

public void setMagicBytes(String magicBytes) {
  this.magicBytes = magicBytes;
}

public String getMimeType() {
  return mimeType;
}

public void setMimeType(String mimeType) {
  this.mimeType = mimeType;
}

public boolean isArchive(){
  return isArchive;
}

public void setIsArchive(boolean isArchive){
  this.isArchive = isArchive;
}

public String toString(){
  return "mime="+mimeType+", 
    browser="+browserContentType+
    ", magic="+magicBytes+
    ", ext="+extensions+
    ", archiv="+Boolean.toString(isArchive)+
    ", desc="+description;
  }
}

package librarian.util.mimetype;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import librarian.util.StringUtils;
import librarian.util.file.FileUtil;
import librarian.util.properties.ExtendedProperties;

import org.apache.log4j.Logger;

public class MimeTypeDetector {
    private static final Logger LOG = Logger.getLogger(MimeTypeDetector.class);

    private HashMap fileExtensionsToMimeTypes =
        new HashMap(); // sets
    private HashMap magicBytesToMimeTypes =
        new HashMap();
    private HashMap mimeTypesToPropertyIds =
        new HashMap();
    private int maxMagicByteLen; // längster header

    public MimeTypeDetector(ExtendedProperties config) {
        int number = 0;
        List tokens;
        String token;
        boolean bool;
        while (true) {
            token = config.getString("mimetype." + number);
            if (StringUtils.isEmptyWithTrim(token))
                break;
            else {
                if (LOG.isInfoEnabled())
                    LOG.info("registering mimetype " + token);
                MimeType mimetype = new MimeType();
                mimetype.setMimeType(token.trim().toLowerCase());
                tokens = config.getList("mimetype." + number + ".fileext", true);
                if (tokens.size() > 0) {
                    for (int i = 0; i < tokens.size(); i++) {
                        token = (String) tokens.get(i);
                        if (!StringUtils.isEmptyWithTrim(token))
                            mimetype.addExtension(token.trim().toLowerCase());
                    }
                } else {
                    LOG.warn("mimetype \\"" + mimetype.getMimeType() +
                        "\\" is missing file extensions. it will be skipped.");
                    number++;
                    continue;
                }

                token = config.getString("mimetype." + number + ".browser");
                if (StringUtils.isEmptyWithTrim(token))
                    token = mimetype.getMimeType();
                mimetype.setBrowserContentType(
                    token.trim().toLowerCase());

                token = config.getString("mimetype." + number +
                    ".description");
                if (StringUtils.isEmptyWithTrim(token))
                    token = mimetype.getMimeType();
                mimetype.setDescription(token.trim());

                bool = config.getBoolean("mimetype." + number +
                    ".isarchive");
                mimetype.setIsArchive(bool);


                token = config.getString("mimetype." + number +
                    ".magicbytes");
                if (!StringUtils.isEmptyWithTrim(token)) {
                    mimetype.setMagicBytes(
                        token.trim().toUpperCase().
                            replaceAll("\\\\s", ""));
                    magicBytesToMimeTypes.put(
                        mimetype.getMagicBytes(), mimetype);
                    if (maxMagicByteLen < token.length())
                        maxMagicByteLen = token.length();
                }

                Set mfileext = mimetype.getExtensions();
                Iterator iter = mfileext.iterator();
                while (iter.hasNext()) {
                    String ext = (String) iter.next();
                    Set fileext = (Set) fileExtensionsToMimeTypes.
                        get(ext);
                    if (fileext == null) {
                        fileext = new HashSet();
                        fileExtensionsToMimeTypes.put(
                            ext, fileext);
                    }
                    fileext.add(mimetype);
                }

                mimeTypesToPropertyIds.put(
                    new Integer(number), mimetype);
                number++;
            }
        }
    }

    /**
     * Try to detect by extension.
     *
     * @param f
     * @return
     */
    public MimeType[] detectByFileExtension(File f) {
        String extension = FileUtil.getFileExtension(
            f.getName());
        if (StringUtils.isEmptyWithTrim(extension))
            return null;
        Set mimes = (Set) this.fileExtensionsToMimeTypes.
            get(extension);
        if (mimes == null || mimes.size() <= 0)
            return null;
        return (MimeType[]) mimes.toArray(
            new MimeType[mimes.size()]);
    }

    /**
     * Try to detect by fileheader.
     *
     * @param f
     * @return
     */
    public MimeType[] detectByFileHeader(File f) {
        LinkedHashSet mimes = new LinkedHashSet();
        InputStream fi = null;
        MimeType mime = null;
        try {
            fi = new BufferedInputStream(
                new FileInputStream(f),
                maxMagicByteLen + 10);
            int readBytes = 0;
            int readByte = 0;
            StringBuffer magicBytes =
                new StringBuffer(maxMagicByteLen + 10);
            String magic;
            String hex;
            while (readBytes <= maxMagicByteLen &&
                readByte > -1) {

                readByte = fi.read();
                readBytes++;
                hex = Integer.toHexString(readByte);
                if (hex.length() < 2) hex = "0" + hex;
                magicBytes.append(hex);
                magic = magicBytes.toString().
                    toUpperCase();
                if (LOG.isDebugEnabled())
                    LOG.debug("magic: " + magic);
                mime = (MimeType) magicBytesToMimeTypes.
                    get(magic);
                if (mime != null) mimes.add(mime);
            }

            if (mimes.size() <= 0) return null;
            return (MimeType[]) mimes.
                toArray(new MimeType[mimes.size()]);
        } catch (IOException e) {
            LOG.warn(e);
            return null;
        } finally {
            try {
                if (fi != null) fi.close();
            } catch (Throwable t) {
            }
        }
    }

    /**
     * First try to detect filetype by file header,
     * then by fileextension.
     *
     * @param f
     * @return
     */
    public MimeType[] detect(File f) {
        MimeType[] mimes = detectByFileHeader(f);
        if (mimes == null) mimes = detectByFileExtension(f);
        return mimes;
    }
}