Introduce MASQUE, part 1: shared code
This CL introduces the shared code for MASQUE as defined by <https://tools.ietf.org/html/draft-schinazi-masque>. Most of the work here is plumbing in order to override the right methods of the QUIC codebase. The meat of the MASQUE protocol work is in masque_compression_engine.cc.
gfe-relnote: n/a, adds unused code
PiperOrigin-RevId: 285439559
Change-Id: I2739a002a723d5ba783034fb78959f02f3d89365
diff --git a/quic/masque/README.md b/quic/masque/README.md
new file mode 100644
index 0000000..6bfc08e
--- /dev/null
+++ b/quic/masque/README.md
@@ -0,0 +1,4 @@
+# MASQUE
+
+The files in this directory implement MASQUE as described in
+<https://tools.ietf.org/html/draft-schinazi-masque>.
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
new file mode 100644
index 0000000..fc8957b
--- /dev/null
+++ b/quic/masque/masque_compression_engine.cc
@@ -0,0 +1,540 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/masque/masque_compression_engine.h"
+
+#include <cstdint>
+
+#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
+#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
+#include "net/third_party/quiche/src/quic/core/quic_framer.h"
+#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+
+namespace quic {
+
+namespace {
+// |kFlowId0| is used to indicate creation of a new compression context.
+const QuicDatagramFlowId kFlowId0 = 0;
+
+enum MasqueAddressFamily : uint8_t {
+ MasqueAddressFamilyIPv4 = 4,
+ MasqueAddressFamilyIPv6 = 6,
+};
+
+} // namespace
+
+MasqueCompressionEngine::MasqueCompressionEngine(QuicSession* masque_session)
+ : masque_session_(masque_session) {
+ if (masque_session_->perspective() == Perspective::IS_SERVER) {
+ next_flow_id_ = 1;
+ } else {
+ next_flow_id_ = 2;
+ }
+}
+
+QuicDatagramFlowId MasqueCompressionEngine::FindOrCreateCompressionContext(
+ QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address,
+ bool client_connection_id_present,
+ bool server_connection_id_present,
+ bool* validated) {
+ QuicDatagramFlowId flow_id = kFlowId0;
+ *validated = false;
+ for (const auto& kv : contexts_) {
+ const MasqueCompressionContext& context = kv.second;
+ if (context.server_address != server_address) {
+ continue;
+ }
+ if (client_connection_id_present &&
+ context.client_connection_id != client_connection_id) {
+ continue;
+ }
+ if (server_connection_id_present &&
+ context.server_connection_id != server_connection_id) {
+ continue;
+ }
+
+ flow_id = kv.first;
+ DCHECK_NE(flow_id, kFlowId0);
+ *validated = context.validated;
+ QUIC_DVLOG(1) << "Compressing using " << (*validated ? "" : "un")
+ << "validated flow_id " << flow_id << " to "
+ << context.server_address << " client "
+ << context.client_connection_id << " server "
+ << context.server_connection_id;
+ break;
+ }
+
+ if (flow_id != kFlowId0) {
+ // Found a compression context, use it.
+ return flow_id;
+ }
+
+ // Create new compression context.
+ flow_id = GetNextFlowId();
+ QUIC_DVLOG(1) << "Compression assigning new flow_id " << flow_id << " to "
+ << server_address << " client " << client_connection_id
+ << " server " << server_connection_id;
+ MasqueCompressionContext context;
+ context.client_connection_id = client_connection_id;
+ context.server_connection_id = server_connection_id;
+ context.server_address = server_address;
+ contexts_[flow_id] = context;
+
+ return flow_id;
+}
+
+bool MasqueCompressionEngine::WriteCompressedPacketToSlice(
+ QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address,
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ QuicDatagramFlowId flow_id,
+ bool validated,
+ uint8_t first_byte,
+ bool long_header,
+ QuicDataReader* reader,
+ QuicMemSlice* slice) {
+ QuicDataWriter writer(slice->length(), const_cast<char*>(slice->data()));
+ if (validated) {
+ QUIC_DVLOG(1) << "Compressing using validated flow_id " << flow_id;
+ if (!writer.WriteVarInt62(flow_id)) {
+ QUIC_BUG << "Failed to write flow_id";
+ return false;
+ }
+ } else {
+ QUIC_DVLOG(1) << "Compressing using unvalidated flow_id " << flow_id;
+ if (!writer.WriteVarInt62(kFlowId0)) {
+ QUIC_BUG << "Failed to write kFlowId0";
+ return false;
+ }
+ if (!writer.WriteVarInt62(flow_id)) {
+ QUIC_BUG << "Failed to write flow_id";
+ return false;
+ }
+ if (!writer.WriteLengthPrefixedConnectionId(client_connection_id)) {
+ QUIC_BUG << "Failed to write client_connection_id";
+ return false;
+ }
+ if (!writer.WriteLengthPrefixedConnectionId(server_connection_id)) {
+ QUIC_BUG << "Failed to write server_connection_id";
+ return false;
+ }
+ if (!writer.WriteUInt16(server_address.port())) {
+ QUIC_BUG << "Failed to write port";
+ return false;
+ }
+ QuicIpAddress peer_ip = server_address.host();
+ DCHECK(peer_ip.IsInitialized());
+ std::string peer_ip_bytes = peer_ip.ToPackedString();
+ DCHECK(!peer_ip_bytes.empty());
+ uint8_t address_id;
+ if (peer_ip.address_family() == IpAddressFamily::IP_V6) {
+ address_id = MasqueAddressFamilyIPv6;
+ if (peer_ip_bytes.length() != QuicIpAddress::kIPv6AddressSize) {
+ QUIC_BUG << "Bad IPv6 length " << server_address;
+ return false;
+ }
+ } else if (peer_ip.address_family() == IpAddressFamily::IP_V4) {
+ address_id = MasqueAddressFamilyIPv4;
+ if (peer_ip_bytes.length() != QuicIpAddress::kIPv4AddressSize) {
+ QUIC_BUG << "Bad IPv4 length " << server_address;
+ return false;
+ }
+ } else {
+ QUIC_BUG << "Unexpected server_address " << server_address;
+ return false;
+ }
+ if (!writer.WriteUInt8(address_id)) {
+ QUIC_BUG << "Failed to write address_id";
+ return false;
+ }
+ if (!writer.WriteStringPiece(peer_ip_bytes)) {
+ QUIC_BUG << "Failed to write IP address";
+ return false;
+ }
+ }
+ if (!writer.WriteUInt8(first_byte)) {
+ QUIC_BUG << "Failed to write first_byte";
+ return false;
+ }
+ if (long_header) {
+ QuicVersionLabel version_label;
+ if (!reader->ReadUInt32(&version_label)) {
+ QUIC_DLOG(ERROR) << "Failed to read version";
+ return false;
+ }
+ if (!writer.WriteUInt32(version_label)) {
+ QUIC_BUG << "Failed to write version";
+ return false;
+ }
+ QuicConnectionId packet_destination_connection_id,
+ packet_source_connection_id;
+ if (!reader->ReadLengthPrefixedConnectionId(
+ &packet_destination_connection_id) ||
+ !reader->ReadLengthPrefixedConnectionId(&packet_source_connection_id)) {
+ QUIC_DLOG(ERROR) << "Failed to parse long header connection IDs";
+ return false;
+ }
+ if (packet_destination_connection_id != destination_connection_id) {
+ QUIC_DLOG(ERROR) << "Long header packet's destination_connection_id "
+ << packet_destination_connection_id
+ << " does not match expected "
+ << destination_connection_id;
+ return false;
+ }
+ if (packet_source_connection_id != source_connection_id) {
+ QUIC_DLOG(ERROR) << "Long header packet's source_connection_id "
+ << packet_source_connection_id
+ << " does not match expected " << source_connection_id;
+ return false;
+ }
+ } else {
+ QuicConnectionId packet_destination_connection_id;
+ if (!reader->ReadConnectionId(&packet_destination_connection_id,
+ destination_connection_id.length())) {
+ QUIC_DLOG(ERROR)
+ << "Failed to read short header packet's destination_connection_id";
+ return false;
+ }
+ if (packet_destination_connection_id != destination_connection_id) {
+ QUIC_DLOG(ERROR) << "Short header packet's destination_connection_id "
+ << packet_destination_connection_id
+ << " does not match expected "
+ << destination_connection_id;
+ return false;
+ }
+ }
+ QuicStringPiece packet_payload = reader->ReadRemainingPayload();
+ if (!writer.WriteStringPiece(packet_payload)) {
+ QUIC_BUG << "Failed to write packet_payload";
+ return false;
+ }
+ return true;
+}
+
+void MasqueCompressionEngine::CompressAndSendPacket(
+ QuicStringPiece packet,
+ QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address) {
+ QUIC_DVLOG(2) << "Compressing client " << client_connection_id << " server "
+ << server_connection_id << "\n"
+ << QuicTextUtils::HexDump(packet);
+ DCHECK(server_address.IsInitialized());
+ if (packet.empty()) {
+ QUIC_BUG << "Tried to send empty packet";
+ return;
+ }
+ QuicDataReader reader(packet.data(), packet.length());
+ uint8_t first_byte;
+ if (!reader.ReadUInt8(&first_byte)) {
+ QUIC_BUG << "Failed to read first_byte";
+ return;
+ }
+ const bool long_header = (first_byte & FLAGS_LONG_HEADER) != 0;
+ bool client_connection_id_present = true, server_connection_id_present = true;
+ QuicConnectionId destination_connection_id, source_connection_id;
+ if (masque_session_->perspective() == Perspective::IS_SERVER) {
+ destination_connection_id = client_connection_id;
+ source_connection_id = server_connection_id;
+ if (!long_header) {
+ server_connection_id_present = false;
+ }
+ } else {
+ destination_connection_id = server_connection_id;
+ source_connection_id = client_connection_id;
+ if (!long_header) {
+ client_connection_id_present = false;
+ }
+ }
+
+ bool validated = false;
+ QuicDatagramFlowId flow_id = FindOrCreateCompressionContext(
+ client_connection_id, server_connection_id, server_address,
+ client_connection_id_present, server_connection_id_present, &validated);
+
+ size_t slice_length = packet.length() - destination_connection_id.length();
+ if (long_header) {
+ slice_length -= sizeof(uint8_t) * 2 + source_connection_id.length();
+ }
+ if (validated) {
+ slice_length += QuicDataWriter::GetVarInt62Len(flow_id);
+ } else {
+ slice_length += QuicDataWriter::GetVarInt62Len(kFlowId0) +
+ QuicDataWriter::GetVarInt62Len(flow_id) + sizeof(uint8_t) +
+ client_connection_id.length() + sizeof(uint8_t) +
+ server_connection_id.length() +
+ sizeof(server_address.port()) + sizeof(uint8_t) +
+ server_address.host().ToPackedString().length();
+ }
+ QuicMemSlice slice(
+ masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
+ slice_length);
+
+ if (!WriteCompressedPacketToSlice(client_connection_id, server_connection_id,
+ server_address, destination_connection_id,
+ source_connection_id, flow_id, validated,
+ first_byte, long_header, &reader, &slice)) {
+ return;
+ }
+
+ MessageResult message_result =
+ masque_session_->SendMessage(QuicMemSliceSpan(&slice));
+
+ QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
+ << " and got message result " << message_result;
+}
+
+bool MasqueCompressionEngine::ParseCompressionContext(
+ QuicDataReader* reader,
+ MasqueCompressionContext* context) {
+ QuicDatagramFlowId new_flow_id;
+ if (!reader->ReadVarInt62(&new_flow_id)) {
+ QUIC_DLOG(ERROR) << "Could not read new_flow_id";
+ return false;
+ }
+ QuicConnectionId new_client_connection_id;
+ if (!reader->ReadLengthPrefixedConnectionId(&new_client_connection_id)) {
+ QUIC_DLOG(ERROR) << "Could not read new_client_connection_id";
+ return false;
+ }
+ QuicConnectionId new_server_connection_id;
+ if (!reader->ReadLengthPrefixedConnectionId(&new_server_connection_id)) {
+ QUIC_DLOG(ERROR) << "Could not read new_server_connection_id";
+ return false;
+ }
+ uint16_t port;
+ if (!reader->ReadUInt16(&port)) {
+ QUIC_DLOG(ERROR) << "Could not read port";
+ return false;
+ }
+ uint8_t address_id;
+ if (!reader->ReadUInt8(&address_id)) {
+ QUIC_DLOG(ERROR) << "Could not read address_id";
+ return false;
+ }
+ size_t ip_bytes_length;
+ if (address_id == MasqueAddressFamilyIPv6) {
+ ip_bytes_length = QuicIpAddress::kIPv6AddressSize;
+ } else if (address_id == MasqueAddressFamilyIPv4) {
+ ip_bytes_length = QuicIpAddress::kIPv4AddressSize;
+ } else {
+ QUIC_DLOG(ERROR) << "Unknown address_id " << static_cast<int>(address_id);
+ return false;
+ }
+ char ip_bytes[QuicIpAddress::kMaxAddressSize];
+ if (!reader->ReadBytes(ip_bytes, ip_bytes_length)) {
+ QUIC_DLOG(ERROR) << "Could not read IP address";
+ return false;
+ }
+ QuicIpAddress ip_address;
+ ip_address.FromPackedString(ip_bytes, ip_bytes_length);
+ if (!ip_address.IsInitialized()) {
+ QUIC_BUG << "Failed to parse IP address";
+ return false;
+ }
+ QuicSocketAddress new_server_address = QuicSocketAddress(ip_address, port);
+ auto context_pair = contexts_.find(new_flow_id);
+ if (context_pair == contexts_.end()) {
+ context->client_connection_id = new_client_connection_id;
+ context->server_connection_id = new_server_connection_id;
+ context->server_address = new_server_address;
+ context->validated = true;
+ contexts_[new_flow_id] = *context;
+ QUIC_DVLOG(1) << "Registered new flow_id " << new_flow_id << " to "
+ << new_server_address << " client "
+ << new_client_connection_id << " server "
+ << new_server_connection_id;
+ } else {
+ *context = context_pair->second;
+ if (context->client_connection_id != new_client_connection_id) {
+ QUIC_LOG(ERROR)
+ << "Received incorrect context registration for existing flow_id "
+ << new_flow_id << " mismatched client "
+ << context->client_connection_id << " " << new_client_connection_id;
+ return false;
+ }
+ if (context->server_connection_id != new_server_connection_id) {
+ QUIC_LOG(ERROR)
+ << "Received incorrect context registration for existing flow_id "
+ << new_flow_id << " mismatched server "
+ << context->server_connection_id << " " << new_server_connection_id;
+ return false;
+ }
+ if (context->server_address != new_server_address) {
+ QUIC_LOG(ERROR)
+ << "Received incorrect context registration for existing flow_id "
+ << new_flow_id << " mismatched server " << context->server_address
+ << " " << new_server_address;
+ return false;
+ }
+ if (!context->validated) {
+ context->validated = true;
+ contexts_[new_flow_id] = *context;
+ QUIC_DLOG(INFO) << "Successfully validated remotely-unvalidated flow_id "
+ << new_flow_id << " to " << new_server_address
+ << " client " << new_client_connection_id << " server "
+ << new_server_connection_id;
+ } else {
+ QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
+ "remotely-unvalidated flow_id "
+ << new_flow_id << " to " << new_server_address << " client "
+ << new_client_connection_id << " server "
+ << new_server_connection_id;
+ }
+ }
+ return true;
+}
+
+bool MasqueCompressionEngine::WriteDecompressedPacket(
+ QuicDataReader* reader,
+ const MasqueCompressionContext& context,
+ std::string* packet,
+ bool* version_present) {
+ QuicConnectionId destination_connection_id, source_connection_id;
+ if (masque_session_->perspective() == Perspective::IS_SERVER) {
+ destination_connection_id = context.server_connection_id;
+ source_connection_id = context.client_connection_id;
+ } else {
+ destination_connection_id = context.client_connection_id;
+ source_connection_id = context.server_connection_id;
+ }
+
+ size_t packet_length =
+ reader->BytesRemaining() + destination_connection_id.length();
+ uint8_t first_byte;
+ if (!reader->ReadUInt8(&first_byte)) {
+ QUIC_DLOG(ERROR) << "Failed to read first_byte";
+ return false;
+ }
+ *version_present = (first_byte & FLAGS_LONG_HEADER) != 0;
+ if (*version_present) {
+ packet_length += sizeof(uint8_t) * 2 + source_connection_id.length();
+ }
+ *packet = std::string(packet_length, 0);
+ QuicDataWriter writer(packet->length(), packet->data());
+ if (!writer.WriteUInt8(first_byte)) {
+ QUIC_BUG << "Failed to write first_byte";
+ return false;
+ }
+ if (*version_present) {
+ QuicVersionLabel version_label;
+ if (!reader->ReadUInt32(&version_label)) {
+ QUIC_DLOG(ERROR) << "Failed to read version";
+ return false;
+ }
+ if (!writer.WriteUInt32(version_label)) {
+ QUIC_BUG << "Failed to write version";
+ return false;
+ }
+ if (!writer.WriteLengthPrefixedConnectionId(destination_connection_id)) {
+ QUIC_BUG << "Failed to write long header destination_connection_id";
+ return false;
+ }
+ if (!writer.WriteLengthPrefixedConnectionId(source_connection_id)) {
+ QUIC_BUG << "Failed to write long header source_connection_id";
+ return false;
+ }
+ } else {
+ if (!writer.WriteConnectionId(destination_connection_id)) {
+ QUIC_BUG << "Failed to write short header destination_connection_id";
+ return false;
+ }
+ }
+ QuicStringPiece payload = reader->ReadRemainingPayload();
+ if (!writer.WriteStringPiece(payload)) {
+ QUIC_BUG << "Failed to write payload";
+ return false;
+ }
+ return true;
+}
+
+bool MasqueCompressionEngine::DecompressDatagram(
+ QuicStringPiece datagram,
+ QuicConnectionId* client_connection_id,
+ QuicConnectionId* server_connection_id,
+ QuicSocketAddress* server_address,
+ std::string* packet,
+ bool* version_present) {
+ QUIC_DVLOG(1) << "Decompressing DATAGRAM frame of length "
+ << datagram.length();
+ QuicDataReader reader(datagram);
+ QuicDatagramFlowId flow_id;
+ if (!reader.ReadVarInt62(&flow_id)) {
+ QUIC_DLOG(ERROR) << "Could not read flow_id";
+ return false;
+ }
+ MasqueCompressionContext context;
+ if (flow_id == kFlowId0) {
+ if (!ParseCompressionContext(&reader, &context)) {
+ return false;
+ }
+ } else {
+ auto context_pair = contexts_.find(flow_id);
+ if (context_pair == contexts_.end()) {
+ QUIC_DLOG(ERROR) << "Received unknown flow_id " << flow_id;
+ return false;
+ }
+ context = context_pair->second;
+
+ if (!context.validated) {
+ context.validated = true;
+ contexts_[flow_id] = context;
+ QUIC_DLOG(INFO) << "Successfully validated remotely-validated flow_id "
+ << flow_id << " to " << context.server_address
+ << " client " << context.client_connection_id
+ << " server " << context.server_connection_id;
+ } else {
+ QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
+ "remotely-validated flow_id "
+ << flow_id << " to " << context.server_address << " client "
+ << context.client_connection_id << " server "
+ << context.server_connection_id;
+ }
+ }
+
+ if (!WriteDecompressedPacket(&reader, context, packet, version_present)) {
+ return false;
+ }
+
+ *server_address = context.server_address;
+ *client_connection_id = context.client_connection_id;
+ *server_connection_id = context.server_connection_id;
+
+ QUIC_DVLOG(2) << "Decompressed client " << context.client_connection_id
+ << " server " << context.server_connection_id << "\n"
+ << QuicTextUtils::HexDump(*packet);
+
+ return true;
+}
+
+QuicDatagramFlowId MasqueCompressionEngine::GetNextFlowId() {
+ const QuicDatagramFlowId next_flow_id = next_flow_id_;
+ next_flow_id_ += 2;
+ return next_flow_id;
+}
+
+void MasqueCompressionEngine::UnregisterClientConnectionId(
+ QuicConnectionId client_connection_id) {
+ std::vector<QuicDatagramFlowId> flow_ids_to_remove;
+ for (const auto& kv : contexts_) {
+ const MasqueCompressionContext& context = kv.second;
+ if (context.client_connection_id == client_connection_id) {
+ flow_ids_to_remove.push_back(kv.first);
+ }
+ }
+ for (QuicDatagramFlowId flow_id : flow_ids_to_remove) {
+ contexts_.erase(flow_id);
+ }
+}
+
+} // namespace quic
diff --git a/quic/masque/masque_compression_engine.h b/quic/masque/masque_compression_engine.h
new file mode 100644
index 0000000..09c49a6
--- /dev/null
+++ b/quic/masque/masque_compression_engine.h
@@ -0,0 +1,126 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
+#define QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
+#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+
+namespace quic {
+
+// MASQUE compression engine used by client and servers.
+// This class allows converting QUIC packets into a compressed form suitable
+// for sending over QUIC DATAGRAM frames. It leverages a flow identifier at the
+// start of each datagram to indicate which compression context was used to
+// compress this packet, or to create new compression contexts.
+// Compression contexts contain client and server connection IDs and the
+// server's IP and port. This allows compressing that information in most
+// packets without requiring access to the cryptographic keys of the end-to-end
+// encapsulated session. When the flow identifier is 0, the DATAGRAM contains
+// all the contents of the compression context. When the flow identifier is
+// non-zero, those fields are removed so the encapsulated QUIC packet is
+// transmitted without connection IDs and reassembled by the peer on
+// decompression. This only needs to contain the HTTP server's IP address since
+// the client's IP address is not visible to the HTTP server.
+
+class QUIC_NO_EXPORT MasqueCompressionEngine {
+ public:
+ // Caller must ensure that |masque_session| has a lifetime longer than the
+ // newly constructed MasqueCompressionEngine.
+ explicit MasqueCompressionEngine(QuicSession* masque_session);
+
+ // Disallow copy and assign.
+ MasqueCompressionEngine(const MasqueCompressionEngine&) = delete;
+ MasqueCompressionEngine& operator=(const MasqueCompressionEngine&) = delete;
+
+ // Compresses packet and sends it in a DATAGRAM frame over a MASQUE session.
+ // When used from MASQUE client to MASQUE server, the MASQUE server will then
+ // send the packet to the provided |server_address|.
+ // When used from MASQUE server to MASQUE client, the MASQUE client will then
+ // hand off the uncompressed packet to an encapsulated session that will treat
+ // it as having come from the provided |server_address|.
+ // The connection IDs are the one used by the encapsulated |packet|.
+ void CompressAndSendPacket(QuicStringPiece packet,
+ QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address);
+
+ // Decompresses received DATAGRAM frame contents from |datagram| and places
+ // them in |packet|. Reverses the transformation from CompressAndSendPacket.
+ // The connection IDs are the one used by the encapsulated |packet|.
+ // |server_address| will be filled with the |server_address| passed to
+ // CompressAndSendPacket. |version_present| will contain whether the
+ // encapsulated |packet| contains a Version field.
+ bool DecompressDatagram(QuicStringPiece datagram,
+ QuicConnectionId* client_connection_id,
+ QuicConnectionId* server_connection_id,
+ QuicSocketAddress* server_address,
+ std::string* packet,
+ bool* version_present);
+
+ // Clears all entries referencing |client_connection_id| from the
+ // compression table.
+ void UnregisterClientConnectionId(QuicConnectionId client_connection_id);
+
+ private:
+ struct QUIC_NO_EXPORT MasqueCompressionContext {
+ QuicConnectionId client_connection_id;
+ QuicConnectionId server_connection_id;
+ QuicSocketAddress server_address;
+ bool validated = false;
+ };
+
+ // Generates a new datagram flow ID.
+ QuicDatagramFlowId GetNextFlowId();
+
+ // Finds or creates a new compression context to use during compression.
+ // |client_connection_id_present| and |server_connection_id_present| indicate
+ // whether the corresponding connection ID is present in the current packet.
+ // |validated| will contain whether the compression context that matches
+ // these arguments is currently validated or not.
+ QuicDatagramFlowId FindOrCreateCompressionContext(
+ QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address,
+ bool client_connection_id_present,
+ bool server_connection_id_present,
+ bool* validated);
+
+ // Writes compressed packet to |slice| during compression.
+ bool WriteCompressedPacketToSlice(QuicConnectionId client_connection_id,
+ QuicConnectionId server_connection_id,
+ const QuicSocketAddress& server_address,
+ QuicConnectionId destination_connection_id,
+ QuicConnectionId source_connection_id,
+ QuicDatagramFlowId flow_id,
+ bool validated,
+ uint8_t first_byte,
+ bool long_header,
+ QuicDataReader* reader,
+ QuicMemSlice* slice);
+
+ // Parses compression context from flow ID 0 during decompression.
+ bool ParseCompressionContext(QuicDataReader* reader,
+ MasqueCompressionContext* context);
+
+ // Writes decompressed packet to |packet| during decompression.
+ bool WriteDecompressedPacket(QuicDataReader* reader,
+ const MasqueCompressionContext& context,
+ std::string* packet,
+ bool* version_present);
+
+ QuicSession* masque_session_; // Unowned.
+ QuicUnorderedMap<QuicDatagramFlowId, MasqueCompressionContext> contexts_;
+ QuicDatagramFlowId next_flow_id_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
diff --git a/quic/masque/masque_utils.cc b/quic/masque/masque_utils.cc
new file mode 100644
index 0000000..6ef88ae
--- /dev/null
+++ b/quic/masque/masque_utils.cc
@@ -0,0 +1,22 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/masque/masque_utils.h"
+
+namespace quic {
+
+ParsedQuicVersionVector MasqueSupportedVersions() {
+ QuicVersionInitializeSupportForIetfDraft();
+ ParsedQuicVersion version(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+ QuicEnableVersion(version);
+ return {version};
+}
+
+QuicConfig MasqueEncapsulatedConfig() {
+ QuicConfig config;
+ config.SetMaxPacketSizeToSend(kMasqueMaxEncapsulatedPacketSize);
+ return config;
+}
+
+} // namespace quic
diff --git a/quic/masque/masque_utils.h b/quic/masque/masque_utils.h
new file mode 100644
index 0000000..d8f9d0f
--- /dev/null
+++ b/quic/masque/masque_utils.h
@@ -0,0 +1,25 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_MASQUE_MASQUE_UTILS_H_
+#define QUICHE_QUIC_MASQUE_MASQUE_UTILS_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_config.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+
+namespace quic {
+
+// List of QUIC versions that support MASQUE. Currently restricted to IETF QUIC.
+QUIC_NO_EXPORT ParsedQuicVersionVector MasqueSupportedVersions();
+
+// Default QuicConfig for use with MASQUE. Sets a custom max_packet_size.
+QUIC_NO_EXPORT QuicConfig MasqueEncapsulatedConfig();
+
+// Maximum packet size for encapsulated connections.
+const QuicByteCount kMasqueMaxEncapsulatedPacketSize = 1300;
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_MASQUE_MASQUE_UTILS_H_
