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