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/Unistd.h>
  31
  32 #include <gtest/gtest.h>
  33 #include <iostream>
  34 #include <list>
  35 #include <fcntl.h>
  36 #include <poll.h>
  37 #include <sys/types.h>
  38 #include <sys/socket.h>
  39 #include <netinet/tcp.h>
  40
  41 namespace folly {
  42
  43 enum StateEnum {
  44   STATE_WAITING,
  45   STATE_SUCCEEDED,
  46   STATE_FAILED
  47 };
  48
  49 // The destructors of all callback classes assert that the state is
  50 // STATE_SUCCEEDED, for both possitive and negative tests. The tests
  51 // are responsible for setting the succeeded state properly before the
  52 // destructors are called.
  53
  54 class WriteCallbackBase :
  55 public AsyncTransportWrapper::WriteCallback {
  56 public:
  57   WriteCallbackBase()
  58       : state(STATE_WAITING)
  59       , bytesWritten(0)
  60       , exception(AsyncSocketException::UNKNOWN, "none") {}
  61
  62   ~WriteCallbackBase() {
  63     EXPECT_EQ(STATE_SUCCEEDED, state);
  64   }
  65
  66   void setSocket(
  67     const std::shared_ptr<AsyncSSLSocket> &socket) {
  68     socket_ = socket;
  69   }
  70
  71   void writeSuccess() noexcept override {
  72     std::cerr << "writeSuccess" << std::endl;
  73     state = STATE_SUCCEEDED;
  74   }
  75
  76   void writeErr(
  77     size_t bytesWritten,
  78     const AsyncSocketException& ex) noexcept override {
  79     std::cerr << "writeError: bytesWritten " << bytesWritten
  80          << ", exception " << ex.what() << std::endl;
  81
  82     state = STATE_FAILED;
  83     this->bytesWritten = bytesWritten;
  84     exception = ex;
  85     socket_->close();
  86     socket_->detachEventBase();
  87   }
  88
  89   std::shared_ptr<AsyncSSLSocket> socket_;
  90   StateEnum state;
  91   size_t bytesWritten;
  92   AsyncSocketException exception;
  93 };
  94
  95 class ReadCallbackBase :
  96 public AsyncTransportWrapper::ReadCallback {
  97  public:
  98   explicit ReadCallbackBase(WriteCallbackBase* wcb)
  99       : wcb_(wcb), state(STATE_WAITING) {}
 100
 101   ~ReadCallbackBase() {
 102     EXPECT_EQ(state, STATE_SUCCEEDED);
 103   }
 104
 105   void setSocket(
 106     const std::shared_ptr<AsyncSSLSocket> &socket) {
 107     socket_ = socket;
 108   }
 109
 110   void setState(StateEnum s) {
 111     state = s;
 112     if (wcb_) {
 113       wcb_->state = s;
 114     }
 115   }
 116
 117   void readErr(
 118     const AsyncSocketException& ex) noexcept override {
 119     std::cerr << "readError " << ex.what() << std::endl;
 120     state = STATE_FAILED;
 121     socket_->close();
 122     socket_->detachEventBase();
 123   }
 124
 125   void readEOF() noexcept override {
 126     std::cerr << "readEOF" << std::endl;
 127
 128     socket_->close();
 129     socket_->detachEventBase();
 130   }
 131
 132   std::shared_ptr<AsyncSSLSocket> socket_;
 133   WriteCallbackBase *wcb_;
 134   StateEnum state;
 135 };
 136
 137 class ReadCallback : public ReadCallbackBase {
 138 public:
 139   explicit ReadCallback(WriteCallbackBase *wcb)
 140       : ReadCallbackBase(wcb)
 141       , buffers() {}
 142
 143   ~ReadCallback() {
 144     for (std::vector<Buffer>::iterator it = buffers.begin();
 145          it != buffers.end();
 146          ++it) {
 147       it->free();
 148     }
 149     currentBuffer.free();
 150   }
 151
 152   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 153     if (!currentBuffer.buffer) {
 154       currentBuffer.allocate(4096);
 155     }
 156     *bufReturn = currentBuffer.buffer;
 157     *lenReturn = currentBuffer.length;
 158   }
 159
 160   void readDataAvailable(size_t len) noexcept override {
 161     std::cerr << "readDataAvailable, len " << len << std::endl;
 162
 163     currentBuffer.length = len;
 164
 165     wcb_->setSocket(socket_);
 166
 167     // Write back the same data.
 168     socket_->write(wcb_, currentBuffer.buffer, len);
 169
 170     buffers.push_back(currentBuffer);
 171     currentBuffer.reset();
 172     state = STATE_SUCCEEDED;
 173   }
 174
 175   class Buffer {
 176   public:
 177     Buffer() : buffer(nullptr), length(0) {}
 178     Buffer(char* buf, size_t len) : buffer(buf), length(len) {}
 179
 180     void reset() {
 181       buffer = nullptr;
 182       length = 0;
 183     }
 184     void allocate(size_t length) {
 185       assert(buffer == nullptr);
 186       this->buffer = static_cast<char*>(malloc(length));
 187       this->length = length;
 188     }
 189     void free() {
 190       ::free(buffer);
 191       reset();
 192     }
 193
 194     char* buffer;
 195     size_t length;
 196   };
 197
 198   std::vector<Buffer> buffers;
 199   Buffer currentBuffer;
 200 };
 201
 202 class ReadErrorCallback : public ReadCallbackBase {
 203 public:
 204   explicit ReadErrorCallback(WriteCallbackBase *wcb)
 205       : ReadCallbackBase(wcb) {}
 206
 207   // Return nullptr buffer to trigger readError()
 208   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 209     *bufReturn = nullptr;
 210     *lenReturn = 0;
 211   }
 212
 213   void readDataAvailable(size_t /* len */) noexcept override {
 214     // This should never to called.
 215     FAIL();
 216   }
 217
 218   void readErr(
 219     const AsyncSocketException& ex) noexcept override {
 220     ReadCallbackBase::readErr(ex);
 221     std::cerr << "ReadErrorCallback::readError" << std::endl;
 222     setState(STATE_SUCCEEDED);
 223   }
 224 };
 225
 226 class ReadEOFCallback : public ReadCallbackBase {
 227  public:
 228   explicit ReadEOFCallback(WriteCallbackBase* wcb) : ReadCallbackBase(wcb) {}
 229
 230   // Return nullptr buffer to trigger readError()
 231   void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
 232     *bufReturn = nullptr;
 233     *lenReturn = 0;
 234   }
 235
 236   void readDataAvailable(size_t /* len */) noexcept override {
 237     // This should never to called.
 238     FAIL();
 239   }
 240
 241   void readEOF() noexcept override {
 242     ReadCallbackBase::readEOF();
 243     setState(STATE_SUCCEEDED);
 244   }
 245 };
 246
 247 class WriteErrorCallback : public ReadCallback {
 248 public:
 249   explicit WriteErrorCallback(WriteCallbackBase *wcb)
 250       : ReadCallback(wcb) {}
 251
 252   void readDataAvailable(size_t len) noexcept override {
 253     std::cerr << "readDataAvailable, len " << len << std::endl;
 254
 255     currentBuffer.length = len;
 256
 257     // close the socket before writing to trigger writeError().
 258     ::close(socket_->getFd());
 259
 260     wcb_->setSocket(socket_);
 261
 262     // Write back the same data.
 263     socket_->write(wcb_, currentBuffer.buffer, len);
 264
 265     if (wcb_->state == STATE_FAILED) {
 266       setState(STATE_SUCCEEDED);
 267     } else {
 268       state = STATE_FAILED;
 269     }
 270
 271     buffers.push_back(currentBuffer);
 272     currentBuffer.reset();
 273   }
 274
 275   void readErr(const AsyncSocketException& ex) noexcept override {
 276     std::cerr << "readError " << ex.what() << std::endl;
 277     // do nothing since this is expected
 278   }
 279 };
 280
 281 class EmptyReadCallback : public ReadCallback {
 282 public:
 283   explicit EmptyReadCallback()
 284       : ReadCallback(nullptr) {}
 285
 286   void readErr(const AsyncSocketException& ex) noexcept override {
 287     std::cerr << "readError " << ex.what() << std::endl;
 288     state = STATE_FAILED;
 289     tcpSocket_->close();
 290     tcpSocket_->detachEventBase();
 291   }
 292
 293   void readEOF() noexcept override {
 294     std::cerr << "readEOF" << std::endl;
 295
 296     tcpSocket_->close();
 297     tcpSocket_->detachEventBase();
 298     state = STATE_SUCCEEDED;
 299   }
 300
 301   std::shared_ptr<AsyncSocket> tcpSocket_;
 302 };
 303
 304 class HandshakeCallback :
 305 public AsyncSSLSocket::HandshakeCB {
 306 public:
 307   enum ExpectType {
 308     EXPECT_SUCCESS,
 309     EXPECT_ERROR
 310   };
 311
 312   explicit HandshakeCallback(ReadCallbackBase *rcb,
 313                              ExpectType expect = EXPECT_SUCCESS):
 314       state(STATE_WAITING),
 315       rcb_(rcb),
 316       expect_(expect) {}
 317
 318   void setSocket(
 319     const std::shared_ptr<AsyncSSLSocket> &socket) {
 320     socket_ = socket;
 321   }
 322
 323   void setState(StateEnum s) {
 324     state = s;
 325     rcb_->setState(s);
 326   }
 327
 328   // Functions inherited from AsyncSSLSocketHandshakeCallback
 329   void handshakeSuc(AsyncSSLSocket *sock) noexcept override {
 330     std::lock_guard<std::mutex> g(mutex_);
 331     cv_.notify_all();
 332     EXPECT_EQ(sock, socket_.get());
 333     std::cerr << "HandshakeCallback::connectionAccepted" << std::endl;
 334     rcb_->setSocket(socket_);
 335     sock->setReadCB(rcb_);
 336     state = (expect_ == EXPECT_SUCCESS) ? STATE_SUCCEEDED : STATE_FAILED;
 337   }
 338   void handshakeErr(AsyncSSLSocket* /* sock */,
 339                     const AsyncSocketException& ex) noexcept override {
 340     std::lock_guard<std::mutex> g(mutex_);
 341     cv_.notify_all();
 342     std::cerr << "HandshakeCallback::handshakeError " << ex.what() << std::endl;
 343     state = (expect_ == EXPECT_ERROR) ? STATE_SUCCEEDED : STATE_FAILED;
 344     if (expect_ == EXPECT_ERROR) {
 345       // rcb will never be invoked
 346       rcb_->setState(STATE_SUCCEEDED);
 347     }
 348     errorString_ = ex.what();
 349   }
 350
 351   void waitForHandshake() {
 352     std::unique_lock<std::mutex> lock(mutex_);
 353     cv_.wait(lock, [this] { return state != STATE_WAITING; });
 354   }
 355
 356   ~HandshakeCallback() {
 357     EXPECT_EQ(state, STATE_SUCCEEDED);
 358   }
 359
 360   void closeSocket() {
 361     socket_->close();
 362     state = STATE_SUCCEEDED;
 363   }
 364
 365   std::shared_ptr<AsyncSSLSocket> getSocket() {
 366     return socket_;
 367   }
 368
 369   StateEnum state;
 370   std::shared_ptr<AsyncSSLSocket> socket_;
 371   ReadCallbackBase *rcb_;
 372   ExpectType expect_;
 373   std::mutex mutex_;
 374   std::condition_variable cv_;
 375   std::string errorString_;
 376 };
 377
 378 class SSLServerAcceptCallbackBase:
 379 public folly::AsyncServerSocket::AcceptCallback {
 380 public:
 381   explicit SSLServerAcceptCallbackBase(HandshakeCallback *hcb):
 382   state(STATE_WAITING), hcb_(hcb) {}
 383
 384   ~SSLServerAcceptCallbackBase() {
 385     EXPECT_EQ(state, STATE_SUCCEEDED);
 386   }
 387
 388   void acceptError(const std::exception& ex) noexcept override {
 389     std::cerr << "SSLServerAcceptCallbackBase::acceptError "
 390               << ex.what() << std::endl;
 391     state = STATE_FAILED;
 392   }
 393
 394   void connectionAccepted(
 395       int fd, const folly::SocketAddress& /* clientAddr */) noexcept override {
 396     printf("Connection accepted\n");
 397     std::shared_ptr<AsyncSSLSocket> sslSock;
 398     try {
 399       // Create a AsyncSSLSocket object with the fd. The socket should be
 400       // added to the event base and in the state of accepting SSL connection.
 401       sslSock = AsyncSSLSocket::newSocket(ctx_, base_, fd);
 402     } catch (const std::exception &e) {
 403       LOG(ERROR) << "Exception %s caught while creating a AsyncSSLSocket "
 404         "object with socket " << e.what() << fd;
 405       ::close(fd);
 406       acceptError(e);
 407       return;
 408     }
 409
 410     connAccepted(sslSock);
 411   }
 412
 413   virtual void connAccepted(
 414     const std::shared_ptr<folly::AsyncSSLSocket> &s) = 0;
 415
 416   StateEnum state;
 417   HandshakeCallback *hcb_;
 418   std::shared_ptr<folly::SSLContext> ctx_;
 419   folly::EventBase* base_;
 420 };
 421
 422 class SSLServerAcceptCallback: public SSLServerAcceptCallbackBase {
 423 public:
 424   uint32_t timeout_;
 425
 426   explicit SSLServerAcceptCallback(HandshakeCallback *hcb,
 427                                    uint32_t timeout = 0):
 428       SSLServerAcceptCallbackBase(hcb),
 429       timeout_(timeout) {}
 430
 431   virtual ~SSLServerAcceptCallback() {
 432     if (timeout_ > 0) {
 433       // if we set a timeout, we expect failure
 434       EXPECT_EQ(hcb_->state, STATE_FAILED);
 435       hcb_->setState(STATE_SUCCEEDED);
 436     }
 437   }
 438
 439   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 440   void connAccepted(
 441     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 442     noexcept override {
 443     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 444     std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
 445
 446     hcb_->setSocket(sock);
 447     sock->sslAccept(hcb_, timeout_);
 448     EXPECT_EQ(sock->getSSLState(),
 449                       AsyncSSLSocket::STATE_ACCEPTING);
 450
 451     state = STATE_SUCCEEDED;
 452   }
 453 };
 454
 455 class SSLServerAcceptCallbackDelay: public SSLServerAcceptCallback {
 456 public:
 457   explicit SSLServerAcceptCallbackDelay(HandshakeCallback *hcb):
 458       SSLServerAcceptCallback(hcb) {}
 459
 460   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 461   void connAccepted(
 462     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 463     noexcept override {
 464
 465     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 466
 467     std::cerr << "SSLServerAcceptCallbackDelay::connAccepted"
 468               << std::endl;
 469     int fd = sock->getFd();
 470
 471 #ifndef TCP_NOPUSH
 472     {
 473     // The accepted connection should already have TCP_NODELAY set
 474     int value;
 475     socklen_t valueLength = sizeof(value);
 476     int rc = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
 477     EXPECT_EQ(rc, 0);
 478     EXPECT_EQ(value, 1);
 479     }
 480 #endif
 481
 482     // Unset the TCP_NODELAY option.
 483     int value = 0;
 484     socklen_t valueLength = sizeof(value);
 485     int rc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, valueLength);
 486     EXPECT_EQ(rc, 0);
 487
 488     rc = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &value, &valueLength);
 489     EXPECT_EQ(rc, 0);
 490     EXPECT_EQ(value, 0);
 491
 492     SSLServerAcceptCallback::connAccepted(sock);
 493   }
 494 };
 495
 496 class SSLServerAsyncCacheAcceptCallback: public SSLServerAcceptCallback {
 497 public:
 498   explicit SSLServerAsyncCacheAcceptCallback(HandshakeCallback *hcb,
 499                                              uint32_t timeout = 0):
 500     SSLServerAcceptCallback(hcb, timeout) {}
 501
 502   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 503   void connAccepted(
 504     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 505     noexcept override {
 506     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 507
 508     std::cerr << "SSLServerAcceptCallback::connAccepted" << std::endl;
 509
 510     hcb_->setSocket(sock);
 511     sock->sslAccept(hcb_, timeout_);
 512     ASSERT_TRUE((sock->getSSLState() ==
 513                  AsyncSSLSocket::STATE_ACCEPTING) ||
 514                 (sock->getSSLState() ==
 515                  AsyncSSLSocket::STATE_CACHE_LOOKUP));
 516
 517     state = STATE_SUCCEEDED;
 518   }
 519 };
 520
 521
 522 class HandshakeErrorCallback: public SSLServerAcceptCallbackBase {
 523 public:
 524   explicit HandshakeErrorCallback(HandshakeCallback *hcb):
 525   SSLServerAcceptCallbackBase(hcb)  {}
 526
 527   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 528   void connAccepted(
 529     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 530     noexcept override {
 531     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 532
 533     std::cerr << "HandshakeErrorCallback::connAccepted" << std::endl;
 534
 535     // The first call to sslAccept() should succeed.
 536     hcb_->setSocket(sock);
 537     sock->sslAccept(hcb_);
 538     EXPECT_EQ(sock->getSSLState(),
 539                       AsyncSSLSocket::STATE_ACCEPTING);
 540
 541     // The second call to sslAccept() should fail.
 542     HandshakeCallback callback2(hcb_->rcb_);
 543     callback2.setSocket(sock);
 544     sock->sslAccept(&callback2);
 545     EXPECT_EQ(sock->getSSLState(),
 546                       AsyncSSLSocket::STATE_ERROR);
 547
 548     // Both callbacks should be in the error state.
 549     EXPECT_EQ(hcb_->state, STATE_FAILED);
 550     EXPECT_EQ(callback2.state, STATE_FAILED);
 551
 552     sock->detachEventBase();
 553
 554     state = STATE_SUCCEEDED;
 555     hcb_->setState(STATE_SUCCEEDED);
 556     callback2.setState(STATE_SUCCEEDED);
 557   }
 558 };
 559
 560 class HandshakeTimeoutCallback: public SSLServerAcceptCallbackBase {
 561 public:
 562   explicit HandshakeTimeoutCallback(HandshakeCallback *hcb):
 563   SSLServerAcceptCallbackBase(hcb)  {}
 564
 565   // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
 566   void connAccepted(
 567     const std::shared_ptr<folly::AsyncSSLSocket> &s)
 568     noexcept override {
 569     std::cerr << "HandshakeErrorCallback::connAccepted" << std::endl;
 570
 571     auto sock = std::static_pointer_cast<AsyncSSLSocket>(s);
 572
 573     hcb_->setSocket(sock);
 574     sock->getEventBase()->tryRunAfterDelay([=] {
 575         std::cerr << "Delayed SSL accept, client will have close by now"
 576                   << std::endl;
 577         // SSL accept will fail
 578         EXPECT_EQ(
 579           sock->getSSLState(),
 580           AsyncSSLSocket::STATE_UNINIT);
 581         hcb_->socket_->sslAccept(hcb_);
 582         // This registers for an event
 583         EXPECT_EQ(
 584           sock->getSSLState(),
 585           AsyncSSLSocket::STATE_ACCEPTING);
 586
 587         state = STATE_SUCCEEDED;
 588       }, 100);
 589   }
 590 };
 591
 592
 593 class TestSSLServer {
 594  protected:
 595   EventBase evb_;
 596   std::shared_ptr<folly::SSLContext> ctx_;
 597   SSLServerAcceptCallbackBase *acb_;
 598   std::shared_ptr<folly::AsyncServerSocket> socket_;
 599   folly::SocketAddress address_;
 600   pthread_t thread_;
 601
 602   static void *Main(void *ctx) {
 603     TestSSLServer *self = static_cast<TestSSLServer*>(ctx);
 604     self->evb_.loop();
 605     std::cerr << "Server thread exited event loop" << std::endl;
 606     return nullptr;
 607   }
 608
 609  public:
 610   // Create a TestSSLServer.
 611   // This immediately starts listening on the given port.
 612   explicit TestSSLServer(SSLServerAcceptCallbackBase *acb);
 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 }