folly::HandshakeErrorCallback Class Reference

#include <AsyncSSLSocketTest.h>

Inheritance diagram for folly::HandshakeErrorCallback:

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

Additional Inherited Members
Public Attributes inherited from folly::SSLServerAcceptCallbackBase
StateEnum	state
HandshakeCallback *	hcb_
std::shared_ptr< SSLContext >	ctx_
std::shared_ptr< AsyncSSLSocket >	socket_
EventBase *	base_

Detailed Description

Definition at line 635 of file AsyncSSLSocketTest.h.

Constructor & Destructor Documentation

folly::HandshakeErrorCallback::HandshakeErrorCallback ( HandshakeCallback *  hcb )

inlineexplicit

Definition at line 637 of file AsyncSSLSocketTest.h.

      : SSLServerAcceptCallbackBase(hcb) {}

Member Function Documentation

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

inlineoverridevirtualnoexcept

Implements folly::SSLServerAcceptCallbackBase.

Definition at line 640 of file AsyncSSLSocketTest.h.

References EXPECT_EQ, s, folly::AsyncSSLSocket::sslAccept(), folly::AsyncSSLSocket::STATE_ACCEPTING, folly::AsyncSSLSocket::STATE_ERROR, folly::STATE_FAILED, and folly::STATE_SUCCEEDED.

                                                                     {
    auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);

    std::cerr << "HandshakeErrorCallback::connAccepted" << std::endl;

    // The first call to sslAccept() should succeed.
    hcb_->setSocket(sock);
    sock->sslAccept(hcb_);
    EXPECT_EQ(sock->getSSLState(), AsyncSSLSocket::STATE_ACCEPTING);

    // The second call to sslAccept() should fail.
    HandshakeCallback callback2(hcb_->rcb_);
    callback2.setSocket(sock);
    sock->sslAccept(&callback2);
    EXPECT_EQ(sock->getSSLState(), AsyncSSLSocket::STATE_ERROR);

    // Both callbacks should be in the error state.
    EXPECT_EQ(hcb_->state, STATE_FAILED);
    EXPECT_EQ(callback2.state, STATE_FAILED);

    state = STATE_SUCCEEDED;
    hcb_->setState(STATE_SUCCEEDED);
    callback2.setState(STATE_SUCCEEDED);
  }

---

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

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