(this.running)) {
342 | clientHandler.close();
343 | }
344 | }
345 |
346 | @Override
347 | public void closed(ClientHandler clientHandler) {
348 | this.running.remove(clientHandler);
349 | }
350 |
351 | @Override
352 | public void exec(ClientHandler clientHandler) {
353 | ++this.requestCount;
354 | Thread t = new Thread(clientHandler);
355 | t.setDaemon(true);
356 | t.setName("NanoHttpd Request Processor (#" + this.requestCount + ")");
357 | this.running.add(clientHandler);
358 | t.start();
359 | }
360 | }
361 |
362 | /**
363 | * Default strategy for creating and cleaning up temporary files.
364 | *
365 | *
366 | * By default, files are created by File.createTempFile() in
367 | * the directory specified.
368 | *
369 | */
370 | public static class DefaultTempFile implements TempFile {
371 |
372 | private final File file;
373 |
374 | private final OutputStream fstream;
375 |
376 | public DefaultTempFile(File tempdir) throws IOException {
377 | this.file = File.createTempFile("NanoHTTPD-", "", tempdir);
378 | this.fstream = new FileOutputStream(this.file);
379 | }
380 |
381 | @Override
382 | public void delete() throws Exception {
383 | safeClose(this.fstream);
384 | if (!this.file.delete()) {
385 | throw new Exception("could not delete temporary file: " + this.file.getAbsolutePath());
386 | }
387 | }
388 |
389 | @Override
390 | public String getName() {
391 | return this.file.getAbsolutePath();
392 | }
393 |
394 | @Override
395 | public OutputStream open() throws Exception {
396 | return this.fstream;
397 | }
398 | }
399 |
400 | /**
401 | * Default strategy for creating and cleaning up temporary files.
402 | *
403 | *
404 | * This class stores its files in the standard location (that is, wherever
405 | * java.io.tmpdir points to). Files are added to an internal
406 | * list, and deleted when no longer needed (that is, when
407 | * clear() is invoked at the end of processing a request).
408 | *
409 | */
410 | public static class DefaultTempFileManager implements TempFileManager {
411 |
412 | private final File tmpdir;
413 |
414 | private final List tempFiles;
415 |
416 | public DefaultTempFileManager() {
417 | this.tmpdir = new File(System.getProperty("java.io.tmpdir"));
418 | if (!tmpdir.exists()) {
419 | tmpdir.mkdirs();
420 | }
421 | this.tempFiles = new ArrayList();
422 | }
423 |
424 | @Override
425 | public void clear() {
426 | for (TempFile file : this.tempFiles) {
427 | try {
428 | file.delete();
429 | } catch (Exception ignored) {
430 | NanoHTTPD.LOG.log(Level.WARNING, "could not delete file ", ignored);
431 | }
432 | }
433 | this.tempFiles.clear();
434 | }
435 |
436 | @Override
437 | public TempFile createTempFile(String filename_hint) throws Exception {
438 | DefaultTempFile tempFile = new DefaultTempFile(this.tmpdir);
439 | this.tempFiles.add(tempFile);
440 | return tempFile;
441 | }
442 | }
443 |
444 | /**
445 | * Default strategy for creating and cleaning up temporary files.
446 | */
447 | private class DefaultTempFileManagerFactory implements TempFileManagerFactory {
448 |
449 | @Override
450 | public TempFileManager create() {
451 | return new DefaultTempFileManager();
452 | }
453 | }
454 |
455 | /**
456 | * Creates a normal ServerSocket for TCP connections
457 | */
458 | public static class DefaultServerSocketFactory implements ServerSocketFactory {
459 |
460 | @Override
461 | public ServerSocket create() throws IOException {
462 | return new ServerSocket();
463 | }
464 |
465 | }
466 |
467 | /**
468 | * Creates a new SSLServerSocket
469 | */
470 | public static class SecureServerSocketFactory implements ServerSocketFactory {
471 |
472 | private SSLServerSocketFactory sslServerSocketFactory;
473 |
474 | private String[] sslProtocols;
475 |
476 | public SecureServerSocketFactory(SSLServerSocketFactory sslServerSocketFactory, String[] sslProtocols) {
477 | this.sslServerSocketFactory = sslServerSocketFactory;
478 | this.sslProtocols = sslProtocols;
479 | }
480 |
481 | @Override
482 | public ServerSocket create() throws IOException {
483 | SSLServerSocket ss = null;
484 | ss = (SSLServerSocket) this.sslServerSocketFactory.createServerSocket();
485 | if (this.sslProtocols != null) {
486 | ss.setEnabledProtocols(this.sslProtocols);
487 | } else {
488 | ss.setEnabledProtocols(ss.getSupportedProtocols());
489 | }
490 | ss.setUseClientMode(false);
491 | ss.setWantClientAuth(false);
492 | ss.setNeedClientAuth(false);
493 | return ss;
494 | }
495 |
496 | }
497 |
498 | private static final String CONTENT_DISPOSITION_REGEX = "([ |\t]*Content-Disposition[ |\t]*:)(.*)";
499 |
500 | private static final Pattern CONTENT_DISPOSITION_PATTERN = Pattern.compile(CONTENT_DISPOSITION_REGEX, Pattern.CASE_INSENSITIVE);
501 |
502 | private static final String CONTENT_TYPE_REGEX = "([ |\t]*content-type[ |\t]*:)(.*)";
503 |
504 | private static final Pattern CONTENT_TYPE_PATTERN = Pattern.compile(CONTENT_TYPE_REGEX, Pattern.CASE_INSENSITIVE);
505 |
506 | private static final String CONTENT_DISPOSITION_ATTRIBUTE_REGEX = "[ |\t]*([a-zA-Z]*)[ |\t]*=[ |\t]*['|\"]([^\"^']*)['|\"]";
507 |
508 | private static final Pattern CONTENT_DISPOSITION_ATTRIBUTE_PATTERN = Pattern.compile(CONTENT_DISPOSITION_ATTRIBUTE_REGEX);
509 |
510 | protected static class ContentType {
511 |
512 | private static final String ASCII_ENCODING = "US-ASCII";
513 |
514 | private static final String MULTIPART_FORM_DATA_HEADER = "multipart/form-data";
515 |
516 | private static final String CONTENT_REGEX = "[ |\t]*([^/^ ^;^,]+/[^ ^;^,]+)";
517 |
518 | private static final Pattern MIME_PATTERN = Pattern.compile(CONTENT_REGEX, Pattern.CASE_INSENSITIVE);
519 |
520 | private static final String CHARSET_REGEX = "[ |\t]*(charset)[ |\t]*=[ |\t]*['|\"]?([^\"^'^;^,]*)['|\"]?";
521 |
522 | private static final Pattern CHARSET_PATTERN = Pattern.compile(CHARSET_REGEX, Pattern.CASE_INSENSITIVE);
523 |
524 | private static final String BOUNDARY_REGEX = "[ |\t]*(boundary)[ |\t]*=[ |\t]*['|\"]?([^\"^'^;^,]*)['|\"]?";
525 |
526 | private static final Pattern BOUNDARY_PATTERN = Pattern.compile(BOUNDARY_REGEX, Pattern.CASE_INSENSITIVE);
527 |
528 | private final String contentTypeHeader;
529 |
530 | private final String contentType;
531 |
532 | private final String encoding;
533 |
534 | private final String boundary;
535 |
536 | public ContentType(String contentTypeHeader) {
537 | this.contentTypeHeader = contentTypeHeader;
538 | if (contentTypeHeader != null) {
539 | contentType = getDetailFromContentHeader(contentTypeHeader, MIME_PATTERN, "", 1);
540 | encoding = getDetailFromContentHeader(contentTypeHeader, CHARSET_PATTERN, null, 2);
541 | } else {
542 | contentType = "";
543 | encoding = "UTF-8";
544 | }
545 | if (MULTIPART_FORM_DATA_HEADER.equalsIgnoreCase(contentType)) {
546 | boundary = getDetailFromContentHeader(contentTypeHeader, BOUNDARY_PATTERN, null, 2);
547 | } else {
548 | boundary = null;
549 | }
550 | }
551 |
552 | private String getDetailFromContentHeader(String contentTypeHeader, Pattern pattern, String defaultValue, int group) {
553 | Matcher matcher = pattern.matcher(contentTypeHeader);
554 | return matcher.find() ? matcher.group(group) : defaultValue;
555 | }
556 |
557 | public String getContentTypeHeader() {
558 | return contentTypeHeader;
559 | }
560 |
561 | public String getContentType() {
562 | return contentType;
563 | }
564 |
565 | public String getEncoding() {
566 | return encoding == null ? ASCII_ENCODING : encoding;
567 | }
568 |
569 | public String getBoundary() {
570 | return boundary;
571 | }
572 |
573 | public boolean isMultipart() {
574 | return MULTIPART_FORM_DATA_HEADER.equalsIgnoreCase(contentType);
575 | }
576 |
577 | public ContentType tryUTF8() {
578 | if (encoding == null) {
579 | return new ContentType(this.contentTypeHeader + "; charset=UTF-8");
580 | }
581 | return this;
582 | }
583 | }
584 |
585 | protected class HTTPSession implements IHTTPSession {
586 |
587 | private static final int REQUEST_BUFFER_LEN = 512;
588 |
589 | private static final int MEMORY_STORE_LIMIT = 1024;
590 |
591 | public static final int BUFSIZE = 8192;
592 |
593 | public static final int MAX_HEADER_SIZE = 1024;
594 |
595 | private final TempFileManager tempFileManager;
596 |
597 | private final OutputStream outputStream;
598 |
599 | private final BufferedInputStream inputStream;
600 |
601 | private int splitbyte;
602 |
603 | private int rlen;
604 |
605 | private String uri;
606 |
607 | private Method method;
608 |
609 | private Map> parms;
610 |
611 | private Map headers;
612 |
613 | private CookieHandler cookies;
614 |
615 | private String queryParameterString;
616 |
617 | private String remoteIp;
618 |
619 | private String remoteHostname;
620 |
621 | private String protocolVersion;
622 |
623 | public HTTPSession(TempFileManager tempFileManager, InputStream inputStream, OutputStream outputStream) {
624 | this.tempFileManager = tempFileManager;
625 | this.inputStream = new BufferedInputStream(inputStream, HTTPSession.BUFSIZE);
626 | this.outputStream = outputStream;
627 | }
628 |
629 | public HTTPSession(TempFileManager tempFileManager, InputStream inputStream, OutputStream outputStream, InetAddress inetAddress) {
630 | this.tempFileManager = tempFileManager;
631 | this.inputStream = new BufferedInputStream(inputStream, HTTPSession.BUFSIZE);
632 | this.outputStream = outputStream;
633 | this.remoteIp = inetAddress.isLoopbackAddress() || inetAddress.isAnyLocalAddress() ? "127.0.0.1" : inetAddress.getHostAddress().toString();
634 | this.remoteHostname = inetAddress.isLoopbackAddress() || inetAddress.isAnyLocalAddress() ? "localhost" : inetAddress.getHostName().toString();
635 | this.headers = new HashMap();
636 | }
637 |
638 | /**
639 | * Decodes the sent headers and loads the data into Key/value pairs
640 | */
641 | private void decodeHeader(BufferedReader in, Map pre, Map> parms, Map headers) throws ResponseException {
642 | try {
643 | // Read the request line
644 | String inLine = in.readLine();
645 | if (inLine == null) {
646 | return;
647 | }
648 |
649 | StringTokenizer st = new StringTokenizer(inLine);
650 | if (!st.hasMoreTokens()) {
651 | throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Syntax error. Usage: GET /example/file.html");
652 | }
653 |
654 | pre.put("method", st.nextToken());
655 |
656 | if (!st.hasMoreTokens()) {
657 | throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Missing URI. Usage: GET /example/file.html");
658 | }
659 |
660 | String uri = st.nextToken();
661 |
662 | // Decode parameters from the URI
663 | int qmi = uri.indexOf('?');
664 | if (qmi >= 0) {
665 | decodeParms(uri.substring(qmi + 1), parms);
666 | uri = decodePercent(uri.substring(0, qmi));
667 | } else {
668 | uri = decodePercent(uri);
669 | }
670 |
671 | // If there's another token, its protocol version,
672 | // followed by HTTP headers.
673 | // NOTE: this now forces header names lower case since they are
674 | // case insensitive and vary by client.
675 | if (st.hasMoreTokens()) {
676 | protocolVersion = st.nextToken();
677 | } else {
678 | protocolVersion = "HTTP/1.1";
679 | NanoHTTPD.LOG.log(Level.FINE, "no protocol version specified, strange. Assuming HTTP/1.1.");
680 | }
681 | String line = in.readLine();
682 | while (line != null && !line.trim().isEmpty()) {
683 | int p = line.indexOf(':');
684 | if (p >= 0) {
685 | headers.put(line.substring(0, p).trim().toLowerCase(Locale.US), line.substring(p + 1).trim());
686 | }
687 | line = in.readLine();
688 | }
689 |
690 | pre.put("uri", uri);
691 | } catch (IOException ioe) {
692 | throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage(), ioe);
693 | }
694 | }
695 |
696 | /**
697 | * Decodes the Multipart Body data and put it into Key/Value pairs.
698 | */
699 | private void decodeMultipartFormData(ContentType contentType, ByteBuffer fbuf, Map> parms, Map files) throws ResponseException {
700 | int pcount = 0;
701 | try {
702 | int[] boundaryIdxs = getBoundaryPositions(fbuf, contentType.getBoundary().getBytes());
703 | if (boundaryIdxs.length < 2) {
704 | throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but contains less than two boundary strings.");
705 | }
706 |
707 | byte[] partHeaderBuff = new byte[MAX_HEADER_SIZE];
708 | for (int boundaryIdx = 0; boundaryIdx < boundaryIdxs.length - 1; boundaryIdx++) {
709 | fbuf.position(boundaryIdxs[boundaryIdx]);
710 | int len = (fbuf.remaining() < MAX_HEADER_SIZE) ? fbuf.remaining() : MAX_HEADER_SIZE;
711 | fbuf.get(partHeaderBuff, 0, len);
712 | BufferedReader in =
713 | new BufferedReader(new InputStreamReader(new ByteArrayInputStream(partHeaderBuff, 0, len), Charset.forName(contentType.getEncoding())), len);
714 |
715 | int headerLines = 0;
716 | // First line is boundary string
717 | String mpline = in.readLine();
718 | headerLines++;
719 | if (mpline == null || !mpline.contains(contentType.getBoundary())) {
720 | throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but chunk does not start with boundary.");
721 | }
722 |
723 | String partName = null, fileName = null, partContentType = null;
724 | // Parse the reset of the header lines
725 | mpline = in.readLine();
726 | headerLines++;
727 | while (mpline != null && mpline.trim().length() > 0) {
728 | Matcher matcher = CONTENT_DISPOSITION_PATTERN.matcher(mpline);
729 | if (matcher.matches()) {
730 | String attributeString = matcher.group(2);
731 | matcher = CONTENT_DISPOSITION_ATTRIBUTE_PATTERN.matcher(attributeString);
732 | while (matcher.find()) {
733 | String key = matcher.group(1);
734 | if ("name".equalsIgnoreCase(key)) {
735 | partName = matcher.group(2);
736 | } else if ("filename".equalsIgnoreCase(key)) {
737 | fileName = matcher.group(2);
738 | // add these two line to support multiple
739 | // files uploaded using the same field Id
740 | if (!fileName.isEmpty()) {
741 | if (pcount > 0)
742 | partName = partName + String.valueOf(pcount++);
743 | else
744 | pcount++;
745 | }
746 | }
747 | }
748 | }
749 | matcher = CONTENT_TYPE_PATTERN.matcher(mpline);
750 | if (matcher.matches()) {
751 | partContentType = matcher.group(2).trim();
752 | }
753 | mpline = in.readLine();
754 | headerLines++;
755 | }
756 | int partHeaderLength = 0;
757 | while (headerLines-- > 0) {
758 | partHeaderLength = scipOverNewLine(partHeaderBuff, partHeaderLength);
759 | }
760 | // Read the part data
761 | if (partHeaderLength >= len - 4) {
762 | throw new ResponseException(Response.Status.INTERNAL_ERROR, "Multipart header size exceeds MAX_HEADER_SIZE.");
763 | }
764 | int partDataStart = boundaryIdxs[boundaryIdx] + partHeaderLength;
765 | int partDataEnd = boundaryIdxs[boundaryIdx + 1] - 4;
766 |
767 | fbuf.position(partDataStart);
768 |
769 | List values = parms.get(partName);
770 | if (values == null) {
771 | values = new ArrayList();
772 | parms.put(partName, values);
773 | }
774 |
775 | if (partContentType == null) {
776 | // Read the part into a string
777 | byte[] data_bytes = new byte[partDataEnd - partDataStart];
778 | fbuf.get(data_bytes);
779 |
780 | values.add(new String(data_bytes, contentType.getEncoding()));
781 | } else {
782 | // Read it into a file
783 | String path = saveTmpFile(fbuf, partDataStart, partDataEnd - partDataStart, fileName);
784 | if (!files.containsKey(partName)) {
785 | files.put(partName, path);
786 | } else {
787 | int count = 2;
788 | while (files.containsKey(partName + count)) {
789 | count++;
790 | }
791 | files.put(partName + count, path);
792 | }
793 | values.add(fileName);
794 | }
795 | }
796 | } catch (ResponseException re) {
797 | throw re;
798 | } catch (Exception e) {
799 | throw new ResponseException(Response.Status.INTERNAL_ERROR, e.toString());
800 | }
801 | }
802 |
803 | private int scipOverNewLine(byte[] partHeaderBuff, int index) {
804 | while (partHeaderBuff[index] != '\n') {
805 | index++;
806 | }
807 | return ++index;
808 | }
809 |
810 | /**
811 | * Decodes parameters in percent-encoded URI-format ( e.g.
812 | * "name=Jack%20Daniels&pass=Single%20Malt" ) and adds them to given
813 | * Map.
814 | */
815 | private void decodeParms(String parms, Map> p) {
816 | if (parms == null) {
817 | this.queryParameterString = "";
818 | return;
819 | }
820 |
821 | this.queryParameterString = parms;
822 | StringTokenizer st = new StringTokenizer(parms, "&");
823 | while (st.hasMoreTokens()) {
824 | String e = st.nextToken();
825 | int sep = e.indexOf('=');
826 | String key = null;
827 | String value = null;
828 |
829 | if (sep >= 0) {
830 | key = decodePercent(e.substring(0, sep)).trim();
831 | value = decodePercent(e.substring(sep + 1));
832 | } else {
833 | key = decodePercent(e).trim();
834 | value = "";
835 | }
836 |
837 | List values = p.get(key);
838 | if (values == null) {
839 | values = new ArrayList();
840 | p.put(key, values);
841 | }
842 |
843 | values.add(value);
844 | }
845 | }
846 |
847 | @Override
848 | public void execute() throws IOException {
849 | Response r = null;
850 | try {
851 | // Read the first 8192 bytes.
852 | // The full header should fit in here.
853 | // Apache's default header limit is 8KB.
854 | // Do NOT assume that a single read will get the entire header
855 | // at once!
856 | byte[] buf = new byte[HTTPSession.BUFSIZE];
857 | this.splitbyte = 0;
858 | this.rlen = 0;
859 |
860 | int read = -1;
861 | this.inputStream.mark(HTTPSession.BUFSIZE);
862 | try {
863 | read = this.inputStream.read(buf, 0, HTTPSession.BUFSIZE);
864 | } catch (SSLException e) {
865 | throw e;
866 | } catch (IOException e) {
867 | safeClose(this.inputStream);
868 | safeClose(this.outputStream);
869 | throw new SocketException("NanoHttpd Shutdown");
870 | }
871 | if (read == -1) {
872 | // socket was been closed
873 | safeClose(this.inputStream);
874 | safeClose(this.outputStream);
875 | throw new SocketException("NanoHttpd Shutdown");
876 | }
877 | while (read > 0) {
878 | this.rlen += read;
879 | this.splitbyte = findHeaderEnd(buf, this.rlen);
880 | if (this.splitbyte > 0) {
881 | break;
882 | }
883 | read = this.inputStream.read(buf, this.rlen, HTTPSession.BUFSIZE - this.rlen);
884 | }
885 |
886 | if (this.splitbyte < this.rlen) {
887 | this.inputStream.reset();
888 | this.inputStream.skip(this.splitbyte);
889 | }
890 |
891 | this.parms = new HashMap>();
892 | if (null == this.headers) {
893 | this.headers = new HashMap();
894 | } else {
895 | this.headers.clear();
896 | }
897 |
898 | // Create a BufferedReader for parsing the header.
899 | BufferedReader hin = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buf, 0, this.rlen)));
900 |
901 | // Decode the header into parms and header java properties
902 | Map pre = new HashMap();
903 | decodeHeader(hin, pre, this.parms, this.headers);
904 |
905 | if (null != this.remoteIp) {
906 | this.headers.put("remote-addr", this.remoteIp);
907 | this.headers.put("http-client-ip", this.remoteIp);
908 | }
909 |
910 | this.method = Method.lookup(pre.get("method"));
911 | if (this.method == null) {
912 | throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Syntax error. HTTP verb " + pre.get("method") + " unhandled.");
913 | }
914 |
915 | this.uri = pre.get("uri");
916 |
917 | this.cookies = new CookieHandler(this.headers);
918 |
919 | String connection = this.headers.get("connection");
920 | boolean keepAlive = "HTTP/1.1".equals(protocolVersion) && (connection == null || !connection.matches("(?i).*close.*"));
921 |
922 | // Ok, now do the serve()
923 |
924 | // TODO: long body_size = getBodySize();
925 | // TODO: long pos_before_serve = this.inputStream.totalRead()
926 | // (requires implementation for totalRead())
927 | r = serve(this);
928 | // TODO: this.inputStream.skip(body_size -
929 | // (this.inputStream.totalRead() - pos_before_serve))
930 |
931 | if (r == null) {
932 | throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: Serve() returned a null response.");
933 | } else {
934 | String acceptEncoding = this.headers.get("accept-encoding");
935 | this.cookies.unloadQueue(r);
936 | r.setRequestMethod(this.method);
937 | r.setGzipEncoding(useGzipWhenAccepted(r) && acceptEncoding != null && acceptEncoding.contains("gzip"));
938 | r.setKeepAlive(keepAlive);
939 | r.send(this.outputStream);
940 | }
941 | if (!keepAlive || r.isCloseConnection()) {
942 | throw new SocketException("NanoHttpd Shutdown");
943 | }
944 | } catch (SocketException e) {
945 | // throw it out to close socket object (finalAccept)
946 | throw e;
947 | } catch (SocketTimeoutException ste) {
948 | // treat socket timeouts the same way we treat socket exceptions
949 | // i.e. close the stream & finalAccept object by throwing the
950 | // exception up the call stack.
951 | throw ste;
952 | } catch (SSLException ssle) {
953 | Response resp = newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SSL PROTOCOL FAILURE: " + ssle.getMessage());
954 | resp.send(this.outputStream);
955 | safeClose(this.outputStream);
956 | } catch (IOException ioe) {
957 | Response resp = newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
958 | resp.send(this.outputStream);
959 | safeClose(this.outputStream);
960 | } catch (ResponseException re) {
961 | Response resp = newFixedLengthResponse(re.getStatus(), NanoHTTPD.MIME_PLAINTEXT, re.getMessage());
962 | resp.send(this.outputStream);
963 | safeClose(this.outputStream);
964 | } finally {
965 | safeClose(r);
966 | this.tempFileManager.clear();
967 | }
968 | }
969 |
970 | /**
971 | * Find byte index separating header from body. It must be the last byte
972 | * of the first two sequential new lines.
973 | */
974 | private int findHeaderEnd(final byte[] buf, int rlen) {
975 | int splitbyte = 0;
976 | while (splitbyte + 1 < rlen) {
977 |
978 | // RFC2616
979 | if (buf[splitbyte] == '\r' && buf[splitbyte + 1] == '\n' && splitbyte + 3 < rlen && buf[splitbyte + 2] == '\r' && buf[splitbyte + 3] == '\n') {
980 | return splitbyte + 4;
981 | }
982 |
983 | // tolerance
984 | if (buf[splitbyte] == '\n' && buf[splitbyte + 1] == '\n') {
985 | return splitbyte + 2;
986 | }
987 | splitbyte++;
988 | }
989 | return 0;
990 | }
991 |
992 | /**
993 | * Find the byte positions where multipart boundaries start. This reads
994 | * a large block at a time and uses a temporary buffer to optimize
995 | * (memory mapped) file access.
996 | */
997 | private int[] getBoundaryPositions(ByteBuffer b, byte[] boundary) {
998 | int[] res = new int[0];
999 | if (b.remaining() < boundary.length) {
1000 | return res;
1001 | }
1002 |
1003 | int search_window_pos = 0;
1004 | byte[] search_window = new byte[4 * 1024 + boundary.length];
1005 |
1006 | int first_fill = (b.remaining() < search_window.length) ? b.remaining() : search_window.length;
1007 | b.get(search_window, 0, first_fill);
1008 | int new_bytes = first_fill - boundary.length;
1009 |
1010 | do {
1011 | // Search the search_window
1012 | for (int j = 0; j < new_bytes; j++) {
1013 | for (int i = 0; i < boundary.length; i++) {
1014 | if (search_window[j + i] != boundary[i])
1015 | break;
1016 | if (i == boundary.length - 1) {
1017 | // Match found, add it to results
1018 | int[] new_res = new int[res.length + 1];
1019 | System.arraycopy(res, 0, new_res, 0, res.length);
1020 | new_res[res.length] = search_window_pos + j;
1021 | res = new_res;
1022 | }
1023 | }
1024 | }
1025 | search_window_pos += new_bytes;
1026 |
1027 | // Copy the end of the buffer to the start
1028 | System.arraycopy(search_window, search_window.length - boundary.length, search_window, 0, boundary.length);
1029 |
1030 | // Refill search_window
1031 | new_bytes = search_window.length - boundary.length;
1032 | new_bytes = (b.remaining() < new_bytes) ? b.remaining() : new_bytes;
1033 | b.get(search_window, boundary.length, new_bytes);
1034 | } while (new_bytes > 0);
1035 | return res;
1036 | }
1037 |
1038 | @Override
1039 | public CookieHandler getCookies() {
1040 | return this.cookies;
1041 | }
1042 |
1043 | @Override
1044 | public final Map getHeaders() {
1045 | return this.headers;
1046 | }
1047 |
1048 | @Override
1049 | public final InputStream getInputStream() {
1050 | return this.inputStream;
1051 | }
1052 |
1053 | @Override
1054 | public final Method getMethod() {
1055 | return this.method;
1056 | }
1057 |
1058 | /**
1059 | * @deprecated use {@link #getParameters()} instead.
1060 | */
1061 | @Override
1062 | @Deprecated
1063 | public final Map getParms() {
1064 | Map result = new HashMap();
1065 | for (String key : this.parms.keySet()) {
1066 | result.put(key, this.parms.get(key).get(0));
1067 | }
1068 |
1069 | return result;
1070 | }
1071 |
1072 | @Override
1073 | public final Map> getParameters() {
1074 | return this.parms;
1075 | }
1076 |
1077 | @Override
1078 | public String getQueryParameterString() {
1079 | return this.queryParameterString;
1080 | }
1081 |
1082 | private RandomAccessFile getTmpBucket() {
1083 | try {
1084 | TempFile tempFile = this.tempFileManager.createTempFile(null);
1085 | return new RandomAccessFile(tempFile.getName(), "rw");
1086 | } catch (Exception e) {
1087 | throw new Error(e); // we won't recover, so throw an error
1088 | }
1089 | }
1090 |
1091 | @Override
1092 | public final String getUri() {
1093 | return this.uri;
1094 | }
1095 |
1096 | /**
1097 | * Deduce body length in bytes. Either from "content-length" header or
1098 | * read bytes.
1099 | */
1100 | public long getBodySize() {
1101 | if (this.headers.containsKey("content-length")) {
1102 | return Long.parseLong(this.headers.get("content-length"));
1103 | } else if (this.splitbyte < this.rlen) {
1104 | return this.rlen - this.splitbyte;
1105 | }
1106 | return 0;
1107 | }
1108 |
1109 | @Override
1110 | public void parseBody(Map files) throws IOException, ResponseException {
1111 | RandomAccessFile randomAccessFile = null;
1112 | try {
1113 | long size = getBodySize();
1114 | ByteArrayOutputStream baos = null;
1115 | DataOutput requestDataOutput = null;
1116 |
1117 | // Store the request in memory or a file, depending on size
1118 | if (size < MEMORY_STORE_LIMIT) {
1119 | baos = new ByteArrayOutputStream();
1120 | requestDataOutput = new DataOutputStream(baos);
1121 | } else {
1122 | randomAccessFile = getTmpBucket();
1123 | requestDataOutput = randomAccessFile;
1124 | }
1125 |
1126 | // Read all the body and write it to request_data_output
1127 | byte[] buf = new byte[REQUEST_BUFFER_LEN];
1128 | while (this.rlen >= 0 && size > 0) {
1129 | this.rlen = this.inputStream.read(buf, 0, (int) Math.min(size, REQUEST_BUFFER_LEN));
1130 | size -= this.rlen;
1131 | if (this.rlen > 0) {
1132 | requestDataOutput.write(buf, 0, this.rlen);
1133 | }
1134 | }
1135 |
1136 | ByteBuffer fbuf = null;
1137 | if (baos != null) {
1138 | fbuf = ByteBuffer.wrap(baos.toByteArray(), 0, baos.size());
1139 | } else {
1140 | fbuf = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length());
1141 | randomAccessFile.seek(0);
1142 | }
1143 |
1144 | // If the method is POST, there may be parameters
1145 | // in data section, too, read it:
1146 | if (Method.POST.equals(this.method)) {
1147 | ContentType contentType = new ContentType(this.headers.get("content-type"));
1148 | if (contentType.isMultipart()) {
1149 | String boundary = contentType.getBoundary();
1150 | if (boundary == null) {
1151 | throw new ResponseException(Response.Status.BAD_REQUEST,
1152 | "BAD REQUEST: Content type is multipart/form-data but boundary missing. Usage: GET /example/file.html");
1153 | }
1154 | decodeMultipartFormData(contentType, fbuf, this.parms, files);
1155 | } else {
1156 | byte[] postBytes = new byte[fbuf.remaining()];
1157 | fbuf.get(postBytes);
1158 | String postLine = new String(postBytes, contentType.getEncoding()).trim();
1159 | // Handle application/x-www-form-urlencoded
1160 | if ("application/x-www-form-urlencoded".equalsIgnoreCase(contentType.getContentType())) {
1161 | decodeParms(postLine, this.parms);
1162 | } else if (postLine.length() != 0) {
1163 | // Special case for raw POST data => create a
1164 | // special files entry "postData" with raw content
1165 | // data
1166 | files.put("postData", postLine);
1167 | }
1168 | }
1169 | } else if (Method.PUT.equals(this.method)) {
1170 | files.put("content", saveTmpFile(fbuf, 0, fbuf.limit(), null));
1171 | }
1172 | } finally {
1173 | safeClose(randomAccessFile);
1174 | }
1175 | }
1176 |
1177 | /**
1178 | * Retrieves the content of a sent file and saves it to a temporary
1179 | * file. The full path to the saved file is returned.
1180 | */
1181 | private String saveTmpFile(ByteBuffer b, int offset, int len, String filename_hint) {
1182 | String path = "";
1183 | if (len > 0) {
1184 | FileOutputStream fileOutputStream = null;
1185 | try {
1186 | TempFile tempFile = this.tempFileManager.createTempFile(filename_hint);
1187 | ByteBuffer src = b.duplicate();
1188 | fileOutputStream = new FileOutputStream(tempFile.getName());
1189 | FileChannel dest = fileOutputStream.getChannel();
1190 | src.position(offset).limit(offset + len);
1191 | dest.write(src.slice());
1192 | path = tempFile.getName();
1193 | } catch (Exception e) { // Catch exception if any
1194 | throw new Error(e); // we won't recover, so throw an error
1195 | } finally {
1196 | safeClose(fileOutputStream);
1197 | }
1198 | }
1199 | return path;
1200 | }
1201 |
1202 | @Override
1203 | public String getRemoteIpAddress() {
1204 | return this.remoteIp;
1205 | }
1206 |
1207 | @Override
1208 | public String getRemoteHostName() {
1209 | return this.remoteHostname;
1210 | }
1211 | }
1212 |
1213 | /**
1214 | * Handles one session, i.e. parses the HTTP request and returns the
1215 | * response.
1216 | */
1217 | public interface IHTTPSession {
1218 |
1219 | void execute() throws IOException;
1220 |
1221 | CookieHandler getCookies();
1222 |
1223 | Map getHeaders();
1224 |
1225 | InputStream getInputStream();
1226 |
1227 | Method getMethod();
1228 |
1229 | /**
1230 | * This method will only return the first value for a given parameter.
1231 | * You will want to use getParameters if you expect multiple values for
1232 | * a given key.
1233 | *
1234 | * @deprecated use {@link #getParameters()} instead.
1235 | */
1236 | @Deprecated
1237 | Map getParms();
1238 |
1239 | Map> getParameters();
1240 |
1241 | String getQueryParameterString();
1242 |
1243 | /**
1244 | * @return the path part of the URL.
1245 | */
1246 | String getUri();
1247 |
1248 | /**
1249 | * Adds the files in the request body to the files map.
1250 | *
1251 | * @param files
1252 | * map to modify
1253 | */
1254 | void parseBody(Map files) throws IOException, ResponseException;
1255 |
1256 | /**
1257 | * Get the remote ip address of the requester.
1258 | *
1259 | * @return the IP address.
1260 | */
1261 | String getRemoteIpAddress();
1262 |
1263 | /**
1264 | * Get the remote hostname of the requester.
1265 | *
1266 | * @return the hostname.
1267 | */
1268 | String getRemoteHostName();
1269 | }
1270 |
1271 | /**
1272 | * HTTP Request methods, with the ability to decode a String
1273 | * back to its enum value.
1274 | */
1275 | public enum Method {
1276 | GET,
1277 | PUT,
1278 | POST,
1279 | DELETE,
1280 | HEAD,
1281 | OPTIONS,
1282 | TRACE,
1283 | CONNECT,
1284 | PATCH,
1285 | PROPFIND,
1286 | PROPPATCH,
1287 | MKCOL,
1288 | MOVE,
1289 | COPY,
1290 | LOCK,
1291 | UNLOCK;
1292 |
1293 | static Method lookup(String method) {
1294 | if (method == null)
1295 | return null;
1296 |
1297 | try {
1298 | return valueOf(method);
1299 | } catch (IllegalArgumentException e) {
1300 | // TODO: Log it?
1301 | return null;
1302 | }
1303 | }
1304 | }
1305 |
1306 | /**
1307 | * HTTP response. Return one of these from serve().
1308 | */
1309 | public static class Response implements Closeable {
1310 |
1311 | public interface IStatus {
1312 |
1313 | String getDescription();
1314 |
1315 | int getRequestStatus();
1316 | }
1317 |
1318 | /**
1319 | * Some HTTP response status codes
1320 | */
1321 | public enum Status implements IStatus {
1322 | SWITCH_PROTOCOL(101, "Switching Protocols"),
1323 |
1324 | OK(200, "OK"),
1325 | CREATED(201, "Created"),
1326 | ACCEPTED(202, "Accepted"),
1327 | NO_CONTENT(204, "No Content"),
1328 | PARTIAL_CONTENT(206, "Partial Content"),
1329 | MULTI_STATUS(207, "Multi-Status"),
1330 |
1331 | REDIRECT(301, "Moved Permanently"),
1332 | /**
1333 | * Many user agents mishandle 302 in ways that violate the RFC1945
1334 | * spec (i.e., redirect a POST to a GET). 303 and 307 were added in
1335 | * RFC2616 to address this. You should prefer 303 and 307 unless the
1336 | * calling user agent does not support 303 and 307 functionality
1337 | */
1338 | @Deprecated
1339 | FOUND(302, "Found"),
1340 | REDIRECT_SEE_OTHER(303, "See Other"),
1341 | NOT_MODIFIED(304, "Not Modified"),
1342 | TEMPORARY_REDIRECT(307, "Temporary Redirect"),
1343 |
1344 | BAD_REQUEST(400, "Bad Request"),
1345 | UNAUTHORIZED(401, "Unauthorized"),
1346 | FORBIDDEN(403, "Forbidden"),
1347 | NOT_FOUND(404, "Not Found"),
1348 | METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
1349 | NOT_ACCEPTABLE(406, "Not Acceptable"),
1350 | REQUEST_TIMEOUT(408, "Request Timeout"),
1351 | CONFLICT(409, "Conflict"),
1352 | GONE(410, "Gone"),
1353 | LENGTH_REQUIRED(411, "Length Required"),
1354 | PRECONDITION_FAILED(412, "Precondition Failed"),
1355 | PAYLOAD_TOO_LARGE(413, "Payload Too Large"),
1356 | UNSUPPORTED_MEDIA_TYPE(415, "Unsupported Media Type"),
1357 | RANGE_NOT_SATISFIABLE(416, "Requested Range Not Satisfiable"),
1358 | EXPECTATION_FAILED(417, "Expectation Failed"),
1359 | TOO_MANY_REQUESTS(429, "Too Many Requests"),
1360 |
1361 | INTERNAL_ERROR(500, "Internal Server Error"),
1362 | NOT_IMPLEMENTED(501, "Not Implemented"),
1363 | SERVICE_UNAVAILABLE(503, "Service Unavailable"),
1364 | UNSUPPORTED_HTTP_VERSION(505, "HTTP Version Not Supported");
1365 |
1366 | private final int requestStatus;
1367 |
1368 | private final String description;
1369 |
1370 | Status(int requestStatus, String description) {
1371 | this.requestStatus = requestStatus;
1372 | this.description = description;
1373 | }
1374 |
1375 | public static Status lookup(int requestStatus) {
1376 | for (Status status : Status.values()) {
1377 | if (status.getRequestStatus() == requestStatus) {
1378 | return status;
1379 | }
1380 | }
1381 | return null;
1382 | }
1383 |
1384 | @Override
1385 | public String getDescription() {
1386 | return "" + this.requestStatus + " " + this.description;
1387 | }
1388 |
1389 | @Override
1390 | public int getRequestStatus() {
1391 | return this.requestStatus;
1392 | }
1393 |
1394 | }
1395 |
1396 | /**
1397 | * Output stream that will automatically send every write to the wrapped
1398 | * OutputStream according to chunked transfer:
1399 | * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1
1400 | */
1401 | private static class ChunkedOutputStream extends FilterOutputStream {
1402 |
1403 | public ChunkedOutputStream(OutputStream out) {
1404 | super(out);
1405 | }
1406 |
1407 | @Override
1408 | public void write(int b) throws IOException {
1409 | byte[] data = {
1410 | (byte) b
1411 | };
1412 | write(data, 0, 1);
1413 | }
1414 |
1415 | @Override
1416 | public void write(byte[] b) throws IOException {
1417 | write(b, 0, b.length);
1418 | }
1419 |
1420 | @Override
1421 | public void write(byte[] b, int off, int len) throws IOException {
1422 | if (len == 0)
1423 | return;
1424 | out.write(String.format("%x\r\n", len).getBytes());
1425 | out.write(b, off, len);
1426 | out.write("\r\n".getBytes());
1427 | }
1428 |
1429 | public void finish() throws IOException {
1430 | out.write("0\r\n\r\n".getBytes());
1431 | }
1432 |
1433 | }
1434 |
1435 | /**
1436 | * HTTP status code after processing, e.g. "200 OK", Status.OK
1437 | */
1438 | private IStatus status;
1439 |
1440 | /**
1441 | * MIME type of content, e.g. "text/html"
1442 | */
1443 | private String mimeType;
1444 |
1445 | /**
1446 | * Data of the response, may be null.
1447 | */
1448 | private InputStream data;
1449 |
1450 | private long contentLength;
1451 |
1452 | /**
1453 | * Headers for the HTTP response. Use addHeader() to add lines. the
1454 | * lowercase map is automatically kept up to date.
1455 | */
1456 | @SuppressWarnings("serial")
1457 | private final Map header = new HashMap() {
1458 |
1459 | public String put(String key, String value) {
1460 | lowerCaseHeader.put(key == null ? key : key.toLowerCase(), value);
1461 | return super.put(key, value);
1462 | };
1463 | };
1464 |
1465 | /**
1466 | * copy of the header map with all the keys lowercase for faster
1467 | * searching.
1468 | */
1469 | private final Map lowerCaseHeader = new HashMap();
1470 |
1471 | /**
1472 | * The request method that spawned this response.
1473 | */
1474 | private Method requestMethod;
1475 |
1476 | /**
1477 | * Use chunkedTransfer
1478 | */
1479 | private boolean chunkedTransfer;
1480 |
1481 | private boolean multipartTransfer;
1482 |
1483 | private boolean encodeAsGzip;
1484 |
1485 | private boolean keepAlive;
1486 |
1487 | /**
1488 | * Creates a fixed length response if totalBytes>=0, otherwise chunked.
1489 | */
1490 | protected Response(IStatus status, String mimeType, InputStream data, long totalBytes) {
1491 | this.status = status;
1492 | this.mimeType = mimeType;
1493 | if (data == null) {
1494 | this.data = new ByteArrayInputStream(new byte[0]);
1495 | this.contentLength = 0L;
1496 | } else {
1497 | this.data = data;
1498 | this.contentLength = totalBytes;
1499 | }
1500 | this.chunkedTransfer = this.contentLength < 0 && !mimeType.contains("multipart");
1501 | this.multipartTransfer = this.contentLength < 0 && mimeType.contains("multipart");
1502 | keepAlive = true;
1503 | }
1504 |
1505 | @Override
1506 | public void close() throws IOException {
1507 | if (this.data != null) {
1508 | this.data.close();
1509 | }
1510 | }
1511 |
1512 | /**
1513 | * Adds given line to the header.
1514 | */
1515 | public void addHeader(String name, String value) {
1516 | this.header.put(name, value);
1517 | }
1518 |
1519 | /**
1520 | * Indicate to close the connection after the Response has been sent.
1521 | *
1522 | * @param close
1523 | * {@code true} to hint connection closing, {@code false} to
1524 | * let connection be closed by client.
1525 | */
1526 | public void closeConnection(boolean close) {
1527 | if (close)
1528 | this.header.put("connection", "close");
1529 | else
1530 | this.header.remove("connection");
1531 | }
1532 |
1533 | /**
1534 | * @return {@code true} if connection is to be closed after this
1535 | * Response has been sent.
1536 | */
1537 | public boolean isCloseConnection() {
1538 | return "close".equals(getHeader("connection"));
1539 | }
1540 |
1541 | public InputStream getData() {
1542 | return this.data;
1543 | }
1544 |
1545 | public String getHeader(String name) {
1546 | return this.lowerCaseHeader.get(name.toLowerCase());
1547 | }
1548 |
1549 | public String getMimeType() {
1550 | return this.mimeType;
1551 | }
1552 |
1553 | public Method getRequestMethod() {
1554 | return this.requestMethod;
1555 | }
1556 |
1557 | public IStatus getStatus() {
1558 | return this.status;
1559 | }
1560 |
1561 | public void setGzipEncoding(boolean encodeAsGzip) {
1562 | this.encodeAsGzip = encodeAsGzip;
1563 | }
1564 |
1565 | public void setKeepAlive(boolean useKeepAlive) {
1566 | this.keepAlive = useKeepAlive;
1567 | }
1568 |
1569 | /**
1570 | * Sends given response to the socket.
1571 | */
1572 | protected void send(OutputStream outputStream) {
1573 | SimpleDateFormat gmtFrmt = new SimpleDateFormat("E, d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
1574 | gmtFrmt.setTimeZone(TimeZone.getTimeZone("GMT"));
1575 |
1576 | try {
1577 | if (this.status == null) {
1578 | throw new Error("sendResponse(): Status can't be null.");
1579 | }
1580 | PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream, new ContentType(this.mimeType).getEncoding())), false);
1581 | pw.append("HTTP/1.1 ").append(this.status.getDescription()).append(" \r\n");
1582 | if (this.mimeType != null) {
1583 | printHeader(pw, "Content-Type", this.mimeType);
1584 | }
1585 | if (getHeader("date") == null) {
1586 | printHeader(pw, "Date", gmtFrmt.format(new Date()));
1587 | }
1588 | for (Entry entry : this.header.entrySet()) {
1589 | printHeader(pw, entry.getKey(), entry.getValue());
1590 | }
1591 | if (getHeader("connection") == null) {
1592 | printHeader(pw, "Connection", (this.keepAlive ? "keep-alive" : "close"));
1593 | }
1594 | if (getHeader("content-length") != null) {
1595 | encodeAsGzip = false;
1596 | }
1597 | if (encodeAsGzip) {
1598 | printHeader(pw, "Content-Encoding", "gzip");
1599 | setChunkedTransfer(true);
1600 | }
1601 | long pending = this.data != null ? this.contentLength : 0;
1602 | if (this.requestMethod != Method.HEAD && this.chunkedTransfer) {
1603 | printHeader(pw, "Transfer-Encoding", "chunked");
1604 | } else if (!encodeAsGzip && !multipartTransfer) {
1605 | pending = sendContentLengthHeaderIfNotAlreadyPresent(pw, pending);
1606 | }
1607 | pw.append("\r\n");
1608 | pw.flush();
1609 | sendBodyWithCorrectTransferAndEncoding(outputStream, pending);
1610 | outputStream.flush();
1611 | safeClose(this.data);
1612 | } catch (IOException ioe) {
1613 | NanoHTTPD.LOG.log(Level.SEVERE, "Could not send response to the client", ioe);
1614 | }
1615 | }
1616 |
1617 | @SuppressWarnings("static-method")
1618 | protected void printHeader(PrintWriter pw, String key, String value) {
1619 | pw.append(key).append(": ").append(value).append("\r\n");
1620 | }
1621 |
1622 | protected long sendContentLengthHeaderIfNotAlreadyPresent(PrintWriter pw, long defaultSize) {
1623 | String contentLengthString = getHeader("content-length");
1624 | long size = defaultSize;
1625 | if (contentLengthString != null) {
1626 | try {
1627 | size = Long.parseLong(contentLengthString);
1628 | } catch (NumberFormatException ex) {
1629 | LOG.severe("content-length was no number " + contentLengthString);
1630 | }
1631 | }
1632 | pw.print("Content-Length: " + size + "\r\n");
1633 | return size;
1634 | }
1635 |
1636 | private void sendBodyWithCorrectTransferAndEncoding(OutputStream outputStream, long pending) throws IOException {
1637 | if (this.requestMethod != Method.HEAD && this.chunkedTransfer) {
1638 | ChunkedOutputStream chunkedOutputStream = new ChunkedOutputStream(outputStream);
1639 | sendBodyWithCorrectEncoding(chunkedOutputStream, -1);
1640 | chunkedOutputStream.finish();
1641 | } else {
1642 | sendBodyWithCorrectEncoding(outputStream, pending);
1643 | }
1644 | }
1645 |
1646 | private void sendBodyWithCorrectEncoding(OutputStream outputStream, long pending) throws IOException {
1647 | if (encodeAsGzip) {
1648 | GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
1649 | sendBody(gzipOutputStream, -1);
1650 | gzipOutputStream.finish();
1651 | } else {
1652 | sendBody(outputStream, pending);
1653 | }
1654 | }
1655 |
1656 | /**
1657 | * Sends the body to the specified OutputStream. The pending parameter
1658 | * limits the maximum amounts of bytes sent unless it is -1, in which
1659 | * case everything is sent.
1660 | *
1661 | * @param outputStream
1662 | * the OutputStream to send data to
1663 | * @param pending
1664 | * -1 to send everything, otherwise sets a max limit to the
1665 | * number of bytes sent
1666 | * @throws IOException
1667 | * if something goes wrong while sending the data.
1668 | */
1669 | private void sendBody(OutputStream outputStream, long pending) throws IOException {
1670 | long BUFFER_SIZE = 16 * 1024;
1671 | byte[] buff = new byte[(int) BUFFER_SIZE];
1672 | boolean sendEverything = pending == -1;
1673 | while (pending > 0 || sendEverything) {
1674 | long bytesToRead = sendEverything ? BUFFER_SIZE : Math.min(pending, BUFFER_SIZE);
1675 | int read = this.data.read(buff, 0, (int) bytesToRead);
1676 | if (read <= 0) {
1677 | break;
1678 | }
1679 | outputStream.write(buff, 0, read);
1680 | if (!sendEverything) {
1681 | pending -= read;
1682 | }
1683 | }
1684 | }
1685 |
1686 | public void setChunkedTransfer(boolean chunkedTransfer) {
1687 | this.chunkedTransfer = chunkedTransfer;
1688 | }
1689 |
1690 | public void setData(InputStream data) {
1691 | this.data = data;
1692 | }
1693 |
1694 | public void setMimeType(String mimeType) {
1695 | this.mimeType = mimeType;
1696 | }
1697 |
1698 | public void setRequestMethod(Method requestMethod) {
1699 | this.requestMethod = requestMethod;
1700 | }
1701 |
1702 | public void setStatus(IStatus status) {
1703 | this.status = status;
1704 | }
1705 | }
1706 |
1707 |
1708 |
1709 | public static final class ResponseException extends Exception {
1710 |
1711 | private static final long serialVersionUID = 6569838532917408380L;
1712 |
1713 | private final Response.Status status;
1714 |
1715 | public ResponseException(Response.Status status, String message) {
1716 | super(message);
1717 | this.status = status;
1718 | }
1719 |
1720 | public ResponseException(Response.Status status, String message, Exception e) {
1721 | super(message, e);
1722 | this.status = status;
1723 | }
1724 |
1725 | public Response.Status getStatus() {
1726 | return this.status;
1727 | }
1728 | }
1729 |
1730 | public static final class MultipartStream extends PipedInputStream {
1731 |
1732 | private final PipedOutputStream pipedOutputSteam;
1733 | private final ByteArrayOutputStream outputStream;
1734 |
1735 | public MultipartStream() throws IOException {
1736 | pipedOutputSteam = new PipedOutputStream(this);
1737 | outputStream = new ByteArrayOutputStream();
1738 |
1739 | }
1740 |
1741 | public void writePart(String mimeType, byte[] byteArray) throws IOException {
1742 | outputStream.write((
1743 | "--part\r\n" +
1744 | "Content-Type: " + mimeType + "\r\n" +
1745 | "Content-Length: " +
1746 | byteArray.length +
1747 | "\r\n\r\n").getBytes());
1748 | outputStream.write(byteArray);
1749 | outputStream.write("\r\n\r\n".getBytes());
1750 | outputStream.writeTo(pipedOutputSteam);
1751 | outputStream.flush();
1752 | outputStream.reset();
1753 |
1754 | }
1755 |
1756 | @Override
1757 | public void close() throws IOException {
1758 | super.close();
1759 | outputStream.close();
1760 | pipedOutputSteam.close();
1761 | }
1762 | }
1763 |
1764 | /**
1765 | * The runnable that will be used for the main listening thread.
1766 | */
1767 | public class ServerRunnable implements Runnable {
1768 |
1769 | private final int timeout;
1770 |
1771 | private IOException bindException;
1772 |
1773 | private boolean hasBinded = false;
1774 |
1775 | public ServerRunnable(int timeout) {
1776 | this.timeout = timeout;
1777 | }
1778 |
1779 | @Override
1780 | public void run() {
1781 | try {
1782 | myServerSocket.bind(hostname != null ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort));
1783 | hasBinded = true;
1784 | } catch (IOException e) {
1785 | this.bindException = e;
1786 | return;
1787 | }
1788 | do {
1789 | try {
1790 | final Socket finalAccept = NanoHTTPD.this.myServerSocket.accept();
1791 | if (this.timeout > 0) {
1792 | finalAccept.setSoTimeout(this.timeout);
1793 | }
1794 | final InputStream inputStream = finalAccept.getInputStream();
1795 | NanoHTTPD.this.asyncRunner.exec(createClientHandler(finalAccept, inputStream));
1796 | } catch (IOException e) {
1797 | NanoHTTPD.LOG.log(Level.FINE, "Communication with the client broken", e);
1798 | }
1799 | } while (!NanoHTTPD.this.myServerSocket.isClosed());
1800 | }
1801 | }
1802 |
1803 | /**
1804 | * A temp file.
1805 | *
1806 | *
1807 | * Temp files are responsible for managing the actual temporary storage and
1808 | * cleaning themselves up when no longer needed.
1809 | *
1810 | */
1811 | public interface TempFile {
1812 |
1813 | public void delete() throws Exception;
1814 |
1815 | public String getName();
1816 |
1817 | public OutputStream open() throws Exception;
1818 | }
1819 |
1820 | /**
1821 | * Temp file manager.
1822 | *
1823 | *
1824 | * Temp file managers are created 1-to-1 with incoming requests, to create
1825 | * and cleanup temporary files created as a result of handling the request.
1826 | *
1827 | */
1828 | public interface TempFileManager {
1829 |
1830 | void clear();
1831 |
1832 | public TempFile createTempFile(String filename_hint) throws Exception;
1833 | }
1834 |
1835 | /**
1836 | * Factory to create temp file managers.
1837 | */
1838 | public interface TempFileManagerFactory {
1839 |
1840 | public TempFileManager create();
1841 | }
1842 |
1843 | /**
1844 | * Factory to create ServerSocketFactories.
1845 | */
1846 | public interface ServerSocketFactory {
1847 |
1848 | public ServerSocket create() throws IOException;
1849 |
1850 | }
1851 |
1852 | /**
1853 | * Maximum time to wait on Socket.getInputStream().read() (in milliseconds)
1854 | * This is required as the Keep-Alive HTTP connections would otherwise block
1855 | * the socket reading thread forever (or as long the browser is open).
1856 | */
1857 | public static final int SOCKET_READ_TIMEOUT = 5000;
1858 |
1859 | /**
1860 | * Common MIME type for dynamic content: plain text
1861 | */
1862 | public static final String MIME_PLAINTEXT = "text/plain";
1863 |
1864 | /**
1865 | * Common MIME type for dynamic content: html
1866 | */
1867 | public static final String MIME_HTML = "text/html";
1868 |
1869 | /**
1870 | * Pseudo-Parameter to use to store the actual query string in the
1871 | * parameters map for later re-processing.
1872 | */
1873 | private static final String QUERY_STRING_PARAMETER = "NanoHttpd.QUERY_STRING";
1874 |
1875 | /**
1876 | * logger to log to.
1877 | */
1878 | private static final Logger LOG = Logger.getLogger(NanoHTTPD.class.getName());
1879 |
1880 | /**
1881 | * Hashtable mapping (String)FILENAME_EXTENSION -> (String)MIME_TYPE
1882 | */
1883 | protected static Map MIME_TYPES;
1884 |
1885 | public static Map mimeTypes() {
1886 | if (MIME_TYPES == null) {
1887 | MIME_TYPES = new HashMap();
1888 | loadMimeTypes(MIME_TYPES, "META-INF/nanohttpd/default-mimetypes.properties");
1889 | loadMimeTypes(MIME_TYPES, "META-INF/nanohttpd/mimetypes.properties");
1890 | if (MIME_TYPES.isEmpty()) {
1891 | LOG.log(Level.WARNING, "no mime types found in the classpath! please provide mimetypes.properties");
1892 | }
1893 | }
1894 | return MIME_TYPES;
1895 | }
1896 |
1897 | @SuppressWarnings({
1898 | "unchecked",
1899 | "rawtypes"
1900 | })
1901 | private static void loadMimeTypes(Map result, String resourceName) {
1902 | try {
1903 | Enumeration resources = NanoHTTPD.class.getClassLoader().getResources(resourceName);
1904 | while (resources.hasMoreElements()) {
1905 | URL url = (URL) resources.nextElement();
1906 | Properties properties = new Properties();
1907 | InputStream stream = null;
1908 | try {
1909 | stream = url.openStream();
1910 | properties.load(stream);
1911 | } catch (IOException e) {
1912 | LOG.log(Level.SEVERE, "could not load mimetypes from " + url, e);
1913 | } finally {
1914 | safeClose(stream);
1915 | }
1916 | result.putAll((Map) properties);
1917 | }
1918 | } catch (IOException e) {
1919 | LOG.log(Level.INFO, "no mime types available at " + resourceName);
1920 | }
1921 | };
1922 |
1923 | /**
1924 | * Creates an SSLSocketFactory for HTTPS. Pass a loaded KeyStore and an
1925 | * array of loaded KeyManagers. These objects must properly
1926 | * loaded/initialized by the caller.
1927 | */
1928 | public static SSLServerSocketFactory makeSSLSocketFactory(KeyStore loadedKeyStore, KeyManager[] keyManagers) throws IOException {
1929 | SSLServerSocketFactory res = null;
1930 | try {
1931 | TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
1932 | trustManagerFactory.init(loadedKeyStore);
1933 | SSLContext ctx = SSLContext.getInstance("TLS");
1934 | ctx.init(keyManagers, trustManagerFactory.getTrustManagers(), null);
1935 | res = ctx.getServerSocketFactory();
1936 | } catch (Exception e) {
1937 | throw new IOException(e.getMessage());
1938 | }
1939 | return res;
1940 | }
1941 |
1942 | /**
1943 | * Creates an SSLSocketFactory for HTTPS. Pass a loaded KeyStore and a
1944 | * loaded KeyManagerFactory. These objects must properly loaded/initialized
1945 | * by the caller.
1946 | */
1947 | public static SSLServerSocketFactory makeSSLSocketFactory(KeyStore loadedKeyStore, KeyManagerFactory loadedKeyFactory) throws IOException {
1948 | try {
1949 | return makeSSLSocketFactory(loadedKeyStore, loadedKeyFactory.getKeyManagers());
1950 | } catch (Exception e) {
1951 | throw new IOException(e.getMessage());
1952 | }
1953 | }
1954 |
1955 | /**
1956 | * Creates an SSLSocketFactory for HTTPS. Pass a KeyStore resource with your
1957 | * certificate and passphrase
1958 | */
1959 | public static SSLServerSocketFactory makeSSLSocketFactory(String keyAndTrustStoreClasspathPath, char[] passphrase) throws IOException {
1960 | try {
1961 | KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
1962 | InputStream keystoreStream = NanoHTTPD.class.getResourceAsStream(keyAndTrustStoreClasspathPath);
1963 |
1964 | if (keystoreStream == null) {
1965 | throw new IOException("Unable to load keystore from classpath: " + keyAndTrustStoreClasspathPath);
1966 | }
1967 |
1968 | keystore.load(keystoreStream, passphrase);
1969 | KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
1970 | keyManagerFactory.init(keystore, passphrase);
1971 | return makeSSLSocketFactory(keystore, keyManagerFactory);
1972 | } catch (Exception e) {
1973 | throw new IOException(e.getMessage());
1974 | }
1975 | }
1976 |
1977 | /**
1978 | * Get MIME type from file name extension, if possible
1979 | *
1980 | * @param uri
1981 | * the string representing a file
1982 | * @return the connected mime/type
1983 | */
1984 | public static String getMimeTypeForFile(String uri) {
1985 | int dot = uri.lastIndexOf('.');
1986 | String mime = null;
1987 | if (dot >= 0) {
1988 | mime = mimeTypes().get(uri.substring(dot + 1).toLowerCase());
1989 | }
1990 | return mime == null ? "application/octet-stream" : mime;
1991 | }
1992 |
1993 | private static final void safeClose(Object closeable) {
1994 | try {
1995 | if (closeable != null) {
1996 | if (closeable instanceof Closeable) {
1997 | ((Closeable) closeable).close();
1998 | } else if (closeable instanceof Socket) {
1999 | ((Socket) closeable).close();
2000 | } else if (closeable instanceof ServerSocket) {
2001 | ((ServerSocket) closeable).close();
2002 | } else {
2003 | throw new IllegalArgumentException("Unknown object to close");
2004 | }
2005 | }
2006 | } catch (IOException e) {
2007 | NanoHTTPD.LOG.log(Level.SEVERE, "Could not close", e);
2008 | }
2009 | }
2010 |
2011 | private final String hostname;
2012 |
2013 | private final int myPort;
2014 |
2015 | private volatile ServerSocket myServerSocket;
2016 |
2017 | private ServerSocketFactory serverSocketFactory = new DefaultServerSocketFactory();
2018 |
2019 | private Thread myThread;
2020 |
2021 | /**
2022 | * Pluggable strategy for asynchronously executing requests.
2023 | */
2024 | protected AsyncRunner asyncRunner;
2025 |
2026 | /**
2027 | * Pluggable strategy for creating and cleaning up temporary files.
2028 | */
2029 | private TempFileManagerFactory tempFileManagerFactory;
2030 |
2031 | /**
2032 | * Constructs an HTTP server on given port.
2033 | */
2034 | public NanoHTTPD(int port) {
2035 | this(null, port);
2036 | }
2037 |
2038 | // -------------------------------------------------------------------------------
2039 | // //
2040 | //
2041 | // Threading Strategy.
2042 | //
2043 | // -------------------------------------------------------------------------------
2044 | // //
2045 |
2046 | /**
2047 | * Constructs an HTTP server on given hostname and port.
2048 | */
2049 | public NanoHTTPD(String hostname, int port) {
2050 | this.hostname = hostname;
2051 | this.myPort = port;
2052 | setTempFileManagerFactory(new DefaultTempFileManagerFactory());
2053 | setAsyncRunner(new DefaultAsyncRunner());
2054 | }
2055 |
2056 | /**
2057 | * Forcibly closes all connections that are open.
2058 | */
2059 | public synchronized void closeAllConnections() {
2060 | stop();
2061 | }
2062 |
2063 | /**
2064 | * create a instance of the client handler, subclasses can return a subclass
2065 | * of the ClientHandler.
2066 | *
2067 | * @param finalAccept
2068 | * the socket the cleint is connected to
2069 | * @param inputStream
2070 | * the input stream
2071 | * @return the client handler
2072 | */
2073 | protected ClientHandler createClientHandler(final Socket finalAccept, final InputStream inputStream) {
2074 | return new ClientHandler(inputStream, finalAccept);
2075 | }
2076 |
2077 | /**
2078 | * Instantiate the server runnable, can be overwritten by subclasses to
2079 | * provide a subclass of the ServerRunnable.
2080 | *
2081 | * @param timeout
2082 | * the socet timeout to use.
2083 | * @return the server runnable.
2084 | */
2085 | protected ServerRunnable createServerRunnable(final int timeout) {
2086 | return new ServerRunnable(timeout);
2087 | }
2088 |
2089 | /**
2090 | * Decode parameters from a URL, handing the case where a single parameter
2091 | * name might have been supplied several times, by return lists of values.
2092 | * In general these lists will contain a single element.
2093 | *
2094 | * @param parms
2095 | * original NanoHTTPD parameters values, as passed to the
2096 | * serve() method.
2097 | * @return a map of String (parameter name) to
2098 | * List<String> (a list of the values supplied).
2099 | */
2100 | protected static Map> decodeParameters(Map parms) {
2101 | return decodeParameters(parms.get(NanoHTTPD.QUERY_STRING_PARAMETER));
2102 | }
2103 |
2104 | // -------------------------------------------------------------------------------
2105 | // //
2106 |
2107 | /**
2108 | * Decode parameters from a URL, handing the case where a single parameter
2109 | * name might have been supplied several times, by return lists of values.
2110 | * In general these lists will contain a single element.
2111 | *
2112 | * @param queryString
2113 | * a query string pulled from the URL.
2114 | * @return a map of String (parameter name) to
2115 | * List<String> (a list of the values supplied).
2116 | */
2117 | protected static Map> decodeParameters(String queryString) {
2118 | Map> parms = new HashMap>();
2119 | if (queryString != null) {
2120 | StringTokenizer st = new StringTokenizer(queryString, "&");
2121 | while (st.hasMoreTokens()) {
2122 | String e = st.nextToken();
2123 | int sep = e.indexOf('=');
2124 | String propertyName = sep >= 0 ? decodePercent(e.substring(0, sep)).trim() : decodePercent(e).trim();
2125 | if (!parms.containsKey(propertyName)) {
2126 | parms.put(propertyName, new ArrayList());
2127 | }
2128 | String propertyValue = sep >= 0 ? decodePercent(e.substring(sep + 1)) : null;
2129 | if (propertyValue != null) {
2130 | parms.get(propertyName).add(propertyValue);
2131 | }
2132 | }
2133 | }
2134 | return parms;
2135 | }
2136 |
2137 | /**
2138 | * Decode percent encoded String values.
2139 | *
2140 | * @param str
2141 | * the percent encoded String
2142 | * @return expanded form of the input, for example "foo%20bar" becomes
2143 | * "foo bar"
2144 | */
2145 | protected static String decodePercent(String str) {
2146 | String decoded = null;
2147 | try {
2148 | decoded = URLDecoder.decode(str, "UTF8");
2149 | } catch (UnsupportedEncodingException ignored) {
2150 | NanoHTTPD.LOG.log(Level.WARNING, "Encoding not supported, ignored", ignored);
2151 | }
2152 | return decoded;
2153 | }
2154 |
2155 | /**
2156 | * @return true if the gzip compression should be used if the client
2157 | * accespts it. Default this option is on for text content and off
2158 | * for everything. Override this for custom semantics.
2159 | */
2160 | @SuppressWarnings("static-method")
2161 | protected boolean useGzipWhenAccepted(Response r) {
2162 | return r.getMimeType() != null && (r.getMimeType().toLowerCase().contains("text/") || r.getMimeType().toLowerCase().contains("/json"));
2163 | }
2164 |
2165 | public final int getListeningPort() {
2166 | return this.myServerSocket == null ? -1 : this.myServerSocket.getLocalPort();
2167 | }
2168 |
2169 | public final boolean isAlive() {
2170 | return wasStarted() && !this.myServerSocket.isClosed() && this.myThread.isAlive();
2171 | }
2172 |
2173 | public ServerSocketFactory getServerSocketFactory() {
2174 | return serverSocketFactory;
2175 | }
2176 |
2177 | public void setServerSocketFactory(ServerSocketFactory serverSocketFactory) {
2178 | this.serverSocketFactory = serverSocketFactory;
2179 | }
2180 |
2181 | public String getHostname() {
2182 | return hostname;
2183 | }
2184 |
2185 | public TempFileManagerFactory getTempFileManagerFactory() {
2186 | return tempFileManagerFactory;
2187 | }
2188 |
2189 | /**
2190 | * Call before start() to serve over HTTPS instead of HTTP
2191 | */
2192 | public void makeSecure(SSLServerSocketFactory sslServerSocketFactory, String[] sslProtocols) {
2193 | this.serverSocketFactory = new SecureServerSocketFactory(sslServerSocketFactory, sslProtocols);
2194 | }
2195 |
2196 | /**
2197 | * Create a response with unknown length (using HTTP 1.1 chunking).
2198 | */
2199 | public static Response newChunkedResponse(IStatus status, String mimeType, InputStream data) {
2200 | return new Response(status, mimeType, data, -1);
2201 | }
2202 |
2203 | public static Response newMultipartResponse(IStatus status, InputStream data) {
2204 | return new Response(status, "multipart/x-mixed-replace; boundary=part", data, -1);
2205 | }
2206 |
2207 | /**
2208 | * Create a response with known length.
2209 | */
2210 | public static Response newFixedLengthResponse(IStatus status, String mimeType, InputStream data, long totalBytes) {
2211 | return new Response(status, mimeType, data, totalBytes);
2212 | }
2213 |
2214 | /**
2215 | * Create a text response with known length.
2216 | */
2217 | public static Response newFixedLengthResponse(IStatus status, String mimeType, String txt) {
2218 | ContentType contentType = new ContentType(mimeType);
2219 | if (txt == null) {
2220 | return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(new byte[0]), 0);
2221 | } else {
2222 | byte[] bytes;
2223 | try {
2224 | CharsetEncoder newEncoder = Charset.forName(contentType.getEncoding()).newEncoder();
2225 | if (!newEncoder.canEncode(txt)) {
2226 | contentType = contentType.tryUTF8();
2227 | }
2228 | bytes = txt.getBytes(contentType.getEncoding());
2229 | } catch (UnsupportedEncodingException e) {
2230 | NanoHTTPD.LOG.log(Level.SEVERE, "encoding problem, responding nothing", e);
2231 | bytes = new byte[0];
2232 | }
2233 | return newFixedLengthResponse(status, contentType.getContentTypeHeader(), new ByteArrayInputStream(bytes), bytes.length);
2234 | }
2235 | }
2236 |
2237 | /**
2238 | * Create a text response with known length.
2239 | */
2240 | public static Response newFixedLengthResponse(String msg) {
2241 | return newFixedLengthResponse(Status.OK, NanoHTTPD.MIME_HTML, msg);
2242 | }
2243 |
2244 | /**
2245 | * Override this to customize the server.
2246 | *
2247 | *
2248 | * (By default, this returns a 404 "Not Found" plain text error response.)
2249 | *
2250 | * @param session
2251 | * The HTTP session
2252 | * @return HTTP response, see class Response for details
2253 | */
2254 | public Response serve(IHTTPSession session) {
2255 | Map files = new HashMap();
2256 | Method method = session.getMethod();
2257 | if (Method.PUT.equals(method) || Method.POST.equals(method)) {
2258 | try {
2259 | session.parseBody(files);
2260 | } catch (IOException ioe) {
2261 | return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
2262 | } catch (ResponseException re) {
2263 | return newFixedLengthResponse(re.getStatus(), NanoHTTPD.MIME_PLAINTEXT, re.getMessage());
2264 | }
2265 | }
2266 |
2267 | Map parms = session.getParms();
2268 | parms.put(NanoHTTPD.QUERY_STRING_PARAMETER, session.getQueryParameterString());
2269 | return serve(session.getUri(), method, session.getHeaders(), parms, files);
2270 | }
2271 |
2272 | /**
2273 | * Override this to customize the server.
2274 | *
2275 | *
2276 | * (By default, this returns a 404 "Not Found" plain text error response.)
2277 | *
2278 | * @param uri
2279 | * Percent-decoded URI without parameters, for example
2280 | * "/index.cgi"
2281 | * @param method
2282 | * "GET", "POST" etc.
2283 | * @param parms
2284 | * Parsed, percent decoded parameters from URI and, in case of
2285 | * POST, data.
2286 | * @param headers
2287 | * Header entries, percent decoded
2288 | * @return HTTP response, see class Response for details
2289 | */
2290 | @Deprecated
2291 | public Response serve(String uri, Method method, Map headers, Map parms, Map files) {
2292 | return newFixedLengthResponse(Response.Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT, "Not Found");
2293 | }
2294 |
2295 | /**
2296 | * Pluggable strategy for asynchronously executing requests.
2297 | *
2298 | * @param asyncRunner
2299 | * new strategy for handling threads.
2300 | */
2301 | public void setAsyncRunner(AsyncRunner asyncRunner) {
2302 | this.asyncRunner = asyncRunner;
2303 | }
2304 |
2305 | /**
2306 | * Pluggable strategy for creating and cleaning up temporary files.
2307 | *
2308 | * @param tempFileManagerFactory
2309 | * new strategy for handling temp files.
2310 | */
2311 | public void setTempFileManagerFactory(TempFileManagerFactory tempFileManagerFactory) {
2312 | this.tempFileManagerFactory = tempFileManagerFactory;
2313 | }
2314 |
2315 | /**
2316 | * Start the server.
2317 | *
2318 | * @throws IOException
2319 | * if the socket is in use.
2320 | */
2321 | public void start() throws IOException {
2322 | start(NanoHTTPD.SOCKET_READ_TIMEOUT);
2323 | }
2324 |
2325 | /**
2326 | * Starts the server (in setDaemon(true) mode).
2327 | */
2328 | public void start(final int timeout) throws IOException {
2329 | start(timeout, true);
2330 | }
2331 |
2332 | /**
2333 | * Start the server.
2334 | *
2335 | * @param timeout
2336 | * timeout to use for socket connections.
2337 | * @param daemon
2338 | * start the thread daemon or not.
2339 | * @throws IOException
2340 | * if the socket is in use.
2341 | */
2342 | public void start(final int timeout, boolean daemon) throws IOException {
2343 | this.myServerSocket = this.getServerSocketFactory().create();
2344 | this.myServerSocket.setReuseAddress(true);
2345 |
2346 | ServerRunnable serverRunnable = createServerRunnable(timeout);
2347 | this.myThread = new Thread(serverRunnable);
2348 | this.myThread.setDaemon(daemon);
2349 | this.myThread.setName("NanoHttpd Main Listener");
2350 | this.myThread.start();
2351 | while (!serverRunnable.hasBinded && serverRunnable.bindException == null) {
2352 | try {
2353 | Thread.sleep(10L);
2354 | } catch (Throwable e) {
2355 | // on android this may not be allowed, that's why we
2356 | // catch throwable the wait should be very short because we are
2357 | // just waiting for the bind of the socket
2358 | }
2359 | }
2360 | if (serverRunnable.bindException != null) {
2361 | throw serverRunnable.bindException;
2362 | }
2363 | }
2364 |
2365 | /**
2366 | * Stop the server.
2367 | */
2368 | public void stop() {
2369 | try {
2370 | safeClose(this.myServerSocket);
2371 | this.asyncRunner.closeAll();
2372 | if (this.myThread != null) {
2373 | this.myThread.join();
2374 | }
2375 | } catch (Exception e) {
2376 | NanoHTTPD.LOG.log(Level.SEVERE, "Could not stop all connections", e);
2377 | }
2378 | }
2379 |
2380 | public final boolean wasStarted() {
2381 | return this.myServerSocket != null && this.myThread != null;
2382 | }
2383 | }
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
12 |
13 |
19 |