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(
 611       SSLServerAcceptCallbackBase* acb,
 612       bool enableTFO = false);
 613
 614   // Kill the thread.
 615   ~TestSSLServer() {
 616     evb_.runInEventBaseThread([&](){
 617       socket_->stopAccepting();
 618     });
 619     std::cerr << "Waiting for server thread to exit" << std::endl;
 620     pthread_join(thread_, nullptr);
 621   }
 622
 623   EventBase &getEventBase() { return evb_; }
 624
 625   const folly::SocketAddress& getAddress() const {
 626     return address_;
 627   }
 628 };
 629
 630 class TestSSLAsyncCacheServer : public TestSSLServer {
 631  public:
 632   explicit TestSSLAsyncCacheServer(SSLServerAcceptCallbackBase *acb,
 633         int lookupDelay = 100) :
 634       TestSSLServer(acb) {
 635     SSL_CTX *sslCtx = ctx_->getSSLCtx();
 636     SSL_CTX_sess_set_get_cb(sslCtx,
 637                             TestSSLAsyncCacheServer::getSessionCallback);
 638     SSL_CTX_set_session_cache_mode(
 639       sslCtx, SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_SERVER);
 640     asyncCallbacks_ = 0;
 641     asyncLookups_ = 0;
 642     lookupDelay_ = lookupDelay;
 643   }
 644
 645   uint32_t getAsyncCallbacks() const { return asyncCallbacks_; }
 646   uint32_t getAsyncLookups() const { return asyncLookups_; }
 647
 648  private:
 649   static uint32_t asyncCallbacks_;
 650   static uint32_t asyncLookups_;
 651   static uint32_t lookupDelay_;
 652
 653   static SSL_SESSION* getSessionCallback(SSL* ssl,
 654                                          unsigned char* /* sess_id */,
 655                                          int /* id_len */,
 656                                          int* copyflag) {
 657     *copyflag = 0;
 658     asyncCallbacks_++;
 659 #ifdef SSL_ERROR_WANT_SESS_CACHE_LOOKUP
 660     if (!SSL_want_sess_cache_lookup(ssl)) {
 661       // libssl.so mismatch
 662       std::cerr << "no async support" << std::endl;
 663       return nullptr;
 664     }
 665
 666     AsyncSSLSocket *sslSocket =
 667         AsyncSSLSocket::getFromSSL(ssl);
 668     assert(sslSocket != nullptr);
 669     // Going to simulate an async cache by just running delaying the miss 100ms
 670     if (asyncCallbacks_ % 2 == 0) {
 671       // This socket is already blocked on lookup, return miss
 672       std::cerr << "returning miss" << std::endl;
 673     } else {
 674       // fresh meat - block it
 675       std::cerr << "async lookup" << std::endl;
 676       sslSocket->getEventBase()->tryRunAfterDelay(
 677         std::bind(&AsyncSSLSocket::restartSSLAccept,
 678                   sslSocket), lookupDelay_);
 679       *copyflag = SSL_SESSION_CB_WOULD_BLOCK;
 680       asyncLookups_++;
 681     }
 682 #endif
 683     return nullptr;
 684   }
 685 };
 686
 687 void getfds(int fds[2]);
 688
 689 void getctx(
 690   std::shared_ptr<folly::SSLContext> clientCtx,
 691   std::shared_ptr<folly::SSLContext> serverCtx);
 692
 693 void sslsocketpair(
 694   EventBase* eventBase,
 695   AsyncSSLSocket::UniquePtr* clientSock,
 696   AsyncSSLSocket::UniquePtr* serverSock);
 697
 698 class BlockingWriteClient :
 699   private AsyncSSLSocket::HandshakeCB,
 700   private AsyncTransportWrapper::WriteCallback {
 701  public:
 702   explicit BlockingWriteClient(
 703     AsyncSSLSocket::UniquePtr socket)
 704     : socket_(std::move(socket)),
 705       bufLen_(2500),
 706       iovCount_(2000) {
 707     // Fill buf_
 708     buf_.reset(new uint8_t[bufLen_]);
 709     for (uint32_t n = 0; n < sizeof(buf_); ++n) {
 710       buf_[n] = n % 0xff;
 711     }
 712
 713     // Initialize iov_
 714     iov_.reset(new struct iovec[iovCount_]);
 715     for (uint32_t n = 0; n < iovCount_; ++n) {
 716       iov_[n].iov_base = buf_.get() + n;
 717       if (n & 0x1) {
 718         iov_[n].iov_len = n % bufLen_;
 719       } else {
 720         iov_[n].iov_len = bufLen_ - (n % bufLen_);
 721       }
 722     }
 723
 724     socket_->sslConn(this, 100);
 725   }
 726
 727   struct iovec* getIovec() const {
 728     return iov_.get();
 729   }
 730   uint32_t getIovecCount() const {
 731     return iovCount_;
 732   }
 733
 734  private:
 735   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 736     socket_->writev(this, iov_.get(), iovCount_);
 737   }
 738   void handshakeErr(
 739     AsyncSSLSocket*,
 740     const AsyncSocketException& ex) noexcept override {
 741     ADD_FAILURE() << "client handshake error: " << ex.what();
 742   }
 743   void writeSuccess() noexcept override {
 744     socket_->close();
 745   }
 746   void writeErr(
 747     size_t bytesWritten,
 748     const AsyncSocketException& ex) noexcept override {
 749     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 750                   << ex.what();
 751   }
 752
 753   AsyncSSLSocket::UniquePtr socket_;
 754   uint32_t bufLen_;
 755   uint32_t iovCount_;
 756   std::unique_ptr<uint8_t[]> buf_;
 757   std::unique_ptr<struct iovec[]> iov_;
 758 };
 759
 760 class BlockingWriteServer :
 761     private AsyncSSLSocket::HandshakeCB,
 762     private AsyncTransportWrapper::ReadCallback {
 763  public:
 764   explicit BlockingWriteServer(
 765     AsyncSSLSocket::UniquePtr socket)
 766     : socket_(std::move(socket)),
 767       bufSize_(2500 * 2000),
 768       bytesRead_(0) {
 769     buf_.reset(new uint8_t[bufSize_]);
 770     socket_->sslAccept(this, 100);
 771   }
 772
 773   void checkBuffer(struct iovec* iov, uint32_t count) const {
 774     uint32_t idx = 0;
 775     for (uint32_t n = 0; n < count; ++n) {
 776       size_t bytesLeft = bytesRead_ - idx;
 777       int rc = memcmp(buf_.get() + idx, iov[n].iov_base,
 778                       std::min(iov[n].iov_len, bytesLeft));
 779       if (rc != 0) {
 780         FAIL() << "buffer mismatch at iovec " << n << "/" << count
 781                << ": rc=" << rc;
 782
 783       }
 784       if (iov[n].iov_len > bytesLeft) {
 785         FAIL() << "server did not read enough data: "
 786                << "ended at byte " << bytesLeft << "/" << iov[n].iov_len
 787                << " in iovec " << n << "/" << count;
 788       }
 789
 790       idx += iov[n].iov_len;
 791     }
 792     if (idx != bytesRead_) {
 793       ADD_FAILURE() << "server read extra data: " << bytesRead_
 794                     << " bytes read; expected " << idx;
 795     }
 796   }
 797
 798  private:
 799   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 800     // Wait 10ms before reading, so the client's writes will initially block.
 801     socket_->getEventBase()->tryRunAfterDelay(
 802         [this] { socket_->setReadCB(this); }, 10);
 803   }
 804   void handshakeErr(
 805     AsyncSSLSocket*,
 806     const AsyncSocketException& ex) noexcept override {
 807     ADD_FAILURE() << "server handshake error: " << ex.what();
 808   }
 809   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 810     *bufReturn = buf_.get() + bytesRead_;
 811     *lenReturn = bufSize_ - bytesRead_;
 812   }
 813   void readDataAvailable(size_t len) noexcept override {
 814     bytesRead_ += len;
 815     socket_->setReadCB(nullptr);
 816     socket_->getEventBase()->tryRunAfterDelay(
 817         [this] { socket_->setReadCB(this); }, 2);
 818   }
 819   void readEOF() noexcept override {
 820     socket_->close();
 821   }
 822   void readErr(
 823     const AsyncSocketException& ex) noexcept override {
 824     ADD_FAILURE() << "server read error: " << ex.what();
 825   }
 826
 827   AsyncSSLSocket::UniquePtr socket_;
 828   uint32_t bufSize_;
 829   uint32_t bytesRead_;
 830   std::unique_ptr<uint8_t[]> buf_;
 831 };
 832
 833 class NpnClient :
 834   private AsyncSSLSocket::HandshakeCB,
 835   private AsyncTransportWrapper::WriteCallback {
 836  public:
 837   explicit NpnClient(
 838     AsyncSSLSocket::UniquePtr socket)
 839       : nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
 840     socket_->sslConn(this);
 841   }
 842
 843   const unsigned char* nextProto;
 844   unsigned nextProtoLength;
 845   SSLContext::NextProtocolType protocolType;
 846
 847  private:
 848   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 849     socket_->getSelectedNextProtocol(
 850         &nextProto, &nextProtoLength, &protocolType);
 851   }
 852   void handshakeErr(
 853     AsyncSSLSocket*,
 854     const AsyncSocketException& ex) noexcept override {
 855     ADD_FAILURE() << "client handshake error: " << ex.what();
 856   }
 857   void writeSuccess() noexcept override {
 858     socket_->close();
 859   }
 860   void writeErr(
 861     size_t bytesWritten,
 862     const AsyncSocketException& ex) noexcept override {
 863     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 864                   << ex.what();
 865   }
 866
 867   AsyncSSLSocket::UniquePtr socket_;
 868 };
 869
 870 class NpnServer :
 871     private AsyncSSLSocket::HandshakeCB,
 872     private AsyncTransportWrapper::ReadCallback {
 873  public:
 874   explicit NpnServer(AsyncSSLSocket::UniquePtr socket)
 875       : nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
 876     socket_->sslAccept(this);
 877   }
 878
 879   const unsigned char* nextProto;
 880   unsigned nextProtoLength;
 881   SSLContext::NextProtocolType protocolType;
 882
 883  private:
 884   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 885     socket_->getSelectedNextProtocol(
 886         &nextProto, &nextProtoLength, &protocolType);
 887   }
 888   void handshakeErr(
 889     AsyncSSLSocket*,
 890     const AsyncSocketException& ex) noexcept override {
 891     ADD_FAILURE() << "server handshake error: " << ex.what();
 892   }
 893   void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
 894     *lenReturn = 0;
 895   }
 896   void readDataAvailable(size_t /* len */) noexcept override {}
 897   void readEOF() noexcept override {
 898     socket_->close();
 899   }
 900   void readErr(
 901     const AsyncSocketException& ex) noexcept override {
 902     ADD_FAILURE() << "server read error: " << ex.what();
 903   }
 904
 905   AsyncSSLSocket::UniquePtr socket_;
 906 };
 907
 908 class RenegotiatingServer : public AsyncSSLSocket::HandshakeCB,
 909                             public AsyncTransportWrapper::ReadCallback {
 910  public:
 911   explicit RenegotiatingServer(AsyncSSLSocket::UniquePtr socket)
 912       : socket_(std::move(socket)) {
 913     socket_->sslAccept(this);
 914   }
 915
 916   ~RenegotiatingServer() {
 917     socket_->setReadCB(nullptr);
 918   }
 919
 920   void handshakeSuc(AsyncSSLSocket* /* socket */) noexcept override {
 921     LOG(INFO) << "Renegotiating server handshake success";
 922     socket_->setReadCB(this);
 923   }
 924   void handshakeErr(
 925       AsyncSSLSocket*,
 926       const AsyncSocketException& ex) noexcept override {
 927     ADD_FAILURE() << "Renegotiating server handshake error: " << ex.what();
 928   }
 929   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 930     *lenReturn = sizeof(buf);
 931     *bufReturn = buf;
 932   }
 933   void readDataAvailable(size_t /* len */) noexcept override {}
 934   void readEOF() noexcept override {}
 935   void readErr(const AsyncSocketException& ex) noexcept override {
 936     LOG(INFO) << "server got read error " << ex.what();
 937     auto exPtr = dynamic_cast<const SSLException*>(&ex);
 938     ASSERT_NE(nullptr, exPtr);
 939     std::string exStr(ex.what());
 940     SSLException sslEx(SSLError::CLIENT_RENEGOTIATION);
 941     ASSERT_NE(std::string::npos, exStr.find(sslEx.what()));
 942     renegotiationError_ = true;
 943   }
 944
 945   AsyncSSLSocket::UniquePtr socket_;
 946   unsigned char buf[128];
 947   bool renegotiationError_{false};
 948 };
 949
 950 #ifndef OPENSSL_NO_TLSEXT
 951 class SNIClient :
 952   private AsyncSSLSocket::HandshakeCB,
 953   private AsyncTransportWrapper::WriteCallback {
 954  public:
 955   explicit SNIClient(
 956     AsyncSSLSocket::UniquePtr socket)
 957       : serverNameMatch(false), socket_(std::move(socket)) {
 958     socket_->sslConn(this);
 959   }
 960
 961   bool serverNameMatch;
 962
 963  private:
 964   void handshakeSuc(AsyncSSLSocket*) noexcept override {
 965     serverNameMatch = socket_->isServerNameMatch();
 966   }
 967   void handshakeErr(
 968     AsyncSSLSocket*,
 969     const AsyncSocketException& ex) noexcept override {
 970     ADD_FAILURE() << "client handshake error: " << ex.what();
 971   }
 972   void writeSuccess() noexcept override {
 973     socket_->close();
 974   }
 975   void writeErr(
 976     size_t bytesWritten,
 977     const AsyncSocketException& ex) noexcept override {
 978     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
 979                   << ex.what();
 980   }
 981
 982   AsyncSSLSocket::UniquePtr socket_;
 983 };
 984
 985 class SNIServer :
 986     private AsyncSSLSocket::HandshakeCB,
 987     private AsyncTransportWrapper::ReadCallback {
 988  public:
 989   explicit SNIServer(
 990     AsyncSSLSocket::UniquePtr socket,
 991     const std::shared_ptr<folly::SSLContext>& ctx,
 992     const std::shared_ptr<folly::SSLContext>& sniCtx,
 993     const std::string& expectedServerName)
 994       : serverNameMatch(false), socket_(std::move(socket)), sniCtx_(sniCtx),
 995         expectedServerName_(expectedServerName) {
 996     ctx->setServerNameCallback(std::bind(&SNIServer::serverNameCallback, this,
 997                                          std::placeholders::_1));
 998     socket_->sslAccept(this);
 999   }
1000
1001   bool serverNameMatch;
1002
1003  private:
1004   void handshakeSuc(AsyncSSLSocket* /* ssl */) noexcept override {}
1005   void handshakeErr(
1006     AsyncSSLSocket*,
1007     const AsyncSocketException& ex) noexcept override {
1008     ADD_FAILURE() << "server handshake error: " << ex.what();
1009   }
1010   void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
1011     *lenReturn = 0;
1012   }
1013   void readDataAvailable(size_t /* len */) noexcept override {}
1014   void readEOF() noexcept override {
1015     socket_->close();
1016   }
1017   void readErr(
1018     const AsyncSocketException& ex) noexcept override {
1019     ADD_FAILURE() << "server read error: " << ex.what();
1020   }
1021
1022   folly::SSLContext::ServerNameCallbackResult
1023     serverNameCallback(SSL *ssl) {
1024     const char *sn = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
1025     if (sniCtx_ &&
1026         sn &&
1027         !strcasecmp(expectedServerName_.c_str(), sn)) {
1028       AsyncSSLSocket *sslSocket =
1029           AsyncSSLSocket::getFromSSL(ssl);
1030       sslSocket->switchServerSSLContext(sniCtx_);
1031       serverNameMatch = true;
1032       return folly::SSLContext::SERVER_NAME_FOUND;
1033     } else {
1034       serverNameMatch = false;
1035       return folly::SSLContext::SERVER_NAME_NOT_FOUND;
1036     }
1037   }
1038
1039   AsyncSSLSocket::UniquePtr socket_;
1040   std::shared_ptr<folly::SSLContext> sniCtx_;
1041   std::string expectedServerName_;
1042 };
1043 #endif
1044
1045 class SSLClient : public AsyncSocket::ConnectCallback,
1046                   public AsyncTransportWrapper::WriteCallback,
1047                   public AsyncTransportWrapper::ReadCallback
1048 {
1049  private:
1050   EventBase *eventBase_;
1051   std::shared_ptr<AsyncSSLSocket> sslSocket_;
1052   SSL_SESSION *session_;
1053   std::shared_ptr<folly::SSLContext> ctx_;
1054   uint32_t requests_;
1055   folly::SocketAddress address_;
1056   uint32_t timeout_;
1057   char buf_[128];
1058   char readbuf_[128];
1059   uint32_t bytesRead_;
1060   uint32_t hit_;
1061   uint32_t miss_;
1062   uint32_t errors_;
1063   uint32_t writeAfterConnectErrors_;
1064
1065   // These settings test that we eventually drain the
1066   // socket, even if the maxReadsPerEvent_ is hit during
1067   // a event loop iteration.
1068   static constexpr size_t kMaxReadsPerEvent = 2;
1069   static constexpr size_t kMaxReadBufferSz =
1070     sizeof(readbuf_) / kMaxReadsPerEvent / 2;  // 2 event loop iterations
1071
1072  public:
1073   SSLClient(EventBase *eventBase,
1074             const folly::SocketAddress& address,
1075             uint32_t requests,
1076             uint32_t timeout = 0)
1077       : eventBase_(eventBase),
1078         session_(nullptr),
1079         requests_(requests),
1080         address_(address),
1081         timeout_(timeout),
1082         bytesRead_(0),
1083         hit_(0),
1084         miss_(0),
1085         errors_(0),
1086         writeAfterConnectErrors_(0) {
1087     ctx_.reset(new folly::SSLContext());
1088     ctx_->setOptions(SSL_OP_NO_TICKET);
1089     ctx_->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1090     memset(buf_, 'a', sizeof(buf_));
1091   }
1092
1093   ~SSLClient() {
1094     if (session_) {
1095       SSL_SESSION_free(session_);
1096     }
1097     if (errors_ == 0) {
1098       EXPECT_EQ(bytesRead_, sizeof(buf_));
1099     }
1100   }
1101
1102   uint32_t getHit() const { return hit_; }
1103
1104   uint32_t getMiss() const { return miss_; }
1105
1106   uint32_t getErrors() const { return errors_; }
1107
1108   uint32_t getWriteAfterConnectErrors() const {
1109     return writeAfterConnectErrors_;
1110   }
1111
1112   void connect(bool writeNow = false) {
1113     sslSocket_ = AsyncSSLSocket::newSocket(
1114       ctx_, eventBase_);
1115     if (session_ != nullptr) {
1116       sslSocket_->setSSLSession(session_);
1117     }
1118     requests_--;
1119     sslSocket_->connect(this, address_, timeout_);
1120     if (sslSocket_ && writeNow) {
1121       // write some junk, used in an error test
1122       sslSocket_->write(this, buf_, sizeof(buf_));
1123     }
1124   }
1125
1126   void connectSuccess() noexcept override {
1127     std::cerr << "client SSL socket connected" << std::endl;
1128     if (sslSocket_->getSSLSessionReused()) {
1129       hit_++;
1130     } else {
1131       miss_++;
1132       if (session_ != nullptr) {
1133         SSL_SESSION_free(session_);
1134       }
1135       session_ = sslSocket_->getSSLSession();
1136     }
1137
1138     // write()
1139     sslSocket_->setMaxReadsPerEvent(kMaxReadsPerEvent);
1140     sslSocket_->write(this, buf_, sizeof(buf_));
1141     sslSocket_->setReadCB(this);
1142     memset(readbuf_, 'b', sizeof(readbuf_));
1143     bytesRead_ = 0;
1144   }
1145
1146   void connectErr(
1147     const AsyncSocketException& ex) noexcept override {
1148     std::cerr << "SSLClient::connectError: " << ex.what() << std::endl;
1149     errors_++;
1150     sslSocket_.reset();
1151   }
1152
1153   void writeSuccess() noexcept override {
1154     std::cerr << "client write success" << std::endl;
1155   }
1156
1157   void writeErr(size_t /* bytesWritten */,
1158                 const AsyncSocketException& ex) noexcept override {
1159     std::cerr << "client writeError: " << ex.what() << std::endl;
1160     if (!sslSocket_) {
1161       writeAfterConnectErrors_++;
1162     }
1163   }
1164
1165   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
1166     *bufReturn = readbuf_ + bytesRead_;
1167     *lenReturn = std::min(kMaxReadBufferSz, sizeof(readbuf_) - bytesRead_);
1168   }
1169
1170   void readEOF() noexcept override {
1171     std::cerr << "client readEOF" << std::endl;
1172   }
1173
1174   void readErr(
1175     const AsyncSocketException& ex) noexcept override {
1176     std::cerr << "client readError: " << ex.what() << std::endl;
1177   }
1178
1179   void readDataAvailable(size_t len) noexcept override {
1180     std::cerr << "client read data: " << len << std::endl;
1181     bytesRead_ += len;
1182     if (bytesRead_ == sizeof(buf_)) {
1183       EXPECT_EQ(memcmp(buf_, readbuf_, bytesRead_), 0);
1184       sslSocket_->closeNow();
1185       sslSocket_.reset();
1186       if (requests_ != 0) {
1187         connect();
1188       }
1189     }
1190   }
1191
1192 };
1193
1194 class SSLHandshakeBase :
1195   public AsyncSSLSocket::HandshakeCB,
1196   private AsyncTransportWrapper::WriteCallback {
1197  public:
1198   explicit SSLHandshakeBase(
1199    AsyncSSLSocket::UniquePtr socket,
1200    bool preverifyResult,
1201    bool verifyResult) :
1202     handshakeVerify_(false),
1203     handshakeSuccess_(false),
1204     handshakeError_(false),
1205     socket_(std::move(socket)),
1206     preverifyResult_(preverifyResult),
1207     verifyResult_(verifyResult) {
1208   }
1209
1210   AsyncSSLSocket::UniquePtr moveSocket() && {
1211     return std::move(socket_);
1212   }
1213
1214   bool handshakeVerify_;
1215   bool handshakeSuccess_;
1216   bool handshakeError_;
1217   std::chrono::nanoseconds handshakeTime;
1218
1219  protected:
1220   AsyncSSLSocket::UniquePtr socket_;
1221   bool preverifyResult_;
1222   bool verifyResult_;
1223
1224   // HandshakeCallback
1225   bool handshakeVer(AsyncSSLSocket* /* sock */,
1226                     bool preverifyOk,
1227                     X509_STORE_CTX* /* ctx */) noexcept override {
1228     handshakeVerify_ = true;
1229
1230     EXPECT_EQ(preverifyResult_, preverifyOk);
1231     return verifyResult_;
1232   }
1233
1234   void handshakeSuc(AsyncSSLSocket*) noexcept override {
1235     LOG(INFO) << "Handshake success";
1236     handshakeSuccess_ = true;
1237     handshakeTime = socket_->getHandshakeTime();
1238   }
1239
1240   void handshakeErr(
1241       AsyncSSLSocket*,
1242       const AsyncSocketException& ex) noexcept override {
1243     LOG(INFO) << "Handshake error " << ex.what();
1244     handshakeError_ = true;
1245     handshakeTime = socket_->getHandshakeTime();
1246   }
1247
1248   // WriteCallback
1249   void writeSuccess() noexcept override {
1250     socket_->close();
1251   }
1252
1253   void writeErr(
1254    size_t bytesWritten,
1255    const AsyncSocketException& ex) noexcept override {
1256     ADD_FAILURE() << "client write error after " << bytesWritten << " bytes: "
1257                   << ex.what();
1258   }
1259 };
1260
1261 class SSLHandshakeClient : public SSLHandshakeBase {
1262  public:
1263   SSLHandshakeClient(
1264    AsyncSSLSocket::UniquePtr socket,
1265    bool preverifyResult,
1266    bool verifyResult) :
1267     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1268     socket_->sslConn(this, 0);
1269   }
1270 };
1271
1272 class SSLHandshakeClientNoVerify : public SSLHandshakeBase {
1273  public:
1274   SSLHandshakeClientNoVerify(
1275    AsyncSSLSocket::UniquePtr socket,
1276    bool preverifyResult,
1277    bool verifyResult) :
1278     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1279     socket_->sslConn(this, 0,
1280       folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1281   }
1282 };
1283
1284 class SSLHandshakeClientDoVerify : public SSLHandshakeBase {
1285  public:
1286   SSLHandshakeClientDoVerify(
1287    AsyncSSLSocket::UniquePtr socket,
1288    bool preverifyResult,
1289    bool verifyResult) :
1290     SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1291     socket_->sslConn(this, 0,
1292       folly::SSLContext::SSLVerifyPeerEnum::VERIFY);
1293   }
1294 };
1295
1296 class SSLHandshakeServer : public SSLHandshakeBase {
1297  public:
1298   SSLHandshakeServer(
1299       AsyncSSLSocket::UniquePtr socket,
1300       bool preverifyResult,
1301       bool verifyResult)
1302     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1303     socket_->sslAccept(this, 0);
1304   }
1305 };
1306
1307 class SSLHandshakeServerParseClientHello : public SSLHandshakeBase {
1308  public:
1309   SSLHandshakeServerParseClientHello(
1310       AsyncSSLSocket::UniquePtr socket,
1311       bool preverifyResult,
1312       bool verifyResult)
1313       : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1314     socket_->enableClientHelloParsing();
1315     socket_->sslAccept(this, 0);
1316   }
1317
1318   std::string clientCiphers_, sharedCiphers_, serverCiphers_, chosenCipher_;
1319
1320  protected:
1321   void handshakeSuc(AsyncSSLSocket* sock) noexcept override {
1322     handshakeSuccess_ = true;
1323     sock->getSSLSharedCiphers(sharedCiphers_);
1324     sock->getSSLServerCiphers(serverCiphers_);
1325     sock->getSSLClientCiphers(clientCiphers_);
1326     chosenCipher_ = sock->getNegotiatedCipherName();
1327   }
1328 };
1329
1330
1331 class SSLHandshakeServerNoVerify : public SSLHandshakeBase {
1332  public:
1333   SSLHandshakeServerNoVerify(
1334       AsyncSSLSocket::UniquePtr socket,
1335       bool preverifyResult,
1336       bool verifyResult)
1337     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1338     socket_->sslAccept(this, 0,
1339       folly::SSLContext::SSLVerifyPeerEnum::NO_VERIFY);
1340   }
1341 };
1342
1343 class SSLHandshakeServerDoVerify : public SSLHandshakeBase {
1344  public:
1345   SSLHandshakeServerDoVerify(
1346       AsyncSSLSocket::UniquePtr socket,
1347       bool preverifyResult,
1348       bool verifyResult)
1349     : SSLHandshakeBase(std::move(socket), preverifyResult, verifyResult) {
1350     socket_->sslAccept(this, 0,
1351       folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
1352   }
1353 };
1354
1355 class EventBaseAborter : public AsyncTimeout {
1356  public:
1357   EventBaseAborter(EventBase* eventBase,
1358                    uint32_t timeoutMS)
1359     : AsyncTimeout(
1360       eventBase, AsyncTimeout::InternalEnum::INTERNAL)
1361     , eventBase_(eventBase) {
1362     scheduleTimeout(timeoutMS);
1363   }
1364
1365   void timeoutExpired() noexcept override {
1366     FAIL() << "test timed out";
1367     eventBase_->terminateLoopSoon();
1368   }
1369
1370  private:
1371   EventBase* eventBase_;
1372 };
1373
1374 }