proxygen: SSLCacheClient Class Reference

Inheritance diagram for SSLCacheClient:

Public Member Functions
	SSLCacheClient (EventBase eventBase, SSL_SESSION pSess, ClientRunner cr)

	~SSLCacheClient () override

void	start ()

void	connectSuccess () noexceptoverride

void	connectErr (const AsyncSocketException &ex) noexceptoverride

void	handshakeSuc (AsyncSSLSocket *sock) noexceptoverride

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

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

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

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

Private Attributes
EventBase *	eventBase_

int	currReq_

int	serverIdx_

AsyncSocket *	socket_

AsyncSSLSocket *	sslSocket_

SSL_SESSION *	session_

SSL_SESSION **	pSess_

std::shared_ptr< SSLContext >	ctx_

ClientRunner *	cr_

Detailed Description

Definition at line 52 of file SSLCacheTest.cpp.

Constructor & Destructor Documentation

SSLCacheClient::SSLCacheClient	(	EventBase *	eventBase,
		SSL_SESSION **	pSess,
		ClientRunner *	cr
	)

Definition at line 182 of file SSLCacheTest.cpp.

References ctx_.

     : eventBase_(eb),
       currReq_(0),
       serverIdx_(0),
       socket_(nullptr),
       sslSocket_(nullptr),
       session_(nullptr),
       pSess_(pSess),
       cr_(cr)
 {
   ctx_.reset(new SSLContext());
   ctx_->setOptions(SSL_OP_NO_TICKET);
 }

SSLCacheClient::~SSLCacheClient ( )

inlineoverride

Definition at line 68 of file SSLCacheTest.cpp.

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

                              {
     if (session_ && !FLAGS_global)
       SSL_SESSION_free(session_);
     if (socket_ != nullptr) {
       if (sslSocket_ != nullptr) {
         sslSocket_->destroy();
         sslSocket_ = nullptr;
       }
       socket_->destroy();
       socket_ = nullptr;
     }
   }

Member Function Documentation

void SSLCacheClient::connectErr ( const AsyncSocketException & ex )

overridevirtualnoexcept

connectErr() will be invoked if the connection attempt fails.

Parameters

ex	An exception describing the error that occurred.

Implements folly::AsyncSocket::ConnectCallback.

Definition at line 237 of file SSLCacheTest.cpp.

 {
   cout << "connectError: " << ex.what() << endl;
 }

void SSLCacheClient::connectSuccess ( )

overridevirtualnoexcept

connectSuccess() will be invoked when the connection has been successfully established.

Implements folly::AsyncSocket::ConnectCallback.

Definition at line 222 of file SSLCacheTest.cpp.

References ctx_, folly::AsyncSocket::detachFd(), eventBase_, pSess_, session_, folly::AsyncSSLSocket::setSSLSession(), socket_, folly::AsyncSSLSocket::sslConn(), and sslSocket_.

 {
   sslSocket_ = new AsyncSSLSocket(ctx_, eventBase_, socket_->detachFd(),
                                    false);
 
   if (!FLAGS_handshakes) {
     if (session_ != nullptr)
       sslSocket_->setSSLSession(session_);
     else if (FLAGS_global && pSess_ != nullptr)
       sslSocket_->setSSLSession(*pSess_);
   }
   sslSocket_->sslConn(this);
 }

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

overridevirtualnoexcept

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 268 of file SSLCacheTest.cpp.

 {
   cout << "handshakeError: " << ex.what() << endl;
 }

void SSLCacheClient::handshakeSuc ( AsyncSSLSocket * sock )

overridevirtualnoexcept

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 244 of file SSLCacheTest.cpp.

References folly::AsyncSSLSocket::closeNow(), cr_, currReq_, folly::AsyncSSLSocket::getSSLSession(), folly::AsyncSSLSocket::getSSLSessionReused(), ClientRunner::hits, ClientRunner::miss, ClientRunner::num, pSess_, session_, sslSocket_, and start().

 {
   if (sslSocket_->getSSLSessionReused()) {
     cr_->hits++;
   } else {
     cr_->miss++;
     if (session_ != nullptr) {
       SSL_SESSION_free(session_);
     }
     session_ = sslSocket_->getSSLSession();
     if (FLAGS_global && pSess_ != nullptr && *pSess_ == nullptr) {
       *pSess_ = session_;
     }
   }
   if ( ((cr_->hits + cr_->miss) % 100) == ((100 / FLAGS_threads) * cr_->num)) {
     cout << ".";
     cout.flush();
   }
   sslSocket_->closeNow();
   currReq_++;
   this->start();
 }

void SSLCacheClient::start ( )

Definition at line 199 of file SSLCacheTest.cpp.

References folly::AsyncSocket::connect(), currReq_, folly::AsyncSocket::destroy(), eventBase_, f_num_servers, f_servers, serverIdx_, socket_, sslSocket_, and uint16_t.

Referenced by handshakeSuc(), and ClientRunner::run().

 {
   if (currReq_ >= FLAGS_requests) {
     cout << "+";
     return;
   }
 
   if (currReq_ == 0 || !FLAGS_sticky) {
     serverIdx_ = rand() % f_num_servers;
   }
   if (socket_ != nullptr) {
     if (sslSocket_ != nullptr) {
       sslSocket_->destroy();
       sslSocket_ = nullptr;
     }
     socket_->destroy();
     socket_ = nullptr;
   }
   socket_ = new AsyncSocket(eventBase_);
   socket_->connect(this, f_servers[serverIdx_], (uint16_t)FLAGS_port);
 }