blob: 30b87f002634d79e090d6567413fccda037949a6 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/third_party/quic/core/quic_packet_generator.h"
#include <cstdint>
#include "net/third_party/quic/core/crypto/quic_random.h"
#include "net/third_party/quic/core/quic_connection_id.h"
#include "net/third_party/quic/core/quic_types.h"
#include "net/third_party/quic/core/quic_utils.h"
#include "net/third_party/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quic/platform/api/quic_flags.h"
#include "net/third_party/quic/platform/api/quic_logging.h"
namespace quic {
QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
QuicFramer* framer,
QuicRandom* random_generator,
DelegateInterface* delegate)
: delegate_(delegate),
packet_creator_(connection_id, framer, random_generator, delegate),
next_transmission_type_(NOT_RETRANSMISSION),
flusher_attached_(false),
should_send_ack_(false),
should_send_stop_waiting_(false),
random_generator_(random_generator),
fully_pad_crypto_handshake_packets_(true),
deprecate_ack_bundling_mode_(
GetQuicReloadableFlag(quic_deprecate_ack_bundling_mode)) {}
QuicPacketGenerator::~QuicPacketGenerator() {
DeleteFrames(&queued_control_frames_);
}
void QuicPacketGenerator::SetShouldSendAck(bool also_send_stop_waiting) {
DCHECK(!deprecate_ack_bundling_mode_);
if (packet_creator_.has_ack()) {
// Ack already queued, nothing to do.
return;
}
if (also_send_stop_waiting && packet_creator_.has_stop_waiting()) {
QUIC_BUG << "Should only ever be one pending stop waiting frame.";
return;
}
should_send_ack_ = true;
should_send_stop_waiting_ = also_send_stop_waiting;
SendQueuedFrames(/*flush=*/false);
}
void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
QUIC_BUG_IF(IsControlFrame(frame.type) && !GetControlFrameId(frame))
<< "Adding a control frame with no control frame id: " << frame;
if (deprecate_ack_bundling_mode_) {
MaybeBundleAckOpportunistically();
}
queued_control_frames_.push_back(frame);
SendQueuedFrames(/*flush=*/false);
}
size_t QuicPacketGenerator::ConsumeCryptoData(EncryptionLevel level,
size_t write_length,
QuicStreamOffset offset) {
QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
"generator tries to write crypto data.";
if (deprecate_ack_bundling_mode_) {
MaybeBundleAckOpportunistically();
}
// To make reasoning about crypto frames easier, we don't combine them with
// other retransmittable frames in a single packet.
// TODO(nharper): Once we have separate packet number spaces, everything
// should be driven by encryption level, and we should stop flushing in this
// spot.
const bool flush = packet_creator_.HasPendingRetransmittableFrames();
SendQueuedFrames(flush);
size_t total_bytes_consumed = 0;
while (total_bytes_consumed < write_length) {
QuicFrame frame;
if (!packet_creator_.ConsumeCryptoData(
level, write_length - total_bytes_consumed,
offset + total_bytes_consumed, next_transmission_type_, &frame)) {
// The only pending data in the packet is non-retransmittable frames. I'm
// assuming here that they won't occupy so much of the packet that a
// CRYPTO frame won't fit.
QUIC_BUG << "Failed to ConsumeCryptoData at level " << level;
return 0;
}
total_bytes_consumed += frame.crypto_frame->data_length;
// TODO(ianswett): Move to having the creator flush itself when it's full.
packet_creator_.Flush();
}
// Don't allow the handshake to be bundled with other retransmittable frames.
SendQueuedFrames(/*flush=*/true);
return total_bytes_consumed;
}
QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state) {
QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
"generator tries to write stream data.";
bool has_handshake =
(id == QuicUtils::GetCryptoStreamId(packet_creator_.transport_version()));
if (deprecate_ack_bundling_mode_) {
MaybeBundleAckOpportunistically();
}
bool fin = state != NO_FIN;
QUIC_BUG_IF(has_handshake && fin)
<< "Handshake packets should never send a fin";
// To make reasoning about crypto frames easier, we don't combine them with
// other retransmittable frames in a single packet.
const bool flush =
has_handshake && packet_creator_.HasPendingRetransmittableFrames();
SendQueuedFrames(flush);
size_t total_bytes_consumed = 0;
bool fin_consumed = false;
if (!packet_creator_.HasRoomForStreamFrame(id, offset, write_length)) {
packet_creator_.Flush();
}
if (!fin && (write_length == 0)) {
QUIC_BUG << "Attempt to consume empty data without FIN.";
return QuicConsumedData(0, false);
}
// We determine if we can enter the fast path before executing
// the slow path loop.
bool run_fast_path = !has_handshake && state != FIN_AND_PADDING &&
!HasQueuedFrames() &&
write_length - total_bytes_consumed > kMaxPacketSize;
while (!run_fast_path && delegate_->ShouldGeneratePacket(
HAS_RETRANSMITTABLE_DATA,
has_handshake ? IS_HANDSHAKE : NOT_HANDSHAKE)) {
QuicFrame frame;
bool needs_full_padding =
has_handshake && fully_pad_crypto_handshake_packets_;
if (!packet_creator_.ConsumeData(id, write_length, total_bytes_consumed,
offset + total_bytes_consumed, fin,
needs_full_padding,
next_transmission_type_, &frame)) {
// The creator is always flushed if there's not enough room for a new
// stream frame before ConsumeData, so ConsumeData should always succeed.
QUIC_BUG << "Failed to ConsumeData, stream:" << id;
return QuicConsumedData(0, false);
}
// A stream frame is created and added.
size_t bytes_consumed = frame.stream_frame.data_length;
total_bytes_consumed += bytes_consumed;
fin_consumed = fin && total_bytes_consumed == write_length;
if (fin_consumed && state == FIN_AND_PADDING) {
AddRandomPadding();
}
DCHECK(total_bytes_consumed == write_length ||
(bytes_consumed > 0 && packet_creator_.HasPendingFrames()));
if (total_bytes_consumed == write_length) {
// We're done writing the data. Exit the loop.
// We don't make this a precondition because we could have 0 bytes of data
// if we're simply writing a fin.
break;
}
// TODO(ianswett): Move to having the creator flush itself when it's full.
packet_creator_.Flush();
run_fast_path = !has_handshake && state != FIN_AND_PADDING &&
!HasQueuedFrames() &&
write_length - total_bytes_consumed > kMaxPacketSize;
}
if (run_fast_path) {
return ConsumeDataFastPath(id, write_length, offset, state != NO_FIN,
total_bytes_consumed);
}
// Don't allow the handshake to be bundled with other retransmittable frames.
if (has_handshake) {
SendQueuedFrames(/*flush=*/true);
}
return QuicConsumedData(total_bytes_consumed, fin_consumed);
}
QuicConsumedData QuicPacketGenerator::ConsumeDataFastPath(
QuicStreamId id,
size_t write_length,
QuicStreamOffset offset,
bool fin,
size_t total_bytes_consumed) {
DCHECK_NE(id,
QuicUtils::GetCryptoStreamId(packet_creator_.transport_version()));
while (total_bytes_consumed < write_length &&
delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
// Serialize and encrypt the packet.
size_t bytes_consumed = 0;
packet_creator_.CreateAndSerializeStreamFrame(
id, write_length, total_bytes_consumed, offset + total_bytes_consumed,
fin, next_transmission_type_, &bytes_consumed);
total_bytes_consumed += bytes_consumed;
}
return QuicConsumedData(total_bytes_consumed,
fin && (total_bytes_consumed == write_length));
}
void QuicPacketGenerator::GenerateMtuDiscoveryPacket(QuicByteCount target_mtu) {
// MTU discovery frames must be sent by themselves.
if (!packet_creator_.CanSetMaxPacketLength()) {
QUIC_BUG << "MTU discovery packets should only be sent when no other "
<< "frames needs to be sent.";
return;
}
const QuicByteCount current_mtu = GetCurrentMaxPacketLength();
// The MTU discovery frame is allocated on the stack, since it is going to be
// serialized within this function.
QuicMtuDiscoveryFrame mtu_discovery_frame;
QuicFrame frame(mtu_discovery_frame);
// Send the probe packet with the new length.
SetMaxPacketLength(target_mtu);
const bool success =
packet_creator_.AddPaddedSavedFrame(frame, next_transmission_type_);
packet_creator_.Flush();
// The only reason AddFrame can fail is that the packet is too full to fit in
// a ping. This is not possible for any sane MTU.
DCHECK(success);
// Reset the packet length back.
SetMaxPacketLength(current_mtu);
}
bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
DCHECK(HasPendingFrames() || packet_creator_.pending_padding_bytes() > 0);
HasRetransmittableData retransmittable =
(should_send_ack_ || should_send_stop_waiting_ ||
packet_creator_.pending_padding_bytes() > 0)
? NO_RETRANSMITTABLE_DATA
: HAS_RETRANSMITTABLE_DATA;
if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
DCHECK(!queued_control_frames_.empty()); // These are retransmittable.
}
return delegate_->ShouldGeneratePacket(retransmittable, NOT_HANDSHAKE);
}
void QuicPacketGenerator::SendQueuedFrames(bool flush) {
// Only add pending frames if we are SURE we can then send the whole packet.
while (HasPendingFrames() &&
(flush || CanSendWithNextPendingFrameAddition())) {
bool first_frame = packet_creator_.CanSetMaxPacketLength();
if (!AddNextPendingFrame() && first_frame) {
// A single frame cannot fit into the packet, tear down the connection.
QUIC_BUG << "A single frame cannot fit into packet."
<< " should_send_ack: " << should_send_ack_
<< " should_send_stop_waiting: " << should_send_stop_waiting_
<< " number of queued_control_frames: "
<< queued_control_frames_.size();
if (!queued_control_frames_.empty()) {
QUIC_LOG(INFO) << queued_control_frames_[0];
}
delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
"Single frame cannot fit into a packet",
ConnectionCloseSource::FROM_SELF);
return;
}
}
if (flush) {
packet_creator_.Flush();
}
}
bool QuicPacketGenerator::PacketFlusherAttached() const {
return flusher_attached_;
}
void QuicPacketGenerator::AttachPacketFlusher() {
flusher_attached_ = true;
}
void QuicPacketGenerator::Flush() {
SendQueuedFrames(/*flush=*/false);
packet_creator_.Flush();
SendRemainingPendingPadding();
flusher_attached_ = false;
}
void QuicPacketGenerator::FlushAllQueuedFrames() {
SendQueuedFrames(/*flush=*/true);
}
bool QuicPacketGenerator::HasQueuedFrames() const {
return packet_creator_.HasPendingFrames() || HasPendingFrames();
}
bool QuicPacketGenerator::IsPendingPacketEmpty() const {
return !packet_creator_.HasPendingFrames();
}
bool QuicPacketGenerator::HasPendingFrames() const {
return should_send_ack_ || should_send_stop_waiting_ ||
!queued_control_frames_.empty();
}
bool QuicPacketGenerator::AddNextPendingFrame() {
QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
"generator tries to write control frames.";
if (should_send_ack_) {
should_send_ack_ = !packet_creator_.AddSavedFrame(
delegate_->GetUpdatedAckFrame(), next_transmission_type_);
return !should_send_ack_;
}
if (should_send_stop_waiting_) {
delegate_->PopulateStopWaitingFrame(&pending_stop_waiting_frame_);
// If we can't this add the frame now, then we still need to do so later.
should_send_stop_waiting_ = !packet_creator_.AddSavedFrame(
QuicFrame(pending_stop_waiting_frame_), next_transmission_type_);
// Return success if we have cleared out this flag (i.e., added the frame).
// If we still need to send, then the frame is full, and we have failed.
return !should_send_stop_waiting_;
}
QUIC_BUG_IF(queued_control_frames_.empty())
<< "AddNextPendingFrame called with no queued control frames.";
if (!packet_creator_.AddSavedFrame(queued_control_frames_.back(),
next_transmission_type_)) {
// Packet was full.
return false;
}
queued_control_frames_.pop_back();
return true;
}
void QuicPacketGenerator::StopSendingVersion() {
packet_creator_.StopSendingVersion();
}
void QuicPacketGenerator::SetDiversificationNonce(
const DiversificationNonce& nonce) {
packet_creator_.SetDiversificationNonce(nonce);
}
QuicPacketNumber QuicPacketGenerator::packet_number() const {
return packet_creator_.packet_number();
}
QuicByteCount QuicPacketGenerator::GetCurrentMaxPacketLength() const {
return packet_creator_.max_packet_length();
}
void QuicPacketGenerator::SetMaxPacketLength(QuicByteCount length) {
DCHECK(packet_creator_.CanSetMaxPacketLength());
packet_creator_.SetMaxPacketLength(length);
}
std::unique_ptr<QuicEncryptedPacket>
QuicPacketGenerator::SerializeVersionNegotiationPacket(
bool ietf_quic,
const ParsedQuicVersionVector& supported_versions) {
return packet_creator_.SerializeVersionNegotiationPacket(ietf_quic,
supported_versions);
}
OwningSerializedPacketPointer
QuicPacketGenerator::SerializeConnectivityProbingPacket() {
return packet_creator_.SerializeConnectivityProbingPacket();
}
OwningSerializedPacketPointer
QuicPacketGenerator::SerializePathChallengeConnectivityProbingPacket(
QuicPathFrameBuffer* payload) {
return packet_creator_.SerializePathChallengeConnectivityProbingPacket(
payload);
}
OwningSerializedPacketPointer
QuicPacketGenerator::SerializePathResponseConnectivityProbingPacket(
const QuicDeque<QuicPathFrameBuffer>& payloads,
const bool is_padded) {
return packet_creator_.SerializePathResponseConnectivityProbingPacket(
payloads, is_padded);
}
void QuicPacketGenerator::ReserializeAllFrames(
const QuicPendingRetransmission& retransmission,
char* buffer,
size_t buffer_len) {
packet_creator_.ReserializeAllFrames(retransmission, buffer, buffer_len);
}
void QuicPacketGenerator::UpdatePacketNumberLength(
QuicPacketNumber least_packet_awaited_by_peer,
QuicPacketCount max_packets_in_flight) {
return packet_creator_.UpdatePacketNumberLength(least_packet_awaited_by_peer,
max_packets_in_flight);
}
void QuicPacketGenerator::SetConnectionIdLength(uint32_t length) {
if (length == 0) {
packet_creator_.SetConnectionIdIncluded(CONNECTION_ID_ABSENT);
} else {
packet_creator_.SetConnectionIdIncluded(CONNECTION_ID_PRESENT);
}
}
void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
packet_creator_.set_encryption_level(level);
}
void QuicPacketGenerator::SetEncrypter(
EncryptionLevel level,
std::unique_ptr<QuicEncrypter> encrypter) {
packet_creator_.SetEncrypter(level, std::move(encrypter));
}
void QuicPacketGenerator::AddRandomPadding() {
packet_creator_.AddPendingPadding(
random_generator_->RandUint64() % kMaxNumRandomPaddingBytes + 1);
}
void QuicPacketGenerator::SendRemainingPendingPadding() {
while (packet_creator_.pending_padding_bytes() > 0 && !HasQueuedFrames() &&
CanSendWithNextPendingFrameAddition()) {
packet_creator_.Flush();
}
}
bool QuicPacketGenerator::HasRetransmittableFrames() const {
return !queued_control_frames_.empty() ||
packet_creator_.HasPendingRetransmittableFrames();
}
bool QuicPacketGenerator::HasPendingStreamFramesOfStream(
QuicStreamId id) const {
return packet_creator_.HasPendingStreamFramesOfStream(id);
}
void QuicPacketGenerator::SetTransmissionType(TransmissionType type) {
packet_creator_.SetTransmissionType(type);
if (packet_creator_.ShouldSetTransmissionTypeForNextFrame()) {
next_transmission_type_ = type;
}
}
void QuicPacketGenerator::SetCanSetTransmissionType(
bool can_set_transmission_type) {
packet_creator_.set_can_set_transmission_type(can_set_transmission_type);
}
MessageStatus QuicPacketGenerator::AddMessageFrame(QuicMessageId message_id,
QuicMemSliceSpan message) {
QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
"generator tries to add message frame.";
if (deprecate_ack_bundling_mode_) {
MaybeBundleAckOpportunistically();
}
const QuicByteCount message_length = message.total_length();
if (message_length > GetLargestMessagePayload()) {
return MESSAGE_STATUS_TOO_LARGE;
}
SendQueuedFrames(/*flush=*/false);
if (!packet_creator_.HasRoomForMessageFrame(message_length)) {
packet_creator_.Flush();
}
QuicMessageFrame* frame = new QuicMessageFrame(message_id);
message.SaveMemSlicesAsMessageData(frame);
const bool success =
packet_creator_.AddSavedFrame(QuicFrame(frame), next_transmission_type_);
if (!success) {
QUIC_BUG << "Failed to send message " << message_id;
delete frame;
return MESSAGE_STATUS_INTERNAL_ERROR;
}
return MESSAGE_STATUS_SUCCESS;
}
void QuicPacketGenerator::MaybeBundleAckOpportunistically() {
DCHECK(deprecate_ack_bundling_mode_);
if (packet_creator_.has_ack()) {
// Ack already queued, nothing to do.
return;
}
if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
return;
}
const bool flushed =
FlushAckFrame(delegate_->MaybeBundleAckOpportunistically());
DCHECK(flushed);
}
bool QuicPacketGenerator::FlushAckFrame(const QuicFrames& frames) {
QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
"generator tries to send ACK frame.";
for (const auto& frame : frames) {
DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME);
if (packet_creator_.HasPendingFrames()) {
if (packet_creator_.AddSavedFrame(frame, next_transmission_type_)) {
// There is pending frames and current frame fits.
continue;
}
}
DCHECK(!packet_creator_.HasPendingFrames());
// There is no pending frames, consult the delegate whether a packet can be
// generated.
if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
return false;
}
const bool success =
packet_creator_.AddSavedFrame(frame, next_transmission_type_);
QUIC_BUG_IF(!success) << "Failed to flush " << frame;
}
return true;
}
QuicPacketLength QuicPacketGenerator::GetLargestMessagePayload() const {
return packet_creator_.GetLargestMessagePayload();
}
} // namespace quic