folly/io/async/test/AsyncSSLSocketTest.h

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #pragma once
  17
  18 #include <signal.h>
  19 #include <pthread.h>
  20
  21 #include <folly/ExceptionWrapper.h>
  22 #include <folly/SocketAddress.h>
  23 #include <folly/io/async/AsyncSSLSocket.h>
  24 #include <folly/io/async/AsyncServerSocket.h>
  25 #include <folly/io/async/AsyncSocket.h>
  26 #include <folly/io/async/AsyncTimeout.h>
  27 #include <folly/io/async/AsyncTransport.h>
  28 #include <folly/io/async/EventBase.h>
  29 #include <folly/io/async/ssl/SSLErrors.h>
  30 #include <folly/portability/Sockets.h>
  31 #include <folly/portability/Unistd.h>
  32
  33 #include <gtest/gtest.h>
  34 #include <iostream>
  35 #include <list>
  36 #include <fcntl.h>
  37 #include <sys/types.h>
  38
  39 namespace folly {
  40
  41 enum StateEnum {
  42   STATE_WAITING,
  43   STATE_SUCCEEDED,
  44   STATE_FAILED
  45 };
  46
  47 // The destructors of all callback classes assert that the state is
  48 // STATE_SUCCEEDED, for both possitive and negative tests. The tests
  49 // are responsible for setting the succeeded state properly before the
  50 // destructors are called.
  51
  52 class WriteCallbackBase :
  53 public AsyncTransportWrapper::WriteCallback {
  54 public:
  55   WriteCallbackBase()
  56       : state(STATE_WAITING)
  57       , bytesWritten(0)
  58       , exception(AsyncSocketException::UNKNOWN, "none") {}
  59
  60   ~WriteCallbackBase() {
  61     EXPECT_EQ(STATE_SUCCEEDED, state);
  62   }
  63
  64   void setSocket(
  65     const std::shared_ptr<AsyncSSLSocket> &socket) {
  66     socket_ = socket;
  67   }
  68
  69   void writeSuccess() noexcept override {
  70     std::cerr << "writeSuccess" << std::endl;
  71     state = STATE_SUCCEEDED;
  72   }
  73
  74   void writeErr(
  75     size_t bytesWritten,
  76     const AsyncSocketException& ex) noexcept override {
  77     std::cerr << "writeError: bytesWritten " << bytesWritten
  78          << ", exception " << ex.what() << std::endl;
  79
  80     state = STATE_FAILED;
  81     this->bytesWritten = bytesWritten;
  82     exception = ex;
  83     socket_->close();
  84     socket_->detachEventBase();
  85   }
  86
  87   std::shared_ptr<AsyncSSLSocket> socket_;
  88   StateEnum state;
  89   size_t bytesWritten;
  90   AsyncSocketException exception;
  91 };
  92
  93 class ReadCallbackBase :
  94 public AsyncTransportWrapper::ReadCallback {
  95  public:
  96   explicit ReadCallbackBase(WriteCallbackBase* wcb)
  97       : wcb_(wcb), state(STATE_WAITING) {}
  98
  99   ~ReadCallbackBase() {
 100     EXPECT_EQ(state, STATE_SUCCEEDED);
 101   }
 102
 103   void setSocket(
 104     const std::shared_ptr<AsyncSSLSocket> &socket) {
 105     socket_ = socket;
 106   }
 107
 108   void setState(StateEnum s) {
 109     state = s;
 110     if (wcb_) {
 111       wcb_->state = s;
 112     }
 113   }
 114
 115   void readErr(
 116     const AsyncSocketException& ex) noexcept override {
 117     std::cerr << "readError " << ex.what() << std::endl;
 118     state = STATE_FAILED;
 119     socket_->close();
 120     socket_->detachEventBase();
 121   }
 122
 123   void readEOF() noexcept override {
 124     std::cerr << "readEOF" << std::endl;
 125
 126     socket_->close();
 127     socket_->detachEventBase();
 128   }
 129
 130   std::shared_ptr<AsyncSSLSocket> socket_;
 131   WriteCallbackBase *wcb_;
 132   StateEnum state;
 133 };
 134
 135 class ReadCallback : public ReadCallbackBase {
 136 public:
 137   explicit ReadCallback(WriteCallbackBase *wcb)
 138       : ReadCallbackBase(wcb)
 139       , buffers() {}
 140
 141   ~ReadCallback() {
 142     for (std::vector<Buffer>::iterator it = buffers.begin();
 143          it != buffers.end();
 144          ++it) {
 145       it->free();
 146     }
 147     currentBuffer.free();
 148   }
 149
 150   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 151     if (!currentBuffer.buffer) {
 152       currentBuffer.allocate(4096);
 153     }
 154     *bufReturn = currentBuffer.buffer;
 155     *lenReturn = currentBuffer.length;
 156   }
 157
 158   void readDataAvailable(size_t len) noexcept override {
 159     std::cerr << "readDataAvailable, len " << len << std::endl;
 160
 161     currentBuffer.length = len;
 162
 163     wcb_->setSocket(socket_);
 164
 165     // Write back the same data.
 166     socket_->write(wcb_, currentBuffer.buffer, len);
 167
 168     buffers.push_back(currentBuffer);
 169     currentBuffer.reset();
 170     state = STATE_SUCCEEDED;
 171   }
 172
 173   class Buffer {
 174   public:
 175     Buffer() : buffer(nullptr), length(0) {}
 176     Buffer(char* buf, size_t len) : buffer(buf), length(len) {}
 177
 178     void reset() {
 179       buffer = nullptr;
 180       length = 0;
 181     }
 182     void allocate(size_t length) {
 183       assert(buffer == nullptr);
 184       this->buffer = static_cast<char*>(malloc(length));
 185       this->length = length;
 186     }
 187     void free() {
 188       ::free(buffer);
 189       reset();
 190     }
 191
 192     char* buffer;
 193     size_t length;
 194   };
 195
 196   std::vector<Buffer> buffers;
 197   Buffer currentBuffer;
 198 };
 199
 200 class ReadErrorCallback : public ReadCallbackBase {
 201 public:
 202   explicit ReadErrorCallback(WriteCallbackBase *wcb)
 203       : ReadCallbackBase(wcb) {}
 204
 205   // Return nullptr buffer to trigger readError()
 206   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 207     *bufReturn = nullptr;
 208     *lenReturn = 0;
 209   }
 210
 211   void readDataAvailable(size_t /* len */) noexcept override {
 212     // This should never to called.
 213     FAIL();
 214   }
 215
 216   void readErr(
 217     const AsyncSocketException& ex) noexcept override {
 218     ReadCallbackBase::readErr(ex);
 219     std::cerr << "ReadErrorCallback::readError" << std::endl;
 220     setState(STATE_SUCCEEDED);
 221   }
 222 };
 223
 224 class ReadEOFCallback : public ReadCallbackBase {
 225  public:
 226   explicit ReadEOFCallback(WriteCallbackBase* wcb) : ReadCallbackBase(wcb) {}
 227
 228   // Return nullptr buffer to trigger readError()
 229   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 230     *bufReturn = nullptr;
 231     *lenReturn = 0;
 232   }
 233
 234   void readDataAvailable(size_t /* len */) noexcept override {
 235     // This should never to called.
 236     FAIL();
 237   }
 238
 239   void readEOF() noexcept override {
 240     ReadCallbackBase::readEOF();
 241     setState(STATE_SUCCEEDED);
 242   }
 243 };
 244
 245 class WriteErrorCallback : public ReadCallback {
 246 public:
 247   explicit WriteErrorCallback(WriteCallbackBase *wcb)
 248       : ReadCallback(wcb) {}
 249
 250   void readDataAvailable(size_t len) noexcept override {
 251     std::cerr << "readDataAvailable, len " << len << std::endl;
 252
 253     currentBuffer.length = len;
 254
 255     // close the socket before writing to trigger writeError().
 256     ::close(socket_->getFd());
 257
 258     wcb_->setSocket(socket_);
 259
 260     // Write back the same data.
 261     socket_->write(wcb_, currentBuffer.buffer, len);
 262
 263     if (wcb_->state == STATE_FAILED) {
 264       setState(STATE_SUCCEEDED);
 265     } else {
 266       state = STATE_FAILED;
 267     }
 268
 269     buffers.push_back(currentBuffer);
 270     currentBuffer.reset();
 271   }
 272
 273   void readErr(const AsyncSocketException& ex) noexcept override {
 274     std::cerr << "readError " << ex.what() << std::endl;
 275     // do nothing since this is expected
 276   }
 277 };
 278
 279 class EmptyReadCallback : public ReadCallback {
 280 public:
 281   explicit EmptyReadCallback()
 282       : ReadCallback(nullptr) {}
 283
 284   void readErr(const AsyncSocketException& ex) noexcept override {
 285     std::cerr << "readError " << ex.what() << std::endl;
 286     state = STATE_FAILED;
 287     tcpSocket_->close();
 288     tcpSocket_->detachEventBase();
 289   }
 290
 291   void readEOF() noexcept override {
 292     std::cerr << "readEOF" << std::endl;
 293
 294     tcpSocket_->close();
 295     tcpSocket_->detachEventBase();
 296     state = STATE_SUCCEEDED;
 297   }
 298
 299   std::shared_ptr<AsyncSocket> tcpSocket_;
 300 };
 301
 302 class HandshakeCallback :
 303 public AsyncSSLSocket::HandshakeCB {
 304 public:
 305   enum ExpectType {
 306     EXPECT_SUCCESS,
 307     EXPECT_ERROR
 308   };
 309
 310   explicit HandshakeCallback(ReadCallbackBase *rcb,
 311                              ExpectType expect = EXPECT_SUCCESS):
 312       state(STATE_WAITING),
 313       rcb_(rcb),
 314       expect_(expect) {}
 315
 316   void setSocket(
 317     const std::shared_ptr<AsyncSSLSocket> &socket) {
 318     socket_ = socket;
 319   }
 320
 321   void setState(StateEnum s) {
 322     state = s;
 323     rcb_->setState(s);
 324   }
 325
 326   // Functions inherited from AsyncSSLSocketHandshakeCallback
 327   void handshakeSuc(AsyncSSLSocket *sock) noexcept override {
 328     std::lock_guard<std::mutex> g(mutex_);
 329     cv_.notify_all();
 330     EXPECT_EQ(sock, socket_.get());
 331     std::cerr << "HandshakeCallback::connectionAccepted" << std::endl;
 332     rcb_->setSocket(socket_);
 333     sock->setReadCB(rcb_);
 334     state = (expect_ == EXPECT_SUCCESS) ? STATE_SUCCEEDED : STATE_FAILED;
 335   }
 336   void handshakeErr(AsyncSSLSocket* /* sock */,
 337                     const AsyncSocketException& ex) noexcept override {
 338     std::lock_guard<std::mutex> g(mutex_);
 339     cv_.notify_all();
 340     std::cerr << "HandshakeCallback::handshakeError " << ex.what() << std::endl;
 341     state = (expect_ == EXPECT_ERROR) ? STATE_SUCCEEDED : STATE_FAILED;
 342     if (expect_ == EXPECT_ERROR) {
 343       // rcb will never be invoked
 344       rcb_->setState(STATE_SUCCEEDED);
 345     }
 346     errorString_ = ex.what();
 347   }
 348
 349   void waitForHandshake() {
 350     std::unique_lock<std::mutex> lock(mutex_);
 351     cv_.wait(lock, [this] { return state != STATE_WAITING; });
 352   }
 353
 354   ~HandshakeCallback() {
 355     EXPECT_EQ(state, STATE_SUCCEEDED);
 356   }
 357
 358   void closeSocket() {
 359     socket_->close();
 360     state = STATE_SUCCEEDED;
 361   }
 362
 363   std::shared_ptr<AsyncSSLSocket> getSocket() {
 364     return socket_;
 365   }
 366
 367   StateEnum state;
 368   std::shared_ptr<AsyncSSLSocket> socket_;
 369   ReadCallbackBase *rcb_;
 370   ExpectType expect_;
 371   std::mutex mutex_;
 372   std::condition_variable cv_;
 373   std::string errorString_;
 374 };
 375
 376 class SSLServerAcceptCallbackBase:
 377 public folly::AsyncServerSocket::AcceptCallback {
 378 public:
 379   explicit SSLServerAcceptCallbackBase(HandshakeCallback *hcb):
 380   state(STATE_WAITING), hcb_(hcb) {}
 381
 382   ~SSLServerAcceptCallbackBase() {
 383     EXPECT_EQ(state, STATE_SUCCEEDED);
 384   }
 385
 386   void acceptError(const std::exception& ex) noexcept override {
 387     std::cerr << "SSLServerAcceptCallbackBase::acceptError "
 388               << ex.what() << std::endl;
 389     state = STATE_FAILED;
 390   }
 391
 392   void connectionAccepted(
 393       int fd, const folly::SocketAddress& /* clientAddr */) noexcept override {
 394     printf("Connection accepted\n");
 395     std::shared_ptr<AsyncSSLSocket> sslSock;
 396     try {
 397       // Create a AsyncSSLSocket object with the fd. The socket should be
 398       // added to the event base and in the state of accepting SSL connection.
 399       sslSock = AsyncSSLSocket::newSocket(ctx_, base_, fd);
 400     } catch (const std::exception &e) {
 401       LOG(ERROR) << "Exception %s caught while creating a AsyncSSLSocket "
 402         "object with socket " << e.what() << fd;
 403       ::close(fd);
 404       acceptError(e);
 405       return;
 406     }
 407
 408     connAccepted(sslSock);
 409   }
 410
 411   virtual void connAccepted(
 412     const std::shared_ptr<folly::AsyncSSLSocket> &s) = 0;
 413
 414   StateEnum state;
 415   HandshakeCallback *hcb_;
 416   std::shared_ptr<folly::SSLContext> ctx_;
 417   folly::EventBase* base_;
 418 };
 419
 420 class SSLServerAcceptCallback: public SSLServerAcceptCallbackBase {
 421 public:
 422   uint32_t timeout_;
 423
 424   explicit SSLServerAcceptCallback(HandshakeCallback *hcb,
 425                                    uint32_t timeout = 0):
 426       SSLServerAcceptCallbackBase(hcb),
 427       timeout_(timeout) {}
 428
 429   virtual ~SSLServerAcceptCallback() {
 430     if (timeout_ > 0) {
 431       // if we set a timeout, we expect failure
 432       EXPECT_EQ(hcb_->state, STATE_FAILED);
 433       hcb_->setState(STATE_SUCCEEDED);
 434     }
 435   }
 436
 437   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 438   void connAccepted(
 439     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 440     noexcept override {
 441     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 442     std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
 443
 444     hcb_->setSocket(sock);
 445     sock->sslAccept(hcb_, timeout_);
 446     EXPECT_EQ(sock->getSSLState(),
 447                       AsyncSSLSocket::STATE_ACCEPTING);
 448
 449     state = STATE_SUCCEEDED;
 450   }
 451 };
 452
 453 class SSLServerAcceptCallbackDelay: public SSLServerAcceptCallback {
 454 public:
 455   explicit SSLServerAcceptCallbackDelay(HandshakeCallback *hcb):
 456       SSLServerAcceptCallback(hcb) {}
 457
 458   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 459   void connAccepted(
 460     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 461     noexcept override {
 462
 463     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 464
 465     std::cerr << "SSLServerAcceptCallbackDelay::connAccepted"
 466               << std::endl;
 467     int fd = sock->getFd();
 468
 469 #ifndef TCP_NOPUSH
 470     {
 471     // The accepted connection should already have TCP_NODELAY set
 472     int value;
 473     socklen_t valueLength = sizeof(value);
 474     int rc = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
 475     EXPECT_EQ(rc, 0);
 476     EXPECT_EQ(value, 1);
 477     }
 478 #endif
 479
 480     // Unset the TCP_NODELAY option.
 481     int value = 0;
 482     socklen_t valueLength = sizeof(value);
 483     int rc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, valueLength);
 484     EXPECT_EQ(rc, 0);
 485
 486     rc = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
 487     EXPECT_EQ(rc, 0);
 488     EXPECT_EQ(value, 0);
 489
 490     SSLServerAcceptCallback::connAccepted(sock);
 491   }
 492 };
 493
 494 class SSLServerAsyncCacheAcceptCallback: public SSLServerAcceptCallback {
 495 public:
 496   explicit SSLServerAsyncCacheAcceptCallback(HandshakeCallback *hcb,
 497                                              uint32_t timeout = 0):
 498     SSLServerAcceptCallback(hcb, timeout) {}
 499
 500   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 501   void connAccepted(
 502     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 503     noexcept override {
 504     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 505
 506     std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
 507
 508     hcb_->setSocket(sock);
 509     sock->sslAccept(hcb_, timeout_);
 510     ASSERT_TRUE((sock->getSSLState() ==
 511                  AsyncSSLSocket::STATE_ACCEPTING) ||
 512                 (sock->getSSLState() ==
 513                  AsyncSSLSocket::STATE_CACHE_LOOKUP));
 514
 515     state = STATE_SUCCEEDED;
 516   }
 517 };
 518
 519
 520 class HandshakeErrorCallback: public SSLServerAcceptCallbackBase {
 521 public:
 522   explicit HandshakeErrorCallback(HandshakeCallback *hcb):
 523   SSLServerAcceptCallbackBase(hcb)  {}
 524
 525   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 526   void connAccepted(
 527     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 528     noexcept override {
 529     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 530
 531     std::cerr << "HandshakeErrorCallback::connAccepted" << std::endl;
 532
 533     // The first call to sslAccept() should succeed.
 534     hcb_->setSocket(sock);
 535     sock->sslAccept(hcb_);
 536     EXPECT_EQ(sock->getSSLState(),
 537                       AsyncSSLSocket::STATE_ACCEPTING);
 538
 539     // The second call to sslAccept() should fail.
 540     HandshakeCallback callback2(hcb_->rcb_);
 541     callback2.setSocket(sock);
 542     sock->sslAccept(&callback2);
 543     EXPECT_EQ(sock->getSSLState(),
 544                       AsyncSSLSocket::STATE_ERROR);
 545
 546     // Both callbacks should be in the error state.
 547     EXPECT_EQ(hcb_->state, STATE_FAILED);
 548     EXPECT_EQ(callback2.state, STATE_FAILED);
 549
 550     sock->detachEventBase();
 551
 552     state = STATE_SUCCEEDED;
 553     hcb_->setState(STATE_SUCCEEDED);
 554     callback2.setState(STATE_SUCCEEDED);
 555   }
 556 };
 557
 558 class HandshakeTimeoutCallback: public SSLServerAcceptCallbackBase {
 559 public:
 560   explicit HandshakeTimeoutCallback(HandshakeCallback *hcb):
 561   SSLServerAcceptCallbackBase(hcb)  {}
 562
 563   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 564   void connAccepted(
 565     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 566     noexcept override {
 567     std::cerr << "HandshakeErrorCallback::connAccepted" << std::endl;
 568
 569     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 570
 571     hcb_->setSocket(sock);
 572     sock->getEventBase()->tryRunAfterDelay([=] {
 573         std::cerr << "Delayed SSL accept, client will have close by now"
 574                   << std::endl;
 575         // SSL accept will fail
 576         EXPECT_EQ(
 577           sock->getSSLState(),
 578           AsyncSSLSocket::STATE_UNINIT);
 579         hcb_->socket_->sslAccept(hcb_);
 580         // This registers for an event
 581         EXPECT_EQ(
 582           sock->getSSLState(),
 583           AsyncSSLSocket::STATE_ACCEPTING);
 584
 585         state = STATE_SUCCEEDED;
 586       }, 100);
 587   }
 588 };
 589
 590
 591 class TestSSLServer {
 592  protected:
 593   EventBase evb_;
 594   std::shared_ptr<folly::SSLContext> ctx_;
 595   SSLServerAcceptCallbackBase *acb_;
 596   std::shared_ptr<folly::AsyncServerSocket> socket_;
 597   folly::SocketAddress address_;
 598   pthread_t thread_;
 599
 600   static void *Main(void *ctx) {
 601     TestSSLServer *self = static_cast<TestSSLServer*>(ctx);
 602     self->evb_.loop();
 603     std::cerr << "Server thread exited event loop" << std::endl;
 604     return nullptr;
 605   }
 606
 607  public:
 608   // Create a TestSSLServer.
 609   // This immediately starts listening on the given port.
 610   explicit TestSSLServer(SSLServerAcceptCallbackBase *acb);
 611
 612   // Kill the thread.
 613   ~TestSSLServer() {
 614     evb_.runInEventBaseThread([&](){
 615       socket_->stopAccepting();
 616     });
 617     std::cerr << "Waiting for server thread to exit" << std::endl;
 618     pthread_join(thread_, nullptr);
 619   }
 620
 621   EventBase &getEventBase() { return evb_; }
 622
 623   const folly::SocketAddress& getAddress() const {
 624     return address_;
 625   }
 626 };
 627
 628 class TestSSLAsyncCacheServer : public TestSSLServer {
 629  public:
 630   explicit TestSSLAsyncCacheServer(SSLServerAcceptCallbackBase *acb,
 631         int lookupDelay = 100) :
 632       TestSSLServer(acb) {
 633     SSL_CTX *sslCtx = ctx_->getSSLCtx();
 634     SSL_CTX_sess_set_get_cb(sslCtx,
 635                             TestSSLAsyncCacheServer::getSessionCallback);
 636     SSL_CTX_set_session_cache_mode(
 637       sslCtx, SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_SERVER);
 638     asyncCallbacks_ = 0;
 639     asyncLookups_ = 0;
 640     lookupDelay_ = lookupDelay;
 641   }
 642
 643   uint32_t getAsyncCallbacks() const { return asyncCallbacks_; }
 644   uint32_t getAsyncLookups() const { return asyncLookups_; }
 645
 646  private:
 647   static uint32_t asyncCallbacks_;
 648   static uint32_t asyncLookups_;
 649   static uint32_t lookupDelay_;
 650
 651   static SSL_SESSION* getSessionCallback(SSL* ssl,
 652                                          unsigned char* /* sess_id */,
 653                                          int /* id_len */,
 654                                          int* copyflag) {
 655     *copyflag = 0;
 656     asyncCallbacks_++;
 657 #ifdef SSL_ERROR_WANT_SESS_CACHE_LOOKUP
 658     if (!SSL_want_sess_cache_lookup(ssl)) {
 659       // libssl.so mismatch
 660       std::cerr << "no async support" << std::endl;
 661       return nullptr;
 662     }
 663
 664     AsyncSSLSocket *sslSocket =
 665         AsyncSSLSocket::getFromSSL(ssl);
 666     assert(sslSocket != nullptr);
 667     // Going to simulate an async cache by just running delaying the miss 100ms
 668     if (asyncCallbacks_ % 2 == 0) {
 669       // This socket is already blocked on lookup, return miss
 670       std::cerr << "returning miss" << std::endl;
 671     } else {
 672       // fresh meat - block it
 673       std::cerr << "async lookup" << std::endl;
 674       sslSocket->getEventBase()->tryRunAfterDelay(
 675         std::bind(&AsyncSSLSocket::restartSSLAccept,
 676                   sslSocket), lookupDelay_);
 677       *copyflag = SSL_SESSION_CB_WOULD_BLOCK;
 678       asyncLookups_++;
 679     }
 680 #endif
 681     return nullptr;
 682   }
 683 };
 684
 685 void getfds(int fds[2]);
 686
 687 void getctx(
 688   std::shared_ptr<folly::SSLContext> clientCtx,
 689   std::shared_ptr<folly::SSLContext> serverCtx);
 690
 691 void sslsocketpair(
 692   EventBase* eventBase,
 693   AsyncSSLSocket::UniquePtr* clientSock,
 694   AsyncSSLSocket::UniquePtr* serverSock);
 695
 696 class BlockingWriteClient :
 697   private AsyncSSLSocket::HandshakeCB,
 698   private AsyncTransportWrapper::WriteCallback {
 699  public:
 700   explicit BlockingWriteClient(
 701     AsyncSSLSocket::UniquePtr socket)
 702     : socket_(std::move(socket)),
 703       bufLen_(2500),
 704       iovCount_(2000) {
 705     // Fill buf_
 706     buf_.reset(new uint8_t[bufLen_]);
 707     for (uint32_t n = 0; n < sizeof(buf_); ++n) {
 708       buf_[n] = n % 0xff;
 709     }
 710
 711     // Initialize iov_
 712     iov_.reset(new struct iovec[iovCount_]);
 713     for (uint32_t n = 0; n < iovCount_; ++n) {
 714       iov_[n].iov_base = buf_.get() + n;
 715       if (n & 0x1) {
 716         iov_[n].iov_len = n % bufLen_;
 717       } else {
 718         iov_[n].iov_len = bufLen_ - (n % bufLen_);
 719       }
 720     }
 721
 722     socket_->sslConn(this, 100);
 723   }
 724
 725   struct iovec* getIovec() const {
 726     return iov_.get();
 727   }
 728   uint32_t getIovecCount() const {
 729     return iovCount_;
 730   }
 731
 732  private:
 733   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 734     socket_->writev(this, iov_.get(), iovCount_);
 735   }
 736   void handshakeErr(
 737     AsyncSSLSocket*,
 738     const AsyncSocketException& ex) noexcept override {
 739     ADD_FAILURE() << "client handshake error: " << ex.what();
 740   }
 741   void writeSuccess() noexcept override {
 742     socket_->close();
 743   }
 744   void writeErr(
 745     size_t bytesWritten,
 746     const AsyncSocketException& ex) noexcept override {
 747     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 748                   << ex.what();
 749   }
 750
 751   AsyncSSLSocket::UniquePtr socket_;
 752   uint32_t bufLen_;
 753   uint32_t iovCount_;
 754   std::unique_ptr<uint8_t[]> buf_;
 755   std::unique_ptr<struct iovec[]> iov_;
 756 };
 757
 758 class BlockingWriteServer :
 759     private AsyncSSLSocket::HandshakeCB,
 760     private AsyncTransportWrapper::ReadCallback {
 761  public:
 762   explicit BlockingWriteServer(
 763     AsyncSSLSocket::UniquePtr socket)
 764     : socket_(std::move(socket)),
 765       bufSize_(2500 * 2000),
 766       bytesRead_(0) {
 767     buf_.reset(new uint8_t[bufSize_]);
 768     socket_->sslAccept(this, 100);
 769   }
 770
 771   void checkBuffer(struct iovec* iov, uint32_t count) const {
 772     uint32_t idx = 0;
 773     for (uint32_t n = 0; n < count; ++n) {
 774       size_t bytesLeft = bytesRead_ - idx;
 775       int rc = memcmp(buf_.get() + idx, iov[n].iov_base,
 776                       std::min(iov[n].iov_len, bytesLeft));
 777       if (rc != 0) {
 778         FAIL() << "buffer mismatch at iovec " << n << "/" << count
 779                << ": rc=" << rc;
 780
 781       }
 782       if (iov[n].iov_len > bytesLeft) {
 783         FAIL() << "server did not read enough data: "
 784                << "ended at byte " << bytesLeft << "/" << iov[n].iov_len
 785                << " in iovec " << n << "/" << count;
 786       }
 787
 788       idx += iov[n].iov_len;
 789     }
 790     if (idx != bytesRead_) {
 791       ADD_FAILURE() << "server read extra data: " << bytesRead_
 792                     << " bytes read; expected " << idx;
 793     }
 794   }
 795
 796  private:
 797   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 798     // Wait 10ms before reading, so the client's writes will initially block.
 799     socket_->getEventBase()->tryRunAfterDelay(
 800         [this] { socket_->setReadCB(this); }, 10);
 801   }
 802   void handshakeErr(
 803     AsyncSSLSocket*,
 804     const AsyncSocketException& ex) noexcept override {
 805     ADD_FAILURE() << "server handshake error: " << ex.what();
 806   }
 807   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 808     *bufReturn = buf_.get() + bytesRead_;
 809     *lenReturn = bufSize_ - bytesRead_;
 810   }
 811   void readDataAvailable(size_t len) noexcept override {
 812     bytesRead_ += len;
 813     socket_->setReadCB(nullptr);
 814     socket_->getEventBase()->tryRunAfterDelay(
 815         [this] { socket_->setReadCB(this); }, 2);
 816   }
 817   void readEOF() noexcept override {
 818     socket_->close();
 819   }
 820   void readErr(
 821     const AsyncSocketException& ex) noexcept override {
 822     ADD_FAILURE() << "server read error: " << ex.what();
 823   }
 824
 825   AsyncSSLSocket::UniquePtr socket_;
 826   uint32_t bufSize_;
 827   uint32_t bytesRead_;
 828   std::unique_ptr<uint8_t[]> buf_;
 829 };
 830
 831 class NpnClient :
 832   private AsyncSSLSocket::HandshakeCB,
 833   private AsyncTransportWrapper::WriteCallback {
 834  public:
 835   explicit NpnClient(
 836     AsyncSSLSocket::UniquePtr socket)
 837       : nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
 838     socket_->sslConn(this);
 839   }
 840
 841   const unsigned char* nextProto;
 842   unsigned nextProtoLength;
 843   SSLContext::NextProtocolType protocolType;
 844
 845  private:
 846   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 847     socket_->getSelectedNextProtocol(
 848         &nextProto, &nextProtoLength, &protocolType);
 849   }
 850   void handshakeErr(
 851     AsyncSSLSocket*,
 852     const AsyncSocketException& ex) noexcept override {
 853     ADD_FAILURE() << "client handshake error: " << ex.what();
 854   }
 855   void writeSuccess() noexcept override {
 856     socket_->close();
 857   }
 858   void writeErr(
 859     size_t bytesWritten,
 860     const AsyncSocketException& ex) noexcept override {
 861     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 862                   << ex.what();
 863   }
 864
 865   AsyncSSLSocket::UniquePtr socket_;
 866 };
 867
 868 class NpnServer :
 869     private AsyncSSLSocket::HandshakeCB,
 870     private AsyncTransportWrapper::ReadCallback {
 871  public:
 872   explicit NpnServer(AsyncSSLSocket::UniquePtr socket)
 873       : nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
 874     socket_->sslAccept(this);
 875   }
 876
 877   const unsigned char* nextProto;
 878   unsigned nextProtoLength;
 879   SSLContext::NextProtocolType protocolType;
 880
 881  private:
 882   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 883     socket_->getSelectedNextProtocol(
 884         &nextProto, &nextProtoLength, &protocolType);
 885   }
 886   void handshakeErr(
 887     AsyncSSLSocket*,
 888     const AsyncSocketException& ex) noexcept override {
 889     ADD_FAILURE() << "server handshake error: " << ex.what();
 890   }
 891   void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
 892     *lenReturn = 0;
 893   }
 894   void readDataAvailable(size_t /* len */) noexcept override {}
 895   void readEOF() noexcept override {
 896     socket_->close();
 897   }
 898   void readErr(
 899     const AsyncSocketException& ex) noexcept override {
 900     ADD_FAILURE() << "server read error: " << ex.what();
 901   }
 902
 903   AsyncSSLSocket::UniquePtr socket_;
 904 };
 905
 906 class RenegotiatingServer : public AsyncSSLSocket::HandshakeCB,
 907                             public AsyncTransportWrapper::ReadCallback {
 908  public:
 909   explicit RenegotiatingServer(AsyncSSLSocket::UniquePtr socket)
 910       : socket_(std::move(socket)) {
 911     socket_->sslAccept(this);
 912   }
 913
 914   ~RenegotiatingServer() {
 915     socket_->setReadCB(nullptr);
 916   }
 917
 918   void handshakeSuc(AsyncSSLSocket* /* socket */) noexcept override {
 919     LOG(INFO) << "Renegotiating server handshake success";
 920     socket_->setReadCB(this);
 921   }
 922   void handshakeErr(
 923       AsyncSSLSocket*,
 924       const AsyncSocketException& ex) noexcept override {
 925     ADD_FAILURE() << "Renegotiating server handshake error: " << ex.what();
 926   }
 927   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 928     *lenReturn = sizeof(buf);
 929     *bufReturn = buf;
 930   }
 931   void readDataAvailable(size_t /* len */) noexcept override {}
 932   void readEOF() noexcept override {}
 933   void readErr(const AsyncSocketException& ex) noexcept override {
 934     LOG(INFO) << "server got read error " << ex.what();
 935     auto exPtr = dynamic_cast<const SSLException*>(&ex);
 936     ASSERT_NE(nullptr, exPtr);
 937     std::string exStr(ex.what());
 938     SSLException sslEx(SSLError::CLIENT_RENEGOTIATION);
 939     ASSERT_NE(std::string::npos, exStr.find(sslEx.what()));
 940     renegotiationError_ = true;
 941   }
 942
 943   AsyncSSLSocket::UniquePtr socket_;
 944   unsigned char buf[128];
 945   bool renegotiationError_{false};
 946 };
 947
 948 #ifndef OPENSSL_NO_TLSEXT
 949 class SNIClient :
 950   private AsyncSSLSocket::HandshakeCB,
 951   private AsyncTransportWrapper::WriteCallback {
 952  public:
 953   explicit SNIClient(
 954     AsyncSSLSocket::UniquePtr socket)
 955       : serverNameMatch(false), socket_(std::move(socket)) {
 956     socket_->sslConn(this);
 957   }
 958
 959   bool serverNameMatch;
 960
 961  private:
 962   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 963     serverNameMatch = socket_->isServerNameMatch();
 964   }
 965   void handshakeErr(
 966     AsyncSSLSocket*,
 967     const AsyncSocketException& ex) noexcept override {
 968     ADD_FAILURE() << "client handshake error: " << ex.what();
 969   }
 970   void writeSuccess() noexcept override {
 971     socket_->close();
 972   }
 973   void writeErr(
 974     size_t bytesWritten,
 975     const AsyncSocketException& ex) noexcept override {
 976     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 977                   << ex.what();
 978   }
 979
 980   AsyncSSLSocket::UniquePtr socket_;
 981 };
 982
 983 class SNIServer :
 984     private AsyncSSLSocket::HandshakeCB,
 985     private AsyncTransportWrapper::ReadCallback {
 986  public:
 987   explicit SNIServer(
 988     AsyncSSLSocket::UniquePtr socket,
 989     const std::shared_ptr<folly::SSLContext>& ctx,
 990     const std::shared_ptr<folly::SSLContext>& sniCtx,
 991     const std::string& expectedServerName)
 992       : serverNameMatch(false), socket_(std::move(socket)), sniCtx_(sniCtx),
 993         expectedServerName_(expectedServerName) {
 994     ctx->setServerNameCallback(std::bind(&SNIServer::serverNameCallback, this,
 995                                          std::placeholders::_1));
 996     socket_->sslAccept(this);
 997   }
 998
 999   bool serverNameMatch;
1000
1001  private:
1002   void handshakeSuc(AsyncSSLSocket* /* ssl */) noexcept override {}
1003   void handshakeErr(
1004     AsyncSSLSocket*,
1005     const AsyncSocketException& ex) noexcept override {
1006     ADD_FAILURE() << "server handshake error: " << ex.what();
1007   }
1008   void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
1009     *lenReturn = 0;
1010   }
1011   void readDataAvailable(size_t /* len */) noexcept override {}
1012   void readEOF() noexcept override {
1013     socket_->close();
1014   }
1015   void readErr(
1016     const AsyncSocketException& ex) noexcept override {
1017     ADD_FAILURE() << "server read error: " << ex.what();
1018   }
1019
1020   folly::SSLContext::ServerNameCallbackResult
1021     serverNameCallback(SSL *ssl) {
1022     const char *sn = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1023     if (sniCtx_ &&
1024         sn &&
1025         !strcasecmp(expectedServerName_.c_str(), sn)) {
1026       AsyncSSLSocket *sslSocket =
1027           AsyncSSLSocket::getFromSSL(ssl);
1028       sslSocket->switchServerSSLContext(sniCtx_);
1029       serverNameMatch = true;
1030       return folly::SSLContext::SERVER_NAME_FOUND;
1031     } else {
1032       serverNameMatch = false;
1033       return folly::SSLContext::SERVER_NAME_NOT_FOUND;
1034     }
1035   }
1036
1037   AsyncSSLSocket::UniquePtr socket_;
1038   std::shared_ptr<folly::SSLContext> sniCtx_;
1039   std::string expectedServerName_;
1040 };
1041 #endif
1042
1043 class SSLClient : public AsyncSocket::ConnectCallback,
1044                   public AsyncTransportWrapper::WriteCallback,
1045                   public AsyncTransportWrapper::ReadCallback
1046 {
1047  private:
1048   EventBase *eventBase_;
1049   std::shared_ptr<AsyncSSLSocket> sslSocket_;
1050   SSL_SESSION *session_;
1051   std::shared_ptr<folly::SSLContext> ctx_;
1052   uint32_t requests_;
1053   folly::SocketAddress address_;
1054   uint32_t timeout_;
1055   char buf_[128];
1056   char readbuf_[128];
1057   uint32_t bytesRead_;
1058   uint32_t hit_;
1059   uint32_t miss_;
1060   uint32_t errors_;
1061   uint32_t writeAfterConnectErrors_;
1062
1063   // These settings test that we eventually drain the
1064   // socket, even if the maxReadsPerEvent_ is hit during
1065   // a event loop iteration.
1066   static constexpr size_t kMaxReadsPerEvent = 2;
1067   static constexpr size_t kMaxReadBufferSz =
1068     sizeof(readbuf_) / kMaxReadsPerEvent / 2;  // 2 event loop iterations
1069
1070  public:
1071   SSLClient(EventBase *eventBase,
1072             const folly::SocketAddress& address,
1073             uint32_t requests,
1074             uint32_t timeout = 0)
1075       : eventBase_(eventBase),
1076         session_(nullptr),
1077         requests_(requests),
1078         address_(address),
1079         timeout_(timeout),
1080         bytesRead_(0),
1081         hit_(0),
1082         miss_(0),
1083         errors_(0),
1084         writeAfterConnectErrors_(0) {
1085     ctx_.reset(new folly::SSLContext());
1086     ctx_->setOptions(SSL_OP_NO_TICKET);
1087     ctx_->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1088     memset(buf_, 'a', sizeof(buf_));
1089   }
1090
1091   ~SSLClient() {
1092     if (session_) {
1093       SSL_SESSION_free(session_);
1094     }
1095     if (errors_ == 0) {
1096       EXPECT_EQ(bytesRead_, sizeof(buf_));
1097     }
1098   }
1099
1100   uint32_t getHit() const { return hit_; }
1101
1102   uint32_t getMiss() const { return miss_; }
1103
1104   uint32_t getErrors() const { return errors_; }
1105
1106   uint32_t getWriteAfterConnectErrors() const {
1107     return writeAfterConnectErrors_;
1108   }
1109
1110   void connect(bool writeNow = false) {
1111     sslSocket_ = AsyncSSLSocket::newSocket(
1112       ctx_, eventBase_);
1113     if (session_ != nullptr) {
1114       sslSocket_->setSSLSession(session_);
1115     }
1116     requests_--;
1117     sslSocket_->connect(this, address_, timeout_);
1118     if (sslSocket_ && writeNow) {
1119       // write some junk, used in an error test
1120       sslSocket_->write(this, buf_, sizeof(buf_));
1121     }
1122   }
1123
1124   void connectSuccess() noexcept override {
1125     std::cerr << "client SSL socket connected" << std::endl;
1126     if (sslSocket_->getSSLSessionReused()) {
1127       hit_++;
1128     } else {
1129       miss_++;
1130       if (session_ != nullptr) {
1131         SSL_SESSION_free(session_);
1132       }
1133       session_ = sslSocket_->getSSLSession();
1134     }
1135
1136     // write()
1137     sslSocket_->setMaxReadsPerEvent(kMaxReadsPerEvent);
1138     sslSocket_->write(this, buf_, sizeof(buf_));
1139     sslSocket_->setReadCB(this);
1140     memset(readbuf_, 'b', sizeof(readbuf_));
1141     bytesRead_ = 0;
1142   }
1143
1144   void connectErr(
1145     const AsyncSocketException& ex) noexcept override {
1146     std::cerr << "SSLClient::connectError: " << ex.what() << std::endl;
1147     errors_++;
1148     sslSocket_.reset();
1149   }
1150
1151   void writeSuccess() noexcept override {
1152     std::cerr << "client write success" << std::endl;
1153   }
1154
1155   void writeErr(size_t /* bytesWritten */,
1156                 const AsyncSocketException& ex) noexcept override {
1157     std::cerr << "client writeError: " << ex.what() << std::endl;
1158     if (!sslSocket_) {
1159       writeAfterConnectErrors_++;
1160     }
1161   }
1162
1163   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
1164     *bufReturn = readbuf_ + bytesRead_;
1165     *lenReturn = std::min(kMaxReadBufferSz, sizeof(readbuf_) - bytesRead_);
1166   }
1167
1168   void readEOF() noexcept override {
1169     std::cerr << "client readEOF" << std::endl;
1170   }
1171
1172   void readErr(
1173     const AsyncSocketException& ex) noexcept override {
1174     std::cerr << "client readError: " << ex.what() << std::endl;
1175   }
1176
1177   void readDataAvailable(size_t len) noexcept override {
1178     std::cerr << "client read data: " << len << std::endl;
1179     bytesRead_ += len;
1180     if (bytesRead_ == sizeof(buf_)) {
1181       EXPECT_EQ(memcmp(buf_, readbuf_, bytesRead_), 0);
1182       sslSocket_->closeNow();
1183       sslSocket_.reset();
1184       if (requests_ != 0) {
1185         connect();
1186       }
1187     }
1188   }
1189
1190 };
1191
1192 class SSLHandshakeBase :
1193   public AsyncSSLSocket::HandshakeCB,
1194   private AsyncTransportWrapper::WriteCallback {
1195  public:
1196   explicit SSLHandshakeBase(
1197    AsyncSSLSocket::UniquePtr socket,
1198    bool preverifyResult,
1199    bool verifyResult) :
1200     handshakeVerify_(false),
1201     handshakeSuccess_(false),
1202     handshakeError_(false),
1203     socket_(std::move(socket)),
1204     preverifyResult_(preverifyResult),
1205     verifyResult_(verifyResult) {
1206   }
1207
1208   AsyncSSLSocket::UniquePtr moveSocket() && {
1209     return std::move(socket_);
1210   }
1211
1212   bool handshakeVerify_;
1213   bool handshakeSuccess_;
1214   bool handshakeError_;
1215   std::chrono::nanoseconds handshakeTime;
1216
1217  protected:
1218   AsyncSSLSocket::UniquePtr socket_;
1219   bool preverifyResult_;
1220   bool verifyResult_;
1221
1222   // HandshakeCallback
1223   bool handshakeVer(AsyncSSLSocket* /* sock */,
1224                     bool preverifyOk,
1225                     X509_STORE_CTX* /* ctx */) noexcept override {
1226     handshakeVerify_ = true;
1227
1228     EXPECT_EQ(preverifyResult_, preverifyOk);
1229     return verifyResult_;
1230   }
1231
1232   void handshakeSuc(AsyncSSLSocket*) noexcept override {
1233     LOG(INFO) << "Handshake success";
1234     handshakeSuccess_ = true;
1235     handshakeTime = socket_->getHandshakeTime();
1236   }
1237
1238   void handshakeErr(
1239       AsyncSSLSocket*,
1240       const AsyncSocketException& ex) noexcept override {
1241     LOG(INFO) << "Handshake error " << ex.what();
1242     handshakeError_ = true;
1243     handshakeTime = socket_->getHandshakeTime();
1244   }
1245
1246   // WriteCallback
1247   void writeSuccess() noexcept override {
1248     socket_->close();
1249   }
1250
1251   void writeErr(
1252    size_t bytesWritten,
1253    const AsyncSocketException& ex) noexcept override {
1254     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
1255                   << ex.what();
1256   }
1257 };
1258
1259 class SSLHandshakeClient : public SSLHandshakeBase {
1260  public:
1261   SSLHandshakeClient(
1262    AsyncSSLSocket::UniquePtr socket,
1263    bool preverifyResult,
1264    bool verifyResult) :
1265     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1266     socket_->sslConn(this, 0);
1267   }
1268 };
1269
1270 class SSLHandshakeClientNoVerify : public SSLHandshakeBase {
1271  public:
1272   SSLHandshakeClientNoVerify(
1273    AsyncSSLSocket::UniquePtr socket,
1274    bool preverifyResult,
1275    bool verifyResult) :
1276     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1277     socket_->sslConn(this, 0,
1278       folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1279   }
1280 };
1281
1282 class SSLHandshakeClientDoVerify : public SSLHandshakeBase {
1283  public:
1284   SSLHandshakeClientDoVerify(
1285    AsyncSSLSocket::UniquePtr socket,
1286    bool preverifyResult,
1287    bool verifyResult) :
1288     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1289     socket_->sslConn(this, 0,
1290       folly::SSLContext::SSLVerifyPeerEnum::VERIFY);
1291   }
1292 };
1293
1294 class SSLHandshakeServer : public SSLHandshakeBase {
1295  public:
1296   SSLHandshakeServer(
1297       AsyncSSLSocket::UniquePtr socket,
1298       bool preverifyResult,
1299       bool verifyResult)
1300     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1301     socket_->sslAccept(this, 0);
1302   }
1303 };
1304
1305 class SSLHandshakeServerParseClientHello : public SSLHandshakeBase {
1306  public:
1307   SSLHandshakeServerParseClientHello(
1308       AsyncSSLSocket::UniquePtr socket,
1309       bool preverifyResult,
1310       bool verifyResult)
1311       : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1312     socket_->enableClientHelloParsing();
1313     socket_->sslAccept(this, 0);
1314   }
1315
1316   std::string clientCiphers_, sharedCiphers_, serverCiphers_, chosenCipher_;
1317
1318  protected:
1319   void handshakeSuc(AsyncSSLSocket* sock) noexcept override {
1320     handshakeSuccess_ = true;
1321     sock->getSSLSharedCiphers(sharedCiphers_);
1322     sock->getSSLServerCiphers(serverCiphers_);
1323     sock->getSSLClientCiphers(clientCiphers_);
1324     chosenCipher_ = sock->getNegotiatedCipherName();
1325   }
1326 };
1327
1328
1329 class SSLHandshakeServerNoVerify : public SSLHandshakeBase {
1330  public:
1331   SSLHandshakeServerNoVerify(
1332       AsyncSSLSocket::UniquePtr socket,
1333       bool preverifyResult,
1334       bool verifyResult)
1335     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1336     socket_->sslAccept(this, 0,
1337       folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1338   }
1339 };
1340
1341 class SSLHandshakeServerDoVerify : public SSLHandshakeBase {
1342  public:
1343   SSLHandshakeServerDoVerify(
1344       AsyncSSLSocket::UniquePtr socket,
1345       bool preverifyResult,
1346       bool verifyResult)
1347     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1348     socket_->sslAccept(this, 0,
1349       folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
1350   }
1351 };
1352
1353 class EventBaseAborter : public AsyncTimeout {
1354  public:
1355   EventBaseAborter(EventBase* eventBase,
1356                    uint32_t timeoutMS)
1357     : AsyncTimeout(
1358       eventBase, AsyncTimeout::InternalEnum::INTERNAL)
1359     , eventBase_(eventBase) {
1360     scheduleTimeout(timeoutMS);
1361   }
1362
1363   void timeoutExpired() noexcept override {
1364     FAIL() << "test timed out";
1365     eventBase_->terminateLoopSoon();
1366   }
1367
1368  private:
1369   EventBase* eventBase_;
1370 };
1371
1372 }