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;
}
}