From 2f33a3681ae82e404e85cebf22723e2d6918c8a6 Mon Sep 17 00:00:00 2001 From: Aman Sharma Date: Thu, 17 Apr 2025 11:57:01 -0700 Subject: [PATCH] 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 | 1 + quic/api/QuicStreamAsyncTransport.cpp | 4 ++-- quic/api/QuicTransportFunctions.cpp | 2 +- quic/client/QuicClientTransportLite.cpp | 10 ++++---- quic/client/handshake/ClientHandshake.cpp | 4 ++-- quic/codec/QuicConnectionId.h | 2 +- quic/codec/QuicPacketBuilder.cpp | 24 +++++++++---------- quic/codec/QuicReadCodec.cpp | 9 ++++--- quic/codec/Types.cpp | 6 ++--- quic/codec/Types.h | 4 ++-- quic/common/BufAccessor.cpp | 2 +- quic/common/BufUtil.cpp | 4 ++-- .../udpsocket/QuicAsyncUDPSocketImpl.cpp | 2 +- .../test/QuicAsyncUDPSocketTestBase.h | 6 ++--- quic/dsr/backend/DSRPacketizer.cpp | 2 +- .../client/handshake/FizzClientHandshake.cpp | 10 ++++---- quic/fizz/handshake/FizzCryptoFactory.cpp | 8 +++---- .../fizz/handshake/FizzPacketNumberCipher.cpp | 4 ++-- .../FizzRetryIntegrityTagGenerator.cpp | 4 ++-- .../server/handshake/FizzServerHandshake.cpp | 2 +- quic/handshake/TransportParameters.cpp | 2 +- quic/handshake/TransportParameters.h | 8 +++---- quic/logging/FileQLogger.cpp | 2 +- quic/samples/echo/EchoClient.h | 4 ++-- quic/samples/echo/EchoHandler.h | 4 ++-- quic/samples/echo/EchoTransportServer.h | 2 +- quic/server/QuicServer.cpp | 2 +- quic/server/QuicServerPacketRouter.cpp | 4 ++-- quic/server/QuicServerWorker.cpp | 12 +++++----- quic/server/QuicServerWorker.h | 2 +- quic/server/handshake/ServerHandshake.cpp | 6 ++--- .../ServerTransportParametersExtension.h | 2 +- .../handshake/StatelessResetGenerator.cpp | 2 +- quic/state/QuicStreamFunctions.cpp | 2 +- 34 files changed, 82 insertions(+), 82 deletions(-) diff --git a/quic/QuicConstants.h b/quic/QuicConstants.h index 38e7d69a9..81e0772bf 100644 --- a/quic/QuicConstants.h +++ b/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; using Clock = std::chrono::steady_clock; using TimePoint = std::chrono::time_point; diff --git a/quic/api/QuicStreamAsyncTransport.cpp b/quic/api/QuicStreamAsyncTransport.cpp index 2a1e21140..b235f2959 100644 --- a/quic/api/QuicStreamAsyncTransport.cpp +++ b/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); } diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp index 036df2259..7d4e25222 100644 --- a/quic/api/QuicTransportFunctions.cpp +++ b/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); diff --git a/quic/client/QuicClientTransportLite.cpp b/quic/client/QuicClientTransportLite.cpp index e3011b277..14d876e7e 100644 --- a/quic/client/QuicClientTransportLite.cpp +++ b/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"; diff --git a/quic/client/handshake/ClientHandshake.cpp b/quic/client/handshake/ClientHandshake.cpp index 37f89db97..84778fe70 100644 --- a/quic/client/handshake/ClientHandshake.cpp +++ b/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()); diff --git a/quic/codec/QuicConnectionId.h b/quic/codec/QuicConnectionId.h index 2526ad44d..5dd78e707 100644 --- a/quic/codec/QuicConnectionId.h +++ b/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 { diff --git a/quic/codec/QuicPacketBuilder.cpp b/quic/codec/QuicPacketBuilder.cpp index 4b87d1480..30660f68a 100644 --- a/quic/codec/QuicPacketBuilder.cpp +++ b/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(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 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(); diff --git a/quic/codec/QuicReadCodec.cpp b/quic/codec/QuicReadCodec.cpp index a398631a6..f20d189d8 100644 --- a/quic/codec/QuicReadCodec.cpp +++ b/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) { diff --git a/quic/codec/Types.cpp b/quic/codec/Types.cpp index d20c242b4..73c561834 100644 --- a/quic/codec/Types.cpp +++ b/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( + return BufHelpers::copyBuffer(folly::to( toString(tokenType), originalDstConnId.hex() + clientIp.str())); } Buf NewToken::genAeadAssocData() const { - return folly::IOBuf::copyBuffer( + return BufHelpers::copyBuffer( folly::to(toString(tokenType), clientIp.str())); } diff --git a/quic/codec/Types.h b/quic/codec/Types.h index e93c4d247..88949baac 100644 --- a/quic/codec/Types.h +++ b/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. diff --git a/quic/common/BufAccessor.cpp b/quic/common/BufAccessor.cpp index b5154ed5f..ea42b00ed 100644 --- a/quic/common/BufAccessor.cpp +++ b/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; diff --git a/quic/common/BufUtil.cpp b/quic/common/BufUtil.cpp index f140182d1..2398d6e40 100644 --- a/quic/common/BufUtil.cpp +++ b/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; diff --git a/quic/common/udpsocket/QuicAsyncUDPSocketImpl.cpp b/quic/common/udpsocket/QuicAsyncUDPSocketImpl.cpp index a3b5909ab..6c121c51c 100644 --- a/quic/common/udpsocket/QuicAsyncUDPSocketImpl.cpp +++ b/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; diff --git a/quic/common/udpsocket/test/QuicAsyncUDPSocketTestBase.h b/quic/common/udpsocket/test/QuicAsyncUDPSocketTestBase.h index 4e4c4c831..2c9359c9c 100644 --- a/quic/common/udpsocket/test/QuicAsyncUDPSocketTestBase.h +++ b/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; diff --git a/quic/dsr/backend/DSRPacketizer.cpp b/quic/dsr/backend/DSRPacketizer.cpp index 7bf14d4bd..6f8504d2a 100644 --- a/quic/dsr/backend/DSRPacketizer.cpp +++ b/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, diff --git a/quic/fizz/client/handshake/FizzClientHandshake.cpp b/quic/fizz/client/handshake/FizzClientHandshake.cpp index 65ef97da5..a5f38ab90 100644 --- a/quic/fizz/client/handshake/FizzClientHandshake.cpp +++ b/quic/fizz/client/handshake/FizzClientHandshake.cpp @@ -85,7 +85,7 @@ Optional 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> FizzClientHandshake::getExportedKeyingMaterial( cipherSuite.value(), ems.value()->coalesce(), label, - context == none ? nullptr : folly::IOBuf::wrapBuffer(*context), + context == none ? nullptr : BufHelpers::wrapBuffer(*context), keyLength); std::vector 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; } diff --git a/quic/fizz/handshake/FizzCryptoFactory.cpp b/quic/fizz/handshake/FizzCryptoFactory.cpp index 3a7f937f5..18c9fefd1 100644 --- a/quic/fizz/handshake/FizzCryptoFactory.cpp +++ b/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 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 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; } diff --git a/quic/fizz/handshake/FizzPacketNumberCipher.cpp b/quic/fizz/handshake/FizzPacketNumberCipher.cpp index 4b046b513..df335c000 100644 --- a/quic/fizz/handshake/FizzPacketNumberCipher.cpp +++ b/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); } diff --git a/quic/fizz/handshake/FizzRetryIntegrityTagGenerator.cpp b/quic/fizz/handshake/FizzRetryIntegrityTagGenerator.cpp index ea9350ed9..905a55d7d 100644 --- a/quic/fizz/handshake/FizzRetryIntegrityTagGenerator.cpp +++ b/quic/fizz/handshake/FizzRetryIntegrityTagGenerator.cpp @@ -38,8 +38,8 @@ FizzRetryIntegrityTagGenerator::getRetryIntegrityTag( std::unique_ptr retryCipher = fizz::openssl::OpenSSLEVPCipher::makeCipher(); 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( diff --git a/quic/fizz/server/handshake/FizzServerHandshake.cpp b/quic/fizz/server/handshake/FizzServerHandshake.cpp index 7eb8360d6..fb3b62780 100644 --- a/quic/fizz/server/handshake/FizzServerHandshake.cpp +++ b/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; } diff --git a/quic/handshake/TransportParameters.cpp b/quic/handshake/TransportParameters.cpp index 605bdd4cf..1e0028696 100644 --- a/quic/handshake/TransportParameters.cpp +++ b/quic/handshake/TransportParameters.cpp @@ -67,7 +67,7 @@ Optional 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 { diff --git a/quic/handshake/TransportParameters.h b/quic/handshake/TransportParameters.h index 346f776a6..6ddc60bd5 100644 --- a/quic/handshake/TransportParameters.h +++ b/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(getEncodedSize())); + BufHelpers::createCombined(static_cast(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; } diff --git a/quic/logging/FileQLogger.cpp b/quic/logging/FileQLogger.cpp index 0ac5b101f..c0219f267 100644 --- a/quic/logging/FileQLogger.cpp +++ b/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 diff --git a/quic/samples/echo/EchoClient.h b/quic/samples/echo/EchoClient.h index 49c4b2a40..7aa317b44 100644 --- a/quic/samples/echo/EchoClient.h +++ b/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]); }; diff --git a/quic/samples/echo/EchoHandler.h b/quic/samples/echo/EchoHandler.h index 0427923a4..0be6fc8a3 100644 --- a/quic/samples/echo/EchoHandler.h +++ b/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 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()) { diff --git a/quic/samples/echo/EchoTransportServer.h b/quic/samples/echo/EchoTransportServer.h index dd795e816..a040588ec 100644 --- a/quic/samples/echo/EchoTransportServer.h +++ b/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; } diff --git a/quic/server/QuicServer.cpp b/quic/server/QuicServer.cpp index 0254303f0..e2a94cd61 100644 --- a/quic/server/QuicServer.cpp +++ b/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; diff --git a/quic/server/QuicServerPacketRouter.cpp b/quic/server/QuicServerPacketRouter.cpp index 3546e874f..65fe95a36 100644 --- a/quic/server/QuicServerPacketRouter.cpp +++ b/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(folly::to_underlying(takeoverProtocol_)); sockaddr_storage addrStorage; diff --git a/quic/server/QuicServerWorker.cpp b/quic/server/QuicServerWorker.cpp index 7790858b2..3a45d3d15 100644 --- a/quic/server/QuicServerWorker.cpp +++ b/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 QuicServerWorker::makeSocket( diff --git a/quic/server/QuicServerWorker.h b/quic/server/QuicServerWorker.h index 88a021dd4..874977bd7 100644 --- a/quic/server/QuicServerWorker.h +++ b/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_; diff --git a/quic/server/handshake/ServerHandshake.cpp b/quic/server/handshake/ServerHandshake.cpp index 4c00198e5..203f75a50 100644 --- a/quic/server/handshake/ServerHandshake.cpp +++ b/quic/server/handshake/ServerHandshake.cpp @@ -197,7 +197,7 @@ Optional> ServerHandshake::getExportedKeyingMaterial( cipherSuite.value(), ems.value()->coalesce(), label, - context == none ? nullptr : folly::IOBuf::wrapBuffer(*context), + context == none ? nullptr : BufHelpers::wrapBuffer(*context), keyLength); std::vector 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; diff --git a/quic/server/handshake/ServerTransportParametersExtension.h b/quic/server/handshake/ServerTransportParametersExtension.h index 56dd79b3a..605dfc09a 100644 --- a/quic/server/handshake/ServerTransportParametersExtension.h +++ b/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( diff --git a/quic/server/handshake/StatelessResetGenerator.cpp b/quic/server/handshake/StatelessResetGenerator.cpp index 321c2f017..3e1856005 100644 --- a/quic/server/handshake/StatelessResetGenerator.cpp +++ b/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()); diff --git a/quic/state/QuicStreamFunctions.cpp b/quic/state/QuicStreamFunctions.cpp index 412bdbefb..e9e19f77e 100644 --- a/quic/state/QuicStreamFunctions.cpp +++ b/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(); }