Android Open Source - android_opengles Draft_10






From Project

Back to project page android_opengles.

License

The source code is released under:

MIT License

If you think the Android project android_opengles listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.

Java Source Code

package org.java_websocket.drafts;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
//w  ww . ja va 2 s. co m
import org.java_websocket.WebSocket.Role;
import org.java_websocket.exceptions.InvalidDataException;
import org.java_websocket.exceptions.InvalidFrameException;
import org.java_websocket.exceptions.InvalidHandshakeException;
import org.java_websocket.exceptions.LimitExedeedException;
import org.java_websocket.exceptions.NotSendableException;
import org.java_websocket.framing.CloseFrameBuilder;
import org.java_websocket.framing.FrameBuilder;
import org.java_websocket.framing.Framedata;
import org.java_websocket.framing.Framedata.Opcode;
import org.java_websocket.framing.FramedataImpl1;
import org.java_websocket.handshake.ClientHandshake;
import org.java_websocket.handshake.ClientHandshakeBuilder;
import org.java_websocket.handshake.HandshakeBuilder;
import org.java_websocket.handshake.Handshakedata;
import org.java_websocket.handshake.ServerHandshake;
import org.java_websocket.handshake.ServerHandshakeBuilder;
import org.java_websocket.util.Base64;
import org.java_websocket.util.Charsetfunctions;

public class Draft_10 extends Draft {

  private class IncompleteException extends Throwable {

    /**
     * It's Serializable.
     */
    private static final long serialVersionUID = 7330519489840500997L;

    private int preferedsize;
    public IncompleteException( int preferedsize ) {
      this.preferedsize = preferedsize;
    }
    public int getPreferedSize() {
      return preferedsize;
    }
  }

  public static int readVersion( Handshakedata handshakedata ) {
    String vers = handshakedata.getFieldValue( "Sec-WebSocket-Version" );
    if( vers.length() > 0 ) {
      int v;
      try {
        v = new Integer( vers.trim() );
        return v;
      } catch ( NumberFormatException e ) {
        return -1;
      }
    }
    return -1;
  }

  private ByteBuffer incompleteframe;
  private Framedata fragmentedframe = null;

  private final Random reuseableRandom = new Random();

  @Override
  public HandshakeState acceptHandshakeAsClient( ClientHandshake request, ServerHandshake response ) throws InvalidHandshakeException {
    if( !request.hasFieldValue( "Sec-WebSocket-Key" ) || !response.hasFieldValue( "Sec-WebSocket-Accept" ) )
      return HandshakeState.NOT_MATCHED;

    String seckey_answere = response.getFieldValue( "Sec-WebSocket-Accept" );
    String seckey_challenge = request.getFieldValue( "Sec-WebSocket-Key" );
    seckey_challenge = generateFinalKey( seckey_challenge );

    if( seckey_challenge.equals( seckey_answere ) )
      return HandshakeState.MATCHED;
    return HandshakeState.NOT_MATCHED;
  }

  @Override
  public HandshakeState acceptHandshakeAsServer( ClientHandshake handshakedata ) throws InvalidHandshakeException {
    // Sec-WebSocket-Origin is only required for browser clients
    int v = readVersion( handshakedata );
    if( v == 7 || v == 8 )// g
      return basicAccept( handshakedata ) ? HandshakeState.MATCHED : HandshakeState.NOT_MATCHED;
    return HandshakeState.NOT_MATCHED;
  }

  @Override
  public ByteBuffer createBinaryFrame( Framedata framedata ) {
    ByteBuffer mes = framedata.getPayloadData();
    boolean mask = role == Role.CLIENT; // framedata.getTransfereMasked();
    int sizebytes = mes.remaining() <= 125 ? 1 : mes.remaining() <= 65535 ? 2 : 8;
    ByteBuffer buf = ByteBuffer.allocate( 1 + ( sizebytes > 1 ? sizebytes + 1 : sizebytes ) + ( mask ? 4 : 0 ) + mes.remaining() );
    byte optcode = fromOpcode( framedata.getOpcode() );
    byte one = (byte) ( framedata.isFin() ? -128 : 0 );
    one |= optcode;
    buf.put( one );
    byte[] payloadlengthbytes = toByteArray( mes.remaining(), sizebytes );
    assert ( payloadlengthbytes.length == sizebytes );

    if( sizebytes == 1 ) {
      buf.put( (byte) ( (byte) payloadlengthbytes[ 0 ] | ( mask ? (byte) -128 : 0 ) ) );
    } else if( sizebytes == 2 ) {
      buf.put( (byte) ( (byte) 126 | ( mask ? (byte) -128 : 0 ) ) );
      buf.put( payloadlengthbytes );
    } else if( sizebytes == 8 ) {
      buf.put( (byte) ( (byte) 127 | ( mask ? (byte) -128 : 0 ) ) );
      buf.put( payloadlengthbytes );
    } else
      throw new RuntimeException( "Size representation not supported/specified" );

    if( mask ) {
      ByteBuffer maskkey = ByteBuffer.allocate( 4 );
      maskkey.putInt( reuseableRandom.nextInt() );
      buf.put( maskkey.array() );
      for( int i = 0 ; mes.hasRemaining() ; i++ ) {
        buf.put( (byte) ( mes.get() ^ maskkey.get( i % 4 ) ) );
      }
    } else
      buf.put( mes );
    // translateFrame ( buf.array () , buf.array ().length );
    assert ( buf.remaining() == 0 ) : buf.remaining();
    buf.flip();

    return buf;
  }

  @Override
  public List<Framedata> createFrames( ByteBuffer binary, boolean mask ) {
    FrameBuilder curframe = new FramedataImpl1();
    try {
      curframe.setPayload( binary );
    } catch ( InvalidDataException e ) {
      throw new NotSendableException( e );
    }
    curframe.setFin( true );
    curframe.setOptcode( Opcode.BINARY );
    curframe.setTransferemasked( mask );
    return Collections.singletonList( (Framedata) curframe );
  }

  @Override
  public List<Framedata> createFrames( String text, boolean mask ) {
    FrameBuilder curframe = new FramedataImpl1();
    try {
      curframe.setPayload( ByteBuffer.wrap( Charsetfunctions.utf8Bytes( text ) ) );
    } catch ( InvalidDataException e ) {
      throw new NotSendableException( e );
    }
    curframe.setFin( true );
    curframe.setOptcode( Opcode.TEXT );
    curframe.setTransferemasked( mask );
    return Collections.singletonList( (Framedata) curframe );
  }

  private byte fromOpcode( Opcode opcode ) {
    if( opcode == Opcode.CONTINUOUS )
      return 0;
    else if( opcode == Opcode.TEXT )
      return 1;
    else if( opcode == Opcode.BINARY )
      return 2;
    else if( opcode == Opcode.CLOSING )
      return 8;
    else if( opcode == Opcode.PING )
      return 9;
    else if( opcode == Opcode.PONG )
      return 10;
    throw new RuntimeException( "Don't know how to handle " + opcode.toString() );
  }

  private String generateFinalKey( String in ) {
    String seckey = in.trim();
    String acc = seckey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    MessageDigest sh1;
    try {
      sh1 = MessageDigest.getInstance( "SHA1" );
    } catch ( NoSuchAlgorithmException e ) {
      throw new RuntimeException( e );
    }
    return Base64.encodeBytes( sh1.digest( acc.getBytes() ) );
  }

  @Override
  public ClientHandshakeBuilder postProcessHandshakeRequestAsClient( ClientHandshakeBuilder request ) {
    request.put( "Upgrade", "websocket" );
    request.put( "Connection", "Upgrade" ); // to respond to a Connection keep alives
    request.put( "Sec-WebSocket-Version", "8" );

    byte[] random = new byte[ 16 ];
    reuseableRandom.nextBytes( random );
    request.put( "Sec-WebSocket-Key", Base64.encodeBytes( random ) );

    return request;
  }

  @Override
  public HandshakeBuilder postProcessHandshakeResponseAsServer( ClientHandshake request, ServerHandshakeBuilder response ) throws InvalidHandshakeException {
    response.put( "Upgrade", "websocket" );
    response.put( "Connection", request.getFieldValue( "Connection" ) ); // to respond to a Connection keep alives
    response.setHttpStatusMessage( "Switching Protocols" );
    String seckey = request.getFieldValue( "Sec-WebSocket-Key" );
    if( seckey == null )
      throw new InvalidHandshakeException( "missing Sec-WebSocket-Key" );
    response.put( "Sec-WebSocket-Accept", generateFinalKey( seckey ) );
    return response;
  }

  private byte[] toByteArray( long val, int bytecount ) {
    byte[] buffer = new byte[ bytecount ];
    int highest = 8 * bytecount - 8;
    for( int i = 0 ; i < bytecount ; i++ ) {
      buffer[ i ] = (byte) ( val >>> ( highest - 8 * i ) );
    }
    return buffer;
  }

  private Opcode toOpcode( byte opcode ) throws InvalidFrameException {
    switch ( opcode ) {
      case 0:
        return Opcode.CONTINUOUS;
      case 1:
        return Opcode.TEXT;
      case 2:
        return Opcode.BINARY;
        // 3-7 are not yet defined
      case 8:
        return Opcode.CLOSING;
      case 9:
        return Opcode.PING;
      case 10:
        return Opcode.PONG;
        // 11-15 are not yet defined
      default :
        throw new InvalidFrameException( "unknow optcode " + (short) opcode );
    }
  }

  @Override
  public List<Framedata> translateFrame( ByteBuffer buffer ) throws LimitExedeedException , InvalidDataException {
    List<Framedata> frames = new LinkedList<Framedata>();
    Framedata cur;

    if( incompleteframe != null ) {
      // complete an incomplete frame
      while ( true ) {
        try {
          buffer.mark();
          int available_next_byte_count = buffer.remaining();// The number of bytes received
          int expected_next_byte_count = incompleteframe.remaining();// The number of bytes to complete the incomplete frame

          if( expected_next_byte_count > available_next_byte_count ) {
            // did not receive enough bytes to complete the frame
            incompleteframe.put( buffer.array(), buffer.position(), available_next_byte_count );
            buffer.position( buffer.position() + available_next_byte_count );
            return Collections.emptyList();
          }
          incompleteframe.put( buffer.array(), buffer.position(), expected_next_byte_count );
          buffer.position( buffer.position() + expected_next_byte_count );

          cur = translateSingleFrame( (ByteBuffer) incompleteframe.duplicate().position( 0 ) );
          frames.add( cur );
          incompleteframe = null;
          break; // go on with the normal frame receival
        } catch ( IncompleteException e ) {
          // extending as much as suggested
          int oldsize = incompleteframe.limit();
          ByteBuffer extendedframe = ByteBuffer.allocate( checkAlloc( e.getPreferedSize() ) );
          assert ( extendedframe.limit() > incompleteframe.limit() );
          incompleteframe.rewind();
          extendedframe.put( incompleteframe );
          incompleteframe = extendedframe;
          
          return translateFrame( buffer );
        }
      }
    }

    while ( buffer.hasRemaining() ) {// Read as much as possible full frames
      buffer.mark();
      try {
        cur = translateSingleFrame( buffer );
        frames.add( cur );
      } catch ( IncompleteException e ) {
        // remember the incomplete data
        buffer.reset();
        int pref = e.getPreferedSize();
        incompleteframe = ByteBuffer.allocate( checkAlloc( pref ) );
        incompleteframe.put( buffer );
        break;
      }
    }
    return frames;
  }

  public Framedata translateSingleFrame( ByteBuffer buffer ) throws IncompleteException , InvalidDataException {
    int maxpacketsize = buffer.remaining();
    int realpacketsize = 2;
    if( maxpacketsize < realpacketsize )
      throw new IncompleteException( realpacketsize );
    byte b1 = buffer.get( /*0*/);
    boolean FIN = b1 >> 8 != 0;
    byte rsv = (byte) ( ( b1 & ~(byte) 128 ) >> 4 );
    if( rsv != 0 )
      throw new InvalidFrameException( "bad rsv " + rsv );
    byte b2 = buffer.get( /*1*/);
    boolean MASK = ( b2 & -128 ) != 0;
    int payloadlength = (byte) ( b2 & ~(byte) 128 );
    Opcode optcode = toOpcode( (byte) ( b1 & 15 ) );

    if( !FIN ) {
      if( optcode == Opcode.PING || optcode == Opcode.PONG || optcode == Opcode.CLOSING ) {
        throw new InvalidFrameException( "control frames may no be fragmented" );
      }
    }

    if( payloadlength >= 0 && payloadlength <= 125 ) {
    } else {
      if( optcode == Opcode.PING || optcode == Opcode.PONG || optcode == Opcode.CLOSING ) {
        throw new InvalidFrameException( "more than 125 octets" );
      }
      if( payloadlength == 126 ) {
        realpacketsize += 2; // additional length bytes
        if( maxpacketsize < realpacketsize )
          throw new IncompleteException( realpacketsize );
        byte[] sizebytes = new byte[ 3 ];
        sizebytes[ 1 ] = buffer.get( /*1 + 1*/);
        sizebytes[ 2 ] = buffer.get( /*1 + 2*/);
        payloadlength = new BigInteger( sizebytes ).intValue();
      } else {
        realpacketsize += 8; // additional length bytes
        if( maxpacketsize < realpacketsize )
          throw new IncompleteException( realpacketsize );
        byte[] bytes = new byte[ 8 ];
        for( int i = 0 ; i < 8 ; i++ ) {
          bytes[ i ] = buffer.get( /*1 + i*/);
        }
        long length = new BigInteger( bytes ).longValue();
        if( length > Integer.MAX_VALUE ) {
          throw new LimitExedeedException( "Payloadsize is to big..." );
        } else {
          payloadlength = (int) length;
        }
      }
    }

    // int maskskeystart = foff + realpacketsize;
    realpacketsize += ( MASK ? 4 : 0 );
    // int payloadstart = foff + realpacketsize;
    realpacketsize += payloadlength;

    if( maxpacketsize < realpacketsize )
      throw new IncompleteException( realpacketsize );

    ByteBuffer payload = ByteBuffer.allocate( checkAlloc( payloadlength ) );
    if( MASK ) {
      byte[] maskskey = new byte[ 4 ];
      buffer.get( maskskey );
      for( int i = 0 ; i < payloadlength ; i++ ) {
        payload.put( (byte) ( (byte) buffer.get( /*payloadstart + i*/) ^ (byte) maskskey[ i % 4 ] ) );
      }
    } else {
      payload.put( buffer.array(), buffer.position(), payload.limit() );
      buffer.position( buffer.position() + payload.limit() );
    }

    FrameBuilder frame;
    if( optcode == Opcode.CLOSING ) {
      frame = new CloseFrameBuilder();
    } else {
      frame = new FramedataImpl1();
      frame.setFin( FIN );
      frame.setOptcode( optcode );
    }
    payload.flip();
    frame.setPayload( payload );
    return frame;
  }

  @Override
  public void reset() {
    incompleteframe = null;
  }

  @Override
  public Draft copyInstance() {
    return new Draft_10();
  }

  @Override
  public CloseHandshakeType getCloseHandshakeType() {
    return CloseHandshakeType.TWOWAY;
  }
}




Java Source Code List

com.example.android.wifidirect.DeviceDetailFragment.java
com.example.android.wifidirect.DeviceListFragment.java
com.example.android.wifidirect.FileTransferService.java
com.example.android.wifidirect.WiFiDirectActivity.java
com.example.android.wifidirect.WiFiDirectBroadcastReceiver.java
com.example.android.wifidirect.discovery.ChatManager.java
com.example.android.wifidirect.discovery.ClientSocketHandler.java
com.example.android.wifidirect.discovery.GroupOwnerSocketHandler.java
com.example.android.wifidirect.discovery.WiFiChatFragment.java
com.example.android.wifidirect.discovery.WiFiDirectBroadcastReceiver.java
com.example.android.wifidirect.discovery.WiFiDirectServicesList.java
com.example.android.wifidirect.discovery.WiFiP2pService.java
com.example.android.wifidirect.discovery.WiFiServiceDiscoveryActivity.java
com.example.opengles.CubeRenderer.java
com.example.opengles.Cube.java
com.example.opengles.MainActivity.java
com.example.opengles.Planet.java
com.example.opengles.SolarSystemRenderer.java
com.example.opengles.SquareRenderer.java
com.example.opengles.Square.java
com.nfg.sdk.NFGameServer.java
com.nfg.sdk.NFGame.java
com.nfg.wifidirect3p.ChatActivity.java
com.nfg.wifidirect3p.WifiDirect3PActivity.java
fi.iki.elonen.HelloServer.java
fi.iki.elonen.HelloServer.java
fi.iki.elonen.IWebSocketFactory.java
fi.iki.elonen.InternalRewrite.java
fi.iki.elonen.InternalRewrite.java
fi.iki.elonen.NanoHTTPD.java
fi.iki.elonen.NanoHTTPD.java
fi.iki.elonen.NanoWebSocketServer.java
fi.iki.elonen.ServerRunner.java
fi.iki.elonen.ServerRunner.java
fi.iki.elonen.SimpleWebServer.java
fi.iki.elonen.SimpleWebServer.java
fi.iki.elonen.TempFilesServer.java
fi.iki.elonen.TempFilesServer.java
fi.iki.elonen.WebServerPluginInfo.java
fi.iki.elonen.WebServerPluginInfo.java
fi.iki.elonen.WebServerPlugin.java
fi.iki.elonen.WebServerPlugin.java
fi.iki.elonen.WebSocketException.java
fi.iki.elonen.WebSocketFrame.java
fi.iki.elonen.WebSocketResponseHandler.java
fi.iki.elonen.WebSocket.java
fi.iki.elonen.debug.DebugServer.java
fi.iki.elonen.debug.DebugServer.java
fi.iki.elonen.samples.echo.DebugWebSocketServer.java
fi.iki.elonen.samples.echo.DebugWebSocket.java
fi.iki.elonen.samples.echo.EchoSocketSample.java
org.java_websocket.AbstractWrappedByteChannel.java
org.java_websocket.SSLSocketChannel2.java
org.java_websocket.SocketChannelIOHelper.java
org.java_websocket.WebSocketAdapter.java
org.java_websocket.WebSocketFactory.java
org.java_websocket.WebSocketImpl.java
org.java_websocket.WebSocketListener.java
org.java_websocket.WebSocket.java
org.java_websocket.WrappedByteChannel.java
org.java_websocket.client.AbstractClientProxyChannel.java
org.java_websocket.client.WebSocketClient.java
org.java_websocket.drafts.Draft_10.java
org.java_websocket.drafts.Draft_17.java
org.java_websocket.drafts.Draft_75.java
org.java_websocket.drafts.Draft_76.java
org.java_websocket.drafts.Draft.java
org.java_websocket.exceptions.IncompleteHandshakeException.java
org.java_websocket.exceptions.InvalidDataException.java
org.java_websocket.exceptions.InvalidFrameException.java
org.java_websocket.exceptions.InvalidHandshakeException.java
org.java_websocket.exceptions.LimitExedeedException.java
org.java_websocket.exceptions.NotSendableException.java
org.java_websocket.exceptions.WebsocketNotConnectedException.java
org.java_websocket.framing.CloseFrameBuilder.java
org.java_websocket.framing.CloseFrame.java
org.java_websocket.framing.FrameBuilder.java
org.java_websocket.framing.FramedataImpl1.java
org.java_websocket.framing.Framedata.java
org.java_websocket.handshake.ClientHandshakeBuilder.java
org.java_websocket.handshake.ClientHandshake.java
org.java_websocket.handshake.HandshakeBuilder.java
org.java_websocket.handshake.HandshakeImpl1Client.java
org.java_websocket.handshake.HandshakeImpl1Server.java
org.java_websocket.handshake.HandshakedataImpl1.java
org.java_websocket.handshake.Handshakedata.java
org.java_websocket.handshake.ServerHandshakeBuilder.java
org.java_websocket.handshake.ServerHandshake.java
org.java_websocket.server.DefaultSSLWebSocketServerFactory.java
org.java_websocket.server.DefaultWebSocketServerFactory.java
org.java_websocket.server.WebSocketServer.java
org.java_websocket.util.Base64.java
org.java_websocket.util.Charsetfunctions.java