Java HandshakeStatus.NEED_TASK屬性代碼示例

private void runDelegatedTasks(SSLEngineResult result) throws IOException {
	if(logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
		logger.logDebug("Running delegated task for " + result);
	}

	/*
	 *  Delegated tasks are just invisible steps inside the sslEngine state machine.
	 *  Call them every time they have NEED_TASK otherwise the sslEngine won't make progress
	 */
	if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
		Runnable runnable;
		while ((runnable = sslEngine.getDelegatedTask()) != null) {
			runnable.run();
		}
		HandshakeStatus hsStatus = sslEngine.getHandshakeStatus();
		if(logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
			logger.logDebug("Handshake status after delegated tasks " + hsStatus);
		}
		if (hsStatus == HandshakeStatus.NEED_TASK) {
			throw new IOException(
					"handshake shouldn't need additional tasks");
		}
	}
}
 

/**
* Performs the WRAP function
* @param doWrite boolean
* @return SSLEngineResult
* @throws IOException
*/
private SSLEngineResult handshakeWrap(boolean doWrite) throws IOException {
    log.trace("SSLHandshake handshakeWrap {}", channelId);
    if (netWriteBuffer.hasRemaining())
        throw new IllegalStateException("handshakeWrap called with netWriteBuffer not empty");
    //this should never be called with a network buffer that contains data
    //so we can clear it here.
    netWriteBuffer.clear();
    SSLEngineResult result = sslEngine.wrap(emptyBuf, netWriteBuffer);
    //prepare the results to be written
    netWriteBuffer.flip();
    handshakeStatus = result.getHandshakeStatus();
    if (result.getStatus() == SSLEngineResult.Status.OK &&
        result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
        handshakeStatus = runDelegatedTasks();
    }

    if (doWrite) flush(netWriteBuffer);
    return result;
}
 

/**
* Perform handshake unwrap
* @param doRead boolean
* @return SSLEngineResult
* @throws IOException
*/
private SSLEngineResult handshakeUnwrap(boolean doRead) throws IOException {
    log.trace("SSLHandshake handshakeUnwrap {}", channelId);
    SSLEngineResult result;
    if (doRead)  {
        int read = socketChannel.read(netReadBuffer);
        if (read == -1) throw new EOFException("EOF during handshake.");
    }
    boolean cont;
    do {
        //prepare the buffer with the incoming data
        netReadBuffer.flip();
        result = sslEngine.unwrap(netReadBuffer, appReadBuffer);
        netReadBuffer.compact();
        handshakeStatus = result.getHandshakeStatus();
        if (result.getStatus() == SSLEngineResult.Status.OK &&
            result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
            handshakeStatus = runDelegatedTasks();
        }
        cont = result.getStatus() == SSLEngineResult.Status.OK &&
            handshakeStatus == HandshakeStatus.NEED_UNWRAP;
        log.trace("SSLHandshake handshakeUnwrap: handshakeStatus {} status {}", handshakeStatus, result.getStatus());
    } while (netReadBuffer.position() != 0 && cont);

    return result;
}
 

public ByteBuf unwrap(SocketChannel channel, ByteBuf src) throws IOException {
    SSLEngine sslEngine = channel.getSSLEngine();
    ByteBuf dst = getTempDst(sslEngine);
    for (;;) {
        dst.clear();
        SSLEngineResult result = sslEngine.unwrap(src.nioBuffer(), dst.nioBuffer());
        HandshakeStatus handshakeStatus = result.getHandshakeStatus();
        synchByteBuf(result, src, dst);
        if (handshakeStatus != HandshakeStatus.NOT_HANDSHAKING) {
            if (handshakeStatus == HandshakeStatus.NEED_WRAP) {
                channel.doFlush(forgeFuture.duplicate());
                return null;
            } else if (handshakeStatus == HandshakeStatus.NEED_TASK) {
                runDelegatedTasks(sslEngine);
                continue;
            } else if (handshakeStatus == HandshakeStatus.FINISHED) {
                channel.finishHandshake(null);
                return null;
            } else if (handshakeStatus == HandshakeStatus.NEED_UNWRAP) {
                return null;
            }
        }
        return gc(channel, dst.flip());
    }
}
 

/**
 * Produce more handshake output. This is called in response to a
 * call to {@link javax.net.ssl.SSLEngine#wrap}, when the handshake
 * is still in progress.
 *
 * @param record The output record; the callee should put its output
 * handshake message (or a part of it) in the argument's
 * <code>fragment</code>, and should set the record length
 * appropriately.
 * @return An {@link SSLEngineResult} describing the result.
 */
public final HandshakeStatus handleOutput (ByteBuffer fragment)
  throws SSLException
{
  if (!tasks.isEmpty())
    return HandshakeStatus.NEED_TASK;

  int orig = fragment.position();
  SSLEngineResult.HandshakeStatus status = implHandleOutput(fragment);
  if (doHash())
    {
      if (Debug.DEBUG)
        logger.logv(Component.SSL_HANDSHAKE, "hashing output:\n{0}",
                    Util.hexDump((ByteBuffer) fragment.duplicate().flip().position(orig), " >> "));
      sha.update((ByteBuffer) fragment.duplicate().flip().position(orig));
      md5.update((ByteBuffer) fragment.duplicate().flip().position(orig));
    }
  return status;
}
 

private void runDelegatedTasks(SSLEngineResult result)
{
    if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK)
    {
        Runnable runnable;
        while ((runnable = _sslEngine.getDelegatedTask()) != null)
        {
            runnable.run();
        }

        HandshakeStatus hsStatus = _sslEngine.getHandshakeStatus();
        if (hsStatus == HandshakeStatus.NEED_TASK)
        {
            throw new RuntimeException("handshake shouldn't need additional tasks");
        }
    }
}
 

private static void runDelegatedTasks(SSLEngineResult result,
		SSLEngine engine) throws Exception {

	if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
		Runnable runnable;
		while ((runnable = engine.getDelegatedTask()) != null) {
			log("\trunning delegated task...");
			runnable.run();
		}
		HandshakeStatus hsStatus = engine.getHandshakeStatus();
		if (hsStatus == HandshakeStatus.NEED_TASK) {
			throw new Exception("handshake shouldn't need additional tasks");
		}
		log("\tnew HandshakeStatus: " + hsStatus);
	}
}
 

/**
 * Attempts to decode SSL/TLS network data into a subsequence of plaintext application data
 * buffers. Depending on the state of the TLSWrapper, this method may consume network data
 * without producing any application data (for example, it may consume handshake data.)
 *
 * If this TLSWrapper has not yet started its initial handshake, this method will automatically
 * start the handshake.
 *
 * @param net a ByteBuffer containing inbound network data
 * @param app a ByteBuffer to hold inbound application data
 * @return a ByteBuffer containing inbound application data
 * @throws SSLException A problem was encountered while processing the data that caused the
 *             TLSHandler to abort.
 */
public ByteBuffer unwrap(ByteBuffer net, ByteBuffer app) throws SSLException {
    ByteBuffer out = app;
    out = resizeApplicationBuffer(out);// guarantees enough room for unwrap
    try {
        tlsEngineResult = tlsEngine.unwrap( net, out );
    } catch ( SSLException e ) {
        if ( e.getMessage().startsWith( "Unsupported record version Unknown-" ) ) {
            throw new SSLException( "We appear to have received plain text data where we expected encrypted data. A common cause for this is a peer sending us a plain-text error message when it shouldn't send a message, but close the socket instead).", e );
        }
        else {
            throw e;
        }
    }
    log("server unwrap: ", tlsEngineResult);
    if (tlsEngineResult.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
        // If the result indicates that we have outstanding tasks to do, go
        // ahead and run them in this thread.
        doTasks();
    }
    return out;
}
 

/**
 * Method description
 * 
 * 
 * @param app
 * @param net
 * 
 * @throws SSLException
 */
public void wrap(ByteBuffer app, ByteBuffer net) throws SSLException {
	tlsEngineResult = tlsEngine.wrap(app, net);
	if (log.isLoggable(Level.FINEST)) {
		log.log(Level.FINEST, "{0}, tlsEngineRsult.getStatus() = {1}, tlsEngineRsult.getHandshakeStatus() = {2}",
				new Object[] { debugId, tlsEngineResult.getStatus(), tlsEngineResult.getHandshakeStatus() });
	}

	if (tlsEngineResult.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.FINISHED) {
		if (eventHandler != null) {
			eventHandler.handshakeCompleted(this);
		}
	}

	if (tlsEngineResult.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
		doTasks();

		if (log.isLoggable(Level.FINEST)) {
			log.log(Level.FINEST, "doTasks(): {0}, {1}", new Object[] { tlsEngine.getHandshakeStatus(), debugId });
		}
	}
}
 

/**
 * Perform handshake unwrap
 * @param doread boolean
 * @return SSLEngineResult
 * @throws IOException
 */
protected SSLEngineResult handshakeUnwrap(boolean doread) throws IOException {

    if (netInBuffer.position() == netInBuffer.limit()) {
        //clear the buffer if we have emptied it out on data
        netInBuffer.clear();
    }
    if ( doread )  {
        //if we have data to read, read it
        int read = sc.read(netInBuffer);
        if (read == -1) throw new IOException("EOF encountered during handshake.");
    }
    SSLEngineResult result;
    boolean cont = false;
    //loop while we can perform pure SSLEngine data
    do {
        //prepare the buffer with the incoming data
        netInBuffer.flip();
        //call unwrap
        result = sslEngine.unwrap(netInBuffer, bufHandler.getReadBuffer());
        //compact the buffer, this is an optional method, wonder what would happen if we didn't
        netInBuffer.compact();
        //read in the status
        handshakeStatus = result.getHandshakeStatus();
        if ( result.getStatus() == SSLEngineResult.Status.OK &&
             result.getHandshakeStatus() == HandshakeStatus.NEED_TASK ) {
            //execute tasks if we need to
            handshakeStatus = tasks();
        }
        //perform another unwrap?
        cont = result.getStatus() == SSLEngineResult.Status.OK &&
               handshakeStatus == HandshakeStatus.NEED_UNWRAP;
    }while ( cont );
    return result;
}
 

private static void runDelegatedTasks(SSLEngine engine) {
    Runnable runnable;
    System.out.println("Running delegated tasks...");
    while ((runnable = engine.getDelegatedTask()) != null) {
        runnable.run();
    }
    HandshakeStatus hs = engine.getHandshakeStatus();
    if (hs == HandshakeStatus.NEED_TASK) {
        throw new Error("Handshake shouldn't need additional tasks.");
    }
}
 

/**
 * Perform handshake unwrap
 * 
 * @param doread
 *            boolean
 * @return SSLEngineResult
 * @throws IOException
 */
protected SSLEngineResult handshakeUnwrap(boolean doread) throws IOException {

	if (netInBuffer.position() == netInBuffer.limit()) {
		// clear the buffer if we have emptied it out on data
		netInBuffer.clear();
	}
	if (doread) {
		// if we have data to read, read it
		int read = sc.read(netInBuffer);
		if (read == -1)
			throw new IOException("EOF encountered during handshake.");
	}
	SSLEngineResult result;
	boolean cont = false;
	// loop while we can perform pure SSLEngine data
	do {
		// prepare the buffer with the incoming data
		netInBuffer.flip();
		// call unwrap
		result = sslEngine.unwrap(netInBuffer, bufHandler.getReadBuffer());
		// compact the buffer, this is an optional method, wonder what would
		// happen if we didn't
		netInBuffer.compact();
		// read in the status
		handshakeStatus = result.getHandshakeStatus();
		if (result.getStatus() == SSLEngineResult.Status.OK
				&& result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
			// execute tasks if we need to
			handshakeStatus = tasks();
		}
		// perform another unwrap?
		cont = result.getStatus() == SSLEngineResult.Status.OK && handshakeStatus == HandshakeStatus.NEED_UNWRAP;
	} while (cont);
	return result;
}
 

/**
* Perform handshake unwrap
* @param doRead boolean
* @return SSLEngineResult
* @throws IOException
*/
private SSLEngineResult handshakeUnwrap(boolean doRead) throws IOException {
    log.trace("SSLHandshake handshakeUnwrap {}", channelId);
    SSLEngineResult result;
    boolean cont = false;
    int read = 0;
    if (doRead)  {
        read = socketChannel.read(netReadBuffer);
        if (read == -1) throw new EOFException("EOF during handshake.");
    }
    do {
        //prepare the buffer with the incoming data
        netReadBuffer.flip();
        result = sslEngine.unwrap(netReadBuffer, appReadBuffer);
        netReadBuffer.compact();
        handshakeStatus = result.getHandshakeStatus();
        if (result.getStatus() == SSLEngineResult.Status.OK &&
            result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
            handshakeStatus = runDelegatedTasks();
        }
        cont = result.getStatus() == SSLEngineResult.Status.OK &&
            handshakeStatus == HandshakeStatus.NEED_UNWRAP;
        log.trace("SSLHandshake handshakeUnwrap: handshakeStatus {} status {}", handshakeStatus, result.getStatus());
    } while (netReadBuffer.position() != 0 && cont);

    return result;
}
 

@Override HandshakeStatus status()
{
  if (!tasks.isEmpty())
    return HandshakeStatus.NEED_TASK;
  if (state.isReadState())
    return HandshakeStatus.NEED_UNWRAP;
  if (state.isWriteState())
    return HandshakeStatus.NEED_WRAP;

  return HandshakeStatus.FINISHED;
}
 

public static boolean handShakeWrapIfNeeded(SSLConnection cc, Pipe<NetPayloadSchema> target, ByteBuffer buffer, boolean isServer, long arrivalTime) {
					
	 HandshakeStatus handshakeStatus = cc.getEngine().getHandshakeStatus();

	 boolean didShake = false;
	 while (HandshakeStatus.NOT_HANDSHAKING != handshakeStatus && HandshakeStatus.FINISHED != handshakeStatus	 ) {

		 didShake = true;
		 if (HandshakeStatus.NEED_UNWRAP == handshakeStatus) {				 
			 if (cc.durationWaitingForNetwork() > HANDSHAKE_TIMEOUT) {
				
				 logger.warn("Handshake wrap abanonded for {} due to timeout of {} ms waiting for unwrap done by reading stage.",cc,HANDSHAKE_TIMEOUT/1000000);
				 cc.close();	
			 }
			 return true;//done by the other stage.
		 }
		 
		 if (HandshakeStatus.NEED_WRAP == handshakeStatus) {				 
			 SSLUtil.handshakeWrapLogic(cc, target, buffer, isServer, arrivalTime);
			 handshakeStatus = cc.getEngine().getHandshakeStatus();				
		 }
		 
		 if (HandshakeStatus.NEED_TASK == handshakeStatus) {
             Runnable task;
             while ((task = cc.getEngine().getDelegatedTask()) != null) {
                	task.run(); //NOTE: could be run in parallel but we only have 1 thread now
             }
             handshakeStatus = cc.getEngine().getHandshakeStatus();
                
            //return (HandshakeStatus.NOT_HANDSHAKING != handshakeStatus) && (HandshakeStatus.FINISHED != handshakeStatus);
		 }
	 }
	 cc.clearWaitingForNetwork();
	
	 // logger.info("server {} wrap status is now {} for id {} ",isServer,handshakeStatus, cc.getId());
	 
	 return didShake;
 
}