fizz::server::test::FizzTestServer Class Reference

#include <Utils.h>

Inheritance diagram for fizz::server::test::FizzTestServer:

Classes
class	CallbackFactory

Public Member Functions
	FizzTestServer (folly::EventBase &evb, CallbackFactory *factory, int port=0)
void	setFizzContext (std::shared_ptr< FizzServerContext > ctx)
void	acceptError (const std::exception &ex) noexceptoverride
void	connectionAccepted (int fd, const folly::SocketAddress &) noexceptoverride
void	setResumption (bool enable)
void	setCertificate (std::unique_ptr< SelfCert > cert)
void	enableClientAuthWithChain (std::string path, ClientAuthMode mode=ClientAuthMode::Optional)
void	disableClientAuth ()
void	setAcceptEarlyData (bool enable)
void	stopAccepting ()
folly::SocketAddress	getAddress ()
std::shared_ptr< FizzServerContext >	getFizzContext ()
Public Member Functions inherited from folly::AsyncServerSocket::AcceptCallback
virtual	~AcceptCallback ()=default
virtual void	acceptStarted () noexcept
virtual void	acceptStopped () noexcept

Private Attributes
folly::AsyncServerSocket::UniquePtr	socket_
std::shared_ptr< FizzServerContext >	ctx_
CallbackFactory *	factory_
folly::EventBase &	evb_

Detailed Description

Definition at line 21 of file Utils.h.

Constructor & Destructor Documentation

fizz::server::test::FizzTestServer::FizzTestServer ( folly::EventBase &  evb, CallbackFactory *  factory, int  port = 0  )

inline

Definition at line 30 of file Utils.h.

References fizz::test::createCert(), ctx_, evb_, folly::gen::move, and socket_.

      : factory_(factory), evb_(evb) {
    auto certData =
        fizz::test::createCert("fizz-test-selfsign", false, nullptr);
    std::vector<folly::ssl::X509UniquePtr> certChain;
    certChain.push_back(std::move(certData.cert));
    auto fizzCert = std::make_unique<SelfCertImpl<KeyType::P256>>(
        std::move(certData.key), std::move(certChain));
    auto certManager = std::make_unique<CertManager>();
    certManager->addCert(std::move(fizzCert), true);
    ctx_ = std::make_shared<FizzServerContext>();
    ctx_->setCertManager(std::move(certManager));
    socket_ = folly::AsyncServerSocket::UniquePtr(
        new folly::AsyncServerSocket(&evb_));
    socket_->bind(port);
    socket_->listen(100);
    socket_->addAcceptCallback(this, &evb_);
    socket_->startAccepting();
  }

Member Function Documentation

void fizz::server::test::FizzTestServer::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 54 of file Utils.h.

                                                             {
    LOG(ERROR) << "Accept error: " << ex.what();
  }

void fizz::server::test::FizzTestServer::connectionAccepted ( int  fd, const folly::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 58 of file Utils.h.

References ctx_, evb_, factory_, and fizz::server::test::FizzTestServer::CallbackFactory::getCallback().

                                                     {
    auto sock = new folly::AsyncSocket(&evb_, fd);
    std::shared_ptr<AsyncFizzServer> transport = AsyncFizzServer::UniquePtr(
        new AsyncFizzServer(folly::AsyncSocket::UniquePtr(sock), ctx_));
    auto callback = factory_->getCallback(transport);
    transport->accept(callback);
  }

void fizz::server::test::FizzTestServer::disableClientAuth ( )

inline

Definition at line 116 of file Utils.h.

References ctx_, and fizz::server::None.

                           {
    ctx_->setClientAuthMode(ClientAuthMode::None);
    ctx_->setClientCertVerifier(nullptr);
  }

void fizz::server::test::FizzTestServer::enableClientAuthWithChain ( std::string  path, ClientAuthMode  mode = ClientAuthMode::Optional  )

inline

Definition at line 88 of file Utils.h.

References ctx_, mode, folly::gen::move, folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), folly::readFile(), fizz::Server, and string.

                                                    {
    ctx_->setClientAuthMode(mode);
    std::string certData;
    CHECK(folly::readFile(path.c_str(), certData));
    auto certRange = folly::ByteRange(folly::StringPiece(certData));

    auto clientAuthCerts =
        folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(certRange);
    ERR_clear_error();
    folly::ssl::X509StoreUniquePtr store(X509_STORE_new());
    for (auto& caCert : clientAuthCerts) {
      if (X509_STORE_add_cert(store.get(), caCert.get()) != 1) {
        auto err = ERR_get_error();
        CHECK(
            ERR_GET_LIB(err) == ERR_LIB_X509 &&
            ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE)
            << "Could not insert CA certificate into store: "
            << std::string(ERR_error_string(err, nullptr));
      }
    }

    auto verifier = std::make_shared<DefaultCertificateVerifier>(
        VerificationContext::Server, std::move(store));
    ctx_->setClientCertVerifier(std::move(verifier));
  }

folly::SocketAddress fizz::server::test::FizzTestServer::getAddress ( )

inline

Definition at line 136 of file Utils.h.

References addr, and socket_.

                                  {
    folly::SocketAddress addr;
    socket_->getAddress(&addr);
    return addr;
  }

std::shared_ptr<FizzServerContext> fizz::server::test::FizzTestServer::getFizzContext ( )

inline

Definition at line 142 of file Utils.h.

References ctx_.

                                                    {
    return ctx_;
  }

void fizz::server::test::FizzTestServer::setAcceptEarlyData ( bool  enable )

inline

Definition at line 121 of file Utils.h.

References ctx_.

                                       {
    if (enable) {
      ctx_->setEarlyDataSettings(
          true,
          {std::chrono::seconds(-10), std::chrono::seconds(10)},
          std::make_shared<AllowAllReplayReplayCache>());
    } else {
      ctx_->setEarlyDataSettings(false, ClockSkewTolerance(), nullptr);
    }
  }

void fizz::server::test::FizzTestServer::setCertificate ( std::unique_ptr< SelfCert >  cert )

inline

Definition at line 82 of file Utils.h.

References ctx_, and folly::gen::move.

                                                    {
    auto certManager = std::make_unique<CertManager>();
    certManager->addCert(std::move(cert), true);
    ctx_->setCertManager(std::move(certManager));
  }

void fizz::server::test::FizzTestServer::setFizzContext ( std::shared_ptr< FizzServerContext >  ctx )

inline

Definition at line 50 of file Utils.h.

References ctx_.

                                                            {
    ctx_ = ctx;
  }

void fizz::server::test::FizzTestServer::setResumption ( bool  enable )

inline

Definition at line 68 of file Utils.h.

References ctx_, and folly::range().

                                  {
    if (enable) {
      auto ticketCipher = std::make_shared<AeadTicketCipher<
          OpenSSLEVPCipher<AESGCM128>,
          TicketCodec<CertificateStorage::X509>,
          HkdfImpl<Sha256>>>();
      auto ticketSeed = RandomGenerator<32>().generateRandom();
      ticketCipher->setTicketSecrets({{folly::range(ticketSeed)}});
      ctx_->setTicketCipher(ticketCipher);
    } else {
      ctx_->setTicketCipher(nullptr);
    }
  }

void fizz::server::test::FizzTestServer::stopAccepting ( )

inline

Definition at line 132 of file Utils.h.

References socket_.

                       {
    socket_.reset();
  }

Member Data Documentation

std::shared_ptr<FizzServerContext> fizz::server::test::FizzTestServer::ctx_

private

Definition at line 148 of file Utils.h.

Referenced by connectionAccepted(), disableClientAuth(), enableClientAuthWithChain(), FizzTestServer(), getFizzContext(), setAcceptEarlyData(), setCertificate(), setFizzContext(), and setResumption().

folly::EventBase& fizz::server::test::FizzTestServer::evb_

private

Definition at line 150 of file Utils.h.

Referenced by connectionAccepted(), and FizzTestServer().

CallbackFactory* fizz::server::test::FizzTestServer::factory_

private

Definition at line 149 of file Utils.h.

Referenced by connectionAccepted().

folly::AsyncServerSocket::UniquePtr fizz::server::test::FizzTestServer::socket_

private

Definition at line 147 of file Utils.h.

Referenced by FizzTestServer(), getAddress(), and stopAccepting().

---

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

• proxygen/fizz/fizz/server/test/Utils.h