proxygen: wangle::FizzAcceptorHandshakeHelper Class Reference

#include <FizzAcceptorHandshakeHelper.h>

Inheritance diagram for wangle::FizzAcceptorHandshakeHelper:

Classes
class	LoggingCallback

Public Member Functions
	FizzAcceptorHandshakeHelper (std::shared_ptr< fizz::server::FizzServerContext > context, const folly::SocketAddress &clientAddr, std::chrono::steady_clock::time_point acceptTime, wangle::TransportInfo &tinfo, LoggingCallback *loggingCallback, const std::shared_ptr< fizz::extensions::TokenBindingContext > &tokenBindingContext)

void	start (folly::AsyncSSLSocket::UniquePtr sock, wangle::AcceptorHandshakeHelper::Callback *callback) noexceptoverride

void	dropConnection (wangle::SSLErrorEnum reason=wangle::SSLErrorEnum::NO_ERROR) override

Public Member Functions inherited from folly::DelayedDestruction
virtual void	destroy ()

bool	getDestroyPending () const

Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Public Member Functions inherited from fizz::server::AsyncFizzServerT< SM >::HandshakeCallback
virtual	~HandshakeCallback ()=default

virtual void	fizzHandshakeSuccess (AsyncFizzServerT *transport) noexcept=0

virtual void	fizzHandshakeError (AsyncFizzServerT *transport, folly::exception_wrapper ex) noexcept=0

Public Member Functions inherited from folly::AsyncSSLSocket::HandshakeCB
virtual	~HandshakeCB ()=default

virtual bool	handshakeVer (AsyncSSLSocket , bool preverifyOk, X509_STORE_CTX ) noexcept

Protected Member Functions
virtual fizz::server::AsyncFizzServer::UniquePtr	createFizzServer (folly::AsyncSSLSocket::UniquePtr sslSock, const std::shared_ptr< fizz::server::FizzServerContext > &fizzContext, const std::shared_ptr< fizz::ServerExtensions > &extensions)

virtual folly::AsyncSSLSocket::UniquePtr	createSSLSocket (const std::shared_ptr< folly::SSLContext > &sslContext, folly::EventBase *evb, int fd)

void	fizzHandshakeSuccess (fizz::server::AsyncFizzServer *transport) noexceptoverride

void	fizzHandshakeError (fizz::server::AsyncFizzServer *transport, folly::exception_wrapper ex) noexceptoverride

void	fizzHandshakeAttemptFallback (std::unique_ptr< folly::IOBuf > clientHello) override

void	handshakeSuc (folly::AsyncSSLSocket *sock) noexceptoverride

void	handshakeErr (folly::AsyncSSLSocket *sock, const folly::AsyncSocketException &ex) noexceptoverride

Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default

	DelayedDestruction ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

Protected Attributes
std::shared_ptr< fizz::server::FizzServerContext >	context_

std::shared_ptr< folly::SSLContext >	sslContext_

std::shared_ptr< fizz::extensions::TokenBindingContext >	tokenBindingContext_

std::shared_ptr< fizz::extensions::TokenBindingServerExtension >	extension_

fizz::server::AsyncFizzServer::UniquePtr	transport_

folly::AsyncSSLSocket::UniquePtr	sslSocket_

wangle::AcceptorHandshakeHelper::Callback *	callback_

const folly::SocketAddress &	clientAddr_

std::chrono::steady_clock::time_point	acceptTime_

wangle::TransportInfo &	tinfo_

wangle::SSLErrorEnum	sslError_ {wangle::SSLErrorEnum::NO_ERROR}

LoggingCallback *	loggingCallback_

Additional Inherited Members
Public Types inherited from wangle::AcceptorHandshakeHelper
using	UniquePtr = std::unique_ptr< AcceptorHandshakeHelper, folly::DelayedDestruction::Destructor >

Detailed Description

Definition at line 31 of file FizzAcceptorHandshakeHelper.h.

Constructor & Destructor Documentation

wangle::FizzAcceptorHandshakeHelper::FizzAcceptorHandshakeHelper	(	std::shared_ptr< fizz::server::FizzServerContext >	context,
		const folly::SocketAddress &	clientAddr,
		std::chrono::steady_clock::time_point	acceptTime,
		wangle::TransportInfo &	tinfo,
		LoggingCallback *	loggingCallback,
		const std::shared_ptr< fizz::extensions::TokenBindingContext > &	tokenBindingContext
	)

inline

Definition at line 45 of file FizzAcceptorHandshakeHelper.h.

References folly::pushmi::__adl::noexcept(), and start.

       : context_(context),
         tokenBindingContext_(tokenBindingContext),
         clientAddr_(clientAddr),
         acceptTime_(acceptTime),
         tinfo_(tinfo),
         loggingCallback_(loggingCallback) {}

Member Function Documentation

AsyncFizzServer::UniquePtr wangle::FizzAcceptorHandshakeHelper::createFizzServer	(	folly::AsyncSSLSocket::UniquePtr	sslSock,
		const std::shared_ptr< fizz::server::FizzServerContext > &	fizzContext,
		const std::shared_ptr< fizz::ServerExtensions > &	extensions
	)

protectedvirtual

Definition at line 40 of file FizzAcceptorHandshakeHelper.cpp.

References folly::gen::move.

                                                            {
   folly::AsyncSocket::UniquePtr asyncSock(
       new folly::AsyncSocket(std::move(sslSock)));
   asyncSock->cacheAddresses();
   return AsyncFizzServer::UniquePtr(
       new AsyncFizzServer(std::move(asyncSock), fizzContext, extensions));
 }

folly::AsyncSSLSocket::UniquePtr wangle::FizzAcceptorHandshakeHelper::createSSLSocket	(	const std::shared_ptr< folly::SSLContext > &	sslContext,
		folly::EventBase *	evb,
		int	fd
	)

protectedvirtual

Definition at line 102 of file FizzAcceptorHandshakeHelper.cpp.

             {
   return folly::AsyncSSLSocket::UniquePtr(new folly::AsyncSSLSocket(
       context, evb, fd));
 }

void wangle::FizzAcceptorHandshakeHelper::dropConnection ( wangle::SSLErrorEnum reason = wangle::SSLErrorEnum::NO_ERROR )

inlineoverridevirtual

Implements wangle::AcceptorHandshakeHelper.

Definition at line 64 of file FizzAcceptorHandshakeHelper.h.

References sslSocket_, and transport_.

                                                                        {
     sslError_ = reason;
     if (transport_) {
       transport_->closeNow();
       return;
     }
     if (sslSocket_) {
       sslSocket_->closeNow();
       return;
     }
   }

void wangle::FizzAcceptorHandshakeHelper::fizzHandshakeAttemptFallback ( std::unique_ptr< folly::IOBuf > clientHello )

overrideprotectedvirtual

Implements fizz::server::AsyncFizzServerT< SM >::HandshakeCallback.

Definition at line 110 of file FizzAcceptorHandshakeHelper.cpp.

References folly::gen::move, sslSocket_, and transport_.

                                            {
   VLOG(3) << "Fallback to OpenSSL";
 
   auto evb = transport_->getEventBase();
   auto fd =
       transport_->getUnderlyingTransport<folly::AsyncSocket>()->detachFd();
   transport_.reset();
 
   sslSocket_ = createSSLSocket(sslContext_, evb, fd);
   sslSocket_->setPreReceivedData(std::move(clientHello));
   sslSocket_->enableClientHelloParsing();
   sslSocket_->forceCacheAddrOnFailure(true);
   sslSocket_->sslAccept(this);
 }

void wangle::FizzAcceptorHandshakeHelper::fizzHandshakeError	(	fizz::server::AsyncFizzServer *	transport,
		folly::exception_wrapper	ex
	)

overrideprotectednoexcept

Definition at line 82 of file FizzAcceptorHandshakeHelper.cpp.

References callback_, folly::gen::move, now(), and transport_.

                                                                     {
   if (loggingCallback_) {
     loggingCallback_->logFizzHandshakeError(*transport, ex);
   }
 
   auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - acceptTime_);
   VLOG(3) << "Fizz handshake error after " << elapsedTime.count() << " ms; "
           << transport->getRawBytesReceived() << " bytes received & "
           << transport->getRawBytesWritten() << " bytes sent: " << ex.what();
 
   auto handshakeException =
       folly::make_exception_wrapper<FizzHandshakeException>(
           sslError_, elapsedTime, transport->getRawBytesReceived());
 
   callback_->connectionError(
       transport_.get(), std::move(handshakeException), sslError_);
 }

void wangle::FizzAcceptorHandshakeHelper::fizzHandshakeSuccess ( fizz::server::AsyncFizzServer * transport )

overrideprotectednoexcept

Definition at line 51 of file FizzAcceptorHandshakeHelper.cpp.

References callback_, folly::gen::move, now(), transport_, and uint8_t.

                                          {
   if (loggingCallback_) {
     loggingCallback_->logFizzHandshakeSuccess(*transport);
   }
 
   VLOG(3) << "Fizz handshake success";
 
   tinfo_.acceptTime = acceptTime_;
   tinfo_.secure = true;
   tinfo_.securityType = transport->getSecurityProtocol();
   tinfo_.sslSetupTime = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - acceptTime_);
   if (extension_ && extension_->getNegotiatedKeyParam().hasValue()) {
     tinfo_.negotiatedTokenBindingKeyParameters =
         static_cast<uint8_t>(*extension_->getNegotiatedKeyParam());
   }
 
   auto* handshakeLogging = transport->getState().handshakeLogging();
   if (handshakeLogging && handshakeLogging->clientSni) {
     tinfo_.sslServerName =
         std::make_shared<std::string>(*handshakeLogging->clientSni);
   }
 
   auto appProto = transport->getApplicationProtocol();
   callback_->connectionReady(std::move(transport_),
                              std::move(appProto),
                              SecureTransportType::TLS,
                              SSLErrorEnum::NO_ERROR);
 }

void wangle::FizzAcceptorHandshakeHelper::handshakeErr	(	folly::AsyncSSLSocket *	sock,
		const folly::AsyncSocketException &	ex
	)

overrideprotectedvirtualnoexcept

handshakeErr() is called if an error occurs while establishing the SSL connection.

The HandshakeCB will be uninstalled before handshakeErr() is called.

Parameters

sock	SSL socket on which the handshake was initiated
ex	An exception representing the error.

Implements folly::AsyncSSLSocket::HandshakeCB.

Definition at line 149 of file FizzAcceptorHandshakeHelper.cpp.

References callback_, now(), and sslSocket_.

                                                   {
   auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - acceptTime_);
   VLOG(3) << "SSL handshake error after " << elapsedTime.count() << " ms; "
           << sock->getRawBytesReceived() << " bytes received & "
           << sock->getRawBytesWritten() << " bytes sent: " << ex.what();
 
   auto sslEx = folly::make_exception_wrapper<SSLException>(
       sslError_, elapsedTime, sock->getRawBytesReceived());
 
   // The callback will delete this.
   callback_->connectionError(sslSocket_.get(), sslEx, sslError_);
 }

void wangle::FizzAcceptorHandshakeHelper::handshakeSuc ( folly::AsyncSSLSocket * sock )

overrideprotectedvirtualnoexcept

handshakeSuc() is called when a new SSL connection is established, i.e., after SSL_accept/connect() returns successfully.

The HandshakeCB will be uninstalled before handshakeSuc() is called.

Parameters

sock	SSL socket on which the handshake was initiated

Implements folly::AsyncSSLSocket::HandshakeCB.

Definition at line 126 of file FizzAcceptorHandshakeHelper.cpp.

References callback_, wangle::SSLAcceptorHandshakeHelper::fillSSLTransportInfoFields(), folly::gen::move, now(), and sslSocket_.

                                         {
   auto appProto = sock->getApplicationProtocol();
   if (!appProto.empty()) {
     VLOG(3) << "Client selected next protocol " << appProto;
   } else {
     VLOG(3) << "Client did not select a next protocol";
   }
 
   // fill in SSL-related fields from TransportInfo
   // the other fields like RTT are filled in the Acceptor
   tinfo_.acceptTime = acceptTime_;
   tinfo_.sslSetupTime = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - acceptTime_);
   wangle::SSLAcceptorHandshakeHelper::fillSSLTransportInfoFields(sock, tinfo_);
 
   // The callback will delete this.
   callback_->connectionReady(std::move(sslSocket_),
                              std::move(appProto),
                              SecureTransportType::TLS,
                              SSLErrorEnum::NO_ERROR);
 }

void wangle::FizzAcceptorHandshakeHelper::start	(	folly::AsyncSSLSocket::UniquePtr	sock,
		wangle::AcceptorHandshakeHelper::Callback *	callback
	)

overridevirtualnoexcept

Implements wangle::AcceptorHandshakeHelper.

Definition at line 25 of file FizzAcceptorHandshakeHelper.cpp.

References callback_, folly::gen::move, and transport_.

                                                         {
   callback_ = callback;
   sslContext_ = sock->getSSLContext();
 
   if (tokenBindingContext_) {
     extension_ =
         std::make_shared<TokenBindingServerExtension>(tokenBindingContext_);
   }
 
   transport_ = createFizzServer(std::move(sock), context_, extension_);
   transport_->accept(this);
 }

Member Data Documentation

std::chrono::steady_clock::time_point wangle::FizzAcceptorHandshakeHelper::acceptTime_

protected

Definition at line 109 of file FizzAcceptorHandshakeHelper.h.

wangle::AcceptorHandshakeHelper::Callback* wangle::FizzAcceptorHandshakeHelper::callback_

protected

Definition at line 107 of file FizzAcceptorHandshakeHelper.h.

const folly::SocketAddress& wangle::FizzAcceptorHandshakeHelper::clientAddr_

protected

Definition at line 108 of file FizzAcceptorHandshakeHelper.h.

std::shared_ptr<fizz::server::FizzServerContext> wangle::FizzAcceptorHandshakeHelper::context_

protected

Definition at line 101 of file FizzAcceptorHandshakeHelper.h.

std::shared_ptr<fizz::extensions::TokenBindingServerExtension> wangle::FizzAcceptorHandshakeHelper::extension_

protected

Definition at line 104 of file FizzAcceptorHandshakeHelper.h.

LoggingCallback* wangle::FizzAcceptorHandshakeHelper::loggingCallback_

protected

Definition at line 112 of file FizzAcceptorHandshakeHelper.h.

std::shared_ptr<folly::SSLContext> wangle::FizzAcceptorHandshakeHelper::sslContext_

protected

Definition at line 102 of file FizzAcceptorHandshakeHelper.h.

wangle::SSLErrorEnum wangle::FizzAcceptorHandshakeHelper::sslError_ {wangle::SSLErrorEnum::NO_ERROR}

protected

Definition at line 111 of file FizzAcceptorHandshakeHelper.h.

folly::AsyncSSLSocket::UniquePtr wangle::FizzAcceptorHandshakeHelper::sslSocket_

protected

Definition at line 106 of file FizzAcceptorHandshakeHelper.h.

wangle::TransportInfo& wangle::FizzAcceptorHandshakeHelper::tinfo_

protected

Definition at line 110 of file FizzAcceptorHandshakeHelper.h.

std::shared_ptr<fizz::extensions::TokenBindingContext> wangle::FizzAcceptorHandshakeHelper::tokenBindingContext_

protected

Definition at line 103 of file FizzAcceptorHandshakeHelper.h.

fizz::server::AsyncFizzServer::UniquePtr wangle::FizzAcceptorHandshakeHelper::transport_

protected

Definition at line 105 of file FizzAcceptorHandshakeHelper.h.

The documentation for this class was generated from the following files:

proxygen/wangle/wangle/acceptor/FizzAcceptorHandshakeHelper.h
proxygen/wangle/wangle/acceptor/FizzAcceptorHandshakeHelper.cpp

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation