HandShakeStatus

Question

I write a NIO Server program with SSL(JSSE).I encount some problem in here.
SSLEngineResult res = sslEngine.wrap(////);
HandshakeStatus hs = res.getHandshakeStatus();
HandshakeStatus hs2 = engine.getHandshakeStatus();
in my program ,hs = FINISH but hs2=NOT_HANDSHAKE,why it isn't same value? and why my program get a NOT_HANDSHAKE status?
my program :
package cn.com.infosec.isfw2.sfw;
import java.io.EOFException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLEngineResult;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLEngineResult.HandshakeStatus;
import javax.net.ssl.SSLEngineResult.Status;
import com.sun.corba.se.pept.transport.OutboundConnectionCache;
import cn.com.infosec.isfw2.impl.DefaultProtocolHandler;
public class SSLSession extends SocketSession {
     private SocketChannel channel;
     private IOFilterChain filters;
     private ByteBuffer buffer = null;
     private Selector selector;
     //     private HashMap<String, Object> attributes;
     private SSLEngine sslEngine;
     private ProtocolHandler protocolHandler = null;
     private ByteBuffer inNetBuffer;
     private ByteBuffer outNetBuffer;
     // * Applicaton cleartext data to be read by application
     // private IoBuffer appBuffer;
     * Empty buffer used during initial handshake and close operations
     private final ByteBuffer emptyBuffer = ByteBuffer.allocate(0);
     private SSLEngineResult.HandshakeStatus handshakeStatus;
     private boolean initialHandshakeComplete;
     private boolean handshakeComplete;
     public SSLSession(SocketChannel channel, Selector sel, IOFilterChain chain) {
          super(channel, sel, chain);
          this.channel = channel;
          this.filters = chain;
          this.selector = sel;
          buffer = null;
          //          attributes = null;
          filters.SessionCreate(this);
          System.out.println("----create ssl session--------");
          System.out.println("create session,channel=" + this.channel);
     public void read() throws IOException {
          if (buffer == null) {
               buffer = ByteBuffer.allocate(8192);
          if (buffer.position() == buffer.capacity()) {
               adjustBuffer(2 * buffer.capacity());
          int readbytes = 0;
          int ret = 0;
          while (true) {
               ret = read0();
               System.out.println("buffer=" + buffer);
               if (ret > 0) {
                    readbytes += ret;
                    if (buffer.position() == buffer.capacity()) {
                         adjustBuffer(2 * buffer.capacity());
                         System.out.println(Thread.currentThread().getName()
                                   + " session " + this + " channel " + channel
                                   + " buffer=" + buffer + " buffer is full " + " "
                                   + System.nanoTime());
               } else if (ret == 0) {
                    break;
               } else {
                    throw new EOFException("peer connection close.");
          if (protocolHandler == null) {
               protocolHandler = new DefaultProtocolHandler();
          if (protocolHandler.isAllDataRecved(buffer)) {
               final SocketSession s = this;
               try {
                    Runnable r = new Runnable() {
                         public void run() {
                              filters.DataReceived(s);
                    System.out.println(channel.socket().getInetAddress());
                    //if(channel.socket().getInetAddress().isAnyLocalAddress()){
                    Socket s1 = channel.socket();
                    if (s1.getInetAddress().isLoopbackAddress()) {
                         System.out.println("---is local----");
                         new Thread(r).start();
                    } else {
                         ExcuterManager.parserExe.execute(r);
               } catch (Throwable e) {
                    this.close();
          } else {
               continueRead();
     public SocketChannel getChannel() {
          return channel;
     public ByteBuffer getBuffer() {
          return buffer;
     public void continueRead() throws IOException {
          channel.register(selector, SelectionKey.OP_READ, this);
     public void adjustBuffer(int len) {
          if (len > buffer.position()) {
               ByteBuffer newBuffer = ByteBuffer.allocate(len);
               buffer.flip();
               newBuffer.put(buffer);
               buffer = newBuffer;
     //     public void sendData(ByteBuffer buff) throws IOException{
     //          buffer.clear();
     //          continueRead();
     //          OutputWriter.flushChannel(channel, buff);
     public ProtocolHandler getProtocolHandler() {
          return protocolHandler;
     public void setProtocolHandler(ProtocolHandler protocolHandler) {
          this.protocolHandler = protocolHandler;
     public void close() {
          buffer = null;
          filters = null;
          try {
               channel.close();
          } catch (Throwable e) {
          channel = null;
          selector = null;
          protocolHandler = null;
          //          attributes = null;
     public void setSslc(SSLContext sslc) {
          this.sslEngine = sslc.createSSLEngine();
          System.out.println("setsslc,sslengine=" + sslEngine);
          sslEngine.setUseClientMode(false);
          sslEngine.setNeedClientAuth(false);
          sslEngine.setWantClientAuth(false);
//          SSLSession session1 = sslEngine.getSession();
          //ByteBuffer myAppData = ByteBuffer.allocate(sslEngine.getSession().getApplicationBufferSize());
          ByteBuffer myNetData = ByteBuffer.allocate(sslEngine.getSession().getPacketBufferSize());
          ByteBuffer peerNetData = ByteBuffer.allocate(sslEngine.getSession().getPacketBufferSize());
          try {
               doHandshake(channel,sslEngine,myNetData,peerNetData);
          } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          HandshakeStatus hs = sslEngine.getHandshakeStatus();
          System.out.println("in setsslcontext,shakehand status=" + hs);
          //writingEncryptedData = false;
     public SSLEngine getSslEngine() {
          return sslEngine;
     public int read0() throws IOException {
          int dd = channel.read(inNetBuffer);
          SSLEngineResult res = sslEngine.unwrap(inNetBuffer, buffer);
          System.out.println("in read0,status=" + res);
          return dd;
     public void sendData(ByteBuffer buff) throws IOException {
          //sslEngine.wrap(buff, outNetBuffer);
          OutputWriter.flushChannel(channel, outNetBuffer);
     void doHandshake(SocketChannel socketChannel, SSLEngine engine,
     ByteBuffer myNetData, ByteBuffer peerNetData) throws Exception {
     int appBufferSize = engine.getSession().getApplicationBufferSize();
     ByteBuffer myAppData = ByteBuffer.allocate(appBufferSize);
     ByteBuffer peerAppData = ByteBuffer.allocate(appBufferSize);
     // Begin handshake
     engine.beginHandshake();
     SSLEngineResult.HandshakeStatus hs = engine.getHandshakeStatus();
     // Process handshaking message
     while ((hs = engine.getHandshakeStatus()) != SSLEngineResult.HandshakeStatus.FINISHED &&
     (hs = engine.getHandshakeStatus()) != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
     switch (hs) {
     case NEED_UNWRAP:
     // Receive handshaking data from peer
     if (socketChannel.read(peerNetData) < 0) {
     // Handle closed channel
     // Process incoming handshaking data
     peerNetData.flip();
     SSLEngineResult res = engine.unwrap(peerNetData, peerAppData);
     peerNetData.compact();
     hs = res.getHandshakeStatus();
     // Check status
     switch (res.getStatus()) {
     case OK :
//     if( hs == SSLEngineResult.HandshakeStatus.FINISHED ){
//          break myio;
     break;
     case BUFFER_OVERFLOW:
          System.out.println("---------overflow-------");
          break;
     case BUFFER_UNDERFLOW:
          System.out.println("---------underflow-------");
          break;
     // Handle other status: BUFFER_UNDERFLOW, BUFFER_OVERFLOW, CLOSED
     break;
     case NEED_WRAP :
     // Empty the local network packet buffer.
     myNetData.clear();
     // Generate handshaking data
     res = engine.wrap(myAppData, myNetData);
     hs = res.getHandshakeStatus();
     //HandshakeStatus hs2 = engine.getHandshakeStatus();
     // Check status
     switch (res.getStatus()) {
     case OK :
//     if( hs == SSLEngineResult.HandshakeStatus.FINISHED ){
//          break myio;
     myNetData.flip();
     // Send the handshaking data to peer
     while (myNetData.hasRemaining()) {
     if (socketChannel.write(myNetData) < 0) {
     // Handle closed channel
     break;
     // Handle other status: BUFFER_OVERFLOW, BUFFER_UNDERFLOW, CLOSED
     break;
     case NEED_TASK :
          new Thread( sslEngine.getDelegatedTask() ).start();
          // Handle blocking tasks
     break;
     // Handle other status: // FINISHED or NOT_HANDSHAKING
     // Processes after handshaking
}

Answer 1

I write a NIO Server program with SSL(JSSE).You have tackled a seriously difficult problem.
in my program ,hs = FINISH but hs2=NOT_HANDSHAKEYou mean NOT_HANDSHAKING.
why it isn't same value?Because FINISHED is only delivered once. See the Javadoc.