folly::SSLServerAcceptCallbackBase Class Reference

#include <TestSSLServer.h>

Inheritance diagram for folly::SSLServerAcceptCallbackBase:

Public Member Functions
	SSLServerAcceptCallbackBase (HandshakeCallback *hcb)
	~SSLServerAcceptCallbackBase () override
void	acceptError (const std::exception &ex) noexceptoverride
void	connectionAccepted (int fd, const SocketAddress &) noexceptoverride
virtual void	connAccepted (const std::shared_ptr< AsyncSSLSocket > &s)=0
void	detach ()
Public Member Functions inherited from folly::AsyncServerSocket::AcceptCallback
virtual	~AcceptCallback ()=default
virtual void	acceptStarted () noexcept
virtual void	acceptStopped () noexcept

Public Attributes
StateEnum	state
HandshakeCallback *	hcb_
std::shared_ptr< SSLContext >	ctx_
std::shared_ptr< AsyncSSLSocket >	socket_
EventBase *	base_

Detailed Description

Definition at line 49 of file TestSSLServer.h.

Constructor & Destructor Documentation

folly::SSLServerAcceptCallbackBase::SSLServerAcceptCallbackBase ( HandshakeCallback *  hcb )

inlineexplicit

Definition at line 51 of file TestSSLServer.h.

      : state(STATE_WAITING), hcb_(hcb) {}

folly::SSLServerAcceptCallbackBase::~SSLServerAcceptCallbackBase ( )

inlineoverride

Definition at line 54 of file TestSSLServer.h.

References EXPECT_EQ, and folly::STATE_SUCCEEDED.

                                          {
    EXPECT_EQ(STATE_SUCCEEDED, state);
  }

Member Function Documentation

void folly::SSLServerAcceptCallbackBase::acceptError ( const std::exception &  ex )

inlineoverridevirtualnoexcept

acceptError() is called if an error occurs while accepting.

The AcceptCallback will remain installed even after an accept error, as the errors are typically somewhat transient, such as being out of file descriptors. The server socket must be explicitly stopped if you wish to stop accepting after an error.

Parameters

ex	An exception representing the error.

Implements folly::AsyncServerSocket::AcceptCallback.

Definition at line 58 of file TestSSLServer.h.

References folly::STATE_FAILED, and folly::WARNING.

Referenced by connectionAccepted().

                                                             {
    LOG(WARNING) << "SSLServerAcceptCallbackBase::acceptError " << ex.what();
    state = STATE_FAILED;
  }

virtual void folly::SSLServerAcceptCallbackBase::connAccepted ( const std::shared_ptr< AsyncSSLSocket > &  s )

pure virtual

Implemented in folly::ConnectTimeoutCallback, folly::HandshakeTimeoutCallback, folly::HandshakeErrorCallback, folly::SSLServerAsyncCacheAcceptCallback, folly::SSLServerAcceptCallbackDelay, and folly::SSLServerAcceptCallback.

Referenced by connectionAccepted().

void folly::SSLServerAcceptCallbackBase::connectionAccepted ( int  fd, const SocketAddress &  clientAddr  )

inlineoverridevirtualnoexcept

connectionAccepted() is called whenever a new client connection is received.

The AcceptCallback will remain installed after connectionAccepted() returns.

Parameters

fd	The newly accepted client socket. The AcceptCallback assumes ownership of this socket, and is responsible for closing it when done. The newly accepted file descriptor will have already been put into non-blocking mode.
clientAddr	A reference to a SocketAddress struct containing the client's address. This struct is only guaranteed to remain valid until connectionAccepted() returns.

Implements folly::AsyncServerSocket::AcceptCallback.

Definition at line 63 of file TestSSLServer.h.

References acceptError(), base_, folly::netops::close(), connAccepted(), ctx_, folly::INFO, folly::AsyncSSLSocket::newSocket(), s, and socket_.

                                                {
    if (socket_) {
      socket_->detachEventBase();
    }
    LOG(INFO) << "Connection accepted";
    try {
      // Create a AsyncSSLSocket object with the fd. The socket should be
      // added to the event base and in the state of accepting SSL connection.
      socket_ = AsyncSSLSocket::newSocket(ctx_, base_, fd);
    } catch (const std::exception& e) {
      LOG(ERROR) << "Exception %s caught while creating a AsyncSSLSocket "
                    "object with socket "
                 << e.what() << fd;
      ::close(fd);
      acceptError(e);
      return;
    }

    connAccepted(socket_);
  }

void folly::SSLServerAcceptCallbackBase::detach ( )

inline

Definition at line 88 of file TestSSLServer.h.

References socket_.

Referenced by folly::TestSSLServer::init().

                {
    if (socket_) {
      socket_->detachEventBase();
    }
  }

Member Data Documentation

EventBase* folly::SSLServerAcceptCallbackBase::base_

Definition at line 98 of file TestSSLServer.h.

Referenced by connectionAccepted(), and folly::TestSSLServer::init().

std::shared_ptr<SSLContext> folly::SSLServerAcceptCallbackBase::ctx_

Definition at line 96 of file TestSSLServer.h.

Referenced by connectionAccepted(), and folly::TestSSLServer::init().

HandshakeCallback* folly::SSLServerAcceptCallbackBase::hcb_

Definition at line 95 of file TestSSLServer.h.

std::shared_ptr<AsyncSSLSocket> folly::SSLServerAcceptCallbackBase::socket_

Definition at line 97 of file TestSSLServer.h.

Referenced by connectionAccepted(), and detach().

StateEnum folly::SSLServerAcceptCallbackBase::state

Definition at line 94 of file TestSSLServer.h.

---

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

• proxygen/folly/folly/io/async/test/TestSSLServer.h