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