Use AsyncSocket's "stealing" constructor to construct a KTLS socket

Summary: `folly::AsyncSocket` has a constructor that transfers over state from an old socket to the new socket, including the file descriptor. Prefer using that to manually detaching the fd.

Reviewed By: dmm-fb

Differential Revision: D45833219

fbshipit-source-id: 5e4e429edd942bbaf4fc9fa8b44dca8c09a903f7

Author: Sotirios Delimanolis

fizz/experimental/ktls/AsyncFizzBaseKTLS.h

@@ -143,8 +143,6 @@ tryConvertKTLS(FizzSocket& fizzSock) {
   auto rstate = (*state.readRecordLayer()).getRecordLayerState();
   auto wstate = (*state.writeRecordLayer()).getRecordLayerState();
 
-  auto evb = fizzSock.getEventBase();
-
   auto rx = KTLSDirectionalCryptoParams<TrafficDirection::Receive>(
       KTLSCryptoParams::fromRecordState(ciphersuite, rstate));
   auto tx = KTLSDirectionalCryptoParams<TrafficDirection::Transmit>(
@@ -165,14 +163,9 @@ tryConvertKTLS(FizzSocket& fizzSock) {
   auto readCb = fizzSock.getReadCallback();
   fizzSock.setReadCB(nullptr);
 
-  (void)sock->detachNetworkSocket();
   AsyncKTLSSocket::UniquePtr ret;
   ret.reset(new AsyncKTLSSocket(
-      evb,
-      result.value(),
-      std::move(callbackImpl),
-      std::move(selfCert),
-      std::move(peerCert)));
+      sock, std::move(callbackImpl), std::move(selfCert), std::move(peerCert)));
   ret->setReadCB(readCb);
   return ret;
 #else

fizz/experimental/ktls/AsyncKTLSSocket.h

@@ -91,22 +91,20 @@ class AsyncKTLSSocket final : public folly::AsyncSocket {
    *    AsyncKTLSSocket
    *  * You have established a ktls 1.3 connection out of band
    *
-   * @param evb         The eventbase that the AsyncKTLSSocket will initially
-   *                    be attached to.
-   * @param fd          The kTLS enabled file descriptor.
-   * @param tlsCallback An instance of `TLSCallback` which will be used to
-   *                    handle non-application data events.
-   * @param selfCert    The certificate used to authenticate *to* the peer.
-   * @param peerCert    The certificate that the *peer* presented and
+   * @param oldAsyncSocket The AsyncSocket, with kTLS enabled, from which we'll
+   *                       steal the file descriptor and EventBase.
+   * @param tlsCallback    An instance of `TLSCallback` which will be used to
+   *                       handle non-application data events.
+   * @param selfCert       The certificate used to authenticate *to* the peer.
+   * @param peerCert       The certificate that the *peer* presented and
    *                    *we* authenticated.
    */
   AsyncKTLSSocket(
-      folly::EventBase* evb,
-      KTLSNetworkSocket fd,
+      folly::AsyncSocket* oldAsyncSocket,
       std::unique_ptr<TLSCallback> tlsCallback,
       std::shared_ptr<const Cert> selfCert,
       std::shared_ptr<const Cert> peerCert)
-      : AsyncSocket(evb, fd),
+      : AsyncSocket(oldAsyncSocket),
         tlsCallback_(std::move(tlsCallback)),
         selfCert_(std::move(selfCert)),
         peerCert_(std::move(peerCert)) {}

fizz/experimental/ktls/test/AsyncKTLSSocketTest.cpp

@@ -197,10 +197,9 @@ class KTLSReadTest : public KTLSTest {
         clientToServer.toKTLSParams<fizz::TrafficDirection::Receive>(),
         serverToClient.toKTLSParams<fizz::TrafficDirection::Transmit>());
     ASSERT_TRUE(ktlsFDResult.hasValue());
-    serverSocket->detachNetworkSocket();
 
     serverConn_.reset(new fizz::AsyncKTLSSocket(
-        &evb_, ktlsFDResult.value(), std::move(tlsCb), nullptr, nullptr));
+        serverSocket.get(), std::move(tlsCb), nullptr, nullptr));
 
     clientWrite_ = clientToServer.write();
     clientRead_ = serverToClient.read();
@@ -343,15 +342,9 @@ TEST_F(KTLSReadTest, MultipleKTLSError) {
 // message if we don't have a tls callback installed, that we will get
 // a readErr.
 TEST_F(KTLSReadTest, NoTLSCallbackCausesReadErrOnHandshake) {
-  auto serverfd = serverConn_->detachNetworkSocket();
-
   fizz::AsyncKTLSSocket::UniquePtr conn;
-  conn.reset(new fizz::AsyncKTLSSocket(
-      &evb_,
-      fizz::KTLSNetworkSocket::unsafeFromExistingKTLSSocket(serverfd),
-      nullptr,
-      nullptr,
-      nullptr));
+  conn.reset(
+      new fizz::AsyncKTLSSocket(serverConn_.get(), nullptr, nullptr, nullptr));
 
   // Client writes a NewSessionTicket to server.
   {