Introduce a "BufHelpers" typealias

Summary: This introduces a more generic typealias so that we can, for instance, write `BufHelpers::createCombined` instead of `folly::IOBuf::createCombined`.

Reviewed By: jbeshay

Differential Revision: D73127508

fbshipit-source-id: d585790904efc8e9f92d79cbf766bafe0e84a69f

quic/QuicConstants.h

@@ -35,6 +35,7 @@ using SystemClock = folly::chrono::SystemClock;
 
 namespace quic {
 
+using BufHelpers = folly::IOBuf; // For stuff like BufHelpers::create, etc.
 using Buf = std::unique_ptr<folly::IOBuf>;
 using Clock = std::chrono::steady_clock;
 using TimePoint = std::chrono::time_point<Clock>;

quic/api/QuicStreamAsyncTransport.cpp

@@ -133,7 +133,7 @@ void QuicStreamAsyncTransport::write(
   if (handleWriteStateError(callback)) {
     return;
   }
-  writeBuf_.append(folly::IOBuf::wrapBuffer(buf, bytes));
+  writeBuf_.append(BufHelpers::wrapBuffer(buf, bytes));
   addWriteCallback(callback);
 }
 
@@ -146,7 +146,7 @@ void QuicStreamAsyncTransport::writev(
     return;
   }
   for (size_t i = 0; i < count; i++) {
-    writeBuf_.append(folly::IOBuf::wrapBuffer(vec[i].iov_base, vec[i].iov_len));
+    writeBuf_.append(BufHelpers::wrapBuffer(vec[i].iov_base, vec[i].iov_len));
   }
   addWriteCallback(callback);
 }

quic/api/QuicTransportFunctions.cpp

@@ -377,7 +377,7 @@ iobufChainBasedBuildScheduleEncrypt(
   packet->header.coalesce();
   auto headerLen = packet->header.length();
   auto bodyLen = packet->body.computeChainDataLength();
-  auto unencrypted = folly::IOBuf::createCombined(
+  auto unencrypted = BufHelpers::createCombined(
       headerLen + bodyLen + aead.getCipherOverhead());
   auto bodyCursor = folly::io::Cursor(&packet->body);
   bodyCursor.pull(unencrypted->writableData() + headerLen, bodyLen);

quic/client/QuicClientTransportLite.cpp

@@ -1167,7 +1167,7 @@ QuicClientTransportLite::startCryptoHandshake() {
   if (!conn_->transportSettings.flowPriming.empty() &&
       conn_->peerAddress.isInitialized()) {
     auto flowPrimingBuf =
-        folly::IOBuf::copyBuffer(conn_->transportSettings.flowPriming);
+        BufHelpers::copyBuffer(conn_->transportSettings.flowPriming);
     iovec vec[kNumIovecBufferChains];
     size_t iovec_len = fillIovec(flowPrimingBuf, vec);
     socket_->write(conn_->peerAddress, vec, iovec_len);
@@ -1297,7 +1297,7 @@ void QuicClientTransportLite::recvMsg(
     // We create 1 buffer per packet so that it is not shared, this enables
     // us to decrypt in place. If the fizz decrypt api could decrypt in-place
     // even if shared, then we could allocate one giant IOBuf here.
-    Buf readBuffer = folly::IOBuf::createCombined(readBufferSize);
+    Buf readBuffer = BufHelpers::createCombined(readBufferSize);
     struct iovec vec;
     vec.iov_base = readBuffer->writableData();
     vec.iov_len = readBufferSize;
@@ -1439,7 +1439,7 @@ void QuicClientTransportLite::recvFrom(
     // We create 1 buffer per packet so that it is not shared, this enables
     // us to decrypt in place. If the fizz decrypt api could decrypt in-place
     // even if shared, then we could allocate one giant IOBuf here.
-    Buf readBuffer = folly::IOBuf::createCombined(readBufferSize);
+    Buf readBuffer = BufHelpers::createCombined(readBufferSize);
 
     sockaddr* rawAddr{nullptr};
 
@@ -1520,7 +1520,7 @@ void QuicClientTransportLite::recvMmsg(
     struct msghdr* msg = &msgs[i].msg_hdr;
 
     if (!readBuffer) {
-      readBuffer = folly::IOBuf::createCombined(readBufferSize);
+      readBuffer = BufHelpers::createCombined(readBufferSize);
       iovec.iov_base = readBuffer->writableData();
       iovec.iov_len = readBufferSize;
       msg->msg_iov = &iovec;
@@ -1950,7 +1950,7 @@ void QuicClientTransportLite::maybeSendTransportKnobs() {
   if (!transportKnobsSent_ && hasWriteCipher()) {
     for (const auto& knob : conn_->transportSettings.knobs) {
       auto res =
-          setKnob(knob.space, knob.id, folly::IOBuf::copyBuffer(knob.blob));
+          setKnob(knob.space, knob.id, BufHelpers::copyBuffer(knob.blob));
       if (res.hasError()) {
         if (res.error() != LocalErrorCode::KNOB_FRAME_UNSUPPORTED) {
           LOG(ERROR) << "Unexpected error while sending knob frames";

quic/client/handshake/ClientHandshake.cpp

@@ -161,12 +161,12 @@ void ClientHandshake::computeCiphers(CipherKind kind, folly::ByteRange secret) {
       conn_->readCodec->setHandshakeHeaderCipher(std::move(packetNumberCipher));
       break;
     case CipherKind::OneRttWrite:
-      writeTrafficSecret_ = folly::IOBuf::copyBuffer(secret);
+      writeTrafficSecret_ = BufHelpers::copyBuffer(secret);
       conn_->oneRttWriteCipher = std::move(aead);
       conn_->oneRttWriteHeaderCipher = std::move(packetNumberCipher);
       break;
     case CipherKind::OneRttRead:
-      readTrafficSecret_ = folly::IOBuf::copyBuffer(secret);
+      readTrafficSecret_ = BufHelpers::copyBuffer(secret);
       conn_->readCodec->setOneRttReadCipher(std::move(aead));
       conn_->readCodec->setOneRttHeaderCipher(std::move(packetNumberCipher));
       conn_->readCodec->setNextOneRttReadCipher(getNextOneRttReadCipher());

quic/codec/QuicConnectionId.h

@@ -79,7 +79,7 @@ inline std::ostream& operator<<(std::ostream& os, const ConnectionId& connId) {
 }
 
 inline folly::IOBuf toData(const ConnectionId& connId) {
-  return folly::IOBuf::wrapBufferAsValue(connId.data(), connId.size());
+  return BufHelpers::wrapBufferAsValue(connId.data(), connId.size());
 }
 
 struct ConnectionIdData {

quic/codec/QuicPacketBuilder.cpp

@@ -134,8 +134,8 @@ RegularQuicPacketBuilder::RegularQuicPacketBuilder(
     : remainingBytes_(remainingBytes),
       largestAckedPacketNum_(largestAckedPacketNum),
       packet_(std::move(header)),
-      header_(folly::IOBuf::CreateOp::CREATE, kLongHeaderHeaderSize),
-      body_(folly::IOBuf::CreateOp::CREATE, kAppenderGrowthSize),
+      header_(BufHelpers::CreateOp::CREATE, kLongHeaderHeaderSize),
+      body_(BufHelpers::CreateOp::CREATE, kAppenderGrowthSize),
       headerAppender_(&header_, kLongHeaderHeaderSize),
       bodyAppender_(&body_, kAppenderGrowthSize) {
   if (frameHint) {
@@ -216,7 +216,7 @@ void RegularQuicPacketBuilder::insert(
     const ChainedByteRangeHead& buf,
     size_t limit) {
   limit = std::min(limit, buf.chainLength());
-  Buf streamData = folly::IOBuf::wrapBuffer(
+  Buf streamData = BufHelpers::wrapBuffer(
       buf.getHead()->getRange().begin(),
       std::min(limit, buf.getHead()->length()));
   limit -= std::min(limit, buf.getHead()->length());
@@ -225,7 +225,7 @@ void RegularQuicPacketBuilder::insert(
   while (limit > 0) {
     size_t amountToChopOff = std::min(limit, current->length());
     auto tempBuf =
-        folly::IOBuf::wrapBuffer(current->getRange().begin(), amountToChopOff);
+        BufHelpers::wrapBuffer(current->getRange().begin(), amountToChopOff);
     streamData->appendToChain(std::move(tempBuf));
     limit -= amountToChopOff;
     current = current->getNext();
@@ -354,7 +354,7 @@ void PseudoRetryPacketBuilder::writePseudoRetryPacket() {
 
   LOG_IF(ERROR, packetLength > kDefaultUDPSendPacketLen)
       << "Retry packet length exceeds default packet length";
-  packetBuf_ = folly::IOBuf::create(packetLength);
+  packetBuf_ = BufHelpers::create(packetLength);
   BufWriter bufWriter(packetBuf_->writableData(), packetLength);
 
   // ODCID length
@@ -398,13 +398,13 @@ Buf PseudoRetryPacketBuilder::buildPacket() && {
 StatelessResetPacketBuilder::StatelessResetPacketBuilder(
     uint16_t maxPacketSize,
     const StatelessResetToken& resetToken)
-    : data_(folly::IOBuf::create(kAppenderGrowthSize)) {
+    : data_(BufHelpers::create(kAppenderGrowthSize)) {
   BufAppender appender(data_.get(), kAppenderGrowthSize);
   uint16_t randomOctetLength = maxPacketSize - resetToken.size() - 1;
   uint8_t initialByte =
       ShortHeader::kFixedBitMask | (0x3f & folly::Random::secureRand32());
   appender.writeBE<uint8_t>(initialByte);
-  auto randomOctets = folly::IOBuf::create(randomOctetLength);
+  auto randomOctets = BufHelpers::create(randomOctetLength);
   folly::Random::secureRandom(randomOctets->writableData(), randomOctetLength);
   appender.push(randomOctets->data(), randomOctetLength);
   appender.push(resetToken.data(), resetToken.size());
@@ -495,7 +495,7 @@ InplaceSizeEnforcedPacketBuilder::buildPacket() && {
   PacketBuilderInterface::Packet builtPacket(
       std::move(packet_),
       std::move(header_),
-      folly::IOBuf::wrapBufferAsValue(
+      BufHelpers::wrapBufferAsValue(
           body_.data(), bodyWriter.tail() - body_.data()));
 
   // Release internal iobuf
@@ -513,7 +513,7 @@ VersionNegotiationPacketBuilder::VersionNegotiationPacketBuilder(
           generateRandomPacketType(),
           sourceConnectionId,
           destinationConnectionId),
-      data_(folly::IOBuf::create(kAppenderGrowthSize)) {
+      data_(BufHelpers::create(kAppenderGrowthSize)) {
   writeVersionNegotiationPacket(versions);
 }
 
@@ -586,7 +586,7 @@ RetryPacketBuilder::RetryPacketBuilder(
 }
 
 folly::Expected<folly::Unit, QuicError> RetryPacketBuilder::writeRetryPacket() {
-  packetBuf_ = folly::IOBuf::create(kAppenderGrowthSize);
+  packetBuf_ = BufHelpers::create(kAppenderGrowthSize);
 
   // Encode the portion of the retry packet that comes before the
   // integrity tag.
@@ -771,13 +771,13 @@ PacketBuilderInterface::Packet InplaceQuicPacketBuilder::buildPacket() && {
   // TODO: Get rid of these two wrapBuffer when Fizz::AEAD has a new interface
   // for encryption.
   if (bodyStart_) {
-    folly::IOBuf bodyBuf = folly::IOBuf::wrapBufferAsValue(
+    folly::IOBuf bodyBuf = BufHelpers::wrapBufferAsValue(
         bodyStart_, bufWriter_.tail() - bodyStart_ + cipherOverhead_);
     bodyBuf.trimEnd(cipherOverhead_);
 
     PacketBuilderInterface::Packet builtPacket(
         std::move(packet_),
-        folly::IOBuf::wrapBufferAsValue(
+        BufHelpers::wrapBufferAsValue(
             headerStart_, (bodyStart_ - headerStart_)),
         std::move(bodyBuf));
     releaseOutputBufferInternal();

quic/codec/QuicReadCodec.cpp

@@ -238,7 +238,7 @@ CodecResult QuicReadCodec::parseLongHeaderPacket(
     // There should normally be some integrity tag at least in the data,
     // however allowing the aead to process the data even if the tag is not
     // present helps with writing tests.
-    encryptedData = folly::IOBuf::create(0);
+    encryptedData = BufHelpers::create(0);
   }
 
   Buf decrypted;
@@ -255,7 +255,7 @@ CodecResult QuicReadCodec::parseLongHeaderPacket(
 
   if (!decrypted) {
     // TODO better way of handling this (tests break without this)
-    decrypted = folly::IOBuf::create(0);
+    decrypted = BufHelpers::create(0);
   }
 
   auto packetRes =
@@ -354,8 +354,7 @@ CodecResult QuicReadCodec::tryParseShortHeaderPacket(
   // don't clone the buffer, the buffer will not show up as shared and we can
   // decrypt in-place.
   size_t aadLen = packetNumberOffset + packetNum.second;
-  folly::IOBuf headerData =
-      folly::IOBuf::wrapBufferAsValue(data->data(), aadLen);
+  folly::IOBuf headerData = BufHelpers::wrapBufferAsValue(data->data(), aadLen);
   data->trimStart(aadLen);
 
   Buf decrypted;
@@ -371,7 +370,7 @@ CodecResult QuicReadCodec::tryParseShortHeaderPacket(
   decrypted = std::move(*decryptAttempt);
   if (!decrypted) {
     // TODO better way of handling this (tests break without this)
-    decrypted = folly::IOBuf::create(0);
+    decrypted = BufHelpers::create(0);
   }
 
   if (peerKeyUpdateAttempt) {

quic/codec/Types.cpp

@@ -328,16 +328,16 @@ StreamTypeField StreamTypeField::Builder::build() {
  */
 Buf QuicAddrValidationToken::getPlaintextToken() const {
   auto ts = folly::Endian::big(timestampInMs);
-  return folly::IOBuf::copyBuffer(&ts, sizeof(ts));
+  return BufHelpers::copyBuffer(&ts, sizeof(ts));
 }
 
 Buf RetryToken::genAeadAssocData() const {
-  return folly::IOBuf::copyBuffer(folly::to<std::string>(
+  return BufHelpers::copyBuffer(folly::to<std::string>(
       toString(tokenType), originalDstConnId.hex() + clientIp.str()));
 }
 
 Buf NewToken::genAeadAssocData() const {
-  return folly::IOBuf::copyBuffer(
+  return BufHelpers::copyBuffer(
       folly::to<std::string>(toString(tokenType), clientIp.str()));
 }
 

quic/codec/Types.h

@@ -346,7 +346,7 @@ struct ReadCryptoFrame {
       : offset(offsetIn), data(std::move(dataIn)) {}
 
   explicit ReadCryptoFrame(uint64_t offsetIn)
-      : offset(offsetIn), data(folly::IOBuf::create(0)) {}
+      : offset(offsetIn), data(BufHelpers::create(0)) {}
 
   // Stuff stored in a variant type needs to be copyable.
   ReadCryptoFrame(const ReadCryptoFrame& other) {
@@ -516,7 +516,7 @@ struct ReadStreamFrame {
       : streamId(streamIdIn),
         streamGroupId(streamGroupIdIn),
         offset(offsetIn),
-        data(folly::IOBuf::create(0)),
+        data(BufHelpers::create(0)),
         fin(finIn) {}
 
   // Stuff stored in a variant type needs to be copyable.

quic/common/BufAccessor.cpp

@@ -15,7 +15,7 @@ BufAccessor::BufAccessor(Buf buf)
 }
 
 BufAccessor::BufAccessor(size_t capacity)
-    : BufAccessor(folly::IOBuf::createCombined(capacity)) {}
+    : BufAccessor(BufHelpers::createCombined(capacity)) {}
 
 Buf BufAccessor::obtain() {
   Buf ret;

quic/common/BufUtil.cpp

@@ -24,7 +24,7 @@ Buf BufQueue::splitAtMost(size_t len) {
   folly::IOBuf* current = chain_.get();
   // empty queue / requested 0 bytes
   if (current == nullptr || len == 0) {
-    return folly::IOBuf::create(0);
+    return BufHelpers::create(0);
   }
   // entire chain requested
   if (len >= chainLength_) {
@@ -138,7 +138,7 @@ BufAppender::BufAppender(folly::IOBuf* data, size_t appendLen)
 
 void BufAppender::push(const uint8_t* data, size_t len) {
   if (crtBuf_->tailroom() < len || lastBufShared_) {
-    auto newBuf = folly::IOBuf::createCombined(std::max(appendLen_, len));
+    auto newBuf = BufHelpers::createCombined(std::max(appendLen_, len));
     folly::IOBuf* newBufPtr = newBuf.get();
     head_->prependChain(std::move(newBuf));
     crtBuf_ = newBufPtr;

quic/common/udpsocket/QuicAsyncUDPSocketImpl.cpp

@@ -47,7 +47,7 @@ QuicAsyncUDPSocket::RecvResult QuicAsyncUDPSocketImpl::recvmmsgNetworkData(
     struct msghdr* msg = &msgs[i].msg_hdr;
 
     if (!readBuffer) {
-      readBuffer = folly::IOBuf::createCombined(readBufferSize);
+      readBuffer = BufHelpers::createCombined(readBufferSize);
       iovec.iov_base = readBuffer->writableData();
       iovec.iov_len = readBufferSize;
       msg->msg_iov = &iovec;

quic/common/udpsocket/test/QuicAsyncUDPSocketTestBase.h

@@ -61,7 +61,7 @@ TYPED_TEST_P(QuicAsyncUDPSocketTest, ErrToNonExistentServer) {
   // If an error is received, the read callback should not be triggered
   EXPECT_CALL(this->readCb_, onNotifyDataAvailable_(testing::_)).Times(0);
 
-  auto sendBuf = folly::IOBuf::copyBuffer("hey");
+  auto sendBuf = quic::BufHelpers::copyBuffer("hey");
   iovec vec[quic::kNumIovecBufferChains];
   size_t iovec_len =
       sendBuf->fillIov(vec, sizeof(vec) / sizeof(vec[0])).numIovecs;
@@ -82,7 +82,7 @@ TYPED_TEST_P(QuicAsyncUDPSocketTest, TestUnsetErrCallback) {
   EXPECT_CALL(this->errCb_, errMessage_(testing::_)).Times(0);
   EXPECT_CALL(this->readCb_, onNotifyDataAvailable_(testing::_)).Times(0);
 
-  auto sendBuf = folly::IOBuf::copyBuffer("hey");
+  auto sendBuf = quic::BufHelpers::copyBuffer("hey");
   iovec vec[quic::kNumIovecBufferChains];
   size_t iovec_len =
       sendBuf->fillIov(vec, sizeof(vec) / sizeof(vec[0])).numIovecs;
@@ -130,7 +130,7 @@ TYPED_TEST_P(QuicAsyncUDPSocketTest, CloseInErrorCallback) {
   // Since the socket is closed by the error callback, the read callback
   // should not be triggered
   EXPECT_CALL(this->readCb_, onNotifyDataAvailable_(testing::_)).Times(0);
-  auto sendBuf = folly::IOBuf::copyBuffer("hey");
+  auto sendBuf = quic::BufHelpers::copyBuffer("hey");
   iovec vec[quic::kNumIovecBufferChains];
   size_t iovec_len =
       sendBuf->fillIov(vec, sizeof(vec) / sizeof(vec[0])).numIovecs;

quic/dsr/backend/DSRPacketizer.cpp

@@ -229,7 +229,7 @@ BufAccessor* XskPacketGroupWriter::getBufAccessor() {
     return nullptr;
   }
   currentXskBuffer_ = *maybeXskBuffer;
-  auto ioBuf = folly::IOBuf::takeOwnership(
+  auto ioBuf = BufHelpers::takeOwnership(
       currentXskBuffer_.buffer,
       kDefaultMaxUDPPayload,
       0,

quic/fizz/client/handshake/FizzClientHandshake.cpp

@@ -85,7 +85,7 @@ Optional<QuicCachedPsk> FizzClientHandshake::getPsk(
       conn->earlyDataAppParamsValidator &&
       !conn->earlyDataAppParamsValidator(
           quicCachedPsk->cachedPsk.alpn,
-          folly::IOBuf::copyBuffer(quicCachedPsk->appParams))) {
+          BufHelpers::copyBuffer(quicCachedPsk->appParams))) {
     quicCachedPsk->cachedPsk.maxEarlyDataSize = 0;
     // Do not remove psk here, will let application decide
   }
@@ -120,7 +120,7 @@ bool FizzClientHandshake::verifyRetryIntegrityTag(
       retryPacket.header.getDestinationConnId(),
       originalDstConnId,
       retryPacket.header.getVersion(),
-      folly::IOBuf::copyBuffer(retryPacket.header.getToken()));
+      BufHelpers::copyBuffer(retryPacket.header.getToken()));
 
   Buf pseudoRetryPacket = std::move(pseudoRetryPacketBuilder).buildPacket();
 
@@ -128,7 +128,7 @@ bool FizzClientHandshake::verifyRetryIntegrityTag(
   auto expectedIntegrityTag = retryIntegrityTagGenerator.getRetryIntegrityTag(
       retryPacket.header.getVersion(), pseudoRetryPacket.get());
 
-  folly::IOBuf integrityTagWrapper = folly::IOBuf::wrapBufferAsValue(
+  folly::IOBuf integrityTagWrapper = BufHelpers::wrapBufferAsValue(
       retryPacket.integrityTag.data(), retryPacket.integrityTag.size());
   return folly::IOBufEqualTo()(*expectedIntegrityTag, integrityTagWrapper);
 }
@@ -153,7 +153,7 @@ Optional<std::vector<uint8_t>> FizzClientHandshake::getExportedKeyingMaterial(
       cipherSuite.value(),
       ems.value()->coalesce(),
       label,
-      context == none ? nullptr : folly::IOBuf::wrapBuffer(*context),
+      context == none ? nullptr : BufHelpers::wrapBuffer(*context),
       keyLength);
 
   std::vector<uint8_t> result(ekm->coalesce());
@@ -206,7 +206,7 @@ Buf FizzClientHandshake::getNextTrafficSecret(folly::ByteRange secret) const {
   auto deriver =
       state_.context()->getFactory()->makeKeyDeriver(*state_.cipher());
   auto nextSecret = deriver->expandLabel(
-      secret, kQuicKULabel, folly::IOBuf::create(0), secret.size());
+      secret, kQuicKULabel, BufHelpers::create(0), secret.size());
   return nextSecret;
 }
 

quic/fizz/handshake/FizzCryptoFactory.cpp

@@ -26,7 +26,7 @@ Buf FizzCryptoFactory::makeInitialTrafficSecret(
   auto trafficSecret = deriver->expandLabel(
       folly::range(initialSecret),
       label,
-      folly::IOBuf::create(0),
+      BufHelpers::create(0),
       fizz::Sha256::HashLen);
   return trafficSecret;
 }
@@ -43,12 +43,12 @@ std::unique_ptr<Aead> FizzCryptoFactory::makeInitialAead(
   auto key = deriver->expandLabel(
       trafficSecret->coalesce(),
       kQuicKeyLabel,
-      folly::IOBuf::create(0),
+      BufHelpers::create(0),
       aead->keyLength());
   auto iv = deriver->expandLabel(
       trafficSecret->coalesce(),
       kQuicIVLabel,
-      folly::IOBuf::create(0),
+      BufHelpers::create(0),
       aead->ivLength());
 
   fizz::TrafficKey trafficKey = {std::move(key), std::move(iv)};
@@ -63,7 +63,7 @@ std::unique_ptr<PacketNumberCipher> FizzCryptoFactory::makePacketNumberCipher(
   auto deriver =
       fizzFactory_->makeKeyDeriver(fizz::CipherSuite::TLS_AES_128_GCM_SHA256);
   auto pnKey = deriver->expandLabel(
-      baseSecret, kQuicPNLabel, folly::IOBuf::create(0), pnCipher->keyLength());
+      baseSecret, kQuicPNLabel, BufHelpers::create(0), pnCipher->keyLength());
   pnCipher->setKey(pnKey->coalesce());
   return pnCipher;
 }

quic/fizz/handshake/FizzPacketNumberCipher.cpp

@@ -43,12 +43,12 @@ static HeaderProtectionMask maskImpl(
 }
 
 void Aes128PacketNumberCipher::setKey(folly::ByteRange key) {
-  pnKey_ = folly::IOBuf::copyBuffer(key);
+  pnKey_ = BufHelpers::copyBuffer(key);
   return setKeyImpl(encryptCtx_, EVP_aes_128_ecb(), key);
 }
 
 void Aes256PacketNumberCipher::setKey(folly::ByteRange key) {
-  pnKey_ = folly::IOBuf::copyBuffer(key);
+  pnKey_ = BufHelpers::copyBuffer(key);
   return setKeyImpl(encryptCtx_, EVP_aes_256_ecb(), key);
 }
 

quic/fizz/handshake/FizzRetryIntegrityTagGenerator.cpp

@@ -38,8 +38,8 @@ FizzRetryIntegrityTagGenerator::getRetryIntegrityTag(
   std::unique_ptr<fizz::Aead> retryCipher =
       fizz::openssl::OpenSSLEVPCipher::makeCipher<fizz::AESGCM128>();
   fizz::TrafficKey trafficKey;
-  trafficKey.key = folly::IOBuf::copyBuffer(retryPacketKey(version));
-  trafficKey.iv = folly::IOBuf::copyBuffer(retryPacketNonce(version));
+  trafficKey.key = BufHelpers::copyBuffer(retryPacketKey(version));
+  trafficKey.iv = BufHelpers::copyBuffer(retryPacketNonce(version));
   retryCipher->setKey(std::move(trafficKey));
 
   return retryCipher->encrypt(

quic/fizz/server/handshake/FizzServerHandshake.cpp

@@ -106,7 +106,7 @@ Buf FizzServerHandshake::getNextTrafficSecret(folly::ByteRange secret) const {
   auto deriver =
       state_.context()->getFactory()->makeKeyDeriver(*state_.cipher());
   auto nextSecret = deriver->expandLabel(
-      secret, kQuicKULabel, folly::IOBuf::create(0), secret.size());
+      secret, kQuicKULabel, BufHelpers::create(0), secret.size());
   return nextSecret;
 }
 

quic/handshake/TransportParameters.cpp

@@ -67,7 +67,7 @@ Optional<StatelessResetToken> getStatelessResetTokenParameter(
 TransportParameter encodeIntegerParameter(
     TransportParameterId id,
     uint64_t value) {
-  Buf data = folly::IOBuf::create(8);
+  Buf data = BufHelpers::create(8);
   BufAppender appender(data.get(), 8);
   auto encoded = encodeQuicInteger(
       value, [appender = std::move(appender)](auto val) mutable {

quic/handshake/TransportParameters.h

@@ -89,7 +89,7 @@ struct TransportParameter {
   Buf encode() const {
     // reserve the exact size needed
     auto res =
-        folly::IOBuf::createCombined(static_cast<size_t>(getEncodedSize()));
+        BufHelpers::createCombined(static_cast<size_t>(getEncodedSize()));
 
     // write parameter; need to improve QuicInteger encoding methods
     BufWriter writer(res->writableData(), res->capacity());
@@ -147,21 +147,21 @@ TransportParameter encodeIntegerParameter(
 inline TransportParameter encodeEmptyParameter(TransportParameterId id) {
   TransportParameter param;
   param.parameter = id;
-  param.value = folly::IOBuf::create(0);
+  param.value = BufHelpers::create(0);
   return param;
 }
 
 inline TransportParameter encodeConnIdParameter(
     TransportParameterId id,
     const ConnectionId& connId) {
-  return {id, folly::IOBuf::copyBuffer(connId.data(), connId.size())};
+  return {id, BufHelpers::copyBuffer(connId.data(), connId.size())};
 }
 
 inline TransportParameter encodeStatelessResetToken(
     const StatelessResetToken& token) {
   TransportParameter statelessReset;
   statelessReset.parameter = TransportParameterId::stateless_reset_token;
-  statelessReset.value = folly::IOBuf::copyBuffer(token.data(), token.size());
+  statelessReset.value = BufHelpers::copyBuffer(token.data(), token.size());
   return statelessReset;
 }
 

quic/logging/FileQLogger.cpp

@@ -47,7 +47,7 @@ void FileQLogger::setupStream() {
   if (compress_) {
     compressionCodec_ =
         folly::compression::getStreamCodec(folly::compression::CodecType::GZIP);
-    compressionBuffer_ = folly::IOBuf::createCombined(kCompressionBufferSize);
+    compressionBuffer_ = BufHelpers::createCombined(kCompressionBufferSize);
   }
 
   // Create the base json

quic/samples/echo/EchoClient.h

@@ -286,7 +286,7 @@ class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
       // create new stream for each message
       auto streamId = client->createBidirectionalStream().value();
       client->setReadCallback(streamId, this);
-      pendingOutput_[streamId].append(folly::IOBuf::copyBuffer(message));
+      pendingOutput_[streamId].append(BufHelpers::copyBuffer(message));
       sendMessage(streamId, pendingOutput_[streamId]);
     };
 
@@ -297,7 +297,7 @@ class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
       CHECK(streamId.hasValue())
           << "Failed to generate stream id in group: " << streamId.error();
       client->setReadCallback(*streamId, this);
-      pendingOutput_[*streamId].append(folly::IOBuf::copyBuffer(message));
+      pendingOutput_[*streamId].append(BufHelpers::copyBuffer(message));
       sendMessage(*streamId, pendingOutput_[*streamId]);
     };
 

quic/samples/echo/EchoHandler.h

@@ -212,7 +212,7 @@ class EchoHandler : public quic::QuicSocket::ConnectionSetupCallback,
       // only echo when eof is present
       return;
     }
-    auto echoedData = folly::IOBuf::copyBuffer("echo ");
+    auto echoedData = BufHelpers::copyBuffer("echo ");
     echoedData->prependChain(data.first.move());
     auto res = sock->writeChain(id, std::move(echoedData), true, nullptr);
     if (res.hasError()) {
@@ -226,7 +226,7 @@ class EchoHandler : public quic::QuicSocket::ConnectionSetupCallback,
   void echoDg(std::vector<quic::ReadDatagram> datagrams) {
     CHECK_GT(datagrams.size(), 0);
     for (const auto& datagram : datagrams) {
-      auto echoedData = folly::IOBuf::copyBuffer("echo ");
+      auto echoedData = BufHelpers::copyBuffer("echo ");
       echoedData->prependChain(datagram.bufQueue().front()->cloneCoalesced());
       auto res = sock->writeDatagram(std::move(echoedData));
       if (res.hasError()) {

quic/samples/echo/EchoTransportServer.h

@@ -31,7 +31,7 @@ class UDPAcceptor : public folly::AsyncUDPSocket::ReadCallback {
         socket_(std::move(socket)) {}
 
   void getReadBuffer(void** buf, size_t* len) noexcept override {
-    readBuffer_ = folly::IOBuf::create(quic::kDefaultUDPReadBufferSize);
+    readBuffer_ = BufHelpers::create(quic::kDefaultUDPReadBufferSize);
     *buf = readBuffer_->writableData();
     *len = quic::kDefaultUDPReadBufferSize;
   }

quic/server/QuicServer.cpp

@@ -603,7 +603,7 @@ void QuicServer::setHealthCheckToken(const std::string& healthCheckToken) {
   checkRunningInThread(mainThreadId_);
   // Make sure the token satisfies the required properties, i.e. it is not a
   // valid quic header.
-  auto parsed = parseHeader(*folly::IOBuf::copyBuffer(healthCheckToken));
+  auto parsed = parseHeader(*BufHelpers::copyBuffer(healthCheckToken));
   CHECK(!parsed.hasValue());
   CHECK_GT(healthCheckToken.size(), kMinHealthCheckTokenSize);
   healthCheckToken_ = healthCheckToken;

quic/server/QuicServerPacketRouter.cpp

@@ -73,7 +73,7 @@ int TakeoverHandlerCallback::getSocketFD() {
 }
 
 void TakeoverHandlerCallback::getReadBuffer(void** buf, size_t* len) noexcept {
-  readBuffer_ = folly::IOBuf::create(
+  readBuffer_ = BufHelpers::create(
       transportSettings_.maxRecvPacketSize +
       kMaxBufSizeForTakeoverEncapsulation);
   *buf = readBuffer_->writableData();
@@ -137,7 +137,7 @@ void TakeoverPacketHandler::forwardPacketToAnotherServer(
   // Serialize: version (4B), socket(2 + 16)B and time of ack (8B)
   auto bufSize = sizeof(TakeoverProtocolVersion) + sizeof(uint16_t) +
       peerAddress.getActualSize() + sizeof(uint64_t);
-  Buf writeBuffer = folly::IOBuf::create(bufSize);
+  Buf writeBuffer = BufHelpers::create(bufSize);
   BufWriter bufWriter(writeBuffer->writableData(), bufSize);
   bufWriter.writeBE<uint32_t>(folly::to_underlying(takeoverProtocol_));
   sockaddr_storage addrStorage;

quic/server/QuicServerWorker.cpp

@@ -242,7 +242,7 @@ const folly::SocketAddress& QuicServerWorker::getAddress() const {
 
 void QuicServerWorker::getReadBuffer(void** buf, size_t* len) noexcept {
   auto readBufferSize = transportSettings_.maxRecvPacketSize * numGROBuffers_;
-  readBuffer_ = folly::IOBuf::createCombined(readBufferSize);
+  readBuffer_ = BufHelpers::createCombined(readBufferSize);
   *buf = readBuffer_->writableData();
   *len = readBufferSize;
 }
@@ -615,7 +615,7 @@ bool QuicServerWorker::tryHandlingAsHealthCheck(
     // request, so we are not creating an amplification vector. Also
     // ignore the error code.
     VLOG(4) << "Health check request, response=OK";
-    socket_->write(client, folly::IOBuf::copyBuffer("OK"));
+    socket_->write(client, BufHelpers::copyBuffer("OK"));
     return true;
   }
   return false;
@@ -1078,7 +1078,7 @@ bool QuicServerWorker::validRetryToken(
   RetryToken token(dstConnId, clientIp, 0);
 
   auto maybeDecryptedRetryTokenMs = tokenGenerator.decryptToken(
-      folly::IOBuf::copyBuffer(encryptedToken), token.genAeadAssocData());
+      BufHelpers::copyBuffer(encryptedToken), token.genAeadAssocData());
 
   return maybeDecryptedRetryTokenMs &&
       checkTokenAge(maybeDecryptedRetryTokenMs, kMaxRetryTokenValidMs);
@@ -1095,7 +1095,7 @@ bool QuicServerWorker::validNewToken(
   NewToken token(clientIp);
 
   auto maybeDecryptedNewTokenMs = tokenGenerator.decryptToken(
-      folly::IOBuf::copyBuffer(encryptedToken), token.genAeadAssocData());
+      BufHelpers::copyBuffer(encryptedToken), token.genAeadAssocData());
 
   return maybeDecryptedNewTokenMs &&
       checkTokenAge(maybeDecryptedNewTokenMs, kMaxNewTokenValidMs);
@@ -1135,7 +1135,7 @@ void QuicServerWorker::sendRetryPacket(
       srcConnId, /* dst conn id */
       dstConnId, /* original dst conn id */
       QuicVersion::MVFST_INVALID,
-      folly::IOBuf::copyBuffer(encryptedTokenStr));
+      BufHelpers::copyBuffer(encryptedTokenStr));
   Buf pseudoRetryPacketBuf = std::move(pseudoBuilder).buildPacket();
   FizzRetryIntegrityTagGenerator fizzRetryIntegrityTagGenerator;
   auto integrityTagBuf = fizzRetryIntegrityTagGenerator.getRetryIntegrityTag(
@@ -1291,7 +1291,7 @@ void QuicServerWorker::setIsBlockListedSrcPort(
 
 void QuicServerWorker::setHealthCheckToken(
     const std::string& healthCheckToken) {
-  healthCheckToken_ = folly::IOBuf::copyBuffer(healthCheckToken);
+  healthCheckToken_ = BufHelpers::copyBuffer(healthCheckToken);
 }
 
 std::unique_ptr<FollyAsyncUDPSocketAlias> QuicServerWorker::makeSocket(

quic/server/QuicServerWorker.h

@@ -62,7 +62,7 @@ class QuicServerWorker : public FollyAsyncUDPSocketAlias::ReadCallback,
 
     void reset() {
       len_ = getBuffSize();
-      ioBuf_ = folly::IOBuf::create(len_);
+      ioBuf_ = BufHelpers::create(len_);
       ::memset(&data_, 0, sizeof(data_));
       iov_.iov_base = ioBuf_->writableData();
       iov_.iov_len = len_;

quic/server/handshake/ServerHandshake.cpp

@@ -197,7 +197,7 @@ Optional<std::vector<uint8_t>> ServerHandshake::getExportedKeyingMaterial(
       cipherSuite.value(),
       ems.value()->coalesce(),
       label,
-      context == none ? nullptr : folly::IOBuf::wrapBuffer(*context),
+      context == none ? nullptr : BufHelpers::wrapBuffer(*context),
       keyLength);
 
   std::vector<uint8_t> result(ekm->coalesce());
@@ -511,12 +511,12 @@ void ServerHandshake::computeCiphers(CipherKind kind, folly::ByteRange secret) {
       conn_->handshakeWriteHeaderCipher = std::move(headerCipher);
       break;
     case CipherKind::OneRttRead:
-      readTrafficSecret_ = folly::IOBuf::copyBuffer(secret);
+      readTrafficSecret_ = BufHelpers::copyBuffer(secret);
       oneRttReadCipher_ = std::move(aead);
       oneRttReadHeaderCipher_ = std::move(headerCipher);
       break;
     case CipherKind::OneRttWrite:
-      writeTrafficSecret_ = folly::IOBuf::copyBuffer(secret);
+      writeTrafficSecret_ = BufHelpers::copyBuffer(secret);
       oneRttWriteCipher_ = std::move(aead);
       oneRttWriteHeaderCipher_ = std::move(headerCipher);
       break;

quic/server/handshake/ServerTransportParametersExtension.h

@@ -100,7 +100,7 @@ class ServerTransportParametersExtension : public fizz::ServerExtensions {
     // stateless reset token
     params.parameters.push_back(TransportParameter(
         TransportParameterId::stateless_reset_token,
-        folly::IOBuf::copyBuffer(token_)));
+        BufHelpers::copyBuffer(token_)));
 
     if (disableMigration_) {
       params.parameters.push_back(

quic/server/handshake/StatelessResetGenerator.cpp

@@ -29,7 +29,7 @@ StatelessResetToken StatelessResetGenerator::generateToken(
   StatelessResetToken token;
   auto info = toData(connId);
   info.prependChain(
-      folly::IOBuf::wrapBuffer(addressStr_.data(), addressStr_.size()));
+      BufHelpers::wrapBuffer(addressStr_.data(), addressStr_.size()));
   auto out = hkdf_.expand(folly::range(extractedSecret_), info, token.size());
   out->coalesce();
   memcpy(token.data(), out->data(), out->length());

quic/state/QuicStreamFunctions.cpp

@@ -112,7 +112,7 @@ static void pushToTail(folly::IOBuf* dst, Buf src, size_t allocSize) {
         dst->appendChain(std::move(src));
         return;
       }
-      newBuf = folly::IOBuf::createCombined(allocSize);
+      newBuf = BufHelpers::createCombined(allocSize);
       dst->appendChain(std::move(newBuf));
       dst = dst->next();
     }