());
+ }
+ String propertyValue = (sep >= 0) ? decodePercent(e.substring(sep + 1)) : null;
+ if (propertyValue != null) {
+ parms.get(propertyName).add(propertyValue);
+ }
+ }
+ }
+ return parms;
+ }
+
+ // ------------------------------------------------------------------------------- //
+ //
+ // Threading Strategy.
+ //
+ // ------------------------------------------------------------------------------- //
+ /**
+ * Pluggable strategy for asynchronously executing requests.
+ *
+ * @param asyncRunner new strategy for handling threads.
+ */
+ public void setAsyncRunner(AsyncRunner asyncRunner) {
+ this.asyncRunner = asyncRunner;
+ }
+
+ // ------------------------------------------------------------------------------- //
+ //
+ // Temp file handling strategy.
+ //
+ // ------------------------------------------------------------------------------- //
+ /**
+ * Pluggable strategy for creating and cleaning up temporary files.
+ *
+ * @param tempFileManagerFactory new strategy for handling temp files.
+ */
+ public void setTempFileManagerFactory(TempFileManagerFactory tempFileManagerFactory) {
+ this.tempFileManagerFactory = tempFileManagerFactory;
+ }
+
+ /**
+ * HTTP Request methods, with the ability to decode a String
+ * back to its enum value.
+ */
+ public enum Method {
+
+ GET, PUT, POST, DELETE, HEAD, OPTIONS;
+
+ static Method lookup(String method) {
+ for (Method m : Method.values()) {
+ if (m.toString().equalsIgnoreCase(method)) {
+ return m;
+ }
+ }
+ return null;
+ }
+ }
+
+ /**
+ * Pluggable strategy for asynchronously executing requests.
+ */
+ public interface AsyncRunner {
+
+ void exec(Runnable code);
+ }
+
+ /**
+ * Factory to create temp file managers.
+ */
+ public interface TempFileManagerFactory {
+
+ TempFileManager create();
+ }
+
+ // ------------------------------------------------------------------------------- //
+ /**
+ * Temp file manager.
+ *
+ *
+ * Temp file managers are created 1-to-1 with incoming requests, to create
+ * and cleanup temporary files created as a result of handling the
+ * request.
+ */
+ public interface TempFileManager {
+
+ TempFile createTempFile() throws Exception;
+
+ void clear();
+ }
+
+ /**
+ * A temp file.
+ *
+ *
+ * Temp files are responsible for managing the actual temporary storage and
+ * cleaning themselves up when no longer needed.
+ */
+ public interface TempFile {
+
+ OutputStream open() throws Exception;
+
+ void delete() throws Exception;
+
+ String getName();
+ }
+
+ /**
+ * Default threading strategy for NanoHttpd.
+ *
+ *
+ * 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/net/apocalypselabs/symat/Main.java b/src/net/apocalypselabs/symat/Main.java
index 7d3d19f..6a7df46 100644
--- a/src/net/apocalypselabs/symat/Main.java
+++ b/src/net/apocalypselabs/symat/Main.java
@@ -118,6 +118,10 @@ public class Main extends javax.swing.JFrame {
* Application icon, for setting frame icons.
*/
public static ArrayList symatlogo = new ArrayList<>();
+
+ public static SingleInstanceServer sisrv;
+
+ public static Main maingui;
/**
* Creates the main app window and does some quick things that aren't
@@ -125,6 +129,7 @@ public class Main extends javax.swing.JFrame {
*/
public Main() {
initComponents();
+ maingui = this;
// Set icon
setIconImages(symatlogo);
@@ -1006,6 +1011,15 @@ public class Main extends javax.swing.JFrame {
break;
}
}
+
+ SingleInstanceClient sicli = new SingleInstanceClient(argfile);
+
+ try {
+ new SingleInstanceServer().start();
+ } catch (IOException ex) {
+ Debug.printerr("Cannot start instance listener:\n\n");
+ Debug.stacktrace(ex);
+ }
Platform.setImplicitExit(false);
diff --git a/src/net/apocalypselabs/symat/SingleInstanceClient.java b/src/net/apocalypselabs/symat/SingleInstanceClient.java
new file mode 100644
index 0000000..9b1aab0
--- /dev/null
+++ b/src/net/apocalypselabs/symat/SingleInstanceClient.java
@@ -0,0 +1,82 @@
+/*
+ * CODE LICENSE =====================
+ * Copyright (c) 2015, Apocalypse Laboratories
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * 4. You adhere to the Media License detailed below. If you do not, this license
+ * is automatically revoked and you must purge all copies of the software you
+ * possess, in source or binary form.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * MEDIA LICENSE ====================
+ * All images and other graphical files (the "graphics") included with this
+ * software are copyright (c) 2015 Apocalypse Laboratories. You may not distribute
+ * the graphics or any program, source code repository, or other digital storage
+ * media containing them without written permission from Apocalypse Laboratories.
+ * This ban on distribution only applies to publicly available systems.
+ * A password-protected network file share, USB drive, or other storage scheme that
+ * cannot be easily accessed by the public is generally allowed. If in doubt,
+ * contact Apocalypse Laboratories. If Apocalypse Laboratories allows or denies
+ * you permission, that decision is considered final and binding.
+ */
+package net.apocalypselabs.symat;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+
+/**
+ * This class attempts to send startup data to an existing instance, and if it
+ * succeeds it kills this instance of SyMAT.
+ *
+ * @author Skylar
+ */
+public class SingleInstanceClient {
+
+ public SingleInstanceClient(String arg) {
+ String response = "";
+ String args = (arg.equals("") ? "" : "?arg=" + arg);
+ try {
+ URL url = new URL("http://127.0.0.1:26879" + args);
+ InputStream is = url.openStream();
+ BufferedReader br = new BufferedReader(new InputStreamReader(is));
+
+ String line = br.readLine();
+ br.close();
+ is.close();
+ response = line;
+ } catch (Exception ex) {
+
+ }
+
+ if (response.equals("OK")) {
+ Debug.println("Handing off to original instance...");
+ System.exit(0);
+ }
+ }
+}
diff --git a/src/net/apocalypselabs/symat/SingleInstanceServer.java b/src/net/apocalypselabs/symat/SingleInstanceServer.java
new file mode 100644
index 0000000..53fece5
--- /dev/null
+++ b/src/net/apocalypselabs/symat/SingleInstanceServer.java
@@ -0,0 +1,81 @@
+/*
+ * CODE LICENSE =====================
+ * Copyright (c) 2015, Apocalypse Laboratories
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * 4. You adhere to the Media License detailed below. If you do not, this license
+ * is automatically revoked and you must purge all copies of the software you
+ * possess, in source or binary form.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * MEDIA LICENSE ====================
+ * All images and other graphical files (the "graphics") included with this
+ * software are copyright (c) 2015 Apocalypse Laboratories. You may not distribute
+ * the graphics or any program, source code repository, or other digital storage
+ * media containing them without written permission from Apocalypse Laboratories.
+ * This ban on distribution only applies to publicly available systems.
+ * A password-protected network file share, USB drive, or other storage scheme that
+ * cannot be easily accessed by the public is generally allowed. If in doubt,
+ * contact Apocalypse Laboratories. If Apocalypse Laboratories allows or denies
+ * you permission, that decision is considered final and binding.
+ */
+package net.apocalypselabs.symat;
+
+import fi.iki.elonen.NanoHTTPD;
+import java.util.Map;
+
+/**
+ *
+ * @author Skylar
+ */
+public class SingleInstanceServer extends NanoHTTPD {
+
+ public SingleInstanceServer() {
+ super(26879);
+ }
+
+ @Override
+ public Response serve(IHTTPSession session) {
+ Debug.println("Another instance detected");
+ String msg = "OK";
+ Map parms = session.getParms();
+ if (parms.get("arg") != null) {
+ CodeEditor ed = new CodeEditor();
+ Main.loadFrame(ed);
+ ed.openFileFromName(parms.get("arg"));
+ java.awt.EventQueue.invokeLater(new Runnable() {
+ @Override
+ public void run() {
+ Main.maingui.toFront();
+ Main.maingui.repaint();
+ }
+ });
+ }
+ return new NanoHTTPD.Response(msg);
+ }
+
+}
diff --git a/src/net/apocalypselabs/symat/SplashScreen.form b/src/net/apocalypselabs/symat/SplashScreen.form
index 5cdb59f..cb88561 100644
--- a/src/net/apocalypselabs/symat/SplashScreen.form
+++ b/src/net/apocalypselabs/symat/SplashScreen.form
@@ -140,4 +140,4 @@
-
\ No newline at end of file
+
diff --git a/src/net/apocalypselabs/symat/SplashScreen.java b/src/net/apocalypselabs/symat/SplashScreen.java
index ab25dde..dc6d57b 100644
--- a/src/net/apocalypselabs/symat/SplashScreen.java
+++ b/src/net/apocalypselabs/symat/SplashScreen.java
@@ -50,7 +50,6 @@ import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
-import javax.swing.ImageIcon;
import javax.swing.SwingUtilities;
import static net.apocalypselabs.symat.Main.API_URL;
import static net.apocalypselabs.symat.Main.APP_CODE;
@@ -67,7 +66,7 @@ public class SplashScreen extends javax.swing.JFrame {
*/
public SplashScreen() {
initComponents();
- setBackground(new Color(0, 0, 0, 0));
+ setBackground(new Color(255, 255, 255, 0));
setIconImages(Main.symatlogo);
setLocationRelativeTo(null);
}
@@ -103,7 +102,7 @@ public class SplashScreen extends javax.swing.JFrame {
jLayeredPane1.setBackground(new java.awt.Color(255, 255, 255));
- dispLabel.setFont(Main.ubuntuRegular.deriveFont(22.0F));
+ dispLabel.setFont(net.apocalypselabs.symat.Main.ubuntuRegular.deriveFont(22.0F));
dispLabel.setHorizontalAlignment(javax.swing.SwingConstants.LEFT);
dispLabel.setText("Loading...");
dispLabel.setHorizontalTextPosition(javax.swing.SwingConstants.LEFT);
@@ -111,9 +110,9 @@ public class SplashScreen extends javax.swing.JFrame {
jLayeredPane1.add(dispLabel);
dispLabel.setBounds(250, 250, 350, 80);
- jLabel1.setFont(Main.ubuntuRegular.deriveFont(20.0F));
+ jLabel1.setFont(net.apocalypselabs.symat.Main.ubuntuRegular.deriveFont(20.0F));
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.TRAILING);
- jLabel1.setText("v. "+Main.VERSION_NAME);
+ jLabel1.setText("v. "+net.apocalypselabs.symat.Main.VERSION_NAME);
jLayeredPane1.add(jLabel1);
jLabel1.setBounds(520, 70, 80, 30);
jLayeredPane1.setLayer(jLabel1, javax.swing.JLayeredPane.POPUP_LAYER);
@@ -122,14 +121,14 @@ public class SplashScreen extends javax.swing.JFrame {
jLayeredPane1.add(jLabel2);
jLabel2.setBounds(0, 0, 700, 470);
- jLabel3.setFont(Main.ubuntuRegular.deriveFont(12.0F));
+ jLabel3.setFont(net.apocalypselabs.symat.Main.ubuntuRegular.deriveFont(12.0F));
jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel3.setText("Apocalypse
Laboratories
");
jLayeredPane1.add(jLabel3);
jLabel3.setBounds(50, 420, 120, 40);
jLayeredPane1.setLayer(jLabel3, javax.swing.JLayeredPane.POPUP_LAYER);
- jLabel4.setFont(Main.ubuntuRegular.deriveFont(12.0F));
+ jLabel4.setFont(net.apocalypselabs.symat.Main.ubuntuRegular.deriveFont(12.0F));
jLabel4.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel4.setText("symatapp.com");
jLayeredPane1.add(jLabel4);