Improve logging in QuicPacketCreator
Working on cl/368341433 was made harder by the fact that some of the logs didn't contain the ENDPOINT. This CL fixes that by making sure all packet creator logs contain it. This only impacts logging and is therefore not flag protected.
PiperOrigin-RevId: 368873837
Change-Id: I69fc1e6e6e2972a4105c3c9ecf3dbfcb5babaced
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 48da702..48fa88e 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -159,21 +159,21 @@
}
void QuicPacketCreator::SetMaxPacketLength(QuicByteCount length) {
- QUICHE_DCHECK(CanSetMaxPacketLength());
+ QUICHE_DCHECK(CanSetMaxPacketLength()) << ENDPOINT;
// Avoid recomputing |max_plaintext_size_| if the length does not actually
// change.
if (length == max_packet_length_) {
return;
}
- QUIC_DVLOG(1) << "Updating packet creator max packet length from "
+ QUIC_DVLOG(1) << ENDPOINT << "Updating packet creator max packet length from "
<< max_packet_length_ << " to " << length;
max_packet_length_ = length;
max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
QUIC_BUG_IF(quic_bug_12398_2, max_plaintext_size_ - PacketHeaderSize() <
MinPlaintextPacketSize(framer_->version()))
- << "Attempted to set max packet length too small";
+ << ENDPOINT << "Attempted to set max packet length too small";
}
void QuicPacketCreator::SetMaxDatagramFrameSize(
@@ -192,7 +192,7 @@
}
void QuicPacketCreator::SetSoftMaxPacketLength(QuicByteCount length) {
- QUICHE_DCHECK(CanSetMaxPacketLength());
+ QUICHE_DCHECK(CanSetMaxPacketLength()) << ENDPOINT;
if (length > max_packet_length_) {
QUIC_BUG(quic_bug_10752_2)
<< ENDPOINT
@@ -204,11 +204,12 @@
PacketHeaderSize() + MinPlaintextPacketSize(framer_->version())) {
// Please note: this would not guarantee to fit next packet if the size of
// packet header increases (e.g., encryption level changes).
- QUIC_DLOG(INFO) << length << " is too small to fit packet header";
+ QUIC_DLOG(INFO) << ENDPOINT << length
+ << " is too small to fit packet header";
RemoveSoftMaxPacketLength();
return;
}
- QUIC_DVLOG(1) << "Setting soft max packet length to: " << length;
+ QUIC_DVLOG(1) << ENDPOINT << "Setting soft max packet length to: " << length;
latched_hard_max_packet_length_ = max_packet_length_;
max_packet_length_ = length;
max_plaintext_size_ = framer_->GetMaxPlaintextSize(length);
@@ -218,18 +219,18 @@
// A packet that is already open might send kQuicVersionSize bytes less than the
// maximum packet size if we stop sending version before it is serialized.
void QuicPacketCreator::StopSendingVersion() {
- QUICHE_DCHECK(send_version_in_packet_);
- QUICHE_DCHECK(!version().HasIetfInvariantHeader());
+ QUICHE_DCHECK(send_version_in_packet_) << ENDPOINT;
+ QUICHE_DCHECK(!version().HasIetfInvariantHeader()) << ENDPOINT;
send_version_in_packet_ = false;
if (packet_size_ > 0) {
- QUICHE_DCHECK_LT(kQuicVersionSize, packet_size_);
+ QUICHE_DCHECK_LT(kQuicVersionSize, packet_size_) << ENDPOINT;
packet_size_ -= kQuicVersionSize;
}
}
void QuicPacketCreator::SetDiversificationNonce(
const DiversificationNonce& nonce) {
- QUICHE_DCHECK(!have_diversification_nonce_);
+ QUICHE_DCHECK(!have_diversification_nonce_) << ENDPOINT;
have_diversification_nonce_ = true;
diversification_nonce_ = nonce;
}
@@ -240,14 +241,16 @@
if (!queued_frames_.empty()) {
// Don't change creator state if there are frames queued.
QUIC_BUG(quic_bug_10752_3)
- << "Called UpdatePacketNumberLength with " << queued_frames_.size()
+ << ENDPOINT << "Called UpdatePacketNumberLength with "
+ << queued_frames_.size()
<< " queued_frames. First frame type:" << queued_frames_.front().type
<< " last frame type:" << queued_frames_.back().type;
return;
}
const QuicPacketNumber next_packet_number = NextSendingPacketNumber();
- QUICHE_DCHECK_LE(least_packet_awaited_by_peer, next_packet_number);
+ QUICHE_DCHECK_LE(least_packet_awaited_by_peer, next_packet_number)
+ << ENDPOINT;
const uint64_t current_delta =
next_packet_number - least_packet_awaited_by_peer;
const uint64_t delta = std::max(current_delta, max_packets_in_flight);
@@ -273,7 +276,8 @@
if (!queued_frames_.empty()) {
// Don't change creator state if there are frames queued.
QUIC_BUG(quic_bug_10752_4)
- << "Called SkipNPacketNumbers with " << queued_frames_.size()
+ << ENDPOINT << "Called SkipNPacketNumbers with "
+ << queued_frames_.size()
<< " queued_frames. First frame type:" << queued_frames_.front().type
<< " last frame type:" << queued_frames_.back().type;
return;
@@ -281,7 +285,7 @@
if (packet_.packet_number > packet_.packet_number + count) {
// Skipping count packet numbers causes packet number wrapping around,
// reject it.
- QUIC_LOG(WARNING) << "Skipping " << count
+ QUIC_LOG(WARNING) << ENDPOINT << "Skipping " << count
<< " packet numbers causes packet number wrapping "
"around, least_packet_awaited_by_peer: "
<< least_packet_awaited_by_peer
@@ -300,7 +304,7 @@
bool needs_full_padding,
TransmissionType transmission_type,
QuicFrame* frame) {
- QUIC_DVLOG(2) << "ConsumeCryptoDataToFillCurrentPacket " << level
+ QUIC_DVLOG(2) << ENDPOINT << "ConsumeCryptoDataToFillCurrentPacket " << level
<< " write_length " << write_length << " offset " << offset
<< (needs_full_padding ? " needs_full_padding" : "") << " "
<< transmission_type;
@@ -338,7 +342,7 @@
const std::string error_details =
"Client hello won't fit in a single packet.";
QUIC_BUG(quic_bug_10752_5)
- << error_details << " Constructed stream frame length: "
+ << ENDPOINT << error_details << " Constructed stream frame length: "
<< frame->stream_frame.data_length << " CHLO length: " << data_size;
delegate_->OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, error_details);
return false;
@@ -422,16 +426,17 @@
GetSourceConnectionIdLength(), kIncludeVersion,
IncludeNonceInPublicHeader(), PACKET_6BYTE_PACKET_NUMBER,
GetRetryTokenLengthLength(), GetLengthLength(), offset) ||
- latched_hard_max_packet_length_ > 0);
+ latched_hard_max_packet_length_ > 0)
+ << ENDPOINT;
QUIC_BUG_IF(quic_bug_12398_3, !HasRoomForStreamFrame(id, offset, data_size))
- << "No room for Stream frame, BytesFree: " << BytesFree()
+ << ENDPOINT << "No room for Stream frame, BytesFree: " << BytesFree()
<< " MinStreamFrameSize: "
<< QuicFramer::GetMinStreamFrameSize(framer_->transport_version(), id,
offset, true, data_size);
QUIC_BUG_IF(quic_bug_12398_4, data_size == 0 && !fin)
- << "Creating a stream frame for stream ID:" << id
+ << ENDPOINT << "Creating a stream frame for stream ID:" << id
<< " with no data or fin.";
size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
framer_->transport_version(), id, offset,
@@ -472,7 +477,7 @@
external_buffer.release_buffer = nullptr;
}
- QUICHE_DCHECK_EQ(nullptr, packet_.encrypted_buffer);
+ QUICHE_DCHECK_EQ(nullptr, packet_.encrypted_buffer) << ENDPOINT;
if (!SerializePacket(std::move(external_buffer), kMaxOutgoingPacketSize)) {
return;
}
@@ -480,7 +485,8 @@
}
void QuicPacketCreator::OnSerializedPacket() {
- QUIC_BUG_IF(quic_bug_12398_5, packet_.encrypted_buffer == nullptr);
+ QUIC_BUG_IF(quic_bug_12398_5, packet_.encrypted_buffer == nullptr)
+ << ENDPOINT;
SerializedPacket packet(std::move(packet_));
ClearPacket();
@@ -499,10 +505,10 @@
packet_.has_message = false;
packet_.fate = SEND_TO_WRITER;
QUIC_BUG_IF(quic_bug_12398_6, packet_.release_encrypted_buffer != nullptr)
- << "packet_.release_encrypted_buffer should be empty";
+ << ENDPOINT << "packet_.release_encrypted_buffer should be empty";
packet_.release_encrypted_buffer = nullptr;
- QUICHE_DCHECK(packet_.retransmittable_frames.empty());
- QUICHE_DCHECK(packet_.nonretransmittable_frames.empty());
+ QUICHE_DCHECK(packet_.retransmittable_frames.empty()) << ENDPOINT;
+ QUICHE_DCHECK(packet_.nonretransmittable_frames.empty()) << ENDPOINT;
packet_.largest_acked.Clear();
needs_full_padding_ = false;
}
@@ -515,6 +521,7 @@
QUIC_BUG_IF(quic_bug_12398_7, packet.encryption_level != ENCRYPTION_INITIAL);
QUIC_BUG_IF(quic_bug_12398_8, packet.nonretransmittable_frames.empty() &&
packet.retransmittable_frames.empty())
+ << ENDPOINT
<< "Attempt to serialize empty ENCRYPTION_INITIAL packet in coalesced "
"packet";
ScopedPacketContextSwitcher switcher(
@@ -523,13 +530,15 @@
packet.packet_number_length, packet.encryption_level, &packet_);
for (const QuicFrame& frame : packet.nonretransmittable_frames) {
if (!AddFrame(frame, packet.transmission_type)) {
- QUIC_BUG(quic_bug_10752_6) << "Failed to serialize frame: " << frame;
+ QUIC_BUG(quic_bug_10752_6)
+ << ENDPOINT << "Failed to serialize frame: " << frame;
return 0;
}
}
for (const QuicFrame& frame : packet.retransmittable_frames) {
if (!AddFrame(frame, packet.transmission_type)) {
- QUIC_BUG(quic_bug_10752_7) << "Failed to serialize frame: " << frame;
+ QUIC_BUG(quic_bug_10752_7)
+ << ENDPOINT << "Failed to serialize frame: " << frame;
return 0;
}
}
@@ -539,7 +548,7 @@
if (!AddFrame(QuicFrame(QuicPaddingFrame(padding_size)),
packet.transmission_type)) {
QUIC_BUG(quic_bug_10752_8)
- << "Failed to add padding of size " << padding_size
+ << ENDPOINT << "Failed to add padding of size " << padding_size
<< " when serializing ENCRYPTION_INITIAL "
"packet in coalesced packet";
return 0;
@@ -566,8 +575,9 @@
TransmissionType transmission_type,
size_t* num_bytes_consumed) {
// TODO(b/167222597): consider using ScopedSerializationFailureHandler.
- QUICHE_DCHECK(queued_frames_.empty());
- QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
+ QUICHE_DCHECK(queued_frames_.empty()) << ENDPOINT;
+ QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id))
+ << ENDPOINT;
// Write out the packet header
QuicPacketHeader header;
FillPacketHeader(&header);
@@ -590,13 +600,13 @@
QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
size_t length_field_offset = 0;
if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
- QUIC_BUG(quic_bug_10752_9) << "AppendPacketHeader failed";
+ QUIC_BUG(quic_bug_10752_9) << ENDPOINT << "AppendPacketHeader failed";
return;
}
// Create a Stream frame with the remaining space.
QUIC_BUG_IF(quic_bug_12398_9, iov_offset == write_length && !fin)
- << "Creating a stream frame with no data or fin.";
+ << ENDPOINT << "Creating a stream frame with no data or fin.";
const size_t remaining_data_size = write_length - iov_offset;
size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
framer_->transport_version(), id, stream_offset,
@@ -631,18 +641,18 @@
// into one method that takes a QuicStreamFrame, if warranted.
bool omit_frame_length = !needs_padding;
if (!framer_->AppendTypeByte(QuicFrame(frame), omit_frame_length, &writer)) {
- QUIC_BUG(quic_bug_10752_10) << "AppendTypeByte failed";
+ QUIC_BUG(quic_bug_10752_10) << ENDPOINT << "AppendTypeByte failed";
return;
}
if (!framer_->AppendStreamFrame(frame, omit_frame_length, &writer)) {
- QUIC_BUG(quic_bug_10752_11) << "AppendStreamFrame failed";
+ QUIC_BUG(quic_bug_10752_11) << ENDPOINT << "AppendStreamFrame failed";
return;
}
if (needs_padding &&
plaintext_bytes_written < MinPlaintextPacketSize(framer_->version()) &&
!writer.WritePaddingBytes(MinPlaintextPacketSize(framer_->version()) -
plaintext_bytes_written)) {
- QUIC_BUG(quic_bug_10752_12) << "Unable to add padding bytes";
+ QUIC_BUG(quic_bug_10752_12) << ENDPOINT << "Unable to add padding bytes";
return;
}
@@ -655,14 +665,15 @@
QUICHE_DCHECK(packet_.encryption_level == ENCRYPTION_FORWARD_SECURE ||
packet_.encryption_level == ENCRYPTION_ZERO_RTT)
- << packet_.encryption_level;
+ << ENDPOINT << packet_.encryption_level;
size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header),
writer.length(), kMaxOutgoingPacketSize, encrypted_buffer);
if (encrypted_length == 0) {
QUIC_BUG(quic_bug_10752_13)
- << "Failed to encrypt packet number " << header.packet_number;
+ << ENDPOINT << "Failed to encrypt packet number "
+ << header.packet_number;
return;
}
// TODO(ianswett): Optimize the storage so RetransmitableFrames can be
@@ -747,17 +758,17 @@
if (packet_.encrypted_buffer != nullptr) {
const std::string error_details =
"Packet's encrypted buffer is not empty before serialization";
- QUIC_BUG(quic_bug_10752_14) << error_details;
+ QUIC_BUG(quic_bug_10752_14) << ENDPOINT << error_details;
delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
error_details);
return false;
}
ScopedSerializationFailureHandler handler(this);
- QUICHE_DCHECK_LT(0u, encrypted_buffer_len);
+ QUICHE_DCHECK_LT(0u, encrypted_buffer_len) << ENDPOINT;
QUIC_BUG_IF(quic_bug_12398_10,
queued_frames_.empty() && pending_padding_bytes_ == 0)
- << "Attempt to serialize empty packet";
+ << ENDPOINT << "Attempt to serialize empty packet";
QuicPacketHeader header;
// FillPacketHeader increments packet_number_.
FillPacketHeader(&header);
@@ -788,7 +799,7 @@
return false;
}
- QUICHE_DCHECK_GE(max_plaintext_size_, packet_size_);
+ QUICHE_DCHECK_GE(max_plaintext_size_, packet_size_) << ENDPOINT;
// Use the packet_size_ instead of the buffer size to ensure smaller
// packet sizes are properly used.
size_t length =
@@ -796,7 +807,8 @@
packet_size_, packet_.encryption_level);
if (length == 0) {
QUIC_BUG(quic_bug_10752_16)
- << "Failed to serialize " << QuicFramesToString(queued_frames_)
+ << ENDPOINT << "Failed to serialize "
+ << QuicFramesToString(queued_frames_)
<< " at encryption_level: " << packet_.encryption_level
<< ", needs_full_padding_: " << needs_full_padding_
<< ", pending_padding_bytes_: " << pending_padding_bytes_
@@ -817,7 +829,7 @@
// Because of possible truncation, we can't be confident that our
// packet size calculation worked correctly.
if (!possibly_truncated_by_length) {
- QUICHE_DCHECK_EQ(packet_size_, length);
+ QUICHE_DCHECK_EQ(packet_size_, length) << ENDPOINT;
}
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
@@ -825,7 +837,8 @@
encrypted_buffer_len, encrypted_buffer.buffer);
if (encrypted_length == 0) {
QUIC_BUG(quic_bug_10752_17)
- << "Failed to encrypt packet number " << packet_.packet_number;
+ << ENDPOINT << "Failed to encrypt packet number "
+ << packet_.packet_number;
return false;
}
@@ -842,6 +855,7 @@
QuicPacketCreator::SerializeConnectivityProbingPacket() {
QUIC_BUG_IF(quic_bug_12398_11,
VersionHasIetfQuicFrames(framer_->transport_version()))
+ << ENDPOINT
<< "Must not be version 99 to serialize padded ping connectivity probe";
RemoveSoftMaxPacketLength();
QuicPacketHeader header;
@@ -854,14 +868,15 @@
std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = BuildConnectivityProbingPacket(
header, buffer.get(), max_plaintext_size_, packet_.encryption_level);
- QUICHE_DCHECK(length);
+ QUICHE_DCHECK(length) << ENDPOINT;
- QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+ QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE)
+ << ENDPOINT;
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
kMaxOutgoingPacketSize, buffer.get());
- QUICHE_DCHECK(encrypted_length);
+ QUICHE_DCHECK(encrypted_length) << ENDPOINT;
std::unique_ptr<SerializedPacket> serialize_packet(new SerializedPacket(
header.packet_number, header.packet_number_length, buffer.release(),
@@ -881,6 +896,7 @@
const QuicPathFrameBuffer& payload) {
QUIC_BUG_IF(quic_bug_12398_12,
!VersionHasIetfQuicFrames(framer_->transport_version()))
+ << ENDPOINT
<< "Must be version 99 to serialize path challenge connectivity probe, "
"is version "
<< framer_->transport_version();
@@ -895,14 +911,15 @@
size_t length =
BuildPaddedPathChallengePacket(header, buffer.get(), max_plaintext_size_,
payload, packet_.encryption_level);
- QUICHE_DCHECK(length);
+ QUICHE_DCHECK(length) << ENDPOINT;
- QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+ QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE)
+ << ENDPOINT;
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
kMaxOutgoingPacketSize, buffer.get());
- QUICHE_DCHECK(encrypted_length);
+ QUICHE_DCHECK(encrypted_length) << ENDPOINT;
std::unique_ptr<SerializedPacket> serialize_packet(
new SerializedPacket(header.packet_number, header.packet_number_length,
@@ -924,6 +941,7 @@
const bool is_padded) {
QUIC_BUG_IF(quic_bug_12398_13,
!VersionHasIetfQuicFrames(framer_->transport_version()))
+ << ENDPOINT
<< "Must be version 99 to serialize path response connectivity probe, is "
"version "
<< framer_->transport_version();
@@ -938,14 +956,15 @@
size_t length =
BuildPathResponsePacket(header, buffer.get(), max_plaintext_size_,
payloads, is_padded, packet_.encryption_level);
- QUICHE_DCHECK(length);
+ QUICHE_DCHECK(length) << ENDPOINT;
- QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
+ QUICHE_DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE)
+ << ENDPOINT;
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
kMaxOutgoingPacketSize, buffer.get());
- QUICHE_DCHECK(encrypted_length);
+ QUICHE_DCHECK(encrypted_length) << ENDPOINT;
std::unique_ptr<SerializedPacket> serialize_packet(
new SerializedPacket(header.packet_number, header.packet_number_length,
@@ -967,7 +986,8 @@
size_t packet_length,
const QuicPathFrameBuffer& payload,
EncryptionLevel level) {
- QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()))
+ << ENDPOINT;
QuicFrames frames;
// Write a PATH_CHALLENGE frame, which has a random 8-byte payload
@@ -995,10 +1015,12 @@
EncryptionLevel level) {
if (payloads.empty()) {
QUIC_BUG(quic_bug_12398_14)
+ << ENDPOINT
<< "Attempt to generate connectivity response with no request payloads";
return 0;
}
- QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
+ QUICHE_DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()))
+ << ENDPOINT;
std::vector<std::unique_ptr<QuicPathResponseFrame>> path_response_frames;
for (const QuicPathFrameBuffer& payload : payloads) {
@@ -1051,12 +1073,12 @@
size_t buffer_len) {
if (HasPendingFrames()) {
QUIC_BUG(quic_bug_10752_18)
- << "Try to serialize coalesced packet with pending frames";
+ << ENDPOINT << "Try to serialize coalesced packet with pending frames";
return 0;
}
RemoveSoftMaxPacketLength();
QUIC_BUG_IF(quic_bug_12398_15, coalesced.length() == 0)
- << "Attempt to serialize empty coalesced packet";
+ << ENDPOINT << "Attempt to serialize empty coalesced packet";
size_t packet_length = 0;
if (coalesced.initial_packet() != nullptr) {
// Padding coalesced packet containing initial packet to full.
@@ -1072,6 +1094,7 @@
*coalesced.initial_packet(), padding_size, buffer, buffer_len);
if (initial_length == 0) {
QUIC_BUG(quic_bug_10752_19)
+ << ENDPOINT
<< "Failed to reserialize ENCRYPTION_INITIAL packet in "
"coalesced packet";
return 0;
@@ -1140,7 +1163,8 @@
QuicConnectionIdLength QuicPacketCreator::GetDestinationConnectionIdLength()
const {
QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
- transport_version()));
+ transport_version()))
+ << ENDPOINT;
return GetDestinationConnectionIdIncluded() == CONNECTION_ID_PRESENT
? static_cast<QuicConnectionIdLength>(
GetDestinationConnectionId().length())
@@ -1149,7 +1173,8 @@
QuicConnectionIdLength QuicPacketCreator::GetSourceConnectionIdLength() const {
QUICHE_DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
- transport_version()));
+ transport_version()))
+ << ENDPOINT;
return GetSourceConnectionIdIncluded() == CONNECTION_ID_PRESENT
? static_cast<QuicConnectionIdLength>(
GetSourceConnectionId().length())
@@ -1200,8 +1225,10 @@
QUIC_BUG_IF(quic_bug_12398_16, IsControlFrame(frame.type) &&
!GetControlFrameId(frame) &&
frame.type != PING_FRAME)
+ << ENDPOINT
<< "Adding a control frame with no control frame id: " << frame;
- QUICHE_DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
+ QUICHE_DCHECK(QuicUtils::IsRetransmittableFrame(frame.type))
+ << ENDPOINT << frame;
MaybeBundleAckOpportunistically();
if (HasPendingFrames()) {
if (AddFrame(frame, next_transmission_type_)) {
@@ -1209,7 +1236,7 @@
return true;
}
}
- QUICHE_DCHECK(!HasPendingFrames());
+ QUICHE_DCHECK(!HasPendingFrames()) << ENDPOINT;
if (frame.type != PING_FRAME && frame.type != CONNECTION_CLOSE_FRAME &&
!delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
@@ -1218,7 +1245,7 @@
}
const bool success = AddFrame(frame, next_transmission_type_);
QUIC_BUG_IF(quic_bug_10752_20, !success)
- << "Failed to add frame:" << frame
+ << ENDPOINT << "Failed to add frame:" << frame
<< " transmission_type:" << next_transmission_type_;
return success;
}
@@ -1228,13 +1255,14 @@
QuicStreamOffset offset,
StreamSendingState state) {
QUIC_BUG_IF(quic_bug_10752_21, !flusher_attached_)
+ << ENDPOINT
<< "Packet flusher is not attached when "
"generator tries to write stream data.";
bool has_handshake = QuicUtils::IsCryptoStreamId(transport_version(), id);
MaybeBundleAckOpportunistically();
bool fin = state != NO_FIN;
QUIC_BUG_IF(quic_bug_12398_17, has_handshake && fin)
- << "Handshake packets should never send a fin";
+ << ENDPOINT << "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.
if (has_handshake && HasPendingRetransmittableFrames()) {
@@ -1249,7 +1277,8 @@
}
if (!fin && (write_length == 0)) {
- QUIC_BUG(quic_bug_10752_22) << "Attempt to consume empty data without FIN.";
+ QUIC_BUG(quic_bug_10752_22)
+ << ENDPOINT << "Attempt to consume empty data without FIN.";
return QuicConsumedData(0, false);
}
// We determine if we can enter the fast path before executing
@@ -1272,7 +1301,8 @@
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(quic_bug_10752_23) << "Failed to ConsumeData, stream:" << id;
+ QUIC_BUG(quic_bug_10752_23)
+ << ENDPOINT << "Failed to ConsumeData, stream:" << id;
return QuicConsumedData(0, false);
}
@@ -1284,7 +1314,8 @@
AddRandomPadding();
}
QUICHE_DCHECK(total_bytes_consumed == write_length ||
- (bytes_consumed > 0 && HasPendingFrames()));
+ (bytes_consumed > 0 && HasPendingFrames()))
+ << ENDPOINT;
if (total_bytes_consumed == write_length) {
// We're done writing the data. Exit the loop.
@@ -1319,7 +1350,8 @@
QuicStreamOffset offset,
bool fin,
size_t total_bytes_consumed) {
- QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
+ QUICHE_DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id))
+ << ENDPOINT;
if (AttemptingToSendUnencryptedStreamData()) {
return QuicConsumedData(total_bytes_consumed,
fin && (total_bytes_consumed == write_length));
@@ -1336,7 +1368,7 @@
if (bytes_consumed == 0) {
const std::string error_details =
"Failed in CreateAndSerializeStreamFrame.";
- QUIC_BUG(quic_bug_10752_24) << error_details;
+ QUIC_BUG(quic_bug_10752_24) << ENDPOINT << error_details;
delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
error_details);
break;
@@ -1351,9 +1383,10 @@
size_t QuicPacketCreator::ConsumeCryptoData(EncryptionLevel level,
size_t write_length,
QuicStreamOffset offset) {
- QUIC_DVLOG(2) << "ConsumeCryptoData " << level << " write_length "
+ QUIC_DVLOG(2) << ENDPOINT << "ConsumeCryptoData " << level << " write_length "
<< write_length << " offset " << offset;
QUIC_BUG_IF(quic_bug_10752_25, !flusher_attached_)
+ << ENDPOINT
<< "Packet flusher is not attached when "
"generator tries to write crypto data.";
MaybeBundleAckOpportunistically();
@@ -1380,7 +1413,7 @@
// assuming here that they won't occupy so much of the packet that a
// CRYPTO frame won't fit.
QUIC_BUG(quic_bug_10752_26)
- << "Failed to ConsumeCryptoData at level " << level;
+ << ENDPOINT << "Failed to ConsumeCryptoData at level " << level;
return 0;
}
total_bytes_consumed += frame.crypto_frame->data_length;
@@ -1397,6 +1430,7 @@
// MTU discovery frames must be sent by themselves.
if (!CanSetMaxPacketLength()) {
QUIC_BUG(quic_bug_10752_27)
+ << ENDPOINT
<< "MTU discovery packets should only be sent when no other "
<< "frames needs to be sent.";
return;
@@ -1415,7 +1449,7 @@
// 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.
QUIC_BUG_IF(quic_bug_10752_28, !success)
- << "Failed to send path MTU target_mtu:" << target_mtu
+ << ENDPOINT << "Failed to send path MTU target_mtu:" << target_mtu
<< " transmission_type:" << next_transmission_type_;
// Reset the packet length back.
@@ -1434,12 +1468,13 @@
const bool flushed =
FlushAckFrame(delegate_->MaybeBundleAckOpportunistically());
QUIC_BUG_IF(quic_bug_10752_29, !flushed)
- << "Failed to flush ACK frame. encryption_level:"
+ << ENDPOINT << "Failed to flush ACK frame. encryption_level:"
<< packet_.encryption_level;
}
bool QuicPacketCreator::FlushAckFrame(const QuicFrames& frames) {
QUIC_BUG_IF(quic_bug_10752_30, !flusher_attached_)
+ << ENDPOINT
<< "Packet flusher is not attached when "
"generator tries to send ACK frame.";
// MaybeBundleAckOpportunistically could be called nestedly when sending a
@@ -1447,16 +1482,18 @@
QUIC_BUG_IF(quic_bug_12398_18,
GetQuicReloadableFlag(quic_single_ack_in_packet2) &&
!frames.empty() && has_ack())
- << "Trying to flush " << frames << " when there is ACK queued";
+ << ENDPOINT << "Trying to flush " << frames
+ << " when there is ACK queued";
for (const auto& frame : frames) {
- QUICHE_DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME);
+ QUICHE_DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME)
+ << ENDPOINT;
if (HasPendingFrames()) {
if (AddFrame(frame, next_transmission_type_)) {
// There is pending frames and current frame fits.
continue;
}
}
- QUICHE_DCHECK(!HasPendingFrames());
+ QUICHE_DCHECK(!HasPendingFrames()) << ENDPOINT;
// There is no pending frames, consult the delegate whether a packet can be
// generated.
if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
@@ -1464,7 +1501,8 @@
return false;
}
const bool success = AddFrame(frame, next_transmission_type_);
- QUIC_BUG_IF(quic_bug_10752_31, !success) << "Failed to flush " << frame;
+ QUIC_BUG_IF(quic_bug_10752_31, !success)
+ << ENDPOINT << "Failed to flush " << frame;
}
return true;
}
@@ -1487,7 +1525,7 @@
if (GetQuicFlag(FLAGS_quic_export_write_path_stats_at_server)) {
if (!write_start_packet_number_.IsInitialized()) {
QUIC_BUG(quic_bug_10752_32)
- << "write_start_packet_number is not initialized";
+ << ENDPOINT << "write_start_packet_number is not initialized";
return;
}
QUIC_SERVER_HISTOGRAM_COUNTS(
@@ -1521,6 +1559,7 @@
MessageStatus QuicPacketCreator::AddMessageFrame(QuicMessageId message_id,
QuicMemSliceSpan message) {
QUIC_BUG_IF(quic_bug_10752_33, !flusher_attached_)
+ << ENDPOINT
<< "Packet flusher is not attached when "
"generator tries to add message frame.";
MaybeBundleAckOpportunistically();
@@ -1534,7 +1573,8 @@
QuicMessageFrame* frame = new QuicMessageFrame(message_id, message);
const bool success = AddFrame(QuicFrame(frame), next_transmission_type_);
if (!success) {
- QUIC_BUG(quic_bug_10752_34) << "Failed to send message " << message_id;
+ QUIC_BUG(quic_bug_10752_34)
+ << ENDPOINT << "Failed to send message " << message_id;
delete frame;
return MESSAGE_STATUS_INTERNAL_ERROR;
}
@@ -1563,7 +1603,8 @@
header->reset_flag = false;
header->version_flag = IncludeVersionInHeader();
if (IncludeNonceInPublicHeader()) {
- QUICHE_DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
+ QUICHE_DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective())
+ << ENDPOINT;
header->nonce = &diversification_nonce_;
} else {
header->nonce = nullptr;
@@ -1639,7 +1680,8 @@
frame.type != MESSAGE_FRAME && frame.type != NEW_TOKEN_FRAME &&
frame.type != RETIRE_CONNECTION_ID_FRAME &&
frame.type != ACK_FREQUENCY_FRAME))
- << frame.type << " not allowed at " << packet_.encryption_level;
+ << ENDPOINT << frame.type << " not allowed at "
+ << packet_.encryption_level;
if (frame.type == STREAM_FRAME) {
if (MaybeCoalesceStreamFrame(frame.stream_frame)) {
@@ -1655,7 +1697,7 @@
QUICHE_DCHECK(frame.type != ACK_FRAME || (!frame.ack_frame->packets.Empty() &&
frame.ack_frame->packets.Max() ==
frame.ack_frame->largest_acked))
- << "Invalid ACK frame: " << frame;
+ << ENDPOINT << "Invalid ACK frame: " << frame;
size_t frame_len = GetSerializedFrameLength(frame);
if (frame_len == 0 && RemoveSoftMaxPacketLength()) {
@@ -1663,7 +1705,8 @@
frame_len = GetSerializedFrameLength(frame);
}
if (frame_len == 0) {
- QUIC_DVLOG(1) << "Flushing because current open packet is full when adding "
+ QUIC_DVLOG(1) << ENDPOINT
+ << "Flushing because current open packet is full when adding "
<< frame;
FlushCurrentPacket();
return false;
@@ -1671,7 +1714,7 @@
if (queued_frames_.empty()) {
packet_size_ = PacketHeaderSize();
}
- QUICHE_DCHECK_LT(0u, packet_size_);
+ QUICHE_DCHECK_LT(0u, packet_size_) << ENDPOINT;
packet_size_ += ExpansionOnNewFrame() + frame_len;
@@ -1748,12 +1791,14 @@
// The back of retransmittable frames must be the same as the original
// queued frames' back.
- QUICHE_DCHECK_EQ(packet_.retransmittable_frames.back().type, STREAM_FRAME);
+ QUICHE_DCHECK_EQ(packet_.retransmittable_frames.back().type, STREAM_FRAME)
+ << ENDPOINT;
QuicStreamFrame* retransmittable =
&packet_.retransmittable_frames.back().stream_frame;
- QUICHE_DCHECK_EQ(retransmittable->stream_id, frame.stream_id);
+ QUICHE_DCHECK_EQ(retransmittable->stream_id, frame.stream_id) << ENDPOINT;
QUICHE_DCHECK_EQ(retransmittable->offset + retransmittable->data_length,
- frame.offset);
+ frame.offset)
+ << ENDPOINT;
retransmittable->data_length = candidate->data_length;
retransmittable->fin = candidate->fin;
packet_size_ += frame.data_length;
@@ -1770,7 +1815,7 @@
if (!CanSetMaxPacketLength()) {
return false;
}
- QUIC_DVLOG(1) << "Restoring max packet length to: "
+ QUIC_DVLOG(1) << ENDPOINT << "Restoring max packet length to: "
<< latched_hard_max_packet_length_;
SetMaxPacketLength(latched_hard_max_packet_length_);
// Reset latched_max_packet_length_.
@@ -1813,7 +1858,7 @@
bool success = AddFrame(QuicFrame(QuicPaddingFrame(padding_bytes)),
packet_.transmission_type);
QUIC_BUG_IF(quic_bug_10752_36, !success)
- << "Failed to add padding_bytes: " << padding_bytes
+ << ENDPOINT << "Failed to add padding_bytes: " << padding_bytes
<< " transmission_type: " << packet_.transmission_type;
}
@@ -1847,9 +1892,11 @@
void QuicPacketCreator::SetServerConnectionIdIncluded(
QuicConnectionIdIncluded server_connection_id_included) {
QUICHE_DCHECK(server_connection_id_included == CONNECTION_ID_PRESENT ||
- server_connection_id_included == CONNECTION_ID_ABSENT);
+ server_connection_id_included == CONNECTION_ID_ABSENT)
+ << ENDPOINT;
QUICHE_DCHECK(framer_->perspective() == Perspective::IS_SERVER ||
- server_connection_id_included != CONNECTION_ID_ABSENT);
+ server_connection_id_included != CONNECTION_ID_ABSENT)
+ << ENDPOINT;
server_connection_id_included_ = server_connection_id_included;
}
@@ -1861,7 +1908,8 @@
void QuicPacketCreator::SetClientConnectionId(
QuicConnectionId client_connection_id) {
QUICHE_DCHECK(client_connection_id.IsEmpty() ||
- framer_->version().SupportsClientConnectionIds());
+ framer_->version().SupportsClientConnectionIds())
+ << ENDPOINT;
client_connection_id_ = client_connection_id;
}
@@ -1927,7 +1975,8 @@
const QuicPacketLength largest_payload =
largest_frame - std::min(largest_frame, kQuicFrameTypeSize);
// This must always be less than or equal to GetCurrentLargestMessagePayload.
- QUICHE_DCHECK_LE(largest_payload, GetCurrentLargestMessagePayload());
+ QUICHE_DCHECK_LE(largest_payload, GetCurrentLargestMessagePayload())
+ << ENDPOINT;
return largest_payload;
}
@@ -1939,7 +1988,7 @@
const std::string error_details =
absl::StrCat("Cannot send stream data with level: ",
EncryptionLevelToString(packet_.encryption_level));
- QUIC_BUG(quic_bug_10752_37) << error_details;
+ QUIC_BUG(quic_bug_10752_37) << ENDPOINT << error_details;
delegate_->OnUnrecoverableError(QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA,
error_details);
return true;
@@ -2004,6 +2053,10 @@
}
}
+#define ENDPOINT2 \
+ (creator_->framer_->perspective() == Perspective::IS_SERVER ? "Server: " \
+ : "Client: ")
+
QuicPacketCreator::ScopedPeerAddressContext::ScopedPeerAddressContext(
QuicPacketCreator* creator,
QuicSocketAddress address,
@@ -2026,13 +2079,15 @@
old_server_connection_id_(creator_->GetServerConnectionId()),
update_connection_id_(update_connection_id) {
QUIC_BUG_IF(quic_bug_12398_19, !old_peer_address_.IsInitialized())
- << "Context is used before seralized packet's peer address is "
+ << ENDPOINT2
+ << "Context is used before serialized packet's peer address is "
"initialized.";
creator_->SetDefaultPeerAddress(address);
if (update_connection_id_) {
QUICHE_DCHECK(address != old_peer_address_ ||
((client_connection_id == old_client_connection_id_) &&
- (server_connection_id == old_server_connection_id_)));
+ (server_connection_id == old_server_connection_id_)))
+ << ENDPOINT2;
creator_->SetClientConnectionId(client_connection_id);
creator_->SetServerConnectionId(server_connection_id);
}
@@ -2060,16 +2115,19 @@
if (creator_->packet_.encrypted_buffer == nullptr) {
const std::string error_details = "Failed to SerializePacket.";
- QUIC_BUG(quic_bug_10752_38) << error_details;
+ QUIC_BUG(quic_bug_10752_38) << ENDPOINT2 << error_details;
creator_->delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
error_details);
}
}
+#undef ENDPOINT2
+
void QuicPacketCreator::set_encryption_level(EncryptionLevel level) {
QUICHE_DCHECK(level == packet_.encryption_level || !HasPendingFrames())
- << "Cannot update encryption level from " << packet_.encryption_level
- << " to " << level << " when we already have pending frames: "
+ << ENDPOINT << "Cannot update encryption level from "
+ << packet_.encryption_level << " to " << level
+ << " when we already have pending frames: "
<< QuicFramesToString(queued_frames_);
packet_.encryption_level = level;
}
@@ -2080,6 +2138,7 @@
// AddFrame(). Sort out test helper functions and peer class that don't
// enforce this check.
QUIC_BUG_IF(quic_bug_10752_39, !flusher_attached_)
+ << ENDPOINT
<< "Packet flusher is not attached when "
"generator tries to write stream data.";
// Write a PATH_CHALLENGE frame, which has a random 8-byte payload.
@@ -2120,13 +2179,13 @@
}
}
// Frame was not queued but queued frames were flushed.
- QUICHE_DCHECK(!HasPendingFrames());
+ QUICHE_DCHECK(!HasPendingFrames()) << ENDPOINT;
if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
return false;
}
bool success = AddPaddedSavedFrame(frame, NOT_RETRANSMISSION);
- QUIC_BUG_IF(quic_bug_12398_20, !success);
+ QUIC_BUG_IF(quic_bug_12398_20, !success) << ENDPOINT;
return true;
}
