Merge pull request TooTallNate#201 from Davidiusdadi/master

merged bugfixes & FragmentedFramesExample (TooTallNate#194)

Author: Davidiusdadi

src/main/example/ChatServer.java

@@ -7,6 +7,7 @@
 
 import org.java_websocket.WebSocket;
 import org.java_websocket.WebSocketImpl;
+import org.java_websocket.framing.Framedata;
 import org.java_websocket.handshake.ClientHandshake;
 import org.java_websocket.server.WebSocketServer;
 
@@ -41,6 +42,11 @@ public void onMessage( WebSocket conn, String message ) {
 		System.out.println( conn + ": " + message );
 	}
 
+	@Override
+	public void onFragment( WebSocket conn, Framedata fragment ) {
+		System.out.println( "received fragment: " + fragment );
+	}
+
 	public static void main( String[] args ) throws InterruptedException , IOException {
 		WebSocketImpl.DEBUG = true;
 		int port = 8887; // 843 flash policy port
@@ -56,9 +62,16 @@ public static void main( String[] args ) throws InterruptedException , IOExcepti
 		while ( true ) {
 			String in = sysin.readLine();
 			s.sendToAll( in );
+			if( in.equals( "exit" ) ) {
+				s.stop();
+				break;
+			} else if( in.equals( "restart" ) ) {
+				s.stop();
+				s.start();
+				break;
+			}
 		}
 	}
-
 	@Override
 	public void onError( WebSocket conn, Exception ex ) {
 		ex.printStackTrace();

src/main/example/ExampleClient.java

@@ -4,6 +4,7 @@
 import org.java_websocket.client.WebSocketClient;
 import org.java_websocket.drafts.Draft;
 import org.java_websocket.drafts.Draft_10;
+import org.java_websocket.framing.Framedata;
 import org.java_websocket.handshake.ServerHandshake;
 
 /** This example demonstrates how to create a websocket connection to a server. Only the most important callbacks are overloaded. */
@@ -20,13 +21,17 @@ public ExampleClient( URI serverURI ) {
 	@Override
 	public void onOpen( ServerHandshake handshakedata ) {
 		System.out.println( "opened connection" );
-		// if you pan to refuse connection based on ip or httpfields overload: onWebsocketHandshakeReceivedAsClient
+		// if you plan to refuse connection based on ip or httpfields overload: onWebsocketHandshakeReceivedAsClient
 	}
 
 	@Override
 	public void onMessage( String message ) {
 		System.out.println( "received: " + message );
-		// send( "you said: " + message );
+	}
+
+	@Override
+	public void onFragment( Framedata fragment ) {
+		System.out.println( "received fragment: " + new String( fragment.getPayloadData().array() ) );
 	}
 
 	@Override

src/main/example/FragmentedFramesExample.java

@@ -0,0 +1,57 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+
+import org.java_websocket.WebSocket;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.drafts.Draft_17;
+import org.java_websocket.framing.Framedata.Opcode;
+
+/**
+ * This example shows how to send fragmented frames.<br>
+ * For information on when to used fragmented frames see http://tools.ietf.org/html/rfc6455#section-5.4<br>
+ * Fragmented and normal messages can not be mixed.
+ * One is however allowed to mix them with control messages like ping/pong.
+ * 
+ * @see WebSocket#sendFragmentedFrame(Opcode, ByteBuffer, boolean)
+ **/
+public class FragmentedFramesExample {
+	public static void main( String[] args ) throws URISyntaxException , IOException , InterruptedException {
+		// WebSocketImpl.DEBUG = true; // will give extra output
+
+		WebSocketClient websocket = new ExampleClient( new URI( "ws://localhost:8887" ), new Draft_17() ); // Draft_17 is implementation of rfc6455
+		if( !websocket.connectBlocking() ) {
+			System.err.println( "Could not connect to the server." );
+			return;
+		}
+
+		System.out.println( "This example shows how to send fragmented(continuous) messages." );
+
+		BufferedReader stdin = new BufferedReader( new InputStreamReader( System.in ) );
+		while ( websocket.isOpen() ) {
+			System.out.println( "Please type in a loooooong line(which then will be send in 2 byte fragments):" );
+			String longline = stdin.readLine();
+			ByteBuffer longelinebuffer = ByteBuffer.wrap( longline.getBytes() );
+			longelinebuffer.rewind();
+
+			for( int position = 2 ; ; position += 2 ) {
+				if( position < longelinebuffer.capacity() ) {
+					longelinebuffer.limit( position );
+					websocket.sendFragmentedFrame( Opcode.TEXT, longelinebuffer, false );// when sending binary data one should use Opcode.BINARY
+					assert ( longelinebuffer.remaining() == 0 );
+					// after calling sendFragmentedFrame one may reuse the buffer given to the method immediately
+				} else {
+					longelinebuffer.limit( longelinebuffer.capacity() );
+					websocket.sendFragmentedFrame( Opcode.TEXT, longelinebuffer, true );// sending the last frame
+					break;
+				}
+
+			}
+			System.out.println( "You can not type in the next long message or press Ctr-C to exit." );
+		}
+		System.out.println( "FragmentedFramesExample terminated" );
+	}
+}

src/main/java/org/java_websocket/SSLSocketChannel2.java

@@ -56,6 +56,12 @@ public class SSLSocketChannel2 implements ByteChannel, WrappedByteChannel {
 	protected SSLEngineResult readEngineResult;
 	protected SSLEngineResult writeEngineResult;
 
+	/**
+	 * Should be used to count the buffer allocations.
+	 * But because of #190 where HandshakeStatus.FINISHED is not properly returned by nio wrap/unwrap this variable is used to check whether {@link #createBuffers(SSLSession)} needs to be called.
+	 **/
+	protected int bufferallocations = 0;
+
 	public SSLSocketChannel2( SocketChannel channel , SSLEngine sslEngine , ExecutorService exec , SelectionKey key ) throws IOException {
 		if( channel == null || sslEngine == null || exec == null )
 			throw new IllegalArgumentException( "parameter must not be null" );
@@ -127,21 +133,23 @@ private synchronized void processHandshake() throws IOException {
 			}
 			inData.compact();
 			unwrap();
-			if( sslEngine.getHandshakeStatus() == HandshakeStatus.FINISHED ) {
+			if( readEngineResult.getHandshakeStatus() == HandshakeStatus.FINISHED ) {
 				createBuffers( sslEngine.getSession() );
 				return;
 			}
 		}
 		consumeDelegatedTasks();
-		assert ( sslEngine.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING );
 		if( tasks.isEmpty() || sslEngine.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_WRAP ) {
 			socketChannel.write( wrap( emptybuffer ) );
-			if( sslEngine.getHandshakeStatus() == HandshakeStatus.FINISHED ) {
+			if( writeEngineResult.getHandshakeStatus() == HandshakeStatus.FINISHED ) {
 				createBuffers( sslEngine.getSession() );
+				return;
 			}
 		}
-	}
+		assert ( sslEngine.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING );// this function could only leave NOT_HANDSHAKING after createBuffers was called unless #190 occurs which means that nio wrap/unwrap never return HandshakeStatus.FINISHED
 
+		bufferallocations = 1; // look at variable declaration why this line exists and #190. Without this line buffers would not be be recreated when #190 AND a rehandshake occur.
+	}
 	private synchronized ByteBuffer wrap( ByteBuffer b ) throws SSLException {
 		outCrypt.compact();
 		writeEngineResult = sslEngine.wrap( b, outCrypt );
@@ -192,13 +200,18 @@ protected void createBuffers( SSLSession session ) {
 		inCrypt.flip();
 		outCrypt.rewind();
 		outCrypt.flip();
+		bufferallocations++;
 	}
 
 	public int write( ByteBuffer src ) throws IOException {
 		if( !isHandShakeComplete() ) {
 			processHandshake();
 			return 0;
 		}
+		// assert ( bufferallocations > 1 ); //see #190
+		if( bufferallocations <= 1 ) {
+			createBuffers( sslEngine.getSession() );
+		}
 		int num = socketChannel.write( wrap( src ) );
 		return num;
 
@@ -225,6 +238,10 @@ public int read( ByteBuffer dst ) throws IOException {
 				}
 			}
 		}
+		// assert ( bufferallocations > 1 ); //see #190
+		if( bufferallocations <= 1 ) {
+			createBuffers( sslEngine.getSession() );
+		}
 		/* 1. When "dst" is smaller than "inData" readRemaining will fill "dst" with data decoded in a previous read call.
 		 * 2. When "inCrypt" contains more data than "inData" has remaining space, unwrap has to be called on more time(readRemaining)
 		 */
@@ -256,7 +273,6 @@ public int read( ByteBuffer dst ) throws IOException {
 		}
 		return transfered;
 	}
-
 	/**
 	 * {@link #read(ByteBuffer)} may not be to leave all buffers(inData, inCrypt)
 	 **/

src/main/java/org/java_websocket/WebSocket.java

@@ -6,6 +6,7 @@
 
 import org.java_websocket.drafts.Draft;
 import org.java_websocket.framing.Framedata;
+import org.java_websocket.framing.Framedata.Opcode;
 
 public interface WebSocket {
 	public enum Role {
@@ -62,6 +63,21 @@ public enum READYSTATE {
 
 	public abstract void sendFrame( Framedata framedata );
 
+	/**
+	 * Allows to send continuous/fragmented frames conveniently. <br>
+	 * For more into on this frame type see http://tools.ietf.org/html/rfc6455#section-5.4<br>
+	 * 
+	 * If the first frame you send is also the last then it is not a fragmented frame and will received via onMessage instead of onFragmented even though it was send by this method.
+	 * 
+	 * @param op
+	 *            This is only important for the first frame in the sequence. Opcode.TEXT, Opcode.BINARY are allowed.
+	 * @param buffer
+	 *            The buffer which contains the payload. It may have no bytes remaining.
+	 * @param fin
+	 *            true means the current frame is the last in the sequence.
+	 **/
+	public abstract void sendFragmentedFrame( Opcode op, ByteBuffer buffer, boolean fin );
+
 	public abstract boolean hasBufferedData();
 
 	/**

src/main/java/org/java_websocket/WebSocketImpl.java

@@ -580,6 +580,11 @@ private void send( Collection<Framedata> frames ) {
 		}
 	}
 
+	@Override
+	public void sendFragmentedFrame( Opcode op, ByteBuffer buffer, boolean fin ) {
+		send( draft.continuousFrame( op, buffer, fin ) );
+	}
+
 	@Override
 	public void sendFrame( Framedata framedata ) {
 		if( DEBUG )