Move RFC 9000 variable length integer encoding from QUIC to QUICHE
Since BHTTP uses these, and we're starting BHTTP in QUICHE, we need to move the read/write functions for varints to QUICHE. While I was in there, I improved some comments to refer to the published RFC, and removed a few ODR violations.
This CL is a no-op, it does not modify any existing functionality.
PiperOrigin-RevId: 467990159
diff --git a/quiche/common/quiche_data_reader.cc b/quiche/common/quiche_data_reader.cc
index 52b4af4..080431c 100644
--- a/quiche/common/quiche_data_reader.cc
+++ b/quiche/common/quiche_data_reader.cc
@@ -143,6 +143,94 @@
return absl::SimpleAtoi(digits, result);
}
+QuicheVariableLengthIntegerLength QuicheDataReader::PeekVarInt62Length() {
+ QUICHE_DCHECK_EQ(endianness(), NETWORK_BYTE_ORDER);
+ const unsigned char* next =
+ reinterpret_cast<const unsigned char*>(data() + pos());
+ if (BytesRemaining() == 0) {
+ return VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ }
+ return static_cast<QuicheVariableLengthIntegerLength>(
+ 1 << ((*next & 0b11000000) >> 6));
+}
+
+// Read an RFC 9000 62-bit Variable Length Integer.
+//
+// Performance notes
+//
+// Measurements and experiments showed that unrolling the four cases
+// like this and dereferencing next_ as we do (*(next_+n) --- and then
+// doing a single pos_+=x at the end) gains about 10% over making a
+// loop and dereferencing next_ such as *(next_++)
+//
+// Using a register for pos_ was not helpful.
+//
+// Branches are ordered to increase the likelihood of the first being
+// taken.
+//
+// Low-level optimization is useful here because this function will be
+// called frequently, leading to outsize benefits.
+bool QuicheDataReader::ReadVarInt62(uint64_t* result) {
+ QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+
+ size_t remaining = BytesRemaining();
+ const unsigned char* next =
+ reinterpret_cast<const unsigned char*>(data() + pos());
+ if (remaining != 0) {
+ switch (*next & 0xc0) {
+ case 0xc0:
+ // Leading 0b11...... is 8 byte encoding
+ if (remaining >= 8) {
+ *result = (static_cast<uint64_t>((*(next)) & 0x3f) << 56) +
+ (static_cast<uint64_t>(*(next + 1)) << 48) +
+ (static_cast<uint64_t>(*(next + 2)) << 40) +
+ (static_cast<uint64_t>(*(next + 3)) << 32) +
+ (static_cast<uint64_t>(*(next + 4)) << 24) +
+ (static_cast<uint64_t>(*(next + 5)) << 16) +
+ (static_cast<uint64_t>(*(next + 6)) << 8) +
+ (static_cast<uint64_t>(*(next + 7)) << 0);
+ AdvancePos(8);
+ return true;
+ }
+ return false;
+
+ case 0x80:
+ // Leading 0b10...... is 4 byte encoding
+ if (remaining >= 4) {
+ *result = (((*(next)) & 0x3f) << 24) + (((*(next + 1)) << 16)) +
+ (((*(next + 2)) << 8)) + (((*(next + 3)) << 0));
+ AdvancePos(4);
+ return true;
+ }
+ return false;
+
+ case 0x40:
+ // Leading 0b01...... is 2 byte encoding
+ if (remaining >= 2) {
+ *result = (((*(next)) & 0x3f) << 8) + (*(next + 1));
+ AdvancePos(2);
+ return true;
+ }
+ return false;
+
+ case 0x00:
+ // Leading 0b00...... is 1 byte encoding
+ *result = (*next) & 0x3f;
+ AdvancePos(1);
+ return true;
+ }
+ }
+ return false;
+}
+
+bool QuicheDataReader::ReadStringPieceVarInt62(absl::string_view* result) {
+ uint64_t result_length;
+ if (!ReadVarInt62(&result_length)) {
+ return false;
+ }
+ return ReadStringPiece(result, result_length);
+}
+
absl::string_view QuicheDataReader::ReadRemainingPayload() {
absl::string_view payload = PeekRemainingPayload();
pos_ = len_;
diff --git a/quiche/common/quiche_data_reader.h b/quiche/common/quiche_data_reader.h
index bf336f9..ed05b69 100644
--- a/quiche/common/quiche_data_reader.h
+++ b/quiche/common/quiche_data_reader.h
@@ -92,6 +92,25 @@
// iterator on success, may forward it even in case of failure.
bool ReadDecimal64(size_t num_digits, uint64_t* result);
+ // Returns the length in bytes of a variable length integer based on the next
+ // two bits available. Returns 1, 2, 4, or 8 on success, and 0 on failure.
+ QuicheVariableLengthIntegerLength PeekVarInt62Length();
+
+ // Read an RFC 9000 62-bit Variable Length Integer and place the result in
+ // |*result|. Returns false if there is not enough space in the buffer to read
+ // the number, true otherwise. If false is returned, |*result| is not altered.
+ bool ReadVarInt62(uint64_t* result);
+
+ // Reads a string prefixed with a RFC 9000 62-bit variable Length integer
+ // length into the given output parameter.
+ //
+ // NOTE: Does not copy but rather references strings in the underlying buffer.
+ // This should be kept in mind when handling memory management!
+ //
+ // Returns false if there is not enough space in the buffer to read
+ // the number and subsequent string, true otherwise.
+ bool ReadStringPieceVarInt62(absl::string_view* result);
+
// Returns the remaining payload as a absl::string_view.
//
// NOTE: Does not copy but rather references strings in the underlying buffer.
diff --git a/quiche/common/quiche_data_writer.cc b/quiche/common/quiche_data_writer.cc
index 5f83e1f..5e79439 100644
--- a/quiche/common/quiche_data_writer.cc
+++ b/quiche/common/quiche_data_writer.cc
@@ -9,6 +9,7 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
#include "quiche/common/quiche_endian.h"
namespace quiche {
@@ -133,6 +134,158 @@
return WriteBytes(&tag, sizeof(tag));
}
+// Converts a uint64_t into a 62-bit RFC 9000 Variable Length Integer.
+//
+// Performance notes
+//
+// Measurements and experiments showed that unrolling the four cases
+// like this and dereferencing next_ as we do (*(next_+n)) gains about
+// 10% over making a loop and dereferencing it as *(next_++)
+//
+// Using a register for next didn't help.
+//
+// Branches are ordered to increase the likelihood of the first being
+// taken.
+//
+// Low-level optimization is useful here because this function will be
+// called frequently, leading to outsize benefits.
+bool QuicheDataWriter::WriteVarInt62(uint64_t value) {
+ QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
+
+ size_t remaining_bytes = remaining();
+ char* next = buffer() + length();
+
+ if ((value & kVarInt62ErrorMask) == 0) {
+ // We know the high 2 bits are 0 so |value| is legal.
+ // We can do the encoding.
+ if ((value & kVarInt62Mask8Bytes) != 0) {
+ // Someplace in the high-4 bytes is a 1-bit. Do an 8-byte
+ // encoding.
+ if (remaining_bytes >= 8) {
+ *(next + 0) = ((value >> 56) & 0x3f) + 0xc0;
+ *(next + 1) = (value >> 48) & 0xff;
+ *(next + 2) = (value >> 40) & 0xff;
+ *(next + 3) = (value >> 32) & 0xff;
+ *(next + 4) = (value >> 24) & 0xff;
+ *(next + 5) = (value >> 16) & 0xff;
+ *(next + 6) = (value >> 8) & 0xff;
+ *(next + 7) = value & 0xff;
+ IncreaseLength(8);
+ return true;
+ }
+ return false;
+ }
+ // The high-order-4 bytes are all 0, check for a 1, 2, or 4-byte
+ // encoding
+ if ((value & kVarInt62Mask4Bytes) != 0) {
+ // The encoding will not fit into 2 bytes, Do a 4-byte
+ // encoding.
+ if (remaining_bytes >= 4) {
+ *(next + 0) = ((value >> 24) & 0x3f) + 0x80;
+ *(next + 1) = (value >> 16) & 0xff;
+ *(next + 2) = (value >> 8) & 0xff;
+ *(next + 3) = value & 0xff;
+ IncreaseLength(4);
+ return true;
+ }
+ return false;
+ }
+ // The high-order bits are all 0. Check to see if the number
+ // can be encoded as one or two bytes. One byte encoding has
+ // only 6 significant bits (bits 0xffffffff ffffffc0 are all 0).
+ // Two byte encoding has more than 6, but 14 or less significant
+ // bits (bits 0xffffffff ffffc000 are 0 and 0x00000000 00003fc0
+ // are not 0)
+ if ((value & kVarInt62Mask2Bytes) != 0) {
+ // Do 2-byte encoding
+ if (remaining_bytes >= 2) {
+ *(next + 0) = ((value >> 8) & 0x3f) + 0x40;
+ *(next + 1) = (value)&0xff;
+ IncreaseLength(2);
+ return true;
+ }
+ return false;
+ }
+ if (remaining_bytes >= 1) {
+ // Do 1-byte encoding
+ *next = (value & 0x3f);
+ IncreaseLength(1);
+ return true;
+ }
+ return false;
+ }
+ // Can not encode, high 2 bits not 0
+ return false;
+}
+
+bool QuicheDataWriter::WriteStringPieceVarInt62(
+ const absl::string_view& string_piece) {
+ if (!WriteVarInt62(string_piece.size())) {
+ return false;
+ }
+ if (!string_piece.empty()) {
+ if (!WriteBytes(string_piece.data(), string_piece.size())) {
+ return false;
+ }
+ }
+ return true;
+}
+
+// static
+QuicheVariableLengthIntegerLength QuicheDataWriter::GetVarInt62Len(
+ uint64_t value) {
+ if ((value & kVarInt62ErrorMask) != 0) {
+ QUICHE_BUG(invalid_varint) << "Attempted to encode a value, " << value
+ << ", that is too big for VarInt62";
+ return VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ }
+ if ((value & kVarInt62Mask8Bytes) != 0) {
+ return VARIABLE_LENGTH_INTEGER_LENGTH_8;
+ }
+ if ((value & kVarInt62Mask4Bytes) != 0) {
+ return VARIABLE_LENGTH_INTEGER_LENGTH_4;
+ }
+ if ((value & kVarInt62Mask2Bytes) != 0) {
+ return VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ }
+ return VARIABLE_LENGTH_INTEGER_LENGTH_1;
+}
+
+bool QuicheDataWriter::WriteVarInt62WithForcedLength(
+ uint64_t value, QuicheVariableLengthIntegerLength write_length) {
+ QUICHE_DCHECK_EQ(endianness(), NETWORK_BYTE_ORDER);
+
+ size_t remaining_bytes = remaining();
+ if (remaining_bytes < write_length) {
+ return false;
+ }
+
+ const QuicheVariableLengthIntegerLength min_length = GetVarInt62Len(value);
+ if (write_length < min_length) {
+ QUICHE_BUG(invalid_varint_forced) << "Cannot write value " << value
+ << " with write_length " << write_length;
+ return false;
+ }
+ if (write_length == min_length) {
+ return WriteVarInt62(value);
+ }
+
+ if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_2) {
+ return WriteUInt8(0b01000000) && WriteUInt8(value);
+ }
+ if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_4) {
+ return WriteUInt8(0b10000000) && WriteUInt8(0) && WriteUInt16(value);
+ }
+ if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_8) {
+ return WriteUInt8(0b11000000) && WriteUInt8(0) && WriteUInt16(0) &&
+ WriteUInt32(value);
+ }
+
+ QUICHE_BUG(invalid_write_length)
+ << "Invalid write_length " << static_cast<int>(write_length);
+ return false;
+}
+
bool QuicheDataWriter::Seek(size_t length) {
if (!BeginWrite(length)) {
return false;
diff --git a/quiche/common/quiche_data_writer.h b/quiche/common/quiche_data_writer.h
index 5f027a9..8035bb2 100644
--- a/quiche/common/quiche_data_writer.h
+++ b/quiche/common/quiche_data_writer.h
@@ -17,6 +17,24 @@
namespace quiche {
+// Maximum value that can be properly encoded using RFC 9000 62-bit Variable
+// Length Integer encoding.
+enum : uint64_t {
+ kVarInt62MaxValue = UINT64_C(0x3fffffffffffffff),
+};
+
+// RFC 9000 62-bit Variable Length Integer encoding masks
+// If a uint64_t anded with a mask is not 0 then the value is encoded
+// using that length (or is too big, in the case of kVarInt62ErrorMask).
+// Values must be checked in order (error, 8-, 4-, and then 2- bytes)
+// and if none are non-0, the value is encoded in 1 byte.
+enum : uint64_t {
+ kVarInt62ErrorMask = UINT64_C(0xc000000000000000),
+ kVarInt62Mask8Bytes = UINT64_C(0x3fffffffc0000000),
+ kVarInt62Mask4Bytes = UINT64_C(0x000000003fffc000),
+ kVarInt62Mask2Bytes = UINT64_C(0x0000000000003fc0),
+};
+
// This class provides facilities for packing binary data.
//
// The QuicheDataWriter supports appending primitive values (int, string, etc)
@@ -69,6 +87,28 @@
// in big endian.
bool WriteTag(uint32_t tag);
+ // Write a 62-bit unsigned integer using RFC 9000 Variable Length Integer
+ // encoding. Returns false if the value is out of range or if there is no room
+ // in the buffer.
+ bool WriteVarInt62(uint64_t value);
+
+ // Same as WriteVarInt62(uint64_t), but forces an encoding size to write to.
+ // This is not as optimized as WriteVarInt62(uint64_t). Returns false if the
+ // value does not fit in the specified write_length or if there is no room in
+ // the buffer.
+ bool WriteVarInt62WithForcedLength(
+ uint64_t value, QuicheVariableLengthIntegerLength write_length);
+
+ // Writes a string piece as a consecutive length/content pair. The
+ // length uses RFC 9000 Variable Length Integer encoding.
+ bool WriteStringPieceVarInt62(const absl::string_view& string_piece);
+
+ // Utility function to return the number of bytes needed to encode
+ // the given value using IETF VarInt62 encoding. Returns the number
+ // of bytes required to encode the given integer or 0 if the value
+ // is too large to encode.
+ static QuicheVariableLengthIntegerLength GetVarInt62Len(uint64_t value);
+
// Advance the writer's position for writing by |length| bytes without writing
// anything. This method only makes sense to be used on a buffer that has
// already been written to (and is having certain parts rewritten).
diff --git a/quiche/common/quiche_data_writer_test.cc b/quiche/common/quiche_data_writer_test.cc
index 7ae15d2..eb14350 100644
--- a/quiche/common/quiche_data_writer_test.cc
+++ b/quiche/common/quiche_data_writer_test.cc
@@ -337,6 +337,416 @@
}
}
+const int kVarIntBufferLength = 1024;
+
+// Encodes and then decodes a specified value, checks that the
+// value that was encoded is the same as the decoded value, the length
+// is correct, and that after decoding, all data in the buffer has
+// been consumed..
+// Returns true if everything works, false if not.
+bool EncodeDecodeValue(uint64_t value_in, char* buffer, size_t size_of_buffer) {
+ // Init the buffer to all 0, just for cleanliness. Makes for better
+ // output if, in debugging, we need to dump out the buffer.
+ memset(buffer, 0, size_of_buffer);
+ // make a writer. Note that for IETF encoding
+ // we do not care about endianness... It's always big-endian,
+ // but the c'tor expects to be told what endianness is in force...
+ QuicheDataWriter writer(size_of_buffer, buffer,
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+
+ // Try to write the value.
+ if (writer.WriteVarInt62(value_in) != true) {
+ return false;
+ }
+ // Look at the value we encoded. Determine how much should have been
+ // used based on the value, and then check the state of the writer
+ // to see that it matches.
+ size_t expected_length = 0;
+ if (value_in <= 0x3f) {
+ expected_length = 1;
+ } else if (value_in <= 0x3fff) {
+ expected_length = 2;
+ } else if (value_in <= 0x3fffffff) {
+ expected_length = 4;
+ } else {
+ expected_length = 8;
+ }
+ if (writer.length() != expected_length) {
+ return false;
+ }
+
+ // set up a reader, just the length we've used, no more, no less.
+ QuicheDataReader reader(buffer, expected_length,
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ uint64_t value_out;
+
+ if (reader.ReadVarInt62(&value_out) == false) {
+ return false;
+ }
+ if (value_in != value_out) {
+ return false;
+ }
+ // We only write one value so there had better be nothing left to read
+ return reader.IsDoneReading();
+}
+
+// Test that 8-byte-encoded Variable Length Integers are properly laid
+// out in the buffer.
+TEST_P(QuicheDataWriterTest, VarInt8Layout) {
+ char buffer[1024];
+
+ // Check that the layout of bytes in the buffer is correct. Bytes
+ // are always encoded big endian...
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8)));
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
+ (0x31 + 0xc0)); // 0xc0 for encoding
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x42);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 2)), 0xf3);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 3)), 0xe4);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 4)), 0xd5);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 5)), 0xc6);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 6)), 0xb7);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 7)), 0xa8);
+}
+
+// Test that 4-byte-encoded Variable Length Integers are properly laid
+// out in the buffer.
+TEST_P(QuicheDataWriterTest, VarInt4Layout) {
+ char buffer[1024];
+
+ // Check that the layout of bytes in the buffer is correct. Bytes
+ // are always encoded big endian...
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ EXPECT_TRUE(writer.WriteVarInt62(0x3243f4e5));
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
+ (0x32 + 0x80)); // 0x80 for encoding
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x43);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 2)), 0xf4);
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 3)), 0xe5);
+}
+
+// Test that 2-byte-encoded Variable Length Integers are properly laid
+// out in the buffer.
+TEST_P(QuicheDataWriterTest, VarInt2Layout) {
+ char buffer[1024];
+
+ // Check that the layout of bytes in the buffer is correct. Bytes
+ // are always encoded big endian...
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ EXPECT_TRUE(writer.WriteVarInt62(0x3647));
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
+ (0x36 + 0x40)); // 0x40 for encoding
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x47);
+}
+
+// Test that 1-byte-encoded Variable Length Integers are properly laid
+// out in the buffer.
+TEST_P(QuicheDataWriterTest, VarInt1Layout) {
+ char buffer[1024];
+
+ // Check that the layout of bytes in the buffer
+ // is correct. Bytes are always encoded big endian...
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ EXPECT_TRUE(writer.WriteVarInt62(0x3f));
+ EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), 0x3f);
+}
+
+// Test certain, targeted, values that are expected to succeed:
+// 0, 1,
+// 0x3e, 0x3f, 0x40, 0x41 (around the 1-2 byte transitions)
+// 0x3ffe, 0x3fff, 0x4000, 0x4001 (the 2-4 byte transition)
+// 0x3ffffffe, 0x3fffffff, 0x40000000, 0x40000001 (the 4-8 byte
+// transition)
+// 0x3ffffffffffffffe, 0x3fffffffffffffff, (the highest valid values)
+// 0xfe, 0xff, 0x100, 0x101,
+// 0xfffe, 0xffff, 0x10000, 0x10001,
+// 0xfffffe, 0xffffff, 0x1000000, 0x1000001,
+// 0xfffffffe, 0xffffffff, 0x100000000, 0x100000001,
+// 0xfffffffffe, 0xffffffffff, 0x10000000000, 0x10000000001,
+// 0xfffffffffffe, 0xffffffffffff, 0x1000000000000, 0x1000000000001,
+// 0xfffffffffffffe, 0xffffffffffffff, 0x100000000000000, 0x100000000000001,
+TEST_P(QuicheDataWriterTest, VarIntGoodTargetedValues) {
+ char buffer[kVarIntBufferLength];
+ uint64_t passing_values[] = {
+ 0,
+ 1,
+ 0x3e,
+ 0x3f,
+ 0x40,
+ 0x41,
+ 0x3ffe,
+ 0x3fff,
+ 0x4000,
+ 0x4001,
+ 0x3ffffffe,
+ 0x3fffffff,
+ 0x40000000,
+ 0x40000001,
+ 0x3ffffffffffffffe,
+ 0x3fffffffffffffff,
+ 0xfe,
+ 0xff,
+ 0x100,
+ 0x101,
+ 0xfffe,
+ 0xffff,
+ 0x10000,
+ 0x10001,
+ 0xfffffe,
+ 0xffffff,
+ 0x1000000,
+ 0x1000001,
+ 0xfffffffe,
+ 0xffffffff,
+ 0x100000000,
+ 0x100000001,
+ 0xfffffffffe,
+ 0xffffffffff,
+ 0x10000000000,
+ 0x10000000001,
+ 0xfffffffffffe,
+ 0xffffffffffff,
+ 0x1000000000000,
+ 0x1000000000001,
+ 0xfffffffffffffe,
+ 0xffffffffffffff,
+ 0x100000000000000,
+ 0x100000000000001,
+ };
+ for (uint64_t test_val : passing_values) {
+ EXPECT_TRUE(
+ EncodeDecodeValue(test_val, static_cast<char*>(buffer), sizeof(buffer)))
+ << " encode/decode of " << test_val << " failed";
+ }
+}
+//
+// Test certain, targeted, values where failure is expected (the
+// values are invalid w.r.t. IETF VarInt encoding):
+// 0x4000000000000000, 0x4000000000000001, ( Just above max allowed value)
+// 0xfffffffffffffffe, 0xffffffffffffffff, (should fail)
+TEST_P(QuicheDataWriterTest, VarIntBadTargetedValues) {
+ char buffer[kVarIntBufferLength];
+ uint64_t failing_values[] = {
+ 0x4000000000000000,
+ 0x4000000000000001,
+ 0xfffffffffffffffe,
+ 0xffffffffffffffff,
+ };
+ for (uint64_t test_val : failing_values) {
+ EXPECT_FALSE(
+ EncodeDecodeValue(test_val, static_cast<char*>(buffer), sizeof(buffer)))
+ << " encode/decode of " << test_val << " succeeded, but was an "
+ << "invalid value";
+ }
+}
+// Test writing varints with a forced length.
+TEST_P(QuicheDataWriterTest, WriteVarInt62WithForcedLength) {
+ char buffer[90];
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer));
+
+ writer.WriteVarInt62WithForcedLength(1, VARIABLE_LENGTH_INTEGER_LENGTH_1);
+ writer.WriteVarInt62WithForcedLength(1, VARIABLE_LENGTH_INTEGER_LENGTH_2);
+ writer.WriteVarInt62WithForcedLength(1, VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(1, VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(63, VARIABLE_LENGTH_INTEGER_LENGTH_1);
+ writer.WriteVarInt62WithForcedLength(63, VARIABLE_LENGTH_INTEGER_LENGTH_2);
+ writer.WriteVarInt62WithForcedLength(63, VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(63, VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(64, VARIABLE_LENGTH_INTEGER_LENGTH_2);
+ writer.WriteVarInt62WithForcedLength(64, VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(64, VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(16383, VARIABLE_LENGTH_INTEGER_LENGTH_2);
+ writer.WriteVarInt62WithForcedLength(16383, VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(16383, VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(16384, VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(16384, VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(1073741823,
+ VARIABLE_LENGTH_INTEGER_LENGTH_4);
+ writer.WriteVarInt62WithForcedLength(1073741823,
+ VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ writer.WriteVarInt62WithForcedLength(1073741824,
+ VARIABLE_LENGTH_INTEGER_LENGTH_8);
+
+ QuicheDataReader reader(buffer, sizeof(buffer));
+
+ uint64_t test_val = 0;
+ for (int i = 0; i < 4; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 1u);
+ }
+ for (int i = 0; i < 4; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 63u);
+ }
+
+ for (int i = 0; i < 3; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 64u);
+ }
+ for (int i = 0; i < 3; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 16383u);
+ }
+
+ for (int i = 0; i < 2; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 16384u);
+ }
+ for (int i = 0; i < 2; ++i) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 1073741823u);
+ }
+
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, 1073741824u);
+
+ // We are at the end of the buffer so this should fail.
+ EXPECT_FALSE(reader.ReadVarInt62(&test_val));
+}
+
+// Following tests all try to fill the buffer with multiple values,
+// go one value more than the buffer can accommodate, then read
+// the successfully encoded values, and try to read the unsuccessfully
+// encoded value. The following is the number of values to encode.
+const int kMultiVarCount = 1000;
+
+// Test writing & reading multiple 8-byte-encoded varints
+TEST_P(QuicheDataWriterTest, MultiVarInt8) {
+ uint64_t test_val;
+ char buffer[8 * kMultiVarCount];
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ // Put N values into the buffer. Adding i to the value ensures that
+ // each value is different so we can detect if we overwrite values,
+ // or read the same value over and over.
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8) + i));
+ }
+ EXPECT_EQ(writer.length(), 8u * kMultiVarCount);
+
+ // N+1st should fail, the buffer is full.
+ EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8)));
+
+ // Now we should be able to read out the N values that were
+ // successfully encoded.
+ QuicheDataReader reader(buffer, sizeof(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4d5c6b7a8) + i));
+ }
+ // And the N+1st should fail.
+ EXPECT_FALSE(reader.ReadVarInt62(&test_val));
+}
+
+// Test writing & reading multiple 4-byte-encoded varints
+TEST_P(QuicheDataWriterTest, MultiVarInt4) {
+ uint64_t test_val;
+ char buffer[4 * kMultiVarCount];
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ // Put N values into the buffer. Adding i to the value ensures that
+ // each value is different so we can detect if we overwrite values,
+ // or read the same value over and over.
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4) + i));
+ }
+ EXPECT_EQ(writer.length(), 4u * kMultiVarCount);
+
+ // N+1st should fail, the buffer is full.
+ EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142f3e4)));
+
+ // Now we should be able to read out the N values that were
+ // successfully encoded.
+ QuicheDataReader reader(buffer, sizeof(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4) + i));
+ }
+ // And the N+1st should fail.
+ EXPECT_FALSE(reader.ReadVarInt62(&test_val));
+}
+
+// Test writing & reading multiple 2-byte-encoded varints
+TEST_P(QuicheDataWriterTest, MultiVarInt2) {
+ uint64_t test_val;
+ char buffer[2 * kMultiVarCount];
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ // Put N values into the buffer. Adding i to the value ensures that
+ // each value is different so we can detect if we overwrite values,
+ // or read the same value over and over.
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142) + i));
+ }
+ EXPECT_EQ(writer.length(), 2u * kMultiVarCount);
+
+ // N+1st should fail, the buffer is full.
+ EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142)));
+
+ // Now we should be able to read out the N values that were
+ // successfully encoded.
+ QuicheDataReader reader(buffer, sizeof(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, (UINT64_C(0x3142) + i));
+ }
+ // And the N+1st should fail.
+ EXPECT_FALSE(reader.ReadVarInt62(&test_val));
+}
+
+// Test writing & reading multiple 1-byte-encoded varints
+TEST_P(QuicheDataWriterTest, MultiVarInt1) {
+ uint64_t test_val;
+ char buffer[1 * kMultiVarCount];
+ memset(buffer, 0, sizeof(buffer));
+ QuicheDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ // Put N values into the buffer. Adding i to the value ensures that
+ // each value is different so we can detect if we overwrite values,
+ // or read the same value over and over. &0xf ensures we do not
+ // overflow the max value for single-byte encoding.
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x30) + (i & 0xf)));
+ }
+ EXPECT_EQ(writer.length(), 1u * kMultiVarCount);
+
+ // N+1st should fail, the buffer is full.
+ EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x31)));
+
+ // Now we should be able to read out the N values that were
+ // successfully encoded.
+ QuicheDataReader reader(buffer, sizeof(buffer),
+ quiche::Endianness::NETWORK_BYTE_ORDER);
+ for (int i = 0; i < kMultiVarCount; i++) {
+ EXPECT_TRUE(reader.ReadVarInt62(&test_val));
+ EXPECT_EQ(test_val, (UINT64_C(0x30) + (i & 0xf)));
+ }
+ // And the N+1st should fail.
+ EXPECT_FALSE(reader.ReadVarInt62(&test_val));
+}
+
TEST_P(QuicheDataWriterTest, Seek) {
char buffer[3] = {};
QuicheDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
diff --git a/quiche/common/quiche_endian.h b/quiche/common/quiche_endian.h
index 30639cc..834f743 100644
--- a/quiche/common/quiche_endian.h
+++ b/quiche/common/quiche_endian.h
@@ -54,6 +54,20 @@
}
};
+enum QuicheVariableLengthIntegerLength : uint8_t {
+ // Length zero means the variable length integer is not present.
+ VARIABLE_LENGTH_INTEGER_LENGTH_0 = 0,
+ VARIABLE_LENGTH_INTEGER_LENGTH_1 = 1,
+ VARIABLE_LENGTH_INTEGER_LENGTH_2 = 2,
+ VARIABLE_LENGTH_INTEGER_LENGTH_4 = 4,
+ VARIABLE_LENGTH_INTEGER_LENGTH_8 = 8,
+
+ // By default we write the IETF long header length using the 2-byte encoding
+ // of variable length integers, even when the length is below 64, which allows
+ // us to fill in the length before knowing what the length actually is.
+ kQuicheDefaultLongHeaderLengthLength = VARIABLE_LENGTH_INTEGER_LENGTH_2,
+};
+
} // namespace quiche
#endif // QUICHE_COMMON_QUICHE_ENDIAN_H_
diff --git a/quiche/quic/core/chlo_extractor_test.cc b/quiche/quic/core/chlo_extractor_test.cc
index 3852469..6b49fdc 100644
--- a/quiche/quic/core/chlo_extractor_test.cc
+++ b/quiche/quic/core/chlo_extractor_test.cc
@@ -65,8 +65,9 @@
header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
header.packet_number = QuicPacketNumber(1);
if (version_.HasLongHeaderLengths()) {
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrames frames;
size_t offset = 0;
diff --git a/quiche/quic/core/crypto/transport_parameters.cc b/quiche/quic/core/crypto/transport_parameters.cc
index 635d159..140c16a 100644
--- a/quiche/quic/core/crypto/transport_parameters.cc
+++ b/quiche/quic/core/crypto/transport_parameters.cc
@@ -177,13 +177,13 @@
has_been_read_(false) {
QUICHE_DCHECK_LE(min_value, default_value);
QUICHE_DCHECK_LE(default_value, max_value);
- QUICHE_DCHECK_LE(max_value, kVarInt62MaxValue);
+ QUICHE_DCHECK_LE(max_value, quiche::kVarInt62MaxValue);
}
TransportParameters::IntegerParameter::IntegerParameter(
TransportParameters::TransportParameterId param_id)
: TransportParameters::IntegerParameter::IntegerParameter(
- param_id, 0, 0, kVarInt62MaxValue) {}
+ param_id, 0, 0, quiche::kVarInt62MaxValue) {}
void TransportParameters::IntegerParameter::set_value(uint64_t value) {
value_ = value;
@@ -206,13 +206,13 @@
QUIC_BUG(quic_bug_10743_1) << "Failed to write param_id for " << *this;
return false;
}
- const QuicVariableLengthIntegerLength value_length =
+ const quiche::QuicheVariableLengthIntegerLength value_length =
QuicDataWriter::GetVarInt62Len(value_);
if (!writer->WriteVarInt62(value_length)) {
QUIC_BUG(quic_bug_10743_2) << "Failed to write value_length for " << *this;
return false;
}
- if (!writer->WriteVarInt62(value_, value_length)) {
+ if (!writer->WriteVarInt62WithForcedLength(value_, value_length)) {
QUIC_BUG(quic_bug_10743_3) << "Failed to write value for " << *this;
return false;
}
@@ -451,7 +451,8 @@
TransportParameters::TransportParameters()
: max_idle_timeout_ms(kMaxIdleTimeout),
max_udp_payload_size(kMaxPacketSize, kDefaultMaxPacketSizeTransportParam,
- kMinMaxPacketSizeTransportParam, kVarInt62MaxValue),
+ kMinMaxPacketSizeTransportParam,
+ quiche::kVarInt62MaxValue),
initial_max_data(kInitialMaxData),
initial_max_stream_data_bidi_local(kInitialMaxStreamDataBidiLocal),
initial_max_stream_data_bidi_remote(kInitialMaxStreamDataBidiRemote),
@@ -469,7 +470,7 @@
active_connection_id_limit(kActiveConnectionIdLimit,
kDefaultActiveConnectionIdLimitTransportParam,
kMinActiveConnectionIdLimitTransportParam,
- kVarInt62MaxValue),
+ quiche::kVarInt62MaxValue),
max_datagram_frame_size(kMaxDatagramFrameSize),
initial_round_trip_time_us(kInitialRoundTripTime)
// Important note: any new transport parameters must be added
diff --git a/quiche/quic/core/crypto/transport_parameters.h b/quiche/quic/core/crypto/transport_parameters.h
index e1f349b..14ae6e9 100644
--- a/quiche/quic/core/crypto/transport_parameters.h
+++ b/quiche/quic/core/crypto/transport_parameters.h
@@ -61,7 +61,7 @@
friend struct TransportParameters;
// Constructors for initial setup used by TransportParameters only.
// This constructor sets |default_value| and |min_value| to 0, and
- // |max_value| to kVarInt62MaxValue.
+ // |max_value| to quiche::kVarInt62MaxValue.
explicit IntegerParameter(TransportParameterId param_id);
IntegerParameter(TransportParameterId param_id, uint64_t default_value,
uint64_t min_value, uint64_t max_value);
diff --git a/quiche/quic/core/http/http_decoder.cc b/quiche/quic/core/http/http_decoder.cc
index 5845a37..2bdce8e 100644
--- a/quiche/quic/core/http/http_decoder.cc
+++ b/quiche/quic/core/http/http_decoder.cc
@@ -657,9 +657,9 @@
case static_cast<uint64_t>(HttpFrameType::SETTINGS):
return kPayloadLengthLimit;
case static_cast<uint64_t>(HttpFrameType::GOAWAY):
- return VARIABLE_LENGTH_INTEGER_LENGTH_8;
+ return quiche::VARIABLE_LENGTH_INTEGER_LENGTH_8;
case static_cast<uint64_t>(HttpFrameType::MAX_PUSH_ID):
- return VARIABLE_LENGTH_INTEGER_LENGTH_8;
+ return quiche::VARIABLE_LENGTH_INTEGER_LENGTH_8;
case static_cast<uint64_t>(HttpFrameType::PRIORITY_UPDATE_REQUEST_STREAM):
return kPayloadLengthLimit;
case static_cast<uint64_t>(HttpFrameType::ACCEPT_CH):
diff --git a/quiche/quic/core/http/http_decoder_test.cc b/quiche/quic/core/http/http_decoder_test.cc
index 3ea97ca..c0a18ee 100644
--- a/quiche/quic/core/http/http_decoder_test.cc
+++ b/quiche/quic/core/http/http_decoder_test.cc
@@ -569,7 +569,8 @@
HttpDecoder decoder(&visitor);
QuicDataWriter writer(max_input_length, input);
ASSERT_TRUE(writer.WriteVarInt62(frame_type)); // frame type.
- ASSERT_TRUE(writer.WriteVarInt62(kVarInt62MaxValue)); // frame length.
+ ASSERT_TRUE(
+ writer.WriteVarInt62(quiche::kVarInt62MaxValue)); // frame length.
ASSERT_TRUE(writer.WriteUInt8(0x00)); // one byte of payload.
EXPECT_NE(decoder.ProcessInput(input, writer.length()), 0u) << frame_type;
}
diff --git a/quiche/quic/core/quic_chaos_protector_test.cc b/quiche/quic/core/quic_chaos_protector_test.cc
index 95c073a..92d3af9 100644
--- a/quiche/quic/core/quic_chaos_protector_test.cc
+++ b/quiche/quic/core/quic_chaos_protector_test.cc
@@ -87,8 +87,9 @@
header_.packet_number = QuicPacketNumber(1);
header_.form = IETF_QUIC_LONG_HEADER_PACKET;
header_.long_packet_type = INITIAL;
- header_.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header_.length_length = kQuicDefaultLongHeaderLengthLength;
+ header_.retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header_.length_length = quiche::kQuicheDefaultLongHeaderLengthLength;
// Setup validation framer.
validation_framer_.framer()->SetInitialObfuscators(
header_.destination_connection_id);
diff --git a/quiche/quic/core/quic_config.cc b/quiche/quic/core/quic_config.cc
index c48001a..04aa196 100644
--- a/quiche/quic/core/quic_config.cc
+++ b/quiche/quic/core/quic_config.cc
@@ -147,9 +147,9 @@
}
void QuicFixedUint62::SetSendValue(uint64_t value) {
- if (value > kVarInt62MaxValue) {
+ if (value > quiche::kVarInt62MaxValue) {
QUIC_BUG(quic_bug_10575_3) << "QuicFixedUint62 invalid value " << value;
- value = kVarInt62MaxValue;
+ value = quiche::kVarInt62MaxValue;
}
has_send_value_ = true;
send_value_ = value;
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 21a4bbf..dca0520 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -1119,9 +1119,10 @@
header.long_packet_type = EncryptionlevelToLongHeaderType(level);
if (QuicVersionHasLongHeaderLengths(
peer_framer_.version().transport_version)) {
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
if (header.long_packet_type == INITIAL) {
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
}
}
}
@@ -2893,8 +2894,8 @@
if (QuicVersionHasLongHeaderLengths(
peer_framer_.version().transport_version)) {
header.long_packet_type = INITIAL;
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrames frames;
@@ -2941,8 +2942,8 @@
if (QuicVersionHasLongHeaderLengths(
peer_framer_.version().transport_version)) {
header.long_packet_type = INITIAL;
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrames frames;
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 904557b..45f5351 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -49,13 +49,13 @@
QuicTransportVersion version, QuicConnectionId connection_id) {
QUICHE_DCHECK(
QuicUtils::IsConnectionIdValidForVersion(connection_id, version));
- QuicVariableLengthIntegerLength retry_token_length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_1;
- QuicVariableLengthIntegerLength length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ quiche::QuicheVariableLengthIntegerLength length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
if (!QuicVersionHasLongHeaderLengths(version)) {
- retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
- length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
}
return QuicPacketCreator::StreamFramePacketOverhead(
version, static_cast<QuicConnectionIdLength>(connection_id.length()),
diff --git a/quiche/quic/core/quic_data_reader.cc b/quiche/quic/core/quic_data_reader.cc
index 1a06057..aa8b278 100644
--- a/quiche/quic/core/quic_data_reader.cc
+++ b/quiche/quic/core/quic_data_reader.cc
@@ -83,93 +83,5 @@
return ReadConnectionId(connection_id, connection_id_length);
}
-QuicVariableLengthIntegerLength QuicDataReader::PeekVarInt62Length() {
- QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
- const unsigned char* next =
- reinterpret_cast<const unsigned char*>(data() + pos());
- if (BytesRemaining() == 0) {
- return VARIABLE_LENGTH_INTEGER_LENGTH_0;
- }
- return static_cast<QuicVariableLengthIntegerLength>(
- 1 << ((*next & 0b11000000) >> 6));
-}
-
-// Read an IETF/QUIC formatted 62-bit Variable Length Integer.
-//
-// Performance notes
-//
-// Measurements and experiments showed that unrolling the four cases
-// like this and dereferencing next_ as we do (*(next_+n) --- and then
-// doing a single pos_+=x at the end) gains about 10% over making a
-// loop and dereferencing next_ such as *(next_++)
-//
-// Using a register for pos_ was not helpful.
-//
-// Branches are ordered to increase the likelihood of the first being
-// taken.
-//
-// Low-level optimization is useful here because this function will be
-// called frequently, leading to outsize benefits.
-bool QuicDataReader::ReadVarInt62(uint64_t* result) {
- QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
-
- size_t remaining = BytesRemaining();
- const unsigned char* next =
- reinterpret_cast<const unsigned char*>(data() + pos());
- if (remaining != 0) {
- switch (*next & 0xc0) {
- case 0xc0:
- // Leading 0b11...... is 8 byte encoding
- if (remaining >= 8) {
- *result = (static_cast<uint64_t>((*(next)) & 0x3f) << 56) +
- (static_cast<uint64_t>(*(next + 1)) << 48) +
- (static_cast<uint64_t>(*(next + 2)) << 40) +
- (static_cast<uint64_t>(*(next + 3)) << 32) +
- (static_cast<uint64_t>(*(next + 4)) << 24) +
- (static_cast<uint64_t>(*(next + 5)) << 16) +
- (static_cast<uint64_t>(*(next + 6)) << 8) +
- (static_cast<uint64_t>(*(next + 7)) << 0);
- AdvancePos(8);
- return true;
- }
- return false;
-
- case 0x80:
- // Leading 0b10...... is 4 byte encoding
- if (remaining >= 4) {
- *result = (((*(next)) & 0x3f) << 24) + (((*(next + 1)) << 16)) +
- (((*(next + 2)) << 8)) + (((*(next + 3)) << 0));
- AdvancePos(4);
- return true;
- }
- return false;
-
- case 0x40:
- // Leading 0b01...... is 2 byte encoding
- if (remaining >= 2) {
- *result = (((*(next)) & 0x3f) << 8) + (*(next + 1));
- AdvancePos(2);
- return true;
- }
- return false;
-
- case 0x00:
- // Leading 0b00...... is 1 byte encoding
- *result = (*next) & 0x3f;
- AdvancePos(1);
- return true;
- }
- }
- return false;
-}
-
-bool QuicDataReader::ReadStringPieceVarInt62(absl::string_view* result) {
- uint64_t result_length;
- if (!ReadVarInt62(&result_length)) {
- return false;
- }
- return ReadStringPiece(result, result_length);
-}
-
#undef ENDPOINT // undef for jumbo builds
} // namespace quic
diff --git a/quiche/quic/core/quic_data_reader.h b/quiche/quic/core/quic_data_reader.h
index 0a67df8..0a907e0 100644
--- a/quiche/quic/core/quic_data_reader.h
+++ b/quiche/quic/core/quic_data_reader.h
@@ -62,29 +62,6 @@
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
bool ReadLengthPrefixedConnectionId(QuicConnectionId* connection_id);
-
- // Returns the length in bytes of a variable length integer based on the next
- // two bits available. Returns 1, 2, 4, or 8 on success, and 0 on failure.
- QuicVariableLengthIntegerLength PeekVarInt62Length();
-
- // Read an IETF-encoded Variable Length Integer and place the result
- // in |*result|.
- // Returns true if it works, false if not. The only error is that
- // there is not enough in the buffer to read the number.
- // If there is an error, |*result| is not altered.
- // Numbers are encoded per the rules in draft-ietf-quic-transport-10.txt
- // and that the integers in the range 0 ... (2^62)-1.
- bool ReadVarInt62(uint64_t* result);
-
- // Reads a string prefixed with a Variable Length integer length into the
- // given output parameter.
- //
- // NOTE: Does not copy but rather references strings in the underlying buffer.
- // This should be kept in mind when handling memory management!
- //
- // Forwards the internal iterator on success.
- // Returns true on success, false otherwise.
- bool ReadStringPieceVarInt62(absl::string_view* result);
};
} // namespace quic
diff --git a/quiche/quic/core/quic_data_writer.cc b/quiche/quic/core/quic_data_writer.cc
index 4fbd3b6..09f1923 100644
--- a/quiche/quic/core/quic_data_writer.cc
+++ b/quiche/quic/core/quic_data_writer.cc
@@ -102,157 +102,4 @@
return true;
}
-// Converts a uint64_t into an IETF/Quic formatted Variable Length
-// Integer. IETF Variable Length Integers have 62 significant bits, so
-// the value to write must be in the range of 0..(2^62)-1.
-//
-// Performance notes
-//
-// Measurements and experiments showed that unrolling the four cases
-// like this and dereferencing next_ as we do (*(next_+n)) gains about
-// 10% over making a loop and dereferencing it as *(next_++)
-//
-// Using a register for next didn't help.
-//
-// Branches are ordered to increase the likelihood of the first being
-// taken.
-//
-// Low-level optimization is useful here because this function will be
-// called frequently, leading to outsize benefits.
-bool QuicDataWriter::WriteVarInt62(uint64_t value) {
- QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
-
- size_t remaining_bytes = remaining();
- char* next = buffer() + length();
-
- if ((value & kVarInt62ErrorMask) == 0) {
- // We know the high 2 bits are 0 so |value| is legal.
- // We can do the encoding.
- if ((value & kVarInt62Mask8Bytes) != 0) {
- // Someplace in the high-4 bytes is a 1-bit. Do an 8-byte
- // encoding.
- if (remaining_bytes >= 8) {
- *(next + 0) = ((value >> 56) & 0x3f) + 0xc0;
- *(next + 1) = (value >> 48) & 0xff;
- *(next + 2) = (value >> 40) & 0xff;
- *(next + 3) = (value >> 32) & 0xff;
- *(next + 4) = (value >> 24) & 0xff;
- *(next + 5) = (value >> 16) & 0xff;
- *(next + 6) = (value >> 8) & 0xff;
- *(next + 7) = value & 0xff;
- IncreaseLength(8);
- return true;
- }
- return false;
- }
- // The high-order-4 bytes are all 0, check for a 1, 2, or 4-byte
- // encoding
- if ((value & kVarInt62Mask4Bytes) != 0) {
- // The encoding will not fit into 2 bytes, Do a 4-byte
- // encoding.
- if (remaining_bytes >= 4) {
- *(next + 0) = ((value >> 24) & 0x3f) + 0x80;
- *(next + 1) = (value >> 16) & 0xff;
- *(next + 2) = (value >> 8) & 0xff;
- *(next + 3) = value & 0xff;
- IncreaseLength(4);
- return true;
- }
- return false;
- }
- // The high-order bits are all 0. Check to see if the number
- // can be encoded as one or two bytes. One byte encoding has
- // only 6 significant bits (bits 0xffffffff ffffffc0 are all 0).
- // Two byte encoding has more than 6, but 14 or less significant
- // bits (bits 0xffffffff ffffc000 are 0 and 0x00000000 00003fc0
- // are not 0)
- if ((value & kVarInt62Mask2Bytes) != 0) {
- // Do 2-byte encoding
- if (remaining_bytes >= 2) {
- *(next + 0) = ((value >> 8) & 0x3f) + 0x40;
- *(next + 1) = (value)&0xff;
- IncreaseLength(2);
- return true;
- }
- return false;
- }
- if (remaining_bytes >= 1) {
- // Do 1-byte encoding
- *next = (value & 0x3f);
- IncreaseLength(1);
- return true;
- }
- return false;
- }
- // Can not encode, high 2 bits not 0
- return false;
-}
-
-bool QuicDataWriter::WriteVarInt62(
- uint64_t value, QuicVariableLengthIntegerLength write_length) {
- QUICHE_DCHECK_EQ(endianness(), quiche::NETWORK_BYTE_ORDER);
-
- size_t remaining_bytes = remaining();
- if (remaining_bytes < write_length) {
- return false;
- }
-
- const QuicVariableLengthIntegerLength min_length = GetVarInt62Len(value);
- if (write_length < min_length) {
- QUIC_BUG(quic_bug_10347_1) << "Cannot write value " << value
- << " with write_length " << write_length;
- return false;
- }
- if (write_length == min_length) {
- return WriteVarInt62(value);
- }
-
- if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_2) {
- return WriteUInt8(0b01000000) && WriteUInt8(value);
- }
- if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_4) {
- return WriteUInt8(0b10000000) && WriteUInt8(0) && WriteUInt16(value);
- }
- if (write_length == VARIABLE_LENGTH_INTEGER_LENGTH_8) {
- return WriteUInt8(0b11000000) && WriteUInt8(0) && WriteUInt16(0) &&
- WriteUInt32(value);
- }
-
- QUIC_BUG(quic_bug_10347_2)
- << "Invalid write_length " << static_cast<int>(write_length);
- return false;
-}
-
-// static
-QuicVariableLengthIntegerLength QuicDataWriter::GetVarInt62Len(uint64_t value) {
- if ((value & kVarInt62ErrorMask) != 0) {
- QUIC_BUG(quic_bug_10347_3) << "Attempted to encode a value, " << value
- << ", that is too big for VarInt62";
- return VARIABLE_LENGTH_INTEGER_LENGTH_0;
- }
- if ((value & kVarInt62Mask8Bytes) != 0) {
- return VARIABLE_LENGTH_INTEGER_LENGTH_8;
- }
- if ((value & kVarInt62Mask4Bytes) != 0) {
- return VARIABLE_LENGTH_INTEGER_LENGTH_4;
- }
- if ((value & kVarInt62Mask2Bytes) != 0) {
- return VARIABLE_LENGTH_INTEGER_LENGTH_2;
- }
- return VARIABLE_LENGTH_INTEGER_LENGTH_1;
-}
-
-bool QuicDataWriter::WriteStringPieceVarInt62(
- const absl::string_view& string_piece) {
- if (!WriteVarInt62(string_piece.size())) {
- return false;
- }
- if (!string_piece.empty()) {
- if (!WriteBytes(string_piece.data(), string_piece.size())) {
- return false;
- }
- }
- return true;
-}
-
} // namespace quic
diff --git a/quiche/quic/core/quic_data_writer.h b/quiche/quic/core/quic_data_writer.h
index b1cd198..c96b3b7 100644
--- a/quiche/quic/core/quic_data_writer.h
+++ b/quiche/quic/core/quic_data_writer.h
@@ -18,19 +18,6 @@
class QuicRandom;
-// Maximum value that can be properly encoded using VarInt62 coding.
-const uint64_t kVarInt62MaxValue = UINT64_C(0x3fffffffffffffff);
-
-// VarInt62 encoding masks
-// If a uint64_t anded with a mask is not 0 then the value is encoded
-// using that length (or is too big, in the case of kVarInt62ErrorMask).
-// Values must be checked in order (error, 8-, 4-, and then 2- bytes)
-// and if none are non-0, the value is encoded in 1 byte.
-const uint64_t kVarInt62ErrorMask = UINT64_C(0xc000000000000000);
-const uint64_t kVarInt62Mask8Bytes = UINT64_C(0x3fffffffc0000000);
-const uint64_t kVarInt62Mask4Bytes = UINT64_C(0x000000003fffc000);
-const uint64_t kVarInt62Mask2Bytes = UINT64_C(0x0000000000003fc0);
-
// This class provides facilities for packing QUIC data.
//
// The QuicDataWriter supports appending primitive values (int, string, etc)
@@ -52,31 +39,6 @@
// Methods for adding to the payload. These values are appended to the end
// of the QuicDataWriter payload.
- // Write an unsigned-integer value per the IETF QUIC/Variable Length
- // Integer encoding rules (see draft-ietf-quic-transport-08.txt).
- // IETF Variable Length Integers have 62 significant bits, so the
- // value to write must be in the range of 0...(2^62)-1. Returns
- // false if the value is out of range or if there is no room in the
- // buffer.
- bool WriteVarInt62(uint64_t value);
-
- // Same as WriteVarInt62(uint64_t), but forces an encoding size to write to.
- // This is not as optimized as WriteVarInt62(uint64_t).
- // Returns false if the value does not fit in the specified write_length or if
- // there is no room in the buffer.
- bool WriteVarInt62(uint64_t value,
- QuicVariableLengthIntegerLength write_length);
-
- // Writes a string piece as a consecutive length/content pair. The
- // length is VarInt62 encoded.
- bool WriteStringPieceVarInt62(const absl::string_view& string_piece);
-
- // Utility function to return the number of bytes needed to encode
- // the given value using IETF VarInt62 encoding. Returns the number
- // of bytes required to encode the given integer or 0 if the value
- // is too large to encode.
- static QuicVariableLengthIntegerLength GetVarInt62Len(uint64_t value);
-
// Write unsigned floating point corresponding to the value. Large values are
// clamped to the maximum representable (kUFloat16MaxValue). Values that can
// not be represented directly are rounded down.
diff --git a/quiche/quic/core/quic_data_writer_test.cc b/quiche/quic/core/quic_data_writer_test.cc
index 5d20c84..9d454e9 100644
--- a/quiche/quic/core/quic_data_writer_test.cc
+++ b/quiche/quic/core/quic_data_writer_test.cc
@@ -666,416 +666,12 @@
}
}
-const int kVarIntBufferLength = 1024;
-
-// Encodes and then decodes a specified value, checks that the
-// value that was encoded is the same as the decoded value, the length
-// is correct, and that after decoding, all data in the buffer has
-// been consumed..
-// Returns true if everything works, false if not.
-bool EncodeDecodeValue(uint64_t value_in, char* buffer, size_t size_of_buffer) {
- // Init the buffer to all 0, just for cleanliness. Makes for better
- // output if, in debugging, we need to dump out the buffer.
- memset(buffer, 0, size_of_buffer);
- // make a writer. Note that for IETF encoding
- // we do not care about endianness... It's always big-endian,
- // but the c'tor expects to be told what endianness is in force...
- QuicDataWriter writer(size_of_buffer, buffer,
- quiche::Endianness::NETWORK_BYTE_ORDER);
-
- // Try to write the value.
- if (writer.WriteVarInt62(value_in) != true) {
- return false;
- }
- // Look at the value we encoded. Determine how much should have been
- // used based on the value, and then check the state of the writer
- // to see that it matches.
- size_t expected_length = 0;
- if (value_in <= 0x3f) {
- expected_length = 1;
- } else if (value_in <= 0x3fff) {
- expected_length = 2;
- } else if (value_in <= 0x3fffffff) {
- expected_length = 4;
- } else {
- expected_length = 8;
- }
- if (writer.length() != expected_length) {
- return false;
- }
-
- // set up a reader, just the length we've used, no more, no less.
- QuicDataReader reader(buffer, expected_length,
- quiche::Endianness::NETWORK_BYTE_ORDER);
- uint64_t value_out;
-
- if (reader.ReadVarInt62(&value_out) == false) {
- return false;
- }
- if (value_in != value_out) {
- return false;
- }
- // We only write one value so there had better be nothing left to read
- return reader.IsDoneReading();
-}
-
-// Test that 8-byte-encoded Variable Length Integers are properly laid
-// out in the buffer.
-TEST_P(QuicDataWriterTest, VarInt8Layout) {
- char buffer[1024];
-
- // Check that the layout of bytes in the buffer is correct. Bytes
- // are always encoded big endian...
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8)));
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
- (0x31 + 0xc0)); // 0xc0 for encoding
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x42);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 2)), 0xf3);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 3)), 0xe4);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 4)), 0xd5);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 5)), 0xc6);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 6)), 0xb7);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 7)), 0xa8);
-}
-
-// Test that 4-byte-encoded Variable Length Integers are properly laid
-// out in the buffer.
-TEST_P(QuicDataWriterTest, VarInt4Layout) {
- char buffer[1024];
-
- // Check that the layout of bytes in the buffer is correct. Bytes
- // are always encoded big endian...
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- EXPECT_TRUE(writer.WriteVarInt62(0x3243f4e5));
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
- (0x32 + 0x80)); // 0x80 for encoding
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x43);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 2)), 0xf4);
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 3)), 0xe5);
-}
-
-// Test that 2-byte-encoded Variable Length Integers are properly laid
-// out in the buffer.
-TEST_P(QuicDataWriterTest, VarInt2Layout) {
- char buffer[1024];
-
- // Check that the layout of bytes in the buffer is correct. Bytes
- // are always encoded big endian...
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- EXPECT_TRUE(writer.WriteVarInt62(0x3647));
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)),
- (0x36 + 0x40)); // 0x40 for encoding
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 1)), 0x47);
-}
-
-// Test that 1-byte-encoded Variable Length Integers are properly laid
-// out in the buffer.
-TEST_P(QuicDataWriterTest, VarInt1Layout) {
- char buffer[1024];
-
- // Check that the layout of bytes in the buffer
- // is correct. Bytes are always encoded big endian...
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- EXPECT_TRUE(writer.WriteVarInt62(0x3f));
- EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), 0x3f);
-}
-
-// Test certain, targeted, values that are expected to succeed:
-// 0, 1,
-// 0x3e, 0x3f, 0x40, 0x41 (around the 1-2 byte transitions)
-// 0x3ffe, 0x3fff, 0x4000, 0x4001 (the 2-4 byte transition)
-// 0x3ffffffe, 0x3fffffff, 0x40000000, 0x40000001 (the 4-8 byte
-// transition)
-// 0x3ffffffffffffffe, 0x3fffffffffffffff, (the highest valid values)
-// 0xfe, 0xff, 0x100, 0x101,
-// 0xfffe, 0xffff, 0x10000, 0x10001,
-// 0xfffffe, 0xffffff, 0x1000000, 0x1000001,
-// 0xfffffffe, 0xffffffff, 0x100000000, 0x100000001,
-// 0xfffffffffe, 0xffffffffff, 0x10000000000, 0x10000000001,
-// 0xfffffffffffe, 0xffffffffffff, 0x1000000000000, 0x1000000000001,
-// 0xfffffffffffffe, 0xffffffffffffff, 0x100000000000000, 0x100000000000001,
-TEST_P(QuicDataWriterTest, VarIntGoodTargetedValues) {
- char buffer[kVarIntBufferLength];
- uint64_t passing_values[] = {
- 0,
- 1,
- 0x3e,
- 0x3f,
- 0x40,
- 0x41,
- 0x3ffe,
- 0x3fff,
- 0x4000,
- 0x4001,
- 0x3ffffffe,
- 0x3fffffff,
- 0x40000000,
- 0x40000001,
- 0x3ffffffffffffffe,
- 0x3fffffffffffffff,
- 0xfe,
- 0xff,
- 0x100,
- 0x101,
- 0xfffe,
- 0xffff,
- 0x10000,
- 0x10001,
- 0xfffffe,
- 0xffffff,
- 0x1000000,
- 0x1000001,
- 0xfffffffe,
- 0xffffffff,
- 0x100000000,
- 0x100000001,
- 0xfffffffffe,
- 0xffffffffff,
- 0x10000000000,
- 0x10000000001,
- 0xfffffffffffe,
- 0xffffffffffff,
- 0x1000000000000,
- 0x1000000000001,
- 0xfffffffffffffe,
- 0xffffffffffffff,
- 0x100000000000000,
- 0x100000000000001,
- };
- for (uint64_t test_val : passing_values) {
- EXPECT_TRUE(
- EncodeDecodeValue(test_val, static_cast<char*>(buffer), sizeof(buffer)))
- << " encode/decode of " << test_val << " failed";
- }
-}
-//
-// Test certain, targeted, values where failure is expected (the
-// values are invalid w.r.t. IETF VarInt encoding):
-// 0x4000000000000000, 0x4000000000000001, ( Just above max allowed value)
-// 0xfffffffffffffffe, 0xffffffffffffffff, (should fail)
-TEST_P(QuicDataWriterTest, VarIntBadTargetedValues) {
- char buffer[kVarIntBufferLength];
- uint64_t failing_values[] = {
- 0x4000000000000000,
- 0x4000000000000001,
- 0xfffffffffffffffe,
- 0xffffffffffffffff,
- };
- for (uint64_t test_val : failing_values) {
- EXPECT_FALSE(
- EncodeDecodeValue(test_val, static_cast<char*>(buffer), sizeof(buffer)))
- << " encode/decode of " << test_val << " succeeded, but was an "
- << "invalid value";
- }
-}
-
// Following tests all try to fill the buffer with multiple values,
// go one value more than the buffer can accommodate, then read
// the successfully encoded values, and try to read the unsuccessfully
// encoded value. The following is the number of values to encode.
const int kMultiVarCount = 1000;
-// Test writing & reading multiple 8-byte-encoded varints
-TEST_P(QuicDataWriterTest, MultiVarInt8) {
- uint64_t test_val;
- char buffer[8 * kMultiVarCount];
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- // Put N values into the buffer. Adding i to the value ensures that
- // each value is different so we can detect if we overwrite values,
- // or read the same value over and over.
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8) + i));
- }
- EXPECT_EQ(writer.length(), 8u * kMultiVarCount);
-
- // N+1st should fail, the buffer is full.
- EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8)));
-
- // Now we should be able to read out the N values that were
- // successfully encoded.
- QuicDataReader reader(buffer, sizeof(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4d5c6b7a8) + i));
- }
- // And the N+1st should fail.
- EXPECT_FALSE(reader.ReadVarInt62(&test_val));
-}
-
-// Test writing & reading multiple 4-byte-encoded varints
-TEST_P(QuicDataWriterTest, MultiVarInt4) {
- uint64_t test_val;
- char buffer[4 * kMultiVarCount];
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- // Put N values into the buffer. Adding i to the value ensures that
- // each value is different so we can detect if we overwrite values,
- // or read the same value over and over.
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4) + i));
- }
- EXPECT_EQ(writer.length(), 4u * kMultiVarCount);
-
- // N+1st should fail, the buffer is full.
- EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142f3e4)));
-
- // Now we should be able to read out the N values that were
- // successfully encoded.
- QuicDataReader reader(buffer, sizeof(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4) + i));
- }
- // And the N+1st should fail.
- EXPECT_FALSE(reader.ReadVarInt62(&test_val));
-}
-
-// Test writing & reading multiple 2-byte-encoded varints
-TEST_P(QuicDataWriterTest, MultiVarInt2) {
- uint64_t test_val;
- char buffer[2 * kMultiVarCount];
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- // Put N values into the buffer. Adding i to the value ensures that
- // each value is different so we can detect if we overwrite values,
- // or read the same value over and over.
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142) + i));
- }
- EXPECT_EQ(writer.length(), 2u * kMultiVarCount);
-
- // N+1st should fail, the buffer is full.
- EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x3142)));
-
- // Now we should be able to read out the N values that were
- // successfully encoded.
- QuicDataReader reader(buffer, sizeof(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, (UINT64_C(0x3142) + i));
- }
- // And the N+1st should fail.
- EXPECT_FALSE(reader.ReadVarInt62(&test_val));
-}
-
-// Test writing & reading multiple 1-byte-encoded varints
-TEST_P(QuicDataWriterTest, MultiVarInt1) {
- uint64_t test_val;
- char buffer[1 * kMultiVarCount];
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- // Put N values into the buffer. Adding i to the value ensures that
- // each value is different so we can detect if we overwrite values,
- // or read the same value over and over. &0xf ensures we do not
- // overflow the max value for single-byte encoding.
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x30) + (i & 0xf)));
- }
- EXPECT_EQ(writer.length(), 1u * kMultiVarCount);
-
- // N+1st should fail, the buffer is full.
- EXPECT_FALSE(writer.WriteVarInt62(UINT64_C(0x31)));
-
- // Now we should be able to read out the N values that were
- // successfully encoded.
- QuicDataReader reader(buffer, sizeof(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
- for (int i = 0; i < kMultiVarCount; i++) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, (UINT64_C(0x30) + (i & 0xf)));
- }
- // And the N+1st should fail.
- EXPECT_FALSE(reader.ReadVarInt62(&test_val));
-}
-
-// Test writing varints with a forced length.
-TEST_P(QuicDataWriterTest, VarIntFixedLength) {
- char buffer[90];
- memset(buffer, 0, sizeof(buffer));
- QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
-
- writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_1);
- writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_2);
- writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(63, VARIABLE_LENGTH_INTEGER_LENGTH_1);
- writer.WriteVarInt62(63, VARIABLE_LENGTH_INTEGER_LENGTH_2);
- writer.WriteVarInt62(63, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(63, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(64, VARIABLE_LENGTH_INTEGER_LENGTH_2);
- writer.WriteVarInt62(64, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(64, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(16383, VARIABLE_LENGTH_INTEGER_LENGTH_2);
- writer.WriteVarInt62(16383, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(16383, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(16384, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(16384, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(1073741823, VARIABLE_LENGTH_INTEGER_LENGTH_4);
- writer.WriteVarInt62(1073741823, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- writer.WriteVarInt62(1073741824, VARIABLE_LENGTH_INTEGER_LENGTH_8);
-
- QuicDataReader reader(buffer, sizeof(buffer),
- quiche::Endianness::NETWORK_BYTE_ORDER);
-
- uint64_t test_val = 0;
- for (int i = 0; i < 4; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 1u);
- }
- for (int i = 0; i < 4; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 63u);
- }
-
- for (int i = 0; i < 3; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 64u);
- }
- for (int i = 0; i < 3; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 16383u);
- }
-
- for (int i = 0; i < 2; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 16384u);
- }
- for (int i = 0; i < 2; ++i) {
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 1073741823u);
- }
-
- EXPECT_TRUE(reader.ReadVarInt62(&test_val));
- EXPECT_EQ(test_val, 1073741824u);
-
- // We are at the end of the buffer so this should fail.
- EXPECT_FALSE(reader.ReadVarInt62(&test_val));
-}
-
// Test encoding/decoding stream-id values.
void EncodeDecodeStreamId(uint64_t value_in) {
char buffer[1 * kMultiVarCount];
diff --git a/quiche/quic/core/quic_framer.cc b/quiche/quic/core/quic_framer.cc
index b6b0c5b..1630a2c 100644
--- a/quiche/quic/core/quic_framer.cc
+++ b/quiche/quic/core/quic_framer.cc
@@ -860,20 +860,20 @@
}
if (writer->length() < length_field_offset ||
writer->length() - length_field_offset <
- kQuicDefaultLongHeaderLengthLength) {
+ quiche::kQuicheDefaultLongHeaderLengthLength) {
set_detailed_error("Invalid length_field_offset.");
QUIC_BUG(quic_bug_10850_14) << "Invalid length_field_offset.";
return false;
}
size_t length_to_write = writer->length() - length_field_offset -
- kQuicDefaultLongHeaderLengthLength;
+ quiche::kQuicheDefaultLongHeaderLengthLength;
// Add length of auth tag.
length_to_write = GetCiphertextSize(level, length_to_write);
QuicDataWriter length_writer(writer->length() - length_field_offset,
writer->data() + length_field_offset);
- if (!length_writer.WriteVarInt62(length_to_write,
- kQuicDefaultLongHeaderLengthLength)) {
+ if (!length_writer.WriteVarInt62WithForcedLength(
+ length_to_write, quiche::kQuicheDefaultLongHeaderLengthLength)) {
set_detailed_error("Failed to overwrite long header length.");
QUIC_BUG(quic_bug_10850_15) << "Failed to overwrite long header length.";
return false;
@@ -1741,7 +1741,7 @@
size_t buffer_length) {
QUICHE_DCHECK_NE(GOOGLE_QUIC_PACKET, header->form);
QUICHE_DCHECK(!header->has_possible_stateless_reset_token);
- header->length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ header->length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
header->remaining_packet_length = 0;
if (header->form == IETF_QUIC_SHORT_HEADER_PACKET &&
perspective_ == Perspective::IS_CLIENT) {
@@ -2274,13 +2274,13 @@
if (QuicVersionHasLongHeaderLengths(transport_version()) &&
header.version_flag) {
if (header.long_packet_type == INITIAL) {
- QUICHE_DCHECK_NE(VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ QUICHE_DCHECK_NE(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
header.retry_token_length_length)
<< ENDPOINT << ParsedQuicVersionToString(version_)
<< " bad retry token length length in header: " << header;
// Write retry token length.
- if (!writer->WriteVarInt62(header.retry_token.length(),
- header.retry_token_length_length)) {
+ if (!writer->WriteVarInt62WithForcedLength(
+ header.retry_token.length(), header.retry_token_length_length)) {
return false;
}
// Write retry token.
@@ -3963,7 +3963,8 @@
return false;
}
- if (ack_delay_time_in_us >= (kVarInt62MaxValue >> peer_ack_delay_exponent_)) {
+ if (ack_delay_time_in_us >=
+ (quiche::kVarInt62MaxValue >> peer_ack_delay_exponent_)) {
ack_frame->ack_delay_time = QuicTime::Delta::Infinite();
} else {
ack_delay_time_in_us = (ack_delay_time_in_us << peer_ack_delay_exponent_);
@@ -4358,9 +4359,9 @@
QuicConnectionIdLength source_connection_id_length, bool includes_version,
bool includes_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
uint64_t retry_token_length,
- QuicVariableLengthIntegerLength length_length) {
+ quiche::QuicheVariableLengthIntegerLength length_length) {
// TODO(ianswett): This is identical to QuicData::AssociatedData.
return absl::string_view(
encrypted.data(),
@@ -6028,7 +6029,7 @@
return false;
}
- uint64_t ack_delay_time_us = kVarInt62MaxValue;
+ uint64_t ack_delay_time_us = quiche::kVarInt62MaxValue;
if (!frame.ack_delay_time.IsInfinite()) {
QUICHE_DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
@@ -6812,7 +6813,7 @@
}
const bool ietf_format = QuicUtils::IsIetfPacketHeader(first_byte);
uint8_t unused_first_byte;
- QuicVariableLengthIntegerLength retry_token_length_length;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length;
absl::string_view maybe_retry_token;
QuicErrorCode error_code = ParsePublicHeader(
&reader, expected_destination_connection_id_length, ietf_format,
@@ -6820,7 +6821,7 @@
version_label, parsed_version, destination_connection_id,
source_connection_id, long_packet_type, &retry_token_length_length,
&maybe_retry_token, detailed_error);
- if (retry_token_length_length != VARIABLE_LENGTH_INTEGER_LENGTH_0) {
+ if (retry_token_length_length != quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0) {
*retry_token = maybe_retry_token;
} else {
retry_token->reset();
@@ -6961,7 +6962,7 @@
QuicConnectionId* destination_connection_id,
QuicConnectionId* source_connection_id,
QuicLongHeaderType* long_packet_type,
- QuicVariableLengthIntegerLength* retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength* retry_token_length_length,
absl::string_view* retry_token, std::string* detailed_error) {
*version_present = false;
*has_length_prefix = false;
@@ -6969,7 +6970,7 @@
*parsed_version = UnsupportedQuicVersion();
*source_connection_id = EmptyQuicConnectionId();
*long_packet_type = INVALID_PACKET_TYPE;
- *retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ *retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
*retry_token = absl::string_view();
*detailed_error = "";
@@ -7047,7 +7048,7 @@
*retry_token_length_length = reader->PeekVarInt62Length();
uint64_t retry_token_length;
if (!reader->ReadVarInt62(&retry_token_length)) {
- *retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ *retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
*detailed_error = "Unable to read retry token length.";
return QUIC_INVALID_PACKET_HEADER;
}
diff --git a/quiche/quic/core/quic_framer.h b/quiche/quic/core/quic_framer.h
index f60a109..c39ee2b 100644
--- a/quiche/quic/core/quic_framer.h
+++ b/quiche/quic/core/quic_framer.h
@@ -425,9 +425,9 @@
QuicConnectionIdLength source_connection_id_length, bool includes_version,
bool includes_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
uint64_t retry_token_length,
- QuicVariableLengthIntegerLength length_length);
+ quiche::QuicheVariableLengthIntegerLength length_length);
// Parses the unencrypted fields in a QUIC header using |reader| as input,
// stores the result in the other parameters.
@@ -440,7 +440,7 @@
QuicConnectionId* destination_connection_id,
QuicConnectionId* source_connection_id,
QuicLongHeaderType* long_packet_type,
- QuicVariableLengthIntegerLength* retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength* retry_token_length_length,
absl::string_view* retry_token, std::string* detailed_error);
// Parses the unencrypted fields in |packet| and stores them in the other
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index 9b022a2..08b53f8 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -763,7 +763,8 @@
return CheckDecryption(
encrypted, includes_version, includes_diversification_nonce,
destination_connection_id_length, source_connection_id_length,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
}
bool CheckDecryption(
@@ -771,9 +772,9 @@
bool includes_diversification_nonce,
QuicConnectionIdLength destination_connection_id_length,
QuicConnectionIdLength source_connection_id_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
size_t retry_token_length,
- QuicVariableLengthIntegerLength length_length) {
+ quiche::QuicheVariableLengthIntegerLength length_length) {
if (visitor_.header_->packet_number != decrypter_->packet_number_) {
QUIC_LOG(ERROR) << "Decrypted incorrect packet number. expected "
<< visitor_.header_->packet_number
@@ -1081,7 +1082,8 @@
framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
memset(p + header_size, 0, kMaxIncomingPacketSize - header_size);
@@ -1395,8 +1397,8 @@
QuicConnectionId destination_connection_id = EmptyQuicConnectionId(),
source_connection_id = EmptyQuicConnectionId();
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
- QuicVariableLengthIntegerLength retry_token_length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_4;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_4;
absl::string_view retry_token;
std::string detailed_error = "foobar";
@@ -1418,7 +1420,8 @@
EXPECT_EQ(framer_.version(), parsed_version);
EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
- EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
+ EXPECT_EQ(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ retry_token_length_length);
EXPECT_EQ(absl::string_view(), retry_token);
if (framer_.version().HasIetfInvariantHeader()) {
EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
@@ -1464,8 +1467,8 @@
QuicConnectionId destination_connection_id = EmptyQuicConnectionId(),
source_connection_id = EmptyQuicConnectionId();
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
- QuicVariableLengthIntegerLength retry_token_length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_4;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_4;
absl::string_view retry_token;
std::string detailed_error = "foobar";
@@ -1485,7 +1488,8 @@
EXPECT_EQ(UnsupportedQuicVersion(), parsed_version);
EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
- EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
+ EXPECT_EQ(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ retry_token_length_length);
EXPECT_EQ(absl::string_view(), retry_token);
EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
}
@@ -2964,13 +2968,13 @@
};
// clang-format on
- QuicVariableLengthIntegerLength retry_token_length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
size_t retry_token_length = 0;
- QuicVariableLengthIntegerLength length_length =
+ quiche::QuicheVariableLengthIntegerLength length_length =
QuicVersionHasLongHeaderLengths(framer_.transport_version())
- ? VARIABLE_LENGTH_INTEGER_LENGTH_1
- : VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ ? quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1
+ : quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
ReviseFirstByteByVersion(packet_ietf);
PacketFragments& fragments =
@@ -6551,7 +6555,8 @@
framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6740,7 +6745,8 @@
framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6815,7 +6821,8 @@
framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6890,7 +6897,8 @@
framer_.transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6910,7 +6918,7 @@
header.version_flag = false;
header.packet_number = kPacketNumber;
if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
@@ -7009,7 +7017,7 @@
}
header.packet_number = kPacketNumber;
if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
@@ -10422,11 +10430,12 @@
p = packet46;
}
- std::unique_ptr<QuicPacket> raw(new QuicPacket(
- AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
- PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
- !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0));
+ std::unique_ptr<QuicPacket> raw(
+ new QuicPacket(AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
+ PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
+ !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
@@ -10442,8 +10451,8 @@
PACKET_0BYTE_CONNECTION_ID,
/*includes_version=*/true,
/*includes_diversification_nonce=*/true, PACKET_1BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0,
- /*retry_token_length=*/0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ /*retry_token_length=*/0, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = 1;
EXPECT_QUIC_BUG(
@@ -10530,11 +10539,12 @@
p_size = ABSL_ARRAYSIZE(packet46);
}
- std::unique_ptr<QuicPacket> raw(new QuicPacket(
- AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
- PACKET_0BYTE_CONNECTION_ID, kIncludeVersion,
- !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0));
+ std::unique_ptr<QuicPacket> raw(
+ new QuicPacket(AsChars(p), p_size, false, PACKET_8BYTE_CONNECTION_ID,
+ PACKET_0BYTE_CONNECTION_ID, kIncludeVersion,
+ !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0));
char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
@@ -14741,8 +14751,8 @@
header.packet_number = kPacketNumber;
header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
header.long_packet_type = INITIAL;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
QuicFrames frames = {QuicFrame(QuicPingFrame()),
QuicFrame(QuicPaddingFrame(3))};
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index 6d39ae3..3be9c40 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -384,8 +384,9 @@
QuicConnectionIdLength source_connection_id_length, bool include_version,
bool include_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
- QuicVariableLengthIntegerLength length_length, QuicStreamOffset offset) {
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength length_length,
+ QuicStreamOffset offset) {
return GetPacketHeaderSize(version, destination_connection_id_length,
source_connection_id_length, include_version,
include_diversification_nonce,
@@ -1243,14 +1244,14 @@
GetRetryTokenLengthLength(), GetRetryToken().length(), GetLengthLength());
}
-QuicVariableLengthIntegerLength QuicPacketCreator::GetRetryTokenLengthLength()
- const {
+quiche::QuicheVariableLengthIntegerLength
+QuicPacketCreator::GetRetryTokenLengthLength() const {
if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
HasIetfLongHeader() &&
EncryptionlevelToLongHeaderType(packet_.encryption_level) == INITIAL) {
return QuicDataWriter::GetVarInt62Len(GetRetryToken().length());
}
- return VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ return quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
}
absl::string_view QuicPacketCreator::GetRetryToken() const {
@@ -1629,17 +1630,18 @@
return MESSAGE_STATUS_SUCCESS;
}
-QuicVariableLengthIntegerLength QuicPacketCreator::GetLengthLength() const {
+quiche::QuicheVariableLengthIntegerLength QuicPacketCreator::GetLengthLength()
+ const {
if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
HasIetfLongHeader()) {
QuicLongHeaderType long_header_type =
EncryptionlevelToLongHeaderType(packet_.encryption_level);
if (long_header_type == INITIAL || long_header_type == ZERO_RTT_PROTECTED ||
long_header_type == HANDSHAKE) {
- return VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ return quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
}
- return VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ return quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
}
void QuicPacketCreator::FillPacketHeader(QuicPacketHeader* header) {
@@ -1979,7 +1981,7 @@
GetSourceConnectionIdLength(), IncludeVersionInHeader(),
IncludeNonceInPublicHeader(), GetPacketNumberLength(),
// No Retry token on packets containing application data.
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, GetLengthLength());
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, GetLengthLength());
// This is the largest possible message payload when the length field is
// omitted.
size_t max_plaintext_size =
@@ -2003,13 +2005,13 @@
framer_->version().handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
framer_->perspective() == Perspective::IS_SERVER;
// IETF QUIC long headers include a length on client 0RTT packets.
- QuicVariableLengthIntegerLength length_length =
- VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ quiche::QuicheVariableLengthIntegerLength length_length =
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
if (framer_->perspective() == Perspective::IS_CLIENT) {
- length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
if (!QuicVersionHasLongHeaderLengths(framer_->transport_version())) {
- length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
+ length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
}
const size_t packet_header_size = GetPacketHeaderSize(
framer_->transport_version(), GetDestinationConnectionIdLength(),
@@ -2017,7 +2019,7 @@
GetSourceConnectionIdLength(), kIncludeVersion, may_include_nonce,
PACKET_4BYTE_PACKET_NUMBER,
// No Retry token on packets containing application data.
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, length_length);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, length_length);
// This is the largest possible message payload when the length field is
// omitted.
size_t max_plaintext_size =
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index c2c7e2c..c6b41ad 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -146,8 +146,9 @@
QuicConnectionIdLength source_connection_id_length, bool include_version,
bool include_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
- QuicVariableLengthIntegerLength length_length, QuicStreamOffset offset);
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength length_length,
+ QuicStreamOffset offset);
// Returns false and flushes all pending frames if current open packet is
// full.
@@ -578,7 +579,7 @@
// Returns length of the retry token variable length integer to send over the
// wire. Is non-zero for v99 IETF Initial packets.
- QuicVariableLengthIntegerLength GetRetryTokenLengthLength() const;
+ quiche::QuicheVariableLengthIntegerLength GetRetryTokenLengthLength() const;
// Returns the retry token to send over the wire, only sent in
// v99 IETF Initial packets.
@@ -586,7 +587,7 @@
// Returns length of the length variable length integer to send over the
// wire. Is non-zero for v99 IETF Initial, 0-RTT or Handshake packets.
- QuicVariableLengthIntegerLength GetLengthLength() const;
+ quiche::QuicheVariableLengthIntegerLength GetLengthLength() const;
// Returns true if |frame| is a ClientHello.
bool StreamFrameIsClientHello(const QuicStreamFrame& frame) const;
diff --git a/quiche/quic/core/quic_packets.cc b/quiche/quic/core/quic_packets.cc
index 369a32a..f0b9ccd 100644
--- a/quiche/quic/core/quic_packets.cc
+++ b/quiche/quic/core/quic_packets.cc
@@ -105,9 +105,9 @@
QuicConnectionIdLength source_connection_id_length, bool include_version,
bool include_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length) {
+ quiche::QuicheVariableLengthIntegerLength length_length) {
if (VersionHasIetfInvariantHeader(version)) {
if (include_version) {
// Long header.
@@ -153,9 +153,9 @@
QuicConnectionIdLength source_connection_id_length, bool include_version,
bool include_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length) {
+ quiche::QuicheVariableLengthIntegerLength length_length) {
// Encryption starts before private flags.
return GetPacketHeaderSize(
version, destination_connection_id_length, source_connection_id_length,
@@ -177,9 +177,9 @@
form(GOOGLE_QUIC_PACKET),
long_packet_type(INITIAL),
possible_stateless_reset_token({}),
- retry_token_length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
+ retry_token_length_length(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0),
retry_token(absl::string_view()),
- length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
+ length_length(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0),
remaining_packet_length(0) {}
QuicPacketHeader::QuicPacketHeader(const QuicPacketHeader& other) = default;
@@ -239,14 +239,15 @@
os << ", long_packet_type: "
<< QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
}
- if (header.retry_token_length_length != VARIABLE_LENGTH_INTEGER_LENGTH_0) {
+ if (header.retry_token_length_length !=
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0) {
os << ", retry_token_length_length: "
<< static_cast<int>(header.retry_token_length_length);
}
if (header.retry_token.length() != 0) {
os << ", retry_token_length: " << header.retry_token.length();
}
- if (header.length_length != VARIABLE_LENGTH_INTEGER_LENGTH_0) {
+ if (header.length_length != quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0) {
os << ", length_length: " << static_cast<int>(header.length_length);
}
if (header.remaining_packet_length != 0) {
@@ -285,9 +286,9 @@
QuicConnectionIdLength source_connection_id_length, bool includes_version,
bool includes_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length)
+ quiche::QuicheVariableLengthIntegerLength length_length)
: QuicData(buffer, length, owns_buffer),
buffer_(buffer),
destination_connection_id_length_(destination_connection_id_length),
diff --git a/quiche/quic/core/quic_packets.h b/quiche/quic/core/quic_packets.h
index d4f04c8..c0cc8af 100644
--- a/quiche/quic/core/quic_packets.h
+++ b/quiche/quic/core/quic_packets.h
@@ -82,15 +82,15 @@
QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicTransportVersion version,
const QuicPacketHeader& header);
-QUIC_EXPORT_PRIVATE size_t
-GetPacketHeaderSize(QuicTransportVersion version,
- QuicConnectionIdLength destination_connection_id_length,
- QuicConnectionIdLength source_connection_id_length,
- bool include_version, bool include_diversification_nonce,
- QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
- QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length);
+QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(
+ QuicTransportVersion version,
+ QuicConnectionIdLength destination_connection_id_length,
+ QuicConnectionIdLength source_connection_id_length, bool include_version,
+ bool include_diversification_nonce,
+ QuicPacketNumberLength packet_number_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
+ QuicByteCount retry_token_length,
+ quiche::QuicheVariableLengthIntegerLength length_length);
// Index of the first byte in a QUIC packet of encrypted data.
QUIC_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
@@ -102,9 +102,9 @@
QuicConnectionIdLength source_connection_id_length, bool include_version,
bool include_diversification_nonce,
QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length);
+ quiche::QuicheVariableLengthIntegerLength length_length);
struct QUIC_EXPORT_PRIVATE QuicPacketHeader {
QuicPacketHeader();
@@ -147,12 +147,12 @@
StatelessResetToken possible_stateless_reset_token;
// Length of the retry token length variable length integer field,
// carried only by v99 IETF Initial packets.
- QuicVariableLengthIntegerLength retry_token_length_length;
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length;
// Retry token, carried only by v99 IETF Initial packets.
absl::string_view retry_token;
// Length of the length variable length integer field,
// carried only by v99 IETF Initial, 0-RTT and Handshake packets.
- QuicVariableLengthIntegerLength length_length;
+ quiche::QuicheVariableLengthIntegerLength length_length;
// Length of the packet number and payload, carried only by v99 IETF Initial,
// 0-RTT and Handshake packets. Also includes the length of the
// diversification nonce in server to client 0-RTT packets.
@@ -222,14 +222,15 @@
class QUIC_EXPORT_PRIVATE QuicPacket : public QuicData {
public:
- QuicPacket(char* buffer, size_t length, bool owns_buffer,
- QuicConnectionIdLength destination_connection_id_length,
- QuicConnectionIdLength source_connection_id_length,
- bool includes_version, bool includes_diversification_nonce,
- QuicPacketNumberLength packet_number_length,
- QuicVariableLengthIntegerLength retry_token_length_length,
- QuicByteCount retry_token_length,
- QuicVariableLengthIntegerLength length_length);
+ QuicPacket(
+ char* buffer, size_t length, bool owns_buffer,
+ QuicConnectionIdLength destination_connection_id_length,
+ QuicConnectionIdLength source_connection_id_length, bool includes_version,
+ bool includes_diversification_nonce,
+ QuicPacketNumberLength packet_number_length,
+ quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
+ QuicByteCount retry_token_length,
+ quiche::QuicheVariableLengthIntegerLength length_length);
QuicPacket(QuicTransportVersion version, char* buffer, size_t length,
bool owns_buffer, const QuicPacketHeader& header);
QuicPacket(const QuicPacket&) = delete;
@@ -247,9 +248,9 @@
const bool includes_version_;
const bool includes_diversification_nonce_;
const QuicPacketNumberLength packet_number_length_;
- const QuicVariableLengthIntegerLength retry_token_length_length_;
+ const quiche::QuicheVariableLengthIntegerLength retry_token_length_length_;
const QuicByteCount retry_token_length_;
- const QuicVariableLengthIntegerLength length_length_;
+ const quiche::QuicheVariableLengthIntegerLength length_length_;
};
class QUIC_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index 51b25a5..1bec69f 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -346,8 +346,8 @@
connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
connection_->SetMaxPacketLength(length);
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
@@ -431,8 +431,8 @@
connection_->transport_version(), PACKET_8BYTE_CONNECTION_ID,
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
- VARIABLE_LENGTH_INTEGER_LENGTH_0,
- VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
+ quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
connection_->SetMaxPacketLength(length);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
diff --git a/quiche/quic/core/quic_types.h b/quiche/quic/core/quic_types.h
index b0992c8..ffaf6c6 100644
--- a/quiche/quic/core/quic_types.h
+++ b/quiche/quic/core/quic_types.h
@@ -21,6 +21,7 @@
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/quic/platform/api/quic_flags.h"
+#include "quiche/common/quiche_endian.h"
namespace quic {
@@ -353,20 +354,6 @@
#define IETF_STREAM_FRAME_LEN_BIT 0x02
#define IETF_STREAM_FRAME_OFF_BIT 0x04
-enum QuicVariableLengthIntegerLength : uint8_t {
- // Length zero means the variable length integer is not present.
- VARIABLE_LENGTH_INTEGER_LENGTH_0 = 0,
- VARIABLE_LENGTH_INTEGER_LENGTH_1 = 1,
- VARIABLE_LENGTH_INTEGER_LENGTH_2 = 2,
- VARIABLE_LENGTH_INTEGER_LENGTH_4 = 4,
- VARIABLE_LENGTH_INTEGER_LENGTH_8 = 8,
-
- // By default we write the IETF long header length using the 2-byte encoding
- // of variable length integers, even when the length is below 64, which allows
- // us to fill in the length before knowing what the length actually is.
- kQuicDefaultLongHeaderLengthLength = VARIABLE_LENGTH_INTEGER_LENGTH_2,
-};
-
enum QuicPacketNumberLength : uint8_t {
PACKET_1BYTE_PACKET_NUMBER = 1,
PACKET_2BYTE_PACKET_NUMBER = 2,
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.cc b/quiche/quic/test_tools/quic_packet_creator_peer.cc
index 507de25..2ab9fb0 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.cc
@@ -45,14 +45,14 @@
}
// static
-QuicVariableLengthIntegerLength
+quiche::QuicheVariableLengthIntegerLength
QuicPacketCreatorPeer::GetRetryTokenLengthLength(QuicPacketCreator* creator) {
return creator->GetRetryTokenLengthLength();
}
// static
-QuicVariableLengthIntegerLength QuicPacketCreatorPeer::GetLengthLength(
- QuicPacketCreator* creator) {
+quiche::QuicheVariableLengthIntegerLength
+QuicPacketCreatorPeer::GetLengthLength(QuicPacketCreator* creator) {
return creator->GetLengthLength();
}
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.h b/quiche/quic/test_tools/quic_packet_creator_peer.h
index 0c9ce77..4607bcd 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.h
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.h
@@ -26,9 +26,9 @@
QuicPacketCreator* creator, QuicPacketNumberLength packet_number_length);
static QuicPacketNumberLength GetPacketNumberLength(
QuicPacketCreator* creator);
- static QuicVariableLengthIntegerLength GetRetryTokenLengthLength(
+ static quiche::QuicheVariableLengthIntegerLength GetRetryTokenLengthLength(
QuicPacketCreator* creator);
- static QuicVariableLengthIntegerLength GetLengthLength(
+ static quiche::QuicheVariableLengthIntegerLength GetLengthLength(
QuicPacketCreator* creator);
static void SetPacketNumber(QuicPacketCreator* creator, uint64_t s);
static void SetPacketNumber(QuicPacketCreator* creator, QuicPacketNumber num);
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
index cfb947a..03948b7 100644
--- a/quiche/quic/test_tools/quic_test_utils.cc
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -908,8 +908,8 @@
ParsedQuicVersion version = (*versions)[0];
if (QuicVersionHasLongHeaderLengths(version.transport_version) &&
version_flag) {
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrames frames;
@@ -973,8 +973,8 @@
header.packet_number = QuicPacketNumber(33);
header.long_packet_type = ZERO_RTT_PROTECTED;
if (version.HasLongHeaderLengths()) {
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrames frames;
@@ -1027,8 +1027,8 @@
header.packet_number = QuicPacketNumber(packet_number);
if (QuicVersionHasLongHeaderLengths(version.transport_version) &&
version_flag) {
- header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
- header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
+ header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+ header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
}
QuicFrame frame(QuicStreamFrame(1, false, 0, absl::string_view(data)));
QuicFrames frames;
