/** * Calls {@link #handshake()} once the {@link Channel} is connected */ @Override public void channelConnected(final ChannelHandlerContext ctx, final ChannelStateEvent e) throws Exception { if (issueHandshake) { // issue and handshake and add a listener to it which will fire an exception event if // an exception was thrown while doing the handshake handshake().addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { // Send the event upstream after the handshake was completed without an error. // // See https://github.com/netty/netty/issues/358 ctx.sendUpstream(e); } } }); } else { super.channelConnected(ctx, e); } }
sslHandler.handshake().addListener( new ChannelFutureListener()
handshake(); } else {
sslHandshakeFuture = sslHandler.handshake();
private void onFutureSuccess(final Channel channel) throws ConnectException { SslHandler sslHandler = channel.getPipeline().get(SslHandler.class); if (sslHandler != null) { sslHandler.handshake().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture handshakeFuture) throws Exception { if (handshakeFuture.isSuccess()) { final AsyncHandler<T> asyncHandler = future.getAsyncHandler(); if (asyncHandler instanceof AsyncHandlerExtensions) AsyncHandlerExtensions.class.cast(asyncHandler).onSslHandshakeCompleted(); writeRequest(channel); } else { onFutureFailure(channel, handshakeFuture.getCause()); } } }); } else { writeRequest(channel); } }
@Override public ChannelFuture handshake() { synchronized (this) { hasHandshook = true; return handshakeFuture = super.handshake(); } } }
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { LOGGER.debug("Starting SSL/TLS client (Initiator) handshake."); sslHandler.handshake(); p.remove("sslHandshaker"); super.channelConnected(ctx, e); } });
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class); sslHandler.handshake().addListener(HANDSHAKE_LISTENER); }
private void onFutureSuccess(final Channel channel) throws ConnectException { SslHandler sslHandler = channel.getPipeline().get(SslHandler.class); if (sslHandler != null) { sslHandler.handshake().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture handshakeFuture) throws Exception { if (handshakeFuture.isSuccess()) { final AsyncHandler<T> asyncHandler = future.getAsyncHandler(); if (asyncHandler instanceof AsyncHandlerExtensions) AsyncHandlerExtensions.class.cast(asyncHandler).onSslHandshakeCompleted(); writeRequest(channel); } else { onFutureFailure(channel, handshakeFuture.getCause()); } } }); } else { writeRequest(channel); } }
@Override public void operationComplete(ChannelFuture future) throws Exception { CallbackConnectionListener callbackConnectionListener = new CallbackConnectionListener(remoteAddress, connectionCallback, openChannels); if (future.isSuccess()) { SSLParameters sslParameters = new SSLParameters(); sslParameters.setEndpointIdentificationAlgorithm("HTTPS"); SSLEngine sslEngine = SSLContext.getDefault().createSSLEngine(remoteAddress.getHostString(), remoteAddress.getPort()); sslEngine.setSSLParameters(sslParameters); sslEngine.setUseClientMode(true); SslHandler sslHandler = new SslHandler(sslEngine); future.getChannel().getPipeline().addBefore("codec", "ssl", sslHandler); ChannelFuture handshakeFuture = sslHandler.handshake(); handshakeFuture.addListener(callbackConnectionListener); } else { callbackConnectionListener.operationComplete(future); } } }
sslHandler.handshake().addListener( new ChannelFutureListener()
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.setAttachment(e.getValue()); // Get the SslHandler in the current pipeline. SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class); sslHandler.setEnableRenegotiation(false); // Get notified when SSL handshake is done. ChannelFuture handshakeFuture = sslHandler.handshake(); handshakeFuture.addListener(new SslListener()); }
public void operationComplete(ChannelFuture channelFuture) throws Exception { final NioSocketChannel ch = (NioSocketChannel) channelFuture.getChannel(); if (channelFuture.isSuccess()) { if (tcpHelper.isSSL()) { // TCP connected, so now we must do the SSL handshake SslHandler sslHandler = (SslHandler)ch.getPipeline().get("ssl"); ChannelFuture fut = sslHandler.handshake(); fut.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture channelFuture) throws Exception { if (channelFuture.isSuccess()) { connected(ch, connectHandler); } else { failed(ch, connectErrorHandler, new SSLHandshakeException("Failed to create SSL connection")); } } }); } else { connected(ch, connectHandler); } } else { failed(ch, connectErrorHandler, channelFuture.getCause()); } } });
@Override public void channelConnected(final ChannelHandlerContext ctx, final ChannelStateEvent e) throws Exception { new NettyConnection(configuration, NettyAcceptor.this, e.getChannel(), new Listener(), !httpEnabled && batchDelay > 0, directDeliver); SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class); if (sslHandler != null) { sslHandler.handshake().addListener(new ChannelFutureListener() { public void operationComplete(final ChannelFuture future) throws Exception { if (future.isSuccess()) { active = true; } else { future.getChannel().close(); } } }); } else { active = true; } } }
sslHandler.handshake().addListener( new ChannelFutureListener()
@SuppressWarnings("unchecked") @Override public SMTPClientFuture<FutureResult<me.normanmaurer.niosmtp.transport.FutureResult.Void>> startTLS() { if (!isEncrypted()) { final SMTPClientFutureImpl<FutureResult<me.normanmaurer.niosmtp.transport.FutureResult.Void>> future = new SMTPClientFutureImpl<FutureResult<me.normanmaurer.niosmtp.transport.FutureResult.Void>>(false); SslHandler sslHandler = new SslHandler(engine, false); channel.getPipeline().addFirst(SSL_HANDLER_KEY, sslHandler); sslHandler.handshake().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture cfuture) throws Exception { if (cfuture.isSuccess()) { future.setResult(FutureResult.createVoid()); } else { future.setResult(FutureResult.create(cfuture.getCause())); } } }); return future; } else { return new ReadySMTPClientFuture<FutureResult<me.normanmaurer.niosmtp.transport.FutureResult.Void>>(this, FutureResult.create(STARTTLS_EXCEPTION)); } }
sslHandler.handshake().addListener( new ChannelFutureListener()
@Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) { final NioSocketChannel ch = (NioSocketChannel) e.getChannel(); NioWorker worker = ch.getWorker(); //Choose a handler final HandlerHolder<NetSocket> handler = handlerManager.chooseHandler(worker); if (handler == null) { //Ignore return; } if (tcpHelper.isSSL()) { SslHandler sslHandler = (SslHandler)ch.getPipeline().get("ssl"); ChannelFuture fut = sslHandler.handshake(); fut.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture channelFuture) throws Exception { if (channelFuture.isSuccess()) { connected(ch, handler); } else { log.error("Client from origin " + ch.getRemoteAddress() + " failed to connect over ssl"); } } }); } else { connected(ch, handler); } }
private void onFutureSuccess(final Channel channel) throws Exception { Request request = future.getRequest(); Uri uri = request.getUri(); // in case of proxy tunneling, we'll add the SslHandler later, after the CONNECT request if (future.getProxyServer() == null && uri.isSecured()) { SslHandler sslHandler = channelManager.addSslHandler(channel.getPipeline(), uri, request.getVirtualHost()); sslHandler.handshake().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture handshakeFuture) throws Exception { if (handshakeFuture.isSuccess()) { final AsyncHandler<T> asyncHandler = future.getAsyncHandler(); if (asyncHandler instanceof AsyncHandlerExtensions) AsyncHandlerExtensions.class.cast(asyncHandler).onSslHandshakeCompleted(); writeRequest(channel); } else { onFutureFailure(channel, handshakeFuture.getCause()); } } }); } else { writeRequest(channel); } }