public enum Role {

CLIENT, SERVER

}

public static final int READY_STATE_CONNECTING = 0;

public static final int READY_STATE_OPEN = 1;

public static final int READY_STATE_CLOSING = 2;

public static final int READY_STATE_CLOSED = 3;

public static int BUFFERSIZE = 512;

/**

public static final int DEFAULT_PORT = 80;

public static/*final*/boolean DEBUG = false; // must be final in the future in order to take advantage of VM optimization

/**

private boolean handshakeComplete = false;

/**

private boolean closeHandshakeSent = false;

/**

private boolean connectionClosed = false;

/**

private WebSocketListener wsl;

/**

private ByteBuffer socketBuffer;

/**

private BlockingQueue<ByteBuffer> bufferQueue;

/**

private AtomicLong bufferQueueTotalAmount = new AtomicLong( 0l );

private Draft draft = null;

private Role role;

private Framedata currentframe;

private ClientHandshake handshakerequest = null;

public List<Draft> known_drafts;

private SocketChannel sockchannel;

// CONSTRUCTOR /////////////////////////////////////////////////////////////

/**

public WebSocket( WebSocketListener listener , Draft draft , SocketChannel socketchannel ) {

init( listener, draft, socketchannel );

}

public WebSocket( WebSocketListener listener , List<Draft> drafts , SocketChannel socketchannel ) {

init( listener, null, socketchannel );

this.role = Role.SERVER;

if( known_drafts == null || known_drafts.isEmpty() ) {

known_drafts = new ArrayList<Draft>( 1 );

known_drafts.add( new Draft_17() );

known_drafts.add( new Draft_10() );

known_drafts.add( new Draft_76() );

known_drafts.add( new Draft_75() );

} else {

known_drafts = drafts;

}

}

private void init( WebSocketListener listener, Draft draft, SocketChannel socketchannel ) {

this.sockchannel = socketchannel;

this.bufferQueue = new LinkedBlockingQueue<ByteBuffer>( 3 );

this.socketBuffer = ByteBuffer.allocate( BUFFERSIZE );

socketBuffer.flip();

this.wsl = listener;

this.role = Role.CLIENT;

this.draft = draft;

}

/**

/*package public*/void handleRead() throws IOException {

Date receiveThenSendStartTime = new Date();

if( !socketBuffer.hasRemaining() ) {

socketBuffer.rewind();

socketBuffer.limit( socketBuffer.capacity() );

if( sockchannel.read( socketBuffer ) == -1 ) {

if( draft == null ) {

closeConnection( CloseFrame.ABNROMAL_CLOSE, true );

} else if( draft.getCloseHandshakeType() == CloseHandshakeType.NONE ) {

closeConnection( CloseFrame.NORMAL, true );

} else if( draft.getCloseHandshakeType() == CloseHandshakeType.ONEWAY ) {

if( role == Role.SERVER )

closeConnection( CloseFrame.ABNROMAL_CLOSE, true );

else

closeConnection( CloseFrame.NORMAL, true );

} else {

closeConnection( CloseFrame.ABNROMAL_CLOSE, true );

}

}

socketBuffer.flip();

}

if( socketBuffer.hasRemaining() ) {

if( DEBUG )

System.out.println( "process(" + socketBuffer.remaining() + "): {" + ( socketBuffer.remaining() > 1000 ? "too big to display" : new String( socketBuffer.array(), socketBuffer.position(), socketBuffer.remaining() ) ) + "}" );

if( !handshakeComplete ) {

if( draft == null ) {

HandshakeState isflashedgecase = isFlashEdgeCase( socketBuffer );

if( isflashedgecase == HandshakeState.MATCHED ) {

channelWriteDirect( ByteBuffer.wrap( Charsetfunctions.utf8Bytes( wsl.getFlashPolicy( this ) ) ) );

closeDirect( CloseFrame.FLASHPOLICY, "" );

return;

} else if( isflashedgecase == HandshakeState.MATCHING ) {

return;

}

}

HandshakeState handshakestate = null;

socketBuffer.mark();

try {

if( role == Role.SERVER ) {

if( draft == null ) {

for( Draft d : known_drafts ) {

try {

d.setParseMode( role );

socketBuffer.reset();

Handshakedata tmphandshake = d.translateHandshake( socketBuffer );

if( tmphandshake instanceof ClientHandshake == false ) {

closeConnection( CloseFrame.PROTOCOL_ERROR, "wrong http function", false );

return;

}

ClientHandshake handshake = (ClientHandshake) tmphandshake;

handshakestate = d.acceptHandshakeAsServer( handshake );

if( handshakestate == HandshakeState.MATCHED ) {

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), MessageType.HANDSHAKE, socketBuffer.limit() );

ServerHandshakeBuilder response;

try {

response = wsl.onWebsocketHandshakeReceivedAsServer( this, d, handshake );

} catch ( InvalidDataException e ) {

closeConnection( e.getCloseCode(), e.getMessage(), false );

return;

}

// Reset timer for sending the handshake response back

receiveThenSendStartTime = new Date();

// Send Handshake Response back

Handshakedata handshakeResponse = d.postProcessHandshakeResponseAsServer(handshake, response);

writeDirect( d.createHandshake( handshakeResponse, role ) );

// timing callback

wsl.messageSendTiming( receiveThenSendStartTime, new Date(), MessageType.HANDSHAKE, handshakeResponse.getContent() != null ? handshakeResponse.getContent().length : 0 );

draft = d;

open( handshake );

handleRead();

return;

} else if( handshakestate == HandshakeState.MATCHING ) {

if( draft != null ) {

throw new InvalidHandshakeException( "multible drafts matching" );

}

draft = d;

}

} catch ( InvalidHandshakeException e ) {

// go on with an other draft

} catch ( IncompleteHandshakeException e ) {

if( socketBuffer.limit() == socketBuffer.capacity() ) {

close( CloseFrame.TOOBIG, "handshake is to big" );

}

// read more bytes for the handshake

socketBuffer.position( socketBuffer.limit() );

socketBuffer.limit( socketBuffer.capacity() );

return;

}

}

if( draft == null ) {

close( CloseFrame.PROTOCOL_ERROR, "no draft matches" );

}

return;

} else {

// special case for multiple step handshakes

Handshakedata tmphandshake = draft.translateHandshake( socketBuffer );

if( tmphandshake instanceof ClientHandshake == false ) {

closeConnection( CloseFrame.PROTOCOL_ERROR, "wrong http function", false );

return;

}

ClientHandshake handshake = (ClientHandshake) tmphandshake;

handshakestate = draft.acceptHandshakeAsServer( handshake );

if( handshakestate == HandshakeState.MATCHED ) {

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), MessageType.HANDSHAKE, socketBuffer.limit() );

open( handshake );

handleRead();

} else if( handshakestate != HandshakeState.MATCHING ) {

close( CloseFrame.PROTOCOL_ERROR, "the handshake did finally not match" );

}

return;

}

} else if( role == Role.CLIENT ) {

draft.setParseMode( role );

Handshakedata tmphandshake = draft.translateHandshake( socketBuffer );

if( tmphandshake instanceof ServerHandshake == false ) {

closeConnection( CloseFrame.PROTOCOL_ERROR, "Wrong http function", false );

return;

}

ServerHandshake handshake = (ServerHandshake) tmphandshake;

handshakestate = draft.acceptHandshakeAsClient( handshakerequest, handshake );

if( handshakestate == HandshakeState.MATCHED ) {

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), MessageType.HANDSHAKE, socketBuffer.limit() );

try {

wsl.onWebsocketHandshakeReceivedAsClient( this, handshakerequest, handshake );

} catch ( InvalidDataException e ) {

closeConnection( e.getCloseCode(), e.getMessage(), false );

return;

}

open( handshake );

handleRead();

} else if( handshakestate == HandshakeState.MATCHING ) {

return;

} else {

close( CloseFrame.PROTOCOL_ERROR, "draft " + draft + " refuses handshake" );

}

}

} catch ( InvalidHandshakeException e ) {

close( e );

}

} else {

// Receiving frames

List<Framedata> frames;

try {

frames = draft.translateFrame( socketBuffer );

for( Framedata f : frames ) {

if( DEBUG )

System.out.println( "matched frame: " + f );

Opcode curop = f.getOpcode();

if( curop == Opcode.CLOSING ) {

int code = CloseFrame.NOCODE;

String reason = "";

if( f instanceof CloseFrame ) {

CloseFrame cf = (CloseFrame) f;

code = cf.getCloseCode();

reason = cf.getMessage();

}

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), MessageType.CLOSE, socketBuffer.limit() );

if( closeHandshakeSent ) {

// complete the close handshake by disconnecting

closeConnection( code, reason, true );

} else {

// echo close handshake

if( draft.getCloseHandshakeType() == CloseHandshakeType.TWOWAY )

close( code, reason );

closeConnection( code, reason, false );

}

continue;

} else if( curop == Opcode.PING ) {

wsl.onWebsocketPing( this, f );

continue;

} else if( curop == Opcode.PONG ) {

wsl.onWebsocketPong( this, f );

continue;

} else {

// process non control frames

if( currentframe == null ) {

if( f.getOpcode() == Opcode.CONTINIOUS ) {

throw new InvalidFrameException( "unexpected continious frame" );

} else if( f.isFin() ) {

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), f.getOpcode() == Opcode.BINARY ? MessageType.BINARY : MessageType.TEXT, socketBuffer.limit() );

// receive normal onframe message

deliverMessage( f );

} else {

// remember the frame whose payload is about to be continued

currentframe = f;

}

} else if( f.getOpcode() == Opcode.CONTINIOUS ) {

currentframe.append( f );

if( f.isFin() ) {

// timing callback

wsl.messageReceiveTiming( receiveThenSendStartTime, new Date(), f.getOpcode() == Opcode.BINARY ? MessageType.BINARY : MessageType.TEXT, socketBuffer.limit() );

deliverMessage( currentframe );

currentframe = null;

}

} else {

throw new InvalidDataException( CloseFrame.PROTOCOL_ERROR, "non control or continious frame expected" );

}

}

}

} catch ( InvalidDataException e1 ) {

wsl.onWebsocketError( this, e1 );

close( e1 );

return;

}

}

}

}

// PUBLIC INSTANCE METHODS /////////////////////////////////////////////////

/**

public void close( int code, String message ) {

try {

closeDirect( code, message );

} catch ( IOException e ) {

closeConnection( CloseFrame.ABNROMAL_CLOSE, true );

}

}

public void closeDirect( int code, String message ) throws IOException {

if( !closeHandshakeSent ) {

if( handshakeComplete ) {

Date closeMessageSendStartTime = new Date();

if( code == CloseFrame.ABNROMAL_CLOSE ) {

closeConnection( code, true );

closeHandshakeSent = true;

return;

}

flush();

if( draft.getCloseHandshakeType() != CloseHandshakeType.NONE ) {

Framedata frameData = null;

int frameDataPayloadSize = 0;

try {

frameData = new CloseFrameBuilder( code, message );

frameDataPayloadSize = frameData.getPayloadData().remaining();

sendFrameDirect(frameData);

} catch ( InvalidDataException e ) {

wsl.onWebsocketError( this, e );

closeConnection( CloseFrame.ABNROMAL_CLOSE, "generated frame is invalid", false );

}

// timing callback

wsl.messageSendTiming( closeMessageSendStartTime, new Date(), MessageType.CLOSE, frameDataPayloadSize );

} else {

closeConnection( code, false );

}

} else if( code == CloseFrame.FLASHPOLICY ) {

closeConnection( CloseFrame.FLASHPOLICY, true );

} else {

closeConnection( CloseFrame.NEVERCONNECTED, false );

}

if( code == CloseFrame.PROTOCOL_ERROR )// this endpoint found a PROTOCOL_ERROR

closeConnection( code, false );

closeHandshakeSent = true;

return;

}

}

/**

public void closeConnection( int code, String message, boolean remote ) {

if( connectionClosed ) {

return;

}

connectionClosed = true;

try {

sockchannel.close();

} catch ( IOException e ) {

wsl.onWebsocketError( this, e );

}

this.wsl.onWebsocketClose( this, code, message, remote );

if( draft != null )

draft.reset();

currentframe = null;

handshakerequest = null;

}

public void closeConnection( int code, boolean remote ) {

closeConnection( code, "", remote );

}

public void close( int code ) {

close( code, "" );

}

public void close( InvalidDataException e ) {

close( e.getCloseCode(), e.getMessage() );

}

/**

public void send( String text ) throws NotYetConnectedException , InterruptedException {

if( text == null )

throw new IllegalArgumentException( "Cannot send 'null' data to a WebSocket." );

send( draft.createFrames( text, role == Role.CLIENT ) );

}

/**

public void send( ByteBuffer bytes ) throws IllegalArgumentException , NotYetConnectedException , InterruptedException {

if( bytes == null )

throw new IllegalArgumentException( "Cannot send 'null' data to a WebSocket." );

send( draft.createFrames( bytes, role == Role.CLIENT ) );

}

public void send( byte[] bytes ) throws IllegalArgumentException , NotYetConnectedException , InterruptedException {

send( ByteBuffer.wrap( bytes ) );

}

private void send( Collection<Framedata> frames ) throws InterruptedException {

if( !this.handshakeComplete )

throw new NotYetConnectedException();

for( Framedata f : frames ) {

sendFrame( f );

}

}

public void sendFrame( Framedata framedata ) throws InterruptedException {

if( DEBUG )

System.out.println( "send frame: " + framedata );

channelWrite( draft.createBinaryFrame( framedata ) );

}

private void sendFrameDirect( Framedata framedata ) throws IOException {

if( DEBUG )

System.out.println( "send frame: " + framedata );

channelWriteDirect( draft.createBinaryFrame( framedata ) );

}

boolean hasBufferedData() {

return !this.bufferQueue.isEmpty();

}

/**

long bufferedDataAmount() {

return bufferQueueTotalAmount.get();

}

/**

public void flush() throws IOException {

Date sentStartTime = new Date();

ByteBuffer buffer = this.bufferQueue.peek();

while ( buffer != null ) {

int written = sockchannel.write( buffer );

if( buffer.remaining() > 0 ) {

// there is still stuff to send for this buffer

continue;

} else {

// subtract this amount of data from the total queued (synchronized over this object)

bufferQueueTotalAmount.addAndGet( -written );

// timing callback

if ( isConnecting() ) {

wsl.messageSendTiming( sentStartTime, new Date(), MessageType.HANDSHAKE, buffer.limit() );

} else if ( isOpen() ) {

// TODO - We don't have yet a way to know if we are sending "text" or "binary" at this point

wsl.messageSendTiming( sentStartTime, new Date(), MessageType.TEXT, buffer.limit() );

} //< the "close()" message is handled slightly differently because of it's nature

this.bufferQueue.poll(); //< Buffer finished. Remove it.

buffer = this.bufferQueue.peek();

}

}

}

public HandshakeState isFlashEdgeCase( ByteBuffer request ) {

if( request.limit() > Draft.FLASH_POLICY_REQUEST.length )

return HandshakeState.NOT_MATCHED;

else if( request.limit() < Draft.FLASH_POLICY_REQUEST.length ) {

return HandshakeState.MATCHING;

} else {

request.mark();

for( int flash_policy_index = 0 ; request.hasRemaining() ; flash_policy_index++ ) {

if( Draft.FLASH_POLICY_REQUEST[ flash_policy_index ] != request.get() ) {

request.reset();

return HandshakeState.NOT_MATCHED;

}

}

return HandshakeState.MATCHED;

// return request.remaining() >= Draft.FLASH_POLICY_REQUEST.length ? HandshakeState.MATCHED : HandshakeState.MATCHING;

}

}

public void startHandshake( ClientHandshakeBuilder handshakedata ) throws InvalidHandshakeException , InterruptedException {

if( handshakeComplete )

throw new IllegalStateException( "Handshake has already been sent." );

// Store the Handshake Request we are about to send

this.handshakerequest = draft.postProcessHandshakeRequestAsClient( handshakedata );

// Notify Listener

try {

wsl.onWebsocketHandshakeSentAsClient( this, this.handshakerequest );

} catch ( InvalidDataException e ) {

// Stop if the client code throws an exception

throw new InvalidHandshakeException( "Handshake data rejected by client." );

}

channelWrite( draft.createHandshake( this.handshakerequest, role ) ); //< queue to be sent

}

private void channelWrite( ByteBuffer buf ) throws InterruptedException {

if( DEBUG )

System.out.println( "write(" + buf.remaining() + "): {" + ( buf.remaining() > 1000 ? "too big to display" : new String( buf.array() ) ) + "}" );

// add up the number of bytes to the total queued (synchronized over this object)

bufferQueueTotalAmount.addAndGet( buf.remaining() );

if( !bufferQueue.offer( buf ) ) {

try {

flush();

} catch ( IOException e ) {

wsl.onWebsocketError( this, e );

closeConnection( CloseFrame.ABNROMAL_CLOSE, true );

return;

}

bufferQueue.put( buf );

}

wsl.onWriteDemand( this );

}

private void channelWrite( List<ByteBuffer> bufs ) throws InterruptedException {

for( ByteBuffer b : bufs ) {

channelWrite( b );

}

}

private void channelWriteDirect( ByteBuffer buf ) throws IOException {

while ( buf.hasRemaining() )

sockchannel.write( buf );

}

private void writeDirect( List<ByteBuffer> bufs ) throws IOException {

for( ByteBuffer b : bufs ) {

channelWriteDirect( b );

}

}

private void deliverMessage( Framedata d ) throws InvalidDataException {

if( d.getOpcode() == Opcode.TEXT ) {

wsl.onWebsocketMessage( this, Charsetfunctions.stringUtf8( d.getPayloadData() ) );

} else if( d.getOpcode() == Opcode.BINARY ) {

wsl.onWebsocketMessage( this, d.getPayloadData() );

} else {

if( DEBUG )

System.out.println( "Ignoring frame:" + d.toString() );

assert ( false );

}

}

private void open( Handshakedata d ) throws IOException {

if( DEBUG )

System.out.println( "open using draft: " + draft.getClass().getSimpleName() );

handshakeComplete = true;

wsl.onWebsocketOpen( this, d );

}

public InetSocketAddress getRemoteSocketAddress() {

return (InetSocketAddress) sockchannel.socket().getRemoteSocketAddress();

}

public InetSocketAddress getLocalSocketAddress() {

return (InetSocketAddress) sockchannel.socket().getLocalSocketAddress();

}

public boolean isConnecting() {

return ( !connectionClosed && !closeHandshakeSent && !handshakeComplete );

}

public boolean isOpen() {

return ( !connectionClosed && !closeHandshakeSent && handshakeComplete );

}

public boolean isClosing() {

return ( !connectionClosed && closeHandshakeSent );

}

public boolean isClosed() {

return connectionClosed;

}

/**

public int getReadyState() {

if( isConnecting() ) {

return READY_STATE_CONNECTING;

} else if( isOpen() ) {

return READY_STATE_OPEN;

} else if( isClosing() ) {

return READY_STATE_CLOSING;

} else if( isClosed() ) {

return READY_STATE_CLOSED;

}

assert ( false );

return -1; // < This can't happen, by design!

}

@Override

public int hashCode() {

return super.hashCode();

}

@Override

public String toString() {

return super.toString(); // its nice to be able to set breakpoints here

}