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