By default, the server spawns a new Thread for every incoming request. These are set
+ * to daemon status, and named according to the request number. The name is
+ * useful when profiling the application.
+ */
+ public static class DefaultAsyncRunner implements AsyncRunner {
+ private long requestCount;
+
+ @Override
+ public void exec(Runnable code) {
+ ++requestCount;
+ Thread t = new Thread(code);
+ t.setDaemon(true);
+ t.setName("NanoHttpd Request Processor (#" + requestCount + ")");
+ t.start();
+ }
+ }
+
+ /**
+ * Default strategy for creating and cleaning up temporary files.
+ *
+ * This class stores its files in the standard location (that is,
+ * wherever java.io.tmpdir points to). Files are added
+ * to an internal list, and deleted when no longer needed (that is,
+ * when clear() is invoked at the end of processing a
+ * request).
+ */
+ public static class DefaultTempFileManager implements TempFileManager {
+ private final String tmpdir;
+ private final List tempFiles;
+
+ public DefaultTempFileManager() {
+ tmpdir = System.getProperty("java.io.tmpdir");
+ tempFiles = new ArrayList();
+ }
+
+ @Override
+ public TempFile createTempFile() throws Exception {
+ DefaultTempFile tempFile = new DefaultTempFile(tmpdir);
+ tempFiles.add(tempFile);
+ return tempFile;
+ }
+
+ @Override
+ public void clear() {
+ for (TempFile file : tempFiles) {
+ try {
+ file.delete();
+ } catch (Exception ignored) {
+ }
+ }
+ tempFiles.clear();
+ }
+ }
+
+ /**
+ * Default strategy for creating and cleaning up temporary files.
+ *
+ * [>By default, files are created by File.createTempFile() in
+ * the directory specified.
+ */
+ public static class DefaultTempFile implements TempFile {
+ private File file;
+ private OutputStream fstream;
+
+ public DefaultTempFile(String tempdir) throws IOException {
+ file = File.createTempFile("NanoHTTPD-", "", new File(tempdir));
+ fstream = new FileOutputStream(file);
+ }
+
+ @Override
+ public OutputStream open() throws Exception {
+ return fstream;
+ }
+
+ @Override
+ public void delete() throws Exception {
+ safeClose(fstream);
+ file.delete();
+ }
+
+ @Override
+ public String getName() {
+ return file.getAbsolutePath();
+ }
+ }
+
+ /**
+ * HTTP response. Return one of these from serve().
+ */
+ public static class Response {
+ /**
+ * HTTP status code after processing, e.g. "200 OK", HTTP_OK
+ */
+ private IStatus status;
+ /**
+ * MIME type of content, e.g. "text/html"
+ */
+ private String mimeType;
+ /**
+ * Data of the response, may be null.
+ */
+ private InputStream data;
+ /**
+ * Headers for the HTTP response. Use addHeader() to add lines.
+ */
+ private Map header = new HashMap();
+ /**
+ * The request method that spawned this response.
+ */
+ private Method requestMethod;
+ /**
+ * Use chunkedTransfer
+ */
+ private boolean chunkedTransfer;
+
+ /**
+ * Default constructor: response = HTTP_OK, mime = MIME_HTML and your supplied message
+ */
+ public Response(String msg) {
+ this(Status.OK, MIME_HTML, msg);
+ }
+
+ /**
+ * Basic constructor.
+ */
+ public Response(IStatus status, String mimeType, InputStream data) {
+ this.status = status;
+ this.mimeType = mimeType;
+ this.data = data;
+ }
+
+ /**
+ * Convenience method that makes an InputStream out of given text.
+ */
+ public Response(IStatus status, String mimeType, String txt) {
+ this.status = status;
+ this.mimeType = mimeType;
+ try {
+ this.data = txt != null ? new ByteArrayInputStream(txt.getBytes("UTF-8")) : null;
+ } catch (java.io.UnsupportedEncodingException uee) {
+ uee.printStackTrace();
+ }
+ }
+
+ /**
+ * Adds given line to the header.
+ */
+ public void addHeader(String name, String value) {
+ header.put(name, value);
+ }
+
+ public String getHeader(String name) {
+ return header.get(name);
+ }
+
+ /**
+ * Sends given response to the socket.
+ */
+ protected void send(OutputStream outputStream) {
+ String mime = mimeType;
+ SimpleDateFormat gmtFrmt = new SimpleDateFormat("E, d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
+ gmtFrmt.setTimeZone(TimeZone.getTimeZone("GMT"));
+
+ try {
+ if (status == null) {
+ throw new Error("sendResponse(): Status can't be null.");
+ }
+ PrintWriter pw = new PrintWriter(outputStream);
+ pw.print("HTTP/1.1 " + status.getDescription() + " \r\n");
+
+ if (mime != null) {
+ pw.print("Content-Type: " + mime + "\r\n");
+ }
+
+ if (header == null || header.get("Date") == null) {
+ pw.print("Date: " + gmtFrmt.format(new Date()) + "\r\n");
+ }
+
+ if (header != null) {
+ for (String key : header.keySet()) {
+ String value = header.get(key);
+ pw.print(key + ": " + value + "\r\n");
+ }
+ }
+
+ sendConnectionHeaderIfNotAlreadyPresent(pw, header);
+
+ if (requestMethod != Method.HEAD && chunkedTransfer) {
+ sendAsChunked(outputStream, pw);
+ } else {
+ int pending = data != null ? data.available() : 0;
+ sendContentLengthHeaderIfNotAlreadyPresent(pw, header, pending);
+ pw.print("\r\n");
+ pw.flush();
+ sendAsFixedLength(outputStream, pending);
+ }
+ outputStream.flush();
+ safeClose(data);
+ } catch (IOException ioe) {
+ // Couldn't write? No can do.
+ }
+ }
+
+ protected void sendContentLengthHeaderIfNotAlreadyPresent(PrintWriter pw, Map header, int size) {
+ if (!headerAlreadySent(header, "content-length")) {
+ pw.print("Content-Length: "+ size +"\r\n");
+ }
+ }
+
+ protected void sendConnectionHeaderIfNotAlreadyPresent(PrintWriter pw, Map header) {
+ if (!headerAlreadySent(header, "connection")) {
+ pw.print("Connection: keep-alive\r\n");
+ }
+ }
+
+ private boolean headerAlreadySent(Map header, String name) {
+ boolean alreadySent = false;
+ for (String headerName : header.keySet()) {
+ alreadySent |= headerName.equalsIgnoreCase(name);
+ }
+ return alreadySent;
+ }
+
+ private void sendAsChunked(OutputStream outputStream, PrintWriter pw) throws IOException {
+ pw.print("Transfer-Encoding: chunked\r\n");
+ pw.print("\r\n");
+ pw.flush();
+ int BUFFER_SIZE = 16 * 1024;
+ byte[] CRLF = "\r\n".getBytes();
+ byte[] buff = new byte[BUFFER_SIZE];
+ int read;
+ while ((read = data.read(buff)) > 0) {
+ outputStream.write(String.format("%x\r\n", read).getBytes());
+ outputStream.write(buff, 0, read);
+ outputStream.write(CRLF);
+ }
+ outputStream.write(String.format("0\r\n\r\n").getBytes());
+ }
+
+ private void sendAsFixedLength(OutputStream outputStream, int pending) throws IOException {
+ if (requestMethod != Method.HEAD && data != null) {
+ int BUFFER_SIZE = 16 * 1024;
+ byte[] buff = new byte[BUFFER_SIZE];
+ while (pending > 0) {
+ int read = data.read(buff, 0, ((pending > BUFFER_SIZE) ? BUFFER_SIZE : pending));
+ if (read <= 0) {
+ break;
+ }
+ outputStream.write(buff, 0, read);
+ pending -= read;
+ }
+ }
+ }
+
+ public IStatus getStatus() {
+ return status;
+ }
+
+ public void setStatus(Status status) {
+ this.status = status;
+ }
+
+ public String getMimeType() {
+ return mimeType;
+ }
+
+ public void setMimeType(String mimeType) {
+ this.mimeType = mimeType;
+ }
+
+ public InputStream getData() {
+ return data;
+ }
+
+ public void setData(InputStream data) {
+ this.data = data;
+ }
+
+ public Method getRequestMethod() {
+ return requestMethod;
+ }
+
+ public void setRequestMethod(Method requestMethod) {
+ this.requestMethod = requestMethod;
+ }
+
+ public void setChunkedTransfer(boolean chunkedTransfer) {
+ this.chunkedTransfer = chunkedTransfer;
+ }
+
+ public interface IStatus {
+ int getRequestStatus();
+ String getDescription();
+ }
+
+ /**
+ * Some HTTP response status codes
+ */
+ public enum Status implements IStatus {
+ SWITCH_PROTOCOL(101, "Switching Protocols"), OK(200, "OK"), CREATED(201, "Created"), ACCEPTED(202, "Accepted"), NO_CONTENT(204, "No Content"), PARTIAL_CONTENT(206, "Partial Content"), REDIRECT(301,
+ "Moved Permanently"), NOT_MODIFIED(304, "Not Modified"), BAD_REQUEST(400, "Bad Request"), UNAUTHORIZED(401,
+ "Unauthorized"), FORBIDDEN(403, "Forbidden"), NOT_FOUND(404, "Not Found"), METHOD_NOT_ALLOWED(405, "Method Not Allowed"), RANGE_NOT_SATISFIABLE(416,
+ "Requested Range Not Satisfiable"), INTERNAL_ERROR(500, "Internal Server Error");
+ private final int requestStatus;
+ private final String description;
+
+ Status(int requestStatus, String description) {
+ this.requestStatus = requestStatus;
+ this.description = description;
+ }
+
+ @Override
+ public int getRequestStatus() {
+ return this.requestStatus;
+ }
+
+ @Override
+ public String getDescription() {
+ return "" + this.requestStatus + " " + description;
+ }
+ }
+ }
+
+ public static final class ResponseException extends Exception {
+
+ private final Response.Status status;
+
+ public ResponseException(Response.Status status, String message) {
+ super(message);
+ this.status = status;
+ }
+
+ public ResponseException(Response.Status status, String message, Exception e) {
+ super(message, e);
+ this.status = status;
+ }
+
+ public Response.Status getStatus() {
+ return status;
+ }
+ }
+
+ /**
+ * Default strategy for creating and cleaning up temporary files.
+ */
+ private class DefaultTempFileManagerFactory implements TempFileManagerFactory {
+ @Override
+ public TempFileManager create() {
+ return new DefaultTempFileManager();
+ }
+ }
+
+ /**
+ * Handles one session, i.e. parses the HTTP request and returns the response.
+ */
+ public interface IHTTPSession {
+ void execute() throws IOException;
+
+ Map getParms();
+
+ Map getHeaders();
+
+ /**
+ * @return the path part of the URL.
+ */
+ String getUri();
+
+ String getQueryParameterString();
+
+ Method getMethod();
+
+ InputStream getInputStream();
+
+ CookieHandler getCookies();
+
+ /**
+ * Adds the files in the request body to the files map.
+ * @arg files - map to modify
+ */
+ void parseBody(Map files) throws IOException, ResponseException;
+ }
+
+ protected class HTTPSession implements IHTTPSession {
+ public static final int BUFSIZE = 8192;
+ private final TempFileManager tempFileManager;
+ private final OutputStream outputStream;
+ private PushbackInputStream inputStream;
+ private int splitbyte;
+ private int rlen;
+ private String uri;
+ private Method method;
+ private Map parms;
+ private Map headers;
+ private CookieHandler cookies;
+ private String queryParameterString;
+
+ public HTTPSession(TempFileManager tempFileManager, InputStream inputStream, OutputStream outputStream) {
+ this.tempFileManager = tempFileManager;
+ this.inputStream = new PushbackInputStream(inputStream, BUFSIZE);
+ this.outputStream = outputStream;
+ }
+
+ public HTTPSession(TempFileManager tempFileManager, InputStream inputStream, OutputStream outputStream, InetAddress inetAddress) {
+ this.tempFileManager = tempFileManager;
+ this.inputStream = new PushbackInputStream(inputStream, BUFSIZE);
+ this.outputStream = outputStream;
+ String remoteIp = inetAddress.isLoopbackAddress() || inetAddress.isAnyLocalAddress() ? "127.0.0.1" : inetAddress.getHostAddress().toString();
+ headers = new HashMap();
+
+ headers.put("remote-addr", remoteIp);
+ headers.put("http-client-ip", remoteIp);
+ }
+
+ @Override
+ public void execute() throws IOException {
+ try {
+ // Read the first 8192 bytes.
+ // The full header should fit in here.
+ // Apache's default header limit is 8KB.
+ // Do NOT assume that a single read will get the entire header at once!
+ byte[] buf = new byte[BUFSIZE];
+ splitbyte = 0;
+ rlen = 0;
+ {
+ int read = -1;
+ try {
+ read = inputStream.read(buf, 0, BUFSIZE);
+ } catch (Exception e) {
+ safeClose(inputStream);
+ safeClose(outputStream);
+ throw new SocketException("NanoHttpd Shutdown");
+ }
+ if (read == -1) {
+ // socket was been closed
+ safeClose(inputStream);
+ safeClose(outputStream);
+ throw new SocketException("NanoHttpd Shutdown");
+ }
+ while (read > 0) {
+ rlen += read;
+ splitbyte = findHeaderEnd(buf, rlen);
+ if (splitbyte > 0)
+ break;
+ read = inputStream.read(buf, rlen, BUFSIZE - rlen);
+ }
+ }
+
+ if (splitbyte < rlen) {
+ inputStream.unread(buf, splitbyte, rlen - splitbyte);
+ }
+
+ parms = new HashMap();
+ if(null == headers) {
+ headers = new HashMap();
+ }
+
+ // Create a BufferedReader for parsing the header.
+ BufferedReader hin = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buf, 0, rlen)));
+
+ // Decode the header into parms and header java properties
+ Map pre = new HashMap();
+ decodeHeader(hin, pre, parms, headers);
+
+ method = Method.lookup(pre.get("method"));
+ if (method == null) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Syntax error.");
+ }
+
+ uri = pre.get("uri");
+
+ cookies = new CookieHandler(headers);
+
+ // Ok, now do the serve()
+ Response r = serve(this);
+ if (r == null) {
+ throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: Serve() returned a null response.");
+ } else {
+ cookies.unloadQueue(r);
+ r.setRequestMethod(method);
+ r.send(outputStream);
+ }
+ } catch (SocketException e) {
+ // throw it out to close socket object (finalAccept)
+ throw e;
+ } catch (SocketTimeoutException ste) {
+ throw ste;
+ } catch (IOException ioe) {
+ Response r = new Response(Response.Status.INTERNAL_ERROR, MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
+ r.send(outputStream);
+ safeClose(outputStream);
+ } catch (ResponseException re) {
+ Response r = new Response(re.getStatus(), MIME_PLAINTEXT, re.getMessage());
+ r.send(outputStream);
+ safeClose(outputStream);
+ } finally {
+ tempFileManager.clear();
+ }
+ }
+
+ @Override
+ public void parseBody(Map files) throws IOException, ResponseException {
+ RandomAccessFile randomAccessFile = null;
+ BufferedReader in = null;
+ try {
+
+ randomAccessFile = getTmpBucket();
+
+ long size;
+ if (headers.containsKey("content-length")) {
+ size = Integer.parseInt(headers.get("content-length"));
+ } else if (splitbyte < rlen) {
+ size = rlen - splitbyte;
+ } else {
+ size = 0;
+ }
+
+ // Now read all the body and write it to f
+ byte[] buf = new byte[512];
+ while (rlen >= 0 && size > 0) {
+ rlen = inputStream.read(buf, 0, (int)Math.min(size, 512));
+ size -= rlen;
+ if (rlen > 0) {
+ randomAccessFile.write(buf, 0, rlen);
+ }
+ }
+
+ // Get the raw body as a byte []
+ ByteBuffer fbuf = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length());
+ randomAccessFile.seek(0);
+
+ // Create a BufferedReader for easily reading it as string.
+ InputStream bin = new FileInputStream(randomAccessFile.getFD());
+ in = new BufferedReader(new InputStreamReader(bin));
+
+ // If the method is POST, there may be parameters
+ // in data section, too, read it:
+ if (Method.POST.equals(method)) {
+ String contentType = "";
+ String contentTypeHeader = headers.get("content-type");
+
+ StringTokenizer st = null;
+ if (contentTypeHeader != null) {
+ st = new StringTokenizer(contentTypeHeader, ",; ");
+ if (st.hasMoreTokens()) {
+ contentType = st.nextToken();
+ }
+ }
+
+ if ("multipart/form-data".equalsIgnoreCase(contentType)) {
+ // Handle multipart/form-data
+ if (!st.hasMoreTokens()) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but boundary missing. Usage: GET /example/file.html");
+ }
+
+ String boundaryStartString = "boundary=";
+ int boundaryContentStart = contentTypeHeader.indexOf(boundaryStartString) + boundaryStartString.length();
+ String boundary = contentTypeHeader.substring(boundaryContentStart, contentTypeHeader.length());
+ if (boundary.startsWith("\"") && boundary.endsWith("\"")) {
+ boundary = boundary.substring(1, boundary.length() - 1);
+ }
+
+ decodeMultipartData(boundary, fbuf, in, parms, files);
+ } else {
+ String postLine = "";
+ StringBuilder postLineBuffer = new StringBuilder();
+ char pbuf[] = new char[512];
+ int read = in.read(pbuf);
+ while (read >= 0 && !postLine.endsWith("\r\n")) {
+ postLine = String.valueOf(pbuf, 0, read);
+ postLineBuffer.append(postLine);
+ read = in.read(pbuf);
+ }
+ postLine = postLineBuffer.toString().trim();
+ // Handle application/x-www-form-urlencoded
+ if ("application/x-www-form-urlencoded".equalsIgnoreCase(contentType)) {
+ decodeParms(postLine, parms);
+ } else if (postLine.length() != 0) {
+ // Special case for raw POST data => create a special files entry "postData" with raw content data
+ files.put("postData", postLine);
+ }
+ }
+ } else if (Method.PUT.equals(method)) {
+ files.put("content", saveTmpFile(fbuf, 0, fbuf.limit()));
+ }
+ } finally {
+ safeClose(randomAccessFile);
+ safeClose(in);
+ }
+ }
+
+ /**
+ * Decodes the sent headers and loads the data into Key/value pairs
+ */
+ private void decodeHeader(BufferedReader in, Map pre, Map parms, Map headers)
+ throws ResponseException {
+ try {
+ // Read the request line
+ String inLine = in.readLine();
+ if (inLine == null) {
+ return;
+ }
+
+ StringTokenizer st = new StringTokenizer(inLine);
+ if (!st.hasMoreTokens()) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Syntax error. Usage: GET /example/file.html");
+ }
+
+ pre.put("method", st.nextToken());
+
+ if (!st.hasMoreTokens()) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Missing URI. Usage: GET /example/file.html");
+ }
+
+ String uri = st.nextToken();
+
+ // Decode parameters from the URI
+ int qmi = uri.indexOf('?');
+ if (qmi >= 0) {
+ decodeParms(uri.substring(qmi + 1), parms);
+ uri = decodePercent(uri.substring(0, qmi));
+ } else {
+ uri = decodePercent(uri);
+ }
+
+ // If there's another token, it's protocol version,
+ // followed by HTTP headers. Ignore version but parse headers.
+ // NOTE: this now forces header names lowercase since they are
+ // case insensitive and vary by client.
+ if (st.hasMoreTokens()) {
+ String line = in.readLine();
+ while (line != null && line.trim().length() > 0) {
+ int p = line.indexOf(':');
+ if (p >= 0)
+ headers.put(line.substring(0, p).trim().toLowerCase(Locale.US), line.substring(p + 1).trim());
+ line = in.readLine();
+ }
+ }
+
+ pre.put("uri", uri);
+ } catch (IOException ioe) {
+ throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage(), ioe);
+ }
+ }
+
+ /**
+ * Decodes the Multipart Body data and put it into Key/Value pairs.
+ */
+ private void decodeMultipartData(String boundary, ByteBuffer fbuf, BufferedReader in, Map parms,
+ Map files) throws ResponseException {
+ try {
+ int[] bpositions = getBoundaryPositions(fbuf, boundary.getBytes());
+ int boundarycount = 1;
+ String mpline = in.readLine();
+ while (mpline != null) {
+ if (!mpline.contains(boundary)) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but next chunk does not start with boundary. Usage: GET /example/file.html");
+ }
+ boundarycount++;
+ Map item = new HashMap();
+ mpline = in.readLine();
+ while (mpline != null && mpline.trim().length() > 0) {
+ int p = mpline.indexOf(':');
+ if (p != -1) {
+ item.put(mpline.substring(0, p).trim().toLowerCase(Locale.US), mpline.substring(p + 1).trim());
+ }
+ mpline = in.readLine();
+ }
+ if (mpline != null) {
+ String contentDisposition = item.get("content-disposition");
+ if (contentDisposition == null) {
+ throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but no content-disposition info found. Usage: GET /example/file.html");
+ }
+ StringTokenizer st = new StringTokenizer(contentDisposition, ";");
+ Map disposition = new HashMap();
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken().trim();
+ int p = token.indexOf('=');
+ if (p != -1) {
+ disposition.put(token.substring(0, p).trim().toLowerCase(Locale.US), token.substring(p + 1).trim());
+ }
+ }
+ String pname = disposition.get("name");
+ pname = pname.substring(1, pname.length() - 1);
+
+ String value = "";
+ if (item.get("content-type") == null) {
+ while (mpline != null && !mpline.contains(boundary)) {
+ mpline = in.readLine();
+ if (mpline != null) {
+ int d = mpline.indexOf(boundary);
+ if (d == -1) {
+ value += mpline;
+ } else {
+ value += mpline.substring(0, d - 2);
+ }
+ }
+ }
+ } else {
+ if (boundarycount > bpositions.length) {
+ throw new ResponseException(Response.Status.INTERNAL_ERROR, "Error processing request");
+ }
+ int offset = stripMultipartHeaders(fbuf, bpositions[boundarycount - 2]);
+ String path = saveTmpFile(fbuf, offset, bpositions[boundarycount - 1] - offset - 4);
+ files.put(pname, path);
+ value = disposition.get("filename");
+ value = value.substring(1, value.length() - 1);
+ do {
+ mpline = in.readLine();
+ } while (mpline != null && !mpline.contains(boundary));
+ }
+ parms.put(pname, value);
+ }
+ }
+ } catch (IOException ioe) {
+ throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage(), ioe);
+ }
+ }
+
+ /**
+ * Find byte index separating header from body. It must be the last byte of the first two sequential new lines.
+ */
+ private int findHeaderEnd(final byte[] buf, int rlen) {
+ int splitbyte = 0;
+ while (splitbyte + 3 < rlen) {
+ if (buf[splitbyte] == '\r' && buf[splitbyte + 1] == '\n' && buf[splitbyte + 2] == '\r' && buf[splitbyte + 3] == '\n') {
+ return splitbyte + 4;
+ }
+ splitbyte++;
+ }
+ return 0;
+ }
+
+ /**
+ * Find the byte positions where multipart boundaries start.
+ */
+ private int[] getBoundaryPositions(ByteBuffer b, byte[] boundary) {
+ int matchcount = 0;
+ int matchbyte = -1;
+ List matchbytes = new ArrayList();
+ for (int i = 0; i < b.limit(); i++) {
+ if (b.get(i) == boundary[matchcount]) {
+ if (matchcount == 0)
+ matchbyte = i;
+ matchcount++;
+ if (matchcount == boundary.length) {
+ matchbytes.add(matchbyte);
+ matchcount = 0;
+ matchbyte = -1;
+ }
+ } else {
+ i -= matchcount;
+ matchcount = 0;
+ matchbyte = -1;
+ }
+ }
+ int[] ret = new int[matchbytes.size()];
+ for (int i = 0; i < ret.length; i++) {
+ ret[i] = matchbytes.get(i);
+ }
+ return ret;
+ }
+
+ /**
+ * Retrieves the content of a sent file and saves it to a temporary file. The full path to the saved file is returned.
+ */
+ private String saveTmpFile(ByteBuffer b, int offset, int len) {
+ String path = "";
+ if (len > 0) {
+ FileOutputStream fileOutputStream = null;
+ try {
+ TempFile tempFile = tempFileManager.createTempFile();
+ ByteBuffer src = b.duplicate();
+ fileOutputStream = new FileOutputStream(tempFile.getName());
+ FileChannel dest = fileOutputStream.getChannel();
+ src.position(offset).limit(offset + len);
+ dest.write(src.slice());
+ path = tempFile.getName();
+ } catch (Exception e) { // Catch exception if any
+ throw new Error(e); // we won't recover, so throw an error
+ } finally {
+ safeClose(fileOutputStream);
+ }
+ }
+ return path;
+ }
+
+ private RandomAccessFile getTmpBucket() {
+ try {
+ TempFile tempFile = tempFileManager.createTempFile();
+ return new RandomAccessFile(tempFile.getName(), "rw");
+ } catch (Exception e) {
+ throw new Error(e); // we won't recover, so throw an error
+ }
+ }
+
+ /**
+ * It returns the offset separating multipart file headers from the file's data.
+ */
+ private int stripMultipartHeaders(ByteBuffer b, int offset) {
+ int i;
+ for (i = offset; i < b.limit(); i++) {
+ if (b.get(i) == '\r' && b.get(++i) == '\n' && b.get(++i) == '\r' && b.get(++i) == '\n') {
+ break;
+ }
+ }
+ return i + 1;
+ }
+
+ /**
+ * Decodes parameters in percent-encoded URI-format ( e.g. "name=Jack%20Daniels&pass=Single%20Malt" ) and
+ * adds them to given Map. NOTE: this doesn't support multiple identical keys due to the simplicity of Map.
+ */
+ private void decodeParms(String parms, Map p) {
+ if (parms == null) {
+ queryParameterString = "";
+ return;
+ }
+
+ queryParameterString = parms;
+ StringTokenizer st = new StringTokenizer(parms, "&");
+ while (st.hasMoreTokens()) {
+ String e = st.nextToken();
+ int sep = e.indexOf('=');
+ if (sep >= 0) {
+ p.put(decodePercent(e.substring(0, sep)).trim(),
+ decodePercent(e.substring(sep + 1)));
+ } else {
+ p.put(decodePercent(e).trim(), "");
+ }
+ }
+ }
+
+ @Override
+ public final Map getParms() {
+ return parms;
+ }
+
+ public String getQueryParameterString() {
+ return queryParameterString;
+ }
+
+ @Override
+ public final Map getHeaders() {
+ return headers;
+ }
+
+ @Override
+ public final String getUri() {
+ return uri;
+ }
+
+ @Override
+ public final Method getMethod() {
+ return method;
+ }
+
+ @Override
+ public final InputStream getInputStream() {
+ return inputStream;
+ }
+
+ @Override
+ public CookieHandler getCookies() {
+ return cookies;
+ }
+ }
+
+ public static class Cookie {
+ private String n, v, e;
+
+ public Cookie(String name, String value, String expires) {
+ n = name;
+ v = value;
+ e = expires;
+ }
+
+ public Cookie(String name, String value) {
+ this(name, value, 30);
+ }
+
+ public Cookie(String name, String value, int numDays) {
+ n = name;
+ v = value;
+ e = getHTTPTime(numDays);
+ }
+
+ public String getHTTPHeader() {
+ String fmt = "%s=%s; expires=%s";
+ return String.format(fmt, n, v, e);
+ }
+
+ public static String getHTTPTime(int days) {
+ Calendar calendar = Calendar.getInstance();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
+ dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
+ calendar.add(Calendar.DAY_OF_MONTH, days);
+ return dateFormat.format(calendar.getTime());
+ }
+ }
+
+ /**
+ * Provides rudimentary support for cookies.
+ * Doesn't support 'path', 'secure' nor 'httpOnly'.
+ * Feel free to improve it and/or add unsupported features.
+ *
+ * @author LordFokas
+ */
+ public class CookieHandler implements Iterable {
+ private HashMap cookies = new HashMap();
+ private ArrayList queue = new ArrayList();
+
+ public CookieHandler(Map httpHeaders) {
+ String raw = httpHeaders.get("cookie");
+ if (raw != null) {
+ String[] tokens = raw.split(";");
+ for (String token : tokens) {
+ String[] data = token.trim().split("=");
+ if (data.length == 2) {
+ cookies.put(data[0], data[1]);
+ }
+ }
+ }
+ }
+
+ @Override public Iterator iterator() {
+ return cookies.keySet().iterator();
+ }
+
+ /**
+ * Read a cookie from the HTTP Headers.
+ *
+ * @param name The cookie's name.
+ * @return The cookie's value if it exists, null otherwise.
+ */
+ public String read(String name) {
+ return cookies.get(name);
+ }
+
+ /**
+ * Sets a cookie.
+ *
+ * @param name The cookie's name.
+ * @param value The cookie's value.
+ * @param expires How many days until the cookie expires.
+ */
+ public void set(String name, String value, int expires) {
+ queue.add(new Cookie(name, value, Cookie.getHTTPTime(expires)));
+ }
+
+ public void set(Cookie cookie) {
+ queue.add(cookie);
+ }
+
+ /**
+ * Set a cookie with an expiration date from a month ago, effectively deleting it on the client side.
+ *
+ * @param name The cookie name.
+ */
+ public void delete(String name) {
+ set(name, "-delete-", -30);
+ }
+
+ /**
+ * Internally used by the webserver to add all queued cookies into the Response's HTTP Headers.
+ *
+ * @param response The Response object to which headers the queued cookies will be added.
+ */
+ public void unloadQueue(Response response) {
+ for (Cookie cookie : queue) {
+ response.addHeader("Set-Cookie", cookie.getHTTPHeader());
+ }
+ }
+ }
+}
diff --git a/src/main/java/common/fi/iki/elonen/README.md b/src/main/java/common/fi/iki/elonen/README.md
new file mode 100644
index 000000000..ecc56ff5f
--- /dev/null
+++ b/src/main/java/common/fi/iki/elonen/README.md
@@ -0,0 +1,11 @@
+
+Exact copy/pasted 100% from:
+
+https://github.com/NanoHttpd/nanohttpd
+
+Git rev. ab6feae737b3038532d057e87fd83c58bad3b3cc
+
+Just done for simplicity, instead of using a Git sobmodule, ext. Maven dependency with shadowed über-JAR, or so.
+
+Instead of changing anything in this package, please submit pull requests to
+github.com/NanoHttpd/nanohttpd and then when re-copy/paste the ENTIRE nanohttpd src here.
diff --git a/src/main/java/common/fi/iki/elonen/ServerRunner.java b/src/main/java/common/fi/iki/elonen/ServerRunner.java
new file mode 100644
index 000000000..313097a56
--- /dev/null
+++ b/src/main/java/common/fi/iki/elonen/ServerRunner.java
@@ -0,0 +1,32 @@
+package fi.iki.elonen;
+
+import java.io.IOException;
+
+public class ServerRunner {
+ public static void run(Class serverClass) {
+ try {
+ executeInstance((NanoHTTPD) serverClass.newInstance());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static void executeInstance(NanoHTTPD server) {
+ try {
+ server.start();
+ } catch (IOException ioe) {
+ System.err.println("Couldn't start server:\n" + ioe);
+ System.exit(-1);
+ }
+
+ System.out.println("Server started, Hit Enter to stop.\n");
+
+ try {
+ System.in.read();
+ } catch (Throwable ignored) {
+ }
+
+ server.stop();
+ System.out.println("Server stopped.\n");
+ }
+}
diff --git a/src/main/java/common/fi/iki/elonen/SimpleWebServer.java b/src/main/java/common/fi/iki/elonen/SimpleWebServer.java
new file mode 100644
index 000000000..40ea34273
--- /dev/null
+++ b/src/main/java/common/fi/iki/elonen/SimpleWebServer.java
@@ -0,0 +1,541 @@
+package fi.iki.elonen;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.StringTokenizer;
+
+public class SimpleWebServer extends NanoHTTPD {
+ /**
+ * Common mime type for dynamic content: binary
+ */
+ public static final String MIME_DEFAULT_BINARY = "application/octet-stream";
+ /**
+ * Default Index file names.
+ */
+ public static final List INDEX_FILE_NAMES = new ArrayList() {{
+ add("index.html");
+ add("index.htm");
+ }};
+ /**
+ * Hashtable mapping (String)FILENAME_EXTENSION -> (String)MIME_TYPE
+ */
+ private static final Map MIME_TYPES = new HashMap() {{
+ put("css", "text/css");
+ put("htm", "text/html");
+ put("html", "text/html");
+ put("xml", "text/xml");
+ put("java", "text/x-java-source, text/java");
+ put("md", "text/plain");
+ put("txt", "text/plain");
+ put("asc", "text/plain");
+ put("gif", "image/gif");
+ put("jpg", "image/jpeg");
+ put("jpeg", "image/jpeg");
+ put("png", "image/png");
+ put("mp3", "audio/mpeg");
+ put("m3u", "audio/mpeg-url");
+ put("mp4", "video/mp4");
+ put("ogv", "video/ogg");
+ put("flv", "video/x-flv");
+ put("mov", "video/quicktime");
+ put("swf", "application/x-shockwave-flash");
+ put("js", "application/javascript");
+ put("pdf", "application/pdf");
+ put("doc", "application/msword");
+ put("ogg", "application/x-ogg");
+ put("zip", "application/octet-stream");
+ put("exe", "application/octet-stream");
+ put("class", "application/octet-stream");
+ }};
+ /**
+ * The distribution licence
+ */
+ private static final String LICENCE =
+ "Copyright (c) 2012-2013 by Paul S. Hawke, 2001,2005-2013 by Jarno Elonen, 2010 by Konstantinos Togias\n"
+ + "\n"
+ + "Redistribution and use in source and binary forms, with or without\n"
+ + "modification, are permitted provided that the following conditions\n"
+ + "are met:\n"
+ + "\n"
+ + "Redistributions of source code must retain the above copyright notice,\n"
+ + "this list of conditions and the following disclaimer. Redistributions in\n"
+ + "binary form must reproduce the above copyright notice, this list of\n"
+ + "conditions and the following disclaimer in the documentation and/or other\n"
+ + "materials provided with the distribution. The name of the author may not\n"
+ + "be used to endorse or promote products derived from this software without\n"
+ + "specific prior written permission. \n"
+ + " \n"
+ + "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n"
+ + "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n"
+ + "OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n"
+ + "IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n"
+ + "INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n"
+ + "NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
+ + "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
+ + "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
+ + "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
+ + "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.";
+ private static Map mimeTypeHandlers = new HashMap();
+ private final List rootDirs;
+ private final boolean quiet;
+
+ public SimpleWebServer(String host, int port, File wwwroot, boolean quiet) {
+ super(host, port);
+ this.quiet = quiet;
+ this.rootDirs = new ArrayList();
+ this.rootDirs.add(wwwroot);
+
+ this.init();
+ }
+
+ public SimpleWebServer(String host, int port, List wwwroots, boolean quiet) {
+ super(host, port);
+ this.quiet = quiet;
+ this.rootDirs = new ArrayList(wwwroots);
+
+ this.init();
+ }
+
+ /**
+ * Used to initialize and customize the server.
+ */
+ public void init() {
+ }
+
+ /**
+ * Starts as a standalone file server and waits for Enter.
+ */
+ public static void main(String[] args) {
+ // Defaults
+ int port = 8080;
+
+ String host = "127.0.0.1";
+ List rootDirs = new ArrayList();
+ boolean quiet = false;
+ Map options = new HashMap();
+
+ // Parse command-line, with short and long versions of the options.
+ for (int i = 0; i < args.length; ++i) {
+ if (args[i].equalsIgnoreCase("-h") || args[i].equalsIgnoreCase("--host")) {
+ host = args[i + 1];
+ } else if (args[i].equalsIgnoreCase("-p") || args[i].equalsIgnoreCase("--port")) {
+ port = Integer.parseInt(args[i + 1]);
+ } else if (args[i].equalsIgnoreCase("-q") || args[i].equalsIgnoreCase("--quiet")) {
+ quiet = true;
+ } else if (args[i].equalsIgnoreCase("-d") || args[i].equalsIgnoreCase("--dir")) {
+ rootDirs.add(new File(args[i + 1]).getAbsoluteFile());
+ } else if (args[i].equalsIgnoreCase("--licence")) {
+ System.out.println(LICENCE + "\n");
+ } else if (args[i].startsWith("-X:")) {
+ int dot = args[i].indexOf('=');
+ if (dot > 0) {
+ String name = args[i].substring(0, dot);
+ String value = args[i].substring(dot + 1, args[i].length());
+ options.put(name, value);
+ }
+ }
+ }
+
+ if (rootDirs.isEmpty()) {
+ rootDirs.add(new File(".").getAbsoluteFile());
+ }
+
+ options.put("host", host);
+ options.put("port", ""+port);
+ options.put("quiet", String.valueOf(quiet));
+ StringBuilder sb = new StringBuilder();
+ for (File dir : rootDirs) {
+ if (sb.length() > 0) {
+ sb.append(":");
+ }
+ try {
+ sb.append(dir.getCanonicalPath());
+ } catch (IOException ignored) {}
+ }
+ options.put("home", sb.toString());
+
+ ServiceLoader serviceLoader = ServiceLoader.load(WebServerPluginInfo.class);
+ for (WebServerPluginInfo info : serviceLoader) {
+ String[] mimeTypes = info.getMimeTypes();
+ for (String mime : mimeTypes) {
+ String[] indexFiles = info.getIndexFilesForMimeType(mime);
+ if (!quiet) {
+ System.out.print("# Found plugin for Mime type: \"" + mime + "\"");
+ if (indexFiles != null) {
+ System.out.print(" (serving index files: ");
+ for (String indexFile : indexFiles) {
+ System.out.print(indexFile + " ");
+ }
+ }
+ System.out.println(").");
+ }
+ registerPluginForMimeType(indexFiles, mime, info.getWebServerPlugin(mime), options);
+ }
+ }
+
+ ServerRunner.executeInstance(new SimpleWebServer(host, port, rootDirs, quiet));
+ }
+
+ protected static void registerPluginForMimeType(String[] indexFiles, String mimeType, WebServerPlugin plugin, Map commandLineOptions) {
+ if (mimeType == null || plugin == null) {
+ return;
+ }
+
+ if (indexFiles != null) {
+ for (String filename : indexFiles) {
+ int dot = filename.lastIndexOf('.');
+ if (dot >= 0) {
+ String extension = filename.substring(dot + 1).toLowerCase();
+ MIME_TYPES.put(extension, mimeType);
+ }
+ }
+ INDEX_FILE_NAMES.addAll(Arrays.asList(indexFiles));
+ }
+ mimeTypeHandlers.put(mimeType, plugin);
+ plugin.initialize(commandLineOptions);
+ }
+
+ private File getRootDir() {
+ return rootDirs.get(0);
+ }
+
+ private List getRootDirs() {
+ return rootDirs;
+ }
+
+ private void addWwwRootDir(File wwwroot) {
+ rootDirs.add(wwwroot);
+ }
+
+ /**
+ * URL-encodes everything between "/"-characters. Encodes spaces as '%20' instead of '+'.
+ */
+ private String encodeUri(String uri) {
+ String newUri = "";
+ StringTokenizer st = new StringTokenizer(uri, "/ ", true);
+ while (st.hasMoreTokens()) {
+ String tok = st.nextToken();
+ if (tok.equals("/"))
+ newUri += "/";
+ else if (tok.equals(" "))
+ newUri += "%20";
+ else {
+ try {
+ newUri += URLEncoder.encode(tok, "UTF-8");
+ } catch (UnsupportedEncodingException ignored) {
+ }
+ }
+ }
+ return newUri;
+ }
+
+ public Response serve(IHTTPSession session) {
+ Map header = session.getHeaders();
+ Map parms = session.getParms();
+ String uri = session.getUri();
+
+ if (!quiet) {
+ System.out.println(session.getMethod() + " '" + uri + "' ");
+
+ Iterator e = header.keySet().iterator();
+ while (e.hasNext()) {
+ String value = e.next();
+ System.out.println(" HDR: '" + value + "' = '" + header.get(value) + "'");
+ }
+ e = parms.keySet().iterator();
+ while (e.hasNext()) {
+ String value = e.next();
+ System.out.println(" PRM: '" + value + "' = '" + parms.get(value) + "'");
+ }
+ }
+
+ for (File homeDir : getRootDirs()) {
+ // Make sure we won't die of an exception later
+ if (!homeDir.isDirectory()) {
+ return getInternalErrorResponse("given path is not a directory (" + homeDir + ").");
+ }
+ }
+ return respond(Collections.unmodifiableMap(header), session, uri);
+ }
+
+ private Response respond(Map headers, IHTTPSession session, String uri) {
+ // Remove URL arguments
+ uri = uri.trim().replace(File.separatorChar, '/');
+ if (uri.indexOf('?') >= 0) {
+ uri = uri.substring(0, uri.indexOf('?'));
+ }
+
+ // Prohibit getting out of current directory
+ if (uri.startsWith("src/main") || uri.endsWith("src/main") || uri.contains("../")) {
+ return getForbiddenResponse("Won't serve ../ for security reasons.");
+ }
+
+ boolean canServeUri = false;
+ File homeDir = null;
+ List roots = getRootDirs();
+ for (int i = 0; !canServeUri && i < roots.size(); i++) {
+ homeDir = roots.get(i);
+ canServeUri = canServeUri(uri, homeDir);
+ }
+ if (!canServeUri) {
+ return getNotFoundResponse();
+ }
+
+ // Browsers get confused without '/' after the directory, send a redirect.
+ File f = new File(homeDir, uri);
+ if (f.isDirectory() && !uri.endsWith("/")) {
+ uri += "/";
+ Response res = createResponse(Response.Status.REDIRECT, NanoHTTPD.MIME_HTML, "Redirected: " + uri + "");
+ res.addHeader("Location", uri);
+ return res;
+ }
+
+ if (f.isDirectory()) {
+ // First look for index files (index.html, index.htm, etc) and if none found, list the directory if readable.
+ String indexFile = findIndexFileInDirectory(f);
+ if (indexFile == null) {
+ if (f.canRead()) {
+ // No index file, list the directory if it is readable
+ return createResponse(Response.Status.OK, NanoHTTPD.MIME_HTML, listDirectory(uri, f));
+ } else {
+ return getForbiddenResponse("No directory listing.");
+ }
+ } else {
+ return respond(headers, session, uri + indexFile);
+ }
+ }
+
+ String mimeTypeForFile = getMimeTypeForFile(uri);
+ WebServerPlugin plugin = mimeTypeHandlers.get(mimeTypeForFile);
+ Response response = null;
+ if (plugin != null) {
+ response = plugin.serveFile(uri, headers, session, f, mimeTypeForFile);
+ if (response != null && response instanceof InternalRewrite) {
+ InternalRewrite rewrite = (InternalRewrite) response;
+ return respond(rewrite.getHeaders(), session, rewrite.getUri());
+ }
+ } else {
+ response = serveFile(uri, headers, f, mimeTypeForFile);
+ }
+ return response != null ? response : getNotFoundResponse();
+ }
+
+ protected Response getNotFoundResponse() {
+ return createResponse(Response.Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT,
+ "Error 404, file not found.");
+ }
+
+ protected Response getForbiddenResponse(String s) {
+ return createResponse(Response.Status.FORBIDDEN, NanoHTTPD.MIME_PLAINTEXT, "FORBIDDEN: "
+ + s);
+ }
+
+ protected Response getInternalErrorResponse(String s) {
+ return createResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT,
+ "INTERNAL ERRROR: " + s);
+ }
+
+ private boolean canServeUri(String uri, File homeDir) {
+ boolean canServeUri;
+ File f = new File(homeDir, uri);
+ canServeUri = f.exists();
+ if (!canServeUri) {
+ String mimeTypeForFile = getMimeTypeForFile(uri);
+ WebServerPlugin plugin = mimeTypeHandlers.get(mimeTypeForFile);
+ if (plugin != null) {
+ canServeUri = plugin.canServeUri(uri, homeDir);
+ }
+ }
+ return canServeUri;
+ }
+
+ /**
+ * Serves file from homeDir and its' subdirectories (only). Uses only URI, ignores all headers and HTTP parameters.
+ */
+ Response serveFile(String uri, Map header, File file, String mime) {
+ Response res;
+ try {
+ // Calculate etag
+ String etag = Integer.toHexString((file.getAbsolutePath() + file.lastModified() + "" + file.length()).hashCode());
+
+ // Support (simple) skipping:
+ long startFrom = 0;
+ long endAt = -1;
+ String range = header.get("range");
+ if (range != null) {
+ if (range.startsWith("bytes=")) {
+ range = range.substring("bytes=".length());
+ int minus = range.indexOf('-');
+ try {
+ if (minus > 0) {
+ startFrom = Long.parseLong(range.substring(0, minus));
+ endAt = Long.parseLong(range.substring(minus + 1));
+ }
+ } catch (NumberFormatException ignored) {
+ }
+ }
+ }
+
+ // Change return code and add Content-Range header when skipping is requested
+ long fileLen = file.length();
+ if (range != null && startFrom >= 0) {
+ if (startFrom >= fileLen) {
+ res = createResponse(Response.Status.RANGE_NOT_SATISFIABLE, NanoHTTPD.MIME_PLAINTEXT, "");
+ res.addHeader("Content-Range", "bytes 0-0/" + fileLen);
+ res.addHeader("ETag", etag);
+ } else {
+ if (endAt < 0) {
+ endAt = fileLen - 1;
+ }
+ long newLen = endAt - startFrom + 1;
+ if (newLen < 0) {
+ newLen = 0;
+ }
+
+ final long dataLen = newLen;
+ FileInputStream fis = new FileInputStream(file) {
+ @Override
+ public int available() throws IOException {
+ return (int) dataLen;
+ }
+ };
+ fis.skip(startFrom);
+
+ res = createResponse(Response.Status.PARTIAL_CONTENT, mime, fis);
+ res.addHeader("Content-Length", "" + dataLen);
+ res.addHeader("Content-Range", "bytes " + startFrom + "-" + endAt + "/" + fileLen);
+ res.addHeader("ETag", etag);
+ }
+ } else {
+ if (etag.equals(header.get("if-none-match")))
+ res = createResponse(Response.Status.NOT_MODIFIED, mime, "");
+ else {
+ res = createResponse(Response.Status.OK, mime, new FileInputStream(file));
+ res.addHeader("Content-Length", "" + fileLen);
+ res.addHeader("ETag", etag);
+ }
+ }
+ } catch (IOException ioe) {
+ res = getForbiddenResponse("Reading file failed.");
+ }
+
+ return res;
+ }
+
+ // Get MIME type from file name extension, if possible
+ private String getMimeTypeForFile(String uri) {
+ int dot = uri.lastIndexOf('.');
+ String mime = null;
+ if (dot >= 0) {
+ mime = MIME_TYPES.get(uri.substring(dot + 1).toLowerCase());
+ }
+ return mime == null ? MIME_DEFAULT_BINARY : mime;
+ }
+
+ // Announce that the file server accepts partial content requests
+ private Response createResponse(Response.Status status, String mimeType, InputStream message) {
+ Response res = new Response(status, mimeType, message);
+ res.addHeader("Accept-Ranges", "bytes");
+ return res;
+ }
+
+ // Announce that the file server accepts partial content requests
+ protected Response createResponse(Response.Status status, String mimeType, String message) {
+ Response res = new Response(status, mimeType, message);
+ res.addHeader("Accept-Ranges", "bytes");
+ return res;
+ }
+
+ private String findIndexFileInDirectory(File directory) {
+ for (String fileName : INDEX_FILE_NAMES) {
+ File indexFile = new File(directory, fileName);
+ if (indexFile.exists()) {
+ return fileName;
+ }
+ }
+ return null;
+ }
+
+ protected String listDirectory(String uri, File f) {
+ String heading = "Directory " + uri;
+ StringBuilder msg = new StringBuilder("" + heading + "" +
+ "
" + heading + "
");
+
+ String up = null;
+ if (uri.length() > 1) {
+ String u = uri.substring(0, uri.length() - 1);
+ int slash = u.lastIndexOf('/');
+ if (slash >= 0 && slash < u.length()) {
+ up = uri.substring(0, slash + 1);
+ }
+ }
+
+ List files = Arrays.asList(f.list(new FilenameFilter() {
+ @Override
+ public boolean accept(File dir, String name) {
+ return new File(dir, name).isFile();
+ }
+ }));
+ Collections.sort(files);
+ List directories = Arrays.asList(f.list(new FilenameFilter() {
+ @Override
+ public boolean accept(File dir, String name) {
+ return new File(dir, name).isDirectory();
+ }
+ }));
+ Collections.sort(directories);
+ if (up != null || directories.size() + files.size() > 0) {
+ msg.append("