* The following configuration parameters are used: *
/foo then the the file
* [root]/foo/bar.html will be delivered
* in response to the url /bar.html.
* * mimePatterns=.x* .a? * mime.x*=text/xml * mime.a?=application/octet-stream ** The types corrosponding to mime patterns are searched for * in mimePattern order, first looking for *
prefix.mime.pattern then
* mime.pattern. If neither property exists,
* then the type is invalid.
* * The FileHandler sets the following entries in the request properties * as a side-effect: *
* This handler supports a subset of the http range
* header of the form
* range bytes=[start]-[end], where start and end
* are byte positions in the file, starting at zero. A large or
* missing end value is treated as the end of the file. If a valid
* rangeheader is found, the appropriate
* content-range header is returned, along with the partial
* contents of the file.
*
* @author Stephen Uhler
* @version 2.10
*/
public class FileHandler implements Handler {
private static final String PREFIX = "prefix"; // our prefix
private static final String DEFAULT = "default"; // property for default document, given directory
private static final String GETONLY = "getOnly"; // allow only GETs
private static final String STRICT_TYPES = "strictTypes";
public static final String MIME = "mime"; // property for mime type
public static final String UNKNOWN = "unknown";// make this suffix unknown
public static final String ROOT = "root"; // property for document root
public String urlPrefix = "/";
String prefix;
/**
* Initialize the file handler.
*
* @return The file handler always returns true.
*/
public boolean
init(Server server, String prefix)
{
this.prefix = prefix;
urlPrefix = server.props.getProperty(prefix + PREFIX, urlPrefix);
return true;
}
/**
* Find, read, and deliver via http the requested file.
* The server property root is used as the document root.
* The document root is recalculated for each request, so an upstream
* handler may change it for that request.
* For URL's ending with "/", the server property default
* (normally index.html) is automatically appended.
*
* If the file suffix is not found as a server property
* mime.suffix, the file is not delivered.
*/
public boolean
respond(Request request)
throws IOException
{
if (!request.url.startsWith(urlPrefix)) {
return false;
}
if ((request.props.getProperty(prefix + GETONLY)!=null) &&
(!request.method.equals("GET"))) {
request.log(Server.LOG_INFORMATIONAL, prefix,
"Skipping request, only GET's allowed");
return false;
}
String url = request.url.substring(urlPrefix.length());
Properties props = request.props;
String root = props.getProperty(prefix + ROOT,
props.getProperty(ROOT, "."));
boolean strictTypes = (props.getProperty(prefix+STRICT_TYPES) != null);
String name = urlToPath(url);
request.log(Server.LOG_DIAGNOSTIC, prefix, "Looking for file: (" +
root + ")(" + name + ")");
File file = new File(root + name);
String path = file.getPath();
if (file.isDirectory()) {
/*
* Must check if the original name ends with "/",
* not File.getPath because in jdk-1.2,
* File.getPath truncates the terminating "/".
*/
if (request.url.endsWith("/") == false) {
request.redirect(request.url + "/", null);
return true;
}
props.put("DirectoryName", path);
String index = props.getProperty(prefix + DEFAULT, "index.html");
file = new File(file, index);
path = file.getPath();
}
/*
* Put the name of the file in the request object. This
* may be of some use for down stream handlers.
*/
props.put("fileName", path);
if (file.exists() == false) {
request.log(Server.LOG_INFORMATIONAL, prefix,
"no such file: " + path);
return false;
}
String basename = file.getName();
String type = getMimeType(basename, props, prefix, strictTypes);
if (type == null) {
request.log(Server.LOG_INFORMATIONAL, prefix,
"unknown file suffix for " + basename);
return false;
}
sendFile(request, file, 200, type);
return true;
}
/**
* Get the mime type based on the suffix of a String. The
* suffix (e.g. text after the last ".") is used to lookup
* the entry "prefix.mime.[suffix]" then "mime.[suffix]" in
* props. If neither entry is found, then mime
* glob pattern are used, if available. If there is no suffix,
* then the empty string is used.
*
* If the mime type is set to the special string "unknown", then * the type is unknown. This allows specific types to be undefined * when glob patterns are used. *
* If the property "prefix.mimePatterns" (or "mimePatterns") exists, * then it specifies a white-space delimited set of glob style patterns * for matching file suffixes to types. If a match for a specific file * suffix fails, then the property "mime.[pattern]" is used for type * comparisons. *
* The entries: *
* mimePatterns=*ml
* mime.*ml=text/xml
*
* would associate the type "text/xml" with the file foo.html, foo.xml
* and foo.dhtml.
* The entries:
*
* mimePatterns=*
* mime*=application/octet-stream
* mime.config=unknown
*
* Would set the types for all file types not otherwise defined to be
* "application/octet-stream", except that files ending in ".config"
* would have no type (e.g. they would generate a file not found error).
*
* @param name The string to compute the mime type for
* @param props The properties to look up the mime types in.
* @param prefix The properties prefix for the name lookup
* @return The type (or null if not found).
*/
public static String
getMimeType(String name, Properties props, String prefix) {
return getMimeType(name, props, prefix, false);
}
/**
* If "strict" is set, only return types that specifically
* match properties with this handlers prefix.
*/
public static String
getMimeType(String name, Properties props, String prefix, boolean strict) {
String type = null;
int index = name.lastIndexOf('.');
if (index > 0) {
String suffix = name.substring(index);
if (strict) {
return props.getProperty(prefix + MIME + suffix);
}
type = props.getProperty(prefix + MIME + suffix,
props.getProperty(MIME + suffix));
// check for glob patterns
if (type == null) {
type = getGlobType(suffix, props, prefix);
} else if (type.equals(UNKNOWN)) {
return null;
}
} else if (index < 0) {
type = getGlobType("", props, prefix);
}
return type;
}
/**
* Helper to find mime types for suffixes with glob pattern.
* Used only if a static mime type is not found.
* @param suffix the file suffix to look for
* @param dict where to look
* @param prefix prefix in properties table
*/
static String
getGlobType(String suffix, Properties props, String pre) {
String list = props.getProperty(pre + "mimePatterns",
props.getProperty("mimePatterns"));
if (list == null) {
return null;
}
StringTokenizer st = new StringTokenizer(list);
while(st.hasMoreTokens()) {
String key = st.nextToken();
if (Glob.match(key, suffix)) {
String type = props.getProperty(pre + "mime" + key,
props.getProperty("mime" + key));
if (UNKNOWN.equals(type)) {
break;
} else {
return type;
}
}
}
return null;
}
/**
* Helper function to convert an url into a pathname. URL(String) collapses all "/.." (and "/.") sequences,
* except for a trailing "/.." (or "/."), which would lead to the
* possibility of escaping from the document root.
*
* File.getPath in jdk-1.1 leaves all the "//" constructs
* in, but it collapses them in jdk-1.2, so we have to always take it
* out ourselves, just to be sure.
*
* @param url
* The file path from the URL (that is, minus the "http://host"
* part). May be null.
*
* @return The path that corresponds to the URL. The returned value
* begins with "/". The caller can concatenate this path
* onto the end of some document root.
*/
public static String
urlToPath(String url)
{
String name = HttpUtil.urlDecode(url);
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(name, "/");
while (st.hasMoreTokens()) {
String part = st.nextToken();
if (part.equals(".")) {
continue;
} else if (part.equals("..")) {
for (int i = sb.length(); --i >= 0; ) {
if (sb.charAt(i) == '/') {
sb.setLength(i);
break;
}
}
} else {
sb.append(File.separatorChar).append(part);
}
}
if ((sb.length() == 0) || name.endsWith("/")) {
sb.append(File.separatorChar);
}
return sb.toString();
}
/**
* Send a file as a response.
* @param request The request object
* @param file The file to output
* @param code The HTTP status code.
* @param type The mime type of the file
*/
static public void
sendFile(Request request, File file, int code, String type)
throws IOException
{
if (file.isFile() == false) {
request.sendError(404, null, "not a normal file");
return;
}
if (file.canRead() == false) {
request.sendError(403, null, "Permission Denied");
return;
}
FileInputStream in = null;
try {
in = new FileInputStream(file);
request.addHeader("Last-Modified",
HttpUtil.formatTime(file.lastModified()));
setModified(request.props, file.lastModified());
int size = (int) file.length();
request.setStatus(code);
size = range(request, in, size);
request.sendResponse(in, size, type, -1);
} finally {
if (in != null) {
in.close();
}
}
}
/**
* Set the "lastModified" request property. If already set,
* use the most recent value.
* @param props Where to find the "lastModified" property
* @param mod The modidied time, in ms since the epoch
*/
public static void setModified(Properties props, long mod) {
if (mod <= 0) {
return;
}
String current = props.getProperty("lastModified");
if (current == null) {
props.put("lastModified", "" + mod);
} else {
try {
long l = Long.parseLong(current);
if (l > mod) {
props.put("lastModified", "" + l);
}
} catch (NumberFormatException e) {}
}
}
/**
* Compute simple byte ranges. (for gnutella support). Only simple
* ranges (e.g. xxx-yyy) are supported. This skips over the proper
* number of bytes in the input stream, changes the request status to
* 26, and adds a content-range header.
* @return The (potential partial) size.
*
*/
private static int
range(Request request, FileInputStream in, int size) throws IOException {
String range=request.getRequestHeader("range");
int sep = 0;
if (range != null && request.getStatus()==200 &&
range.indexOf("bytes=") == 0 &&
(sep = range.indexOf("-")) > 0 &&
range.indexOf(",")<0) {
int start = -1;
int end = -1;
try {
start = Integer.parseInt(range.substring(6,sep));
} catch (NumberFormatException e) {}
try {
end = Integer.parseInt(range.substring(sep+1));
} catch (NumberFormatException e) {}
if (end == -1) {
end = size - 1;
} else if (end >= size) {
end = size - 1;
}
if (start == -1) {
start = size - end + 1;
end = size;
}
if (end >= start) {
in.skip(start);
request.addHeader("Content-Range",
"bytes " + start + "-" + end + "/" + size);
size = end - start + 1;
request.setStatus(206);
}
}
return size;
}
}