Merge branch 'websockets'

12 files changed, 1052 insertions, 3 deletions

diff --git a/.gitignore b/.gitignore
index f46b4cf..a257787 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 out
+build
 target
 
 *.iml
diff --git a/core/src/main/java/fi/iki/elonen/NanoHTTPD.java b/core/src/main/java/fi/iki/elonen/NanoHTTPD.java
index 35690ed..38e023d 100644
--- a/core/src/main/java/fi/iki/elonen/NanoHTTPD.java
+++ b/core/src/main/java/fi/iki/elonen/NanoHTTPD.java
@@ -610,7 +610,7 @@ public abstract class NanoHTTPD {
         /**
          * Sends given response to the socket.
          */
-        private void send(OutputStream outputStream) {
+        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"));
@@ -637,7 +637,7 @@ public abstract class NanoHTTPD {
                     }
                 }
 
-                pw.print("Connection: keep-alive\r\n");
+                sendConnectionHeaderIfNotAlreadyPresent(pw, header);
 
                 if (requestMethod != Method.HEAD && chunkedTransfer) {
                     sendAsChunked(outputStream, pw);
@@ -651,6 +651,16 @@ public abstract class NanoHTTPD {
             }
         }
 
+        protected void sendConnectionHeaderIfNotAlreadyPresent(PrintWriter pw, Map<String, String> header) {
+            boolean connectionAlreadySent = false;
+            for (String headerName : header.keySet()) {
+                connectionAlreadySent |= headerName.equalsIgnoreCase("connection");
+            }
+            if (!connectionAlreadySent) {
+                pw.print("Connection: keep-alive\r\n");
+            }
+        }
+
         private void sendAsChunked(OutputStream outputStream, PrintWriter pw) throws IOException {
             pw.print("Transfer-Encoding: chunked\r\n");
             pw.print("\r\n");
@@ -729,7 +739,7 @@ public abstract class NanoHTTPD {
          * Some HTTP response status codes
          */
         public enum Status {
-            OK(200, "OK"), CREATED(201, "Created"), ACCEPTED(202, "Accepted"), NO_CONTENT(204, "No Content"), PARTIAL_CONTENT(206, "Partial Content"), REDIRECT(301,
+            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");
diff --git a/pom.xml b/pom.xml
index 25b175d..20d99b6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -14,6 +14,7 @@
         <module>samples</module>
         <module>webserver</module>
         <module>webserver/markdown-plugin</module>
+        <module>websocket</module>
     </modules>
 
     <build>
diff --git a/websocket/pom.xml b/websocket/pom.xml
new file mode 100644
index 0000000..7d94041
--- /dev/null
+++ b/websocket/pom.xml
@@ -0,0 +1,93 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>fi.iki.elonen</groupId>
+    <artifactId>nanohttpd-websocket</artifactId>
+    <version>2.0.5</version>
+    <packaging>jar</packaging>
+
+    <name>NanoHttpd-Websocket</name>
+    <url>https://github.com/NanoHttpd/nanohttpd</url>
+
+    <dependencies>
+        <dependency>
+            <groupId>fi.iki.elonen</groupId>
+            <artifactId>nanohttpd</artifactId>
+            <version>2.0.5</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <extensions>
+            <extension>
+                <groupId>org.jvnet.wagon-svn</groupId>
+                <artifactId>wagon-svn</artifactId>
+                <version>1.8</version>
+            </extension>
+            <extension>
+                <groupId>org.apache.maven.wagon</groupId>
+                <artifactId>wagon-ftp</artifactId>
+                <version>1.0-alpha-6</version>
+            </extension>
+        </extensions>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>2.2.1</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-release-plugin</artifactId>
+                <version>2.4</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>2.9</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>2.3.1</version>
+                <configuration>
+                    <source>1.6</source>
+                    <target>1.6</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>2.2-beta-5</version>
+                <configuration>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <archive>
+                        <manifest>
+                            <mainClass>fi.iki.elonen.NanoWebSocketServer</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/websocket/src/main/java/fi/iki/elonen/NanoWebSocketServer.java b/websocket/src/main/java/fi/iki/elonen/NanoWebSocketServer.java
new file mode 100644
index 0000000..7a5e588
--- /dev/null
+++ b/websocket/src/main/java/fi/iki/elonen/NanoWebSocketServer.java
@@ -0,0 +1,121 @@
+package fi.iki.elonen;
+
+import fi.iki.elonen.NanoHTTPD;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Map;
+
+public abstract class NanoWebSocketServer extends NanoHTTPD {
+    public static final String HEADER_UPGRADE = "upgrade";
+    public static final String HEADER_UPGRADE_VALUE = "websocket";
+    public static final String HEADER_CONNECTION = "connection";
+    public static final String HEADER_CONNECTION_VALUE = "Upgrade";
+    public static final String HEADER_WEBSOCKET_VERSION = "sec-websocket-version";
+    public static final String HEADER_WEBSOCKET_VERSION_VALUE = "13";
+    public static final String HEADER_WEBSOCKET_KEY = "sec-websocket-key";
+    public static final String HEADER_WEBSOCKET_ACCEPT = "sec-websocket-accept";
+    public static final String HEADER_WEBSOCKET_PROTOCOL = "sec-websocket-protocol";
+
+    public final static String WEBSOCKET_KEY_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+    public NanoWebSocketServer(int port) {
+        super(port);
+    }
+
+    public NanoWebSocketServer(String hostname, int port) {
+        super(hostname, port);
+    }
+
+    @Override
+    public Response serve(final IHTTPSession session) {
+        Map<String, String> headers = session.getHeaders();
+        if (isWebsocketRequested(session)) {
+            if (!HEADER_UPGRADE_VALUE.equalsIgnoreCase(headers.get(HEADER_UPGRADE))
+                    || !isWebSocketConnectionHeader(session.getHeaders())) {
+                return new Response(Response.Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Invalid Websocket handshake");
+            }
+            if (!HEADER_WEBSOCKET_VERSION_VALUE.equalsIgnoreCase(headers.get(HEADER_WEBSOCKET_VERSION))) {
+                return new Response(Response.Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Invalid Websocket-Version " + headers.get(HEADER_WEBSOCKET_VERSION));
+            }
+            if (!headers.containsKey(HEADER_WEBSOCKET_KEY)) {
+                return new Response(Response.Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Missing Websocket-Key");
+            }
+
+            WebSocket webSocket = openWebSocket(session);
+            try {
+                webSocket.getHandshakeResponse().addHeader(HEADER_WEBSOCKET_ACCEPT, makeAcceptKey(headers.get(HEADER_WEBSOCKET_KEY)));
+            } catch (NoSuchAlgorithmException e) {
+                return new Response(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "The SHA-1 Algorithm required for websockets is not available on the server.");
+            }
+            if (headers.containsKey(HEADER_WEBSOCKET_PROTOCOL)) {
+                webSocket.getHandshakeResponse().addHeader(HEADER_WEBSOCKET_PROTOCOL, headers.get(HEADER_WEBSOCKET_PROTOCOL).split(",")[0]);
+            }
+            return webSocket.getHandshakeResponse();
+        } else {
+            return super.serve(session);
+        }
+    }
+
+    protected abstract WebSocket openWebSocket(IHTTPSession handshake);
+
+    protected boolean isWebsocketRequested(IHTTPSession session) {
+        Map<String, String> headers = session.getHeaders();
+        String upgrade = headers.get(HEADER_UPGRADE);
+        boolean isCorrectConnection = isWebSocketConnectionHeader(headers);
+        boolean isUpgrade = HEADER_UPGRADE_VALUE.equalsIgnoreCase(upgrade);
+        return (isUpgrade && isCorrectConnection);
+    }
+
+    private boolean isWebSocketConnectionHeader(Map<String, String> headers) {
+        String connection = headers.get(HEADER_CONNECTION);
+        return (connection != null && connection.toLowerCase().contains(HEADER_CONNECTION_VALUE.toLowerCase()));
+    }
+
+    public static String makeAcceptKey(String key) throws NoSuchAlgorithmException {
+        MessageDigest md = MessageDigest.getInstance("SHA-1");
+        String text = key + WEBSOCKET_KEY_MAGIC;
+        md.update(text.getBytes(), 0, text.length());
+        byte[] sha1hash = md.digest();
+        return encodeBase64(sha1hash);
+    }
+
+
+    private final static char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
+
+    /**
+     * Translates the specified byte array into Base64 string.
+     * <p>
+     * Android has android.util.Base64, sun has sun.misc.Base64Encoder, Java 8 hast java.util.Base64,
+     * I have this from stackoverflow: http://stackoverflow.com/a/4265472
+     * </p>
+     *
+     * @param buf the byte array (not null)
+     * @return the translated Base64 string (not null)
+     */
+    private static String encodeBase64(byte[] buf) {
+        int size = buf.length;
+        char[] ar = new char[((size + 2) / 3) * 4];
+        int a = 0;
+        int i = 0;
+        while (i < size) {
+            byte b0 = buf[i++];
+            byte b1 = (i < size) ? buf[i++] : 0;
+            byte b2 = (i < size) ? buf[i++] : 0;
+
+            int mask = 0x3F;
+            ar[a++] = ALPHABET[(b0 >> 2) & mask];
+            ar[a++] = ALPHABET[((b0 << 4) | ((b1 & 0xFF) >> 4)) & mask];
+            ar[a++] = ALPHABET[((b1 << 2) | ((b2 & 0xFF) >> 6)) & mask];
+            ar[a++] = ALPHABET[b2 & mask];
+        }
+        switch (size % 3) {
+            case 1:
+                ar[--a] = '=';
+            case 2:
+                ar[--a] = '=';
+        }
+        return new String(ar);
+    }
+}
+
diff --git a/websocket/src/main/java/fi/iki/elonen/WebSocket.java b/websocket/src/main/java/fi/iki/elonen/WebSocket.java
new file mode 100644
index 0000000..84bf259
--- /dev/null
+++ b/websocket/src/main/java/fi/iki/elonen/WebSocket.java
@@ -0,0 +1,203 @@
+package fi.iki.elonen;
+
+import fi.iki.elonen.WebSocketFrame.CloseCode;
+import fi.iki.elonen.WebSocketFrame.CloseFrame;
+import fi.iki.elonen.WebSocketFrame.OpCode;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.CharacterCodingException;
+import java.util.LinkedList;
+import java.util.List;
+
+public abstract class WebSocket {
+    protected final InputStream in;
+    protected /*final*/ OutputStream out;
+
+    protected WebSocketFrame.OpCode continuousOpCode = null;
+    protected List<WebSocketFrame> continuousFrames = new LinkedList<WebSocketFrame>();
+
+    protected State state = State.UNCONNECTED;
+
+    public static enum State {
+        UNCONNECTED, CONNECTING, OPEN, CLOSING, CLOSED
+    }
+
+    protected final NanoHTTPD.IHTTPSession handshakeRequest;
+    protected final NanoHTTPD.Response handshakeResponse = new NanoHTTPD.Response(NanoHTTPD.Response.Status.SWITCH_PROTOCOL, null, (InputStream) null) {
+        @Override
+        protected void send(OutputStream out) {
+            WebSocket.this.out = out;
+            state = State.CONNECTING;
+            super.send(out);
+            state = State.OPEN;
+            readWebsocket();
+        }
+    };
+
+    public WebSocket(NanoHTTPD.IHTTPSession handshakeRequest) {
+        this.handshakeRequest = handshakeRequest;
+        this.in = handshakeRequest.getInputStream();
+
+        handshakeResponse.addHeader(NanoWebSocketServer.HEADER_UPGRADE, NanoWebSocketServer.HEADER_UPGRADE_VALUE);
+        handshakeResponse.addHeader(NanoWebSocketServer.HEADER_CONNECTION, NanoWebSocketServer.HEADER_CONNECTION_VALUE);
+    }
+
+    // --------------------------------IO--------------------------------------
+
+    protected void readWebsocket() {
+        try {
+            while (state == State.OPEN) {
+                handleWebsocketFrame(WebSocketFrame.read(in));
+            }
+        } catch (CharacterCodingException e) {
+            onException(e);
+            doClose(CloseCode.InvalidFramePayloadData, e.toString(), false);
+        } catch (IOException e) {
+            onException(e);
+            if (e instanceof WebSocketException) {
+                doClose(((WebSocketException) e).getCode(), ((WebSocketException) e).getReason(), false);
+            }
+        } finally {
+            doClose(CloseCode.InternalServerError, "Handler terminated without closing the connection.", false);
+        }
+    }
+
+    protected void handleWebsocketFrame(WebSocketFrame frame) throws IOException {
+        if (frame.getOpCode() == OpCode.Close) {
+            handleCloseFrame(frame);
+        } else if (frame.getOpCode() == OpCode.Ping) {
+            sendFrame(new WebSocketFrame(OpCode.Pong, true, frame.getBinaryPayload()));
+        } else if (frame.getOpCode() == OpCode.Pong) {
+            onPong(frame);
+        } else if (!frame.isFin() || frame.getOpCode() == OpCode.Continuation) {
+            handleFrameFragment(frame);
+        } else if (continuousOpCode != null) {
+            throw new WebSocketException(CloseCode.ProtocolError, "Continuous frame sequence not completed.");
+        } else if (frame.getOpCode() == OpCode.Text || frame.getOpCode() == OpCode.Binary) {
+            onMessage(frame);
+        } else {
+            throw new WebSocketException(CloseCode.ProtocolError, "Non control or continuous frame expected.");
+        }
+    }
+
+    protected void handleCloseFrame(WebSocketFrame frame) throws IOException {
+        CloseCode code = CloseCode.NormalClosure;
+        String reason = "";
+        if (frame instanceof CloseFrame) {
+            code = ((CloseFrame) frame).getCloseCode();
+            reason = ((CloseFrame) frame).getCloseReason();
+        }
+        if (state == State.CLOSING) {
+            //Answer for my requested close
+            doClose(code, reason, false);
+        } else {
+            //Answer close request from other endpoint and close self
+            State oldState = state;
+            state = State.CLOSING;
+            if (oldState == State.OPEN) {
+                sendFrame(new CloseFrame(code, reason));
+            }
+            doClose(code, reason, true);
+        }
+    }
+
+    protected void handleFrameFragment(WebSocketFrame frame) throws IOException {
+        if (frame.getOpCode() != OpCode.Continuation) {
+            //First
+            if (continuousOpCode != null) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Previous continuous frame sequence not completed.");
+            }
+            continuousOpCode = frame.getOpCode();
+            continuousFrames.clear();
+            continuousFrames.add(frame);
+        } else if (frame.isFin()) {
+            //Last
+            if (continuousOpCode == null) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Continuous frame sequence was not started.");
+            }
+            onMessage(new WebSocketFrame(continuousOpCode, continuousFrames));
+            continuousOpCode = null;
+            continuousFrames.clear();
+        } else if (continuousOpCode == null) {
+            //Unexpected
+            throw new WebSocketException(CloseCode.ProtocolError, "Continuous frame sequence was not started.");
+        } else {
+            //Intermediate
+            continuousFrames.add(frame);
+        }
+    }
+
+    public synchronized void sendFrame(WebSocketFrame frame) throws IOException {
+        frame.write(out);
+    }
+
+    // --------------------------------Close-----------------------------------
+
+    protected void doClose(CloseCode code, String reason, boolean initiatedByRemote) {
+        if (state == State.CLOSED) {
+            return;
+        }
+        if (in != null) {
+            try {
+                in.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        if (out != null) {
+            try {
+                out.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        state = State.CLOSED;
+        onClose(code, reason, initiatedByRemote);
+    }
+
+    // --------------------------------Listener--------------------------------
+
+    protected abstract void onPong(WebSocketFrame pongFrame);
+
+    protected abstract void onMessage(WebSocketFrame messageFrame);
+
+    protected abstract void onClose(CloseCode code, String reason, boolean initiatedByRemote);
+
+    protected abstract void onException(IOException e);
+
+    // --------------------------------Public Facade---------------------------
+
+    public void ping(byte[] payload) throws IOException {
+        sendFrame(new WebSocketFrame(OpCode.Ping, true, payload));
+    }
+
+    public void send(byte[] payload) throws IOException {
+        sendFrame(new WebSocketFrame(OpCode.Binary, true, payload));
+    }
+
+    public void send(String payload) throws IOException {
+        sendFrame(new WebSocketFrame(OpCode.Text, true, payload));
+    }
+
+    public void close(CloseCode code, String reason) throws IOException {
+        State oldState = state;
+        state = State.CLOSING;
+        if (oldState == State.OPEN) {
+            sendFrame(new CloseFrame(code, reason));
+        } else {
+            doClose(code, reason, false);
+        }
+    }
+
+    // --------------------------------Getters---------------------------------
+
+    public NanoHTTPD.IHTTPSession getHandshakeRequest() {
+        return handshakeRequest;
+    }
+
+    public NanoHTTPD.Response getHandshakeResponse() {
+        return handshakeResponse;
+    }
+}
diff --git a/websocket/src/main/java/fi/iki/elonen/WebSocketException.java b/websocket/src/main/java/fi/iki/elonen/WebSocketException.java
new file mode 100644
index 0000000..31cb6c8
--- /dev/null
+++ b/websocket/src/main/java/fi/iki/elonen/WebSocketException.java
@@ -0,0 +1,32 @@
+package fi.iki.elonen;
+
+import fi.iki.elonen.WebSocketFrame.CloseCode;
+
+import java.io.IOException;
+
+public class WebSocketException extends IOException {
+    private CloseCode code;
+    private String reason;
+
+    public WebSocketException(Exception cause) {
+        this(CloseCode.InternalServerError, cause.toString(), cause);
+    }
+
+    public WebSocketException(CloseCode code, String reason) {
+        this(code, reason, null);
+    }
+
+    public WebSocketException(CloseCode code, String reason, Exception cause) {
+        super(code + ": " + reason, cause);
+        this.code = code;
+        this.reason = reason;
+    }
+
+    public CloseCode getCode() {
+        return code;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+}
diff --git a/websocket/src/main/java/fi/iki/elonen/WebSocketFrame.java b/websocket/src/main/java/fi/iki/elonen/WebSocketFrame.java
new file mode 100644
index 0000000..0e209df
--- /dev/null
+++ b/websocket/src/main/java/fi/iki/elonen/WebSocketFrame.java
@@ -0,0 +1,430 @@
+package fi.iki.elonen;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.util.Arrays;
+import java.util.List;
+
+public class WebSocketFrame {
+    private OpCode opCode;
+    private boolean fin;
+    private byte[] maskingKey;
+
+    private byte[] payload;
+
+    private transient int _payloadLength;
+    private transient String _payloadString;
+
+    private WebSocketFrame(OpCode opCode, boolean fin) {
+        setOpCode(opCode);
+        setFin(fin);
+    }
+
+    public WebSocketFrame(OpCode opCode, boolean fin, byte[] payload, byte[] maskingKey) {
+        this(opCode, fin);
+        setMaskingKey(maskingKey);
+        setBinaryPayload(payload);
+    }
+
+    public WebSocketFrame(OpCode opCode, boolean fin, byte[] payload) {
+        this(opCode, fin, payload, null);
+    }
+
+    public WebSocketFrame(OpCode opCode, boolean fin, String payload, byte[] maskingKey) throws CharacterCodingException {
+        this(opCode, fin);
+        setMaskingKey(maskingKey);
+        setTextPayload(payload);
+    }
+
+    public WebSocketFrame(OpCode opCode, boolean fin, String payload) throws CharacterCodingException {
+        this(opCode, fin, payload, null);
+    }
+
+    public WebSocketFrame(WebSocketFrame clone) {
+        setOpCode(clone.getOpCode());
+        setFin(clone.isFin());
+        setBinaryPayload(clone.getBinaryPayload());
+        setMaskingKey(clone.getMaskingKey());
+    }
+
+    public WebSocketFrame(OpCode opCode, List<WebSocketFrame> fragments) throws WebSocketException {
+        setOpCode(opCode);
+        setFin(true);
+
+        long _payloadLength = 0;
+        for (WebSocketFrame inter : fragments) {
+            _payloadLength += inter.getBinaryPayload().length;
+        }
+        if (_payloadLength < 0 || _payloadLength > Integer.MAX_VALUE) {
+            throw new WebSocketException(CloseCode.MessageTooBig, "Max frame length has been exceeded.");
+        }
+        this._payloadLength = (int) _payloadLength;
+        byte[] payload = new byte[this._payloadLength];
+        int offset = 0;
+        for (WebSocketFrame inter : fragments) {
+            System.arraycopy(inter.getBinaryPayload(), 0, payload, offset, inter.getBinaryPayload().length);
+            offset += inter.getBinaryPayload().length;
+        }
+        setBinaryPayload(payload);
+    }
+
+    // --------------------------------GETTERS---------------------------------
+
+    public OpCode getOpCode() {
+        return opCode;
+    }
+
+    public void setOpCode(OpCode opcode) {
+        this.opCode = opcode;
+    }
+
+    public boolean isFin() {
+        return fin;
+    }
+
+    public void setFin(boolean fin) {
+        this.fin = fin;
+    }
+
+    public boolean isMasked() {
+        return maskingKey != null && maskingKey.length == 4;
+    }
+
+    public byte[] getMaskingKey() {
+        return maskingKey;
+    }
+
+    public void setMaskingKey(byte[] maskingKey) {
+        if (maskingKey != null && maskingKey.length != 4) {
+            throw new IllegalArgumentException("MaskingKey " + Arrays.toString(maskingKey) + " hasn't length 4");
+        }
+        this.maskingKey = maskingKey;
+    }
+
+    public void setUnmasked() {
+        setMaskingKey(null);
+    }
+
+    public byte[] getBinaryPayload() {
+        return payload;
+    }
+
+    public void setBinaryPayload(byte[] payload) {
+        this.payload = payload;
+        this._payloadLength = payload.length;
+        this._payloadString = null;
+    }
+
+    public String getTextPayload() {
+        if (_payloadString == null) {
+            try {
+                _payloadString = binary2Text(getBinaryPayload());
+            } catch (CharacterCodingException e) {
+                throw new RuntimeException("Undetected CharacterCodingException", e);
+            }
+        }
+        return _payloadString;
+    }
+
+    public void setTextPayload(String payload) throws CharacterCodingException {
+        this.payload = text2Binary(payload);
+        this._payloadLength = payload.length();
+        this._payloadString = payload;
+    }
+
+    // --------------------------------SERIALIZATION---------------------------
+
+    public static WebSocketFrame read(InputStream in) throws IOException {
+        byte head = (byte) checkedRead(in.read());
+        boolean fin = ((head & 0x80) != 0);
+        OpCode opCode = OpCode.find((byte) (head & 0x0F));
+        if ((head & 0x70) != 0) {
+            throw new WebSocketException(CloseCode.ProtocolError, "The reserved bits (" + Integer.toBinaryString(head & 0x70) + ") must be 0.");
+        }
+        if (opCode == null) {
+            throw new WebSocketException(CloseCode.ProtocolError, "Received frame with reserved/unknown opcode " + (head & 0x0F) + ".");
+        } else if (opCode.isControlFrame() && !fin) {
+            throw new WebSocketException(CloseCode.ProtocolError, "Fragmented control frame.");
+        }
+
+        WebSocketFrame frame = new WebSocketFrame(opCode, fin);
+        frame.readPayloadInfo(in);
+        frame.readPayload(in);
+        if (frame.getOpCode() == OpCode.Close) {
+            return new CloseFrame(frame);
+        } else {
+            return frame;
+        }
+    }
+
+    private static int checkedRead(int read) throws IOException {
+        if (read < 0) {
+            throw new EOFException();
+        }
+        //System.out.println(Integer.toBinaryString(read) + "/" + read + "/" + Integer.toHexString(read));
+        return read;
+    }
+
+
+    private void readPayloadInfo(InputStream in) throws IOException {
+        byte b = (byte) checkedRead(in.read());
+        boolean masked = ((b & 0x80) != 0);
+
+        _payloadLength = (byte) (0x7F & b);
+        if (_payloadLength == 126) {
+            // checkedRead must return int for this to work
+            _payloadLength = (checkedRead(in.read()) << 8 | checkedRead(in.read())) & 0xFFFF;
+            if (_payloadLength < 126) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Invalid data frame 2byte length. (not using minimal length encoding)");
+            }
+        } else if (_payloadLength == 127) {
+            long _payloadLength = ((long) checkedRead(in.read())) << 56 |
+                    ((long) checkedRead(in.read())) << 48 |
+                    ((long) checkedRead(in.read())) << 40 |
+                    ((long) checkedRead(in.read())) << 32 |
+                    checkedRead(in.read()) << 24 | checkedRead(in.read()) << 16 | checkedRead(in.read()) << 8 | checkedRead(in.read());
+            if (_payloadLength < 65536) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Invalid data frame 4byte length. (not using minimal length encoding)");
+            }
+            if (_payloadLength < 0 || _payloadLength > Integer.MAX_VALUE) {
+                throw new WebSocketException(CloseCode.MessageTooBig, "Max frame length has been exceeded.");
+            }
+            this._payloadLength = (int) _payloadLength;
+        }
+
+        if (opCode.isControlFrame()) {
+            if (_payloadLength > 125) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Control frame with payload length > 125 bytes.");
+            }
+            if (opCode == OpCode.Close && _payloadLength == 1) {
+                throw new WebSocketException(CloseCode.ProtocolError, "Received close frame with payload len 1.");
+            }
+        }
+
+        if (masked) {
+            maskingKey = new byte[4];
+            int read = 0;
+            while (read < maskingKey.length) {
+                read += checkedRead(in.read(maskingKey, read, maskingKey.length - read));
+            }
+        }
+    }
+
+    private void readPayload(InputStream in) throws IOException {
+        payload = new byte[_payloadLength];
+        int read = 0;
+        while (read < _payloadLength) {
+            read += checkedRead(in.read(payload, read, _payloadLength - read));
+        }
+
+        if (isMasked()) {
+            for (int i = 0; i < payload.length; i++) {
+                payload[i] ^= maskingKey[i % 4];
+            }
+        }
+
+        //Test for Unicode errors
+        if (getOpCode() == OpCode.Text) {
+            _payloadString = binary2Text(getBinaryPayload());
+        }
+    }
+
+    public void write(OutputStream out) throws IOException {
+        byte header = 0;
+        if (fin) {
+            header |= 0x80;
+        }
+        header |= opCode.getValue() & 0x0F;
+        out.write(header);
+
+        _payloadLength = getBinaryPayload().length;
+        if (_payloadLength <= 125) {
+            out.write(isMasked() ? 0x80 | (byte) _payloadLength : (byte) _payloadLength);
+        } else if (_payloadLength <= 0xFFFF) {
+            out.write(isMasked() ? 0xFE : 126);
+            out.write(_payloadLength >>> 8);
+            out.write(_payloadLength);
+        } else {
+            out.write(isMasked() ? 0xFF : 127);
+            out.write(_payloadLength >>> 56 & 0); //integer only contains 31 bit
+            out.write(_payloadLength >>> 48 & 0);
+            out.write(_payloadLength >>> 40 & 0);
+            out.write(_payloadLength >>> 32 & 0);
+            out.write(_payloadLength >>> 24);
+            out.write(_payloadLength >>> 16);
+            out.write(_payloadLength >>> 8);
+            out.write(_payloadLength);
+        }
+
+
+        if (isMasked()) {
+            out.write(maskingKey);
+            for (int i = 0; i < _payloadLength; i++) {
+                out.write(getBinaryPayload()[i] ^ maskingKey[i % 4]);
+            }
+        } else {
+            out.write(getBinaryPayload());
+        }
+        out.flush();
+    }
+
+    // --------------------------------ENCODING--------------------------------
+
+    public static final Charset TEXT_CHARSET = Charset.forName("UTF-8");
+    public static final CharsetDecoder TEXT_DECODER = TEXT_CHARSET.newDecoder();
+    public static final CharsetEncoder TEXT_ENCODER = TEXT_CHARSET.newEncoder();
+
+
+    public static String binary2Text(byte[] payload) throws CharacterCodingException {
+        return TEXT_DECODER.decode(ByteBuffer.wrap(payload)).toString();
+    }
+
+    public static String binary2Text(byte[] payload, int offset, int length) throws CharacterCodingException {
+        return TEXT_DECODER.decode(ByteBuffer.wrap(payload, offset, length)).toString();
+    }
+
+    public static byte[] text2Binary(String payload) throws CharacterCodingException {
+        return TEXT_ENCODER.encode(CharBuffer.wrap(payload)).array();
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WS[");
+        sb.append(getOpCode());
+        sb.append(", ").append(isFin() ? "fin" : "inter");
+        sb.append(", ").append(isMasked() ? "masked" : "unmasked");
+        sb.append(", ").append(payloadToString());
+        sb.append(']');
+        return sb.toString();
+    }
+
+    protected String payloadToString() {
+        if (payload == null) return "null";
+        else {
+            final StringBuilder sb = new StringBuilder();
+            sb.append('[').append(payload.length).append("b] ");
+            if (getOpCode() == OpCode.Text) {
+                String text = getTextPayload();
+                if (text.length() > 100)
+                    sb.append(text.substring(0, 100)).append("...");
+                else
+                    sb.append(text);
+            } else {
+                sb.append("0x");
+                for (int i = 0; i < Math.min(payload.length, 50); ++i)
+                    sb.append(Integer.toHexString((int) payload[i] & 0xFF));
+                if (payload.length > 50)
+                    sb.append("...");
+            }
+            return sb.toString();
+        }
+    }
+
+    // --------------------------------CONSTANTS-------------------------------
+
+    public static enum OpCode {
+        Continuation(0), Text(1), Binary(2), Close(8), Ping(9), Pong(10);
+
+        private final byte code;
+
+        private OpCode(int code) {
+            this.code = (byte) code;
+        }
+
+        public byte getValue() {
+            return code;
+        }
+
+        public boolean isControlFrame() {
+            return this == Close || this == Ping || this == Pong;
+        }
+
+        public static OpCode find(byte value) {
+            for (OpCode opcode : values()) {
+                if (opcode.getValue() == value) {
+                    return opcode;
+                }
+            }
+            return null;
+        }
+    }
+
+    public static enum CloseCode {
+        NormalClosure(1000), GoingAway(1001), ProtocolError(1002), UnsupportedData(1003), NoStatusRcvd(1005),
+        AbnormalClosure(1006), InvalidFramePayloadData(1007), PolicyViolation(1008), MessageTooBig(1009),
+        MandatoryExt(1010), InternalServerError(1011), TLSHandshake(1015);
+
+        private final int code;
+
+        private CloseCode(int code) {
+            this.code = code;
+        }
+
+        public int getValue() {
+            return code;
+        }
+
+        public static CloseCode find(int value) {
+            for (CloseCode code : values()) {
+                if (code.getValue() == value) {
+                    return code;
+                }
+            }
+            return null;
+        }
+    }
+
+    // ------------------------------------------------------------------------
+
+    public static class CloseFrame extends WebSocketFrame {
+        private CloseCode _closeCode;
+        private String _closeReason;
+
+        private CloseFrame(WebSocketFrame wrap) throws CharacterCodingException {
+            super(wrap);
+            assert wrap.getOpCode() == OpCode.Close;
+            if (wrap.getBinaryPayload().length >= 2) {
+                _closeCode = CloseCode.find((wrap.getBinaryPayload()[0] & 0xFF) << 8 |
+                        (wrap.getBinaryPayload()[1] & 0xFF));
+                _closeReason = binary2Text(getBinaryPayload(), 2, getBinaryPayload().length - 2);
+            }
+        }
+
+        public CloseFrame(CloseCode code, String closeReason) throws CharacterCodingException {
+            super(OpCode.Close, true, generatePayload(code, closeReason));
+        }
+
+        private static byte[] generatePayload(CloseCode code, String closeReason) throws CharacterCodingException {
+            if (code != null) {
+                byte[] reasonBytes = text2Binary(closeReason);
+                byte[] payload = new byte[reasonBytes.length + 2];
+                payload[0] = (byte) ((code.getValue() >> 8) & 0xFF);
+                payload[1] = (byte) ((code.getValue()) & 0xFF);
+                System.arraycopy(reasonBytes, 0, payload, 2, reasonBytes.length);
+                return payload;
+            } else {
+                return new byte[0];
+            }
+        }
+
+        protected String payloadToString() {
+            return (_closeCode != null ? _closeCode : "UnknownCloseCode[" + _closeCode + "]") + (_closeReason != null && !_closeReason.isEmpty() ? ": " + _closeReason : "");
+        }
+
+        public CloseCode getCloseCode() {
+            return _closeCode;
+        }
+
+        public String getCloseReason() {
+            return _closeReason;
+        }
+    }
+}
diff --git a/websocket/src/test/java/fi/iki/elonen/DebugWebSocket.java b/websocket/src/test/java/fi/iki/elonen/DebugWebSocket.java
new file mode 100644
index 0000000..e6c66ad
--- /dev/null
+++ b/websocket/src/test/java/fi/iki/elonen/DebugWebSocket.java
@@ -0,0 +1,61 @@
+package fi.iki.elonen;
+
+import java.io.IOException;
+
+/**
+* @author Paul S. Hawke (paul.hawke@gmail.com)
+*         On: 4/23/14 at 10:34 PM
+*/
+class DebugWebSocket extends WebSocket {
+    private final boolean DEBUG;
+
+    public DebugWebSocket(NanoHTTPD.IHTTPSession handshake, boolean debug) {
+        super(handshake);
+        DEBUG = debug;
+    }
+
+    @Override
+    protected void onPong(WebSocketFrame pongFrame) {
+        if (DEBUG) {
+            System.out.println("P " + pongFrame);
+        }
+    }
+
+    @Override
+    protected void onMessage(WebSocketFrame messageFrame) {
+        try {
+            messageFrame.setUnmasked();
+            sendFrame(messageFrame);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected void onClose(WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) {
+        if (DEBUG) {
+            System.out.println("C [" + (initiatedByRemote ? "Remote" : "Self") + "] " + (code != null ? code : "UnknownCloseCode[" + code + "]") + (reason != null && !reason.isEmpty() ? ": " + reason : ""));
+        }
+    }
+
+    @Override
+    protected void onException(IOException e) {
+        e.printStackTrace();
+    }
+
+    @Override
+    protected void handleWebsocketFrame(WebSocketFrame frame) throws IOException {
+        if (DEBUG) {
+            System.out.println("R " + frame);
+        }
+        super.handleWebsocketFrame(frame);
+    }
+
+    @Override
+    public synchronized void sendFrame(WebSocketFrame frame) throws IOException {
+        if (DEBUG) {
+            System.out.println("S " + frame);
+        }
+        super.sendFrame(frame);
+    }
+}
diff --git a/websocket/src/test/java/fi/iki/elonen/DebugWebSocketServer.java b/websocket/src/test/java/fi/iki/elonen/DebugWebSocketServer.java
new file mode 100644
index 0000000..49fbe4d
--- /dev/null
+++ b/websocket/src/test/java/fi/iki/elonen/DebugWebSocketServer.java
@@ -0,0 +1,19 @@
+package fi.iki.elonen;
+
+/**
+* @author Paul S. Hawke (paul.hawke@gmail.com)
+*         On: 4/23/14 at 10:31 PM
+*/
+class DebugWebSocketServer extends NanoWebSocketServer {
+    private final boolean debug;
+
+    public DebugWebSocketServer(int port, boolean debug) {
+        super(port);
+        this.debug = debug;
+    }
+
+    @Override
+    protected WebSocket openWebSocket(IHTTPSession handshake) {
+        return new DebugWebSocket(handshake, debug);
+    }
+}
diff --git a/websocket/src/test/java/fi/iki/elonen/EchoSocketSample.java b/websocket/src/test/java/fi/iki/elonen/EchoSocketSample.java
new file mode 100644
index 0000000..091dfc0
--- /dev/null
+++ b/websocket/src/test/java/fi/iki/elonen/EchoSocketSample.java
@@ -0,0 +1,20 @@
+package fi.iki.elonen;
+
+import java.io.IOException;
+
+public class EchoSocketSample {
+    public static void main(String[] args) throws IOException {
+        final boolean debugMode = args.length >= 2 && args[1].toLowerCase().equals("-d");
+        NanoWebSocketServer ws = new DebugWebSocketServer(Integer.parseInt(args[0]), debugMode);
+        ws.start();
+        System.out.println("Server started, hit Enter to stop.\n");
+        try {
+            System.in.read();
+        } catch (IOException ignored) {
+        }
+        ws.stop();
+        System.out.println("Server stopped.\n");
+    }
+
+}
+
diff --git a/websocket/src/test/resources/echo-test.html b/websocket/src/test/resources/echo-test.html
new file mode 100644
index 0000000..4b60b80
--- /dev/null
+++ b/websocket/src/test/resources/echo-test.html
@@ -0,0 +1,58 @@
+<html>
+<head>
+    <meta charset="utf-8"/>
+    <title>WebSocket Test</title>
+    <script language="javascript" type="text/javascript">
+        var wsUri = "ws://localhost:9090/";
+        var output;
+        function init() {
+            output = document.getElementById("output");
+            testWebSocket();
+        }
+        function testWebSocket() {
+            websocket = new WebSocket(wsUri);
+            websocket.onopen = function (evt) {
+                onOpen(evt)
+            };
+            websocket.onclose = function (evt) {
+                onClose(evt)
+            };
+            websocket.onmessage = function (evt) {
+                onMessage(evt)
+            };
+            websocket.onerror = function (evt) {
+                onError(evt)
+            };
+        }
+        function onOpen(evt) {
+            writeToScreen("CONNECTED");
+            doSend("WebSocket rocks");
+        }
+        function onClose(evt) {
+            writeToScreen("DISCONNECTED");
+        }
+        function onMessage(evt) {
+            writeToScreen('<span style="color: blue;">RESPONSE: ' + evt.data + '</span>');
+            websocket.close();
+        }
+        function onError(evt) {
+            writeToScreen('<span style="color: red;">ERROR:</span> ' + evt.data);
+        }
+        function doSend(message) {
+            writeToScreen("SENT: " + message);
+            websocket.send(message);
+        }
+        function writeToScreen(message) {
+            var pre = document.createElement("p");
+            pre.style.wordWrap = "break-word";
+            pre.innerHTML = message;
+            output.appendChild(pre);
+        }
+        window.addEventListener("load", init, false);  </script>
+</head>
+<body>
+<h2>WebSocket Test</h2>
+
+<div id="output"></div>
+</body>
+</html>
\ No newline at end of file