Add the client address to the Public Reset packet.

net/quic/quic_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
+#include "net/quic/crypto/crypto_framer.h"
+#include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
+#include "net/quic/quic_socket_address_coder.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::max;
 using std::min;
 using std::numeric_limits;
 using std::string;
 
 bool FLAGS_quic_allow_oversized_packets_for_test = false;
@@ skipping 400 matching lines @@
                                header.public_header.guid_length,
                                header.public_header.version_flag,
                                header.public_header.sequence_number_length),
       GetPacketEntropyHash(header), NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
-  size_t len = GetPublicResetPacketSize();
+
+  CryptoHandshakeMessage reset;
+  reset.set_tag(kPRST);
+  reset.SetValue(kRNON, packet.nonce_proof);
+  reset.SetValue(kRSEQ, packet.rejected_sequence_number);
+  if (!packet.client_address.address().empty()) {
+    // packet.client_address is non-empty.
+    QuicSocketAddressCoder address_coder(packet.client_address);
+    string serialized_address = address_coder.Encode();
+    if (serialized_address.empty()) {
+      return NULL;
+    }
+    reset.SetStringPiece(kCADR, serialized_address);
+  }
+  const QuicData& reset_serialized = reset.GetSerialized();
+
+  size_t len = kPublicFlagsSize + PACKET_8BYTE_GUID + reset_serialized.length();
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
-                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(packet.public_header.guid)) {
     return NULL;
   }
 
-  if (!writer.WriteUInt64(packet.nonce_proof)) {
-    return NULL;
-  }
-
-  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                  packet.rejected_sequence_number,
-                                  &writer)) {
+  if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 QuicEncryptedPacket* QuicFramer::BuildVersionNegotiationPacket(
     const QuicPacketPublicHeader& header,
     const QuicVersionVector& supported_versions) {
   DCHECK(header.version_flag);
   size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
-                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(header.guid)) {
     return NULL;
   }
 
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) {
@@ skipping 99 matching lines @@
     visitor_->OnFecData(fec_data);
   }
 
   visitor_->OnPacketComplete();
   return true;
 }
 
 bool QuicFramer::ProcessPublicResetPacket(
     const QuicPacketPublicHeader& public_header) {
   QuicPublicResetPacket packet(public_header);
-  if (!reader_->ReadUInt64(&packet.nonce_proof)) {
+
+  if (reader_->BytesRemaining() <=
+      kPublicResetNonceSize + PACKET_6BYTE_SEQUENCE_NUMBER) {
+    // An old-style public reset packet.
+    // TODO(wtc): remove this when we drop support for QUIC_VERSION_13.
+    if (!reader_->ReadUInt64(&packet.nonce_proof)) {
+      set_detailed_error("Unable to read nonce proof.");
+      return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
+    }
+
+    if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
+      set_detailed_error("Unable to read rejected sequence number.");
+      return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
+    }
+
+    visitor_->OnPublicResetPacket(packet);
+    return true;
+  }
+
+  scoped_ptr<CryptoHandshakeMessage> reset(
+      CryptoFramer::ParseMessage(reader_->ReadRemainingPayload()));
+  if (!reset.get()) {
+    set_detailed_error("Unable to read reset message.");
+    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
+  }
+  if (reset->tag() != kPRST) {
+    set_detailed_error("Incorrect message tag.");
+    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
+  }
+
+  if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) {
     set_detailed_error("Unable to read nonce proof.");
     return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
   // TODO(satyamshekhar): validate nonce to protect against DoS.
 
-  if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
+  if (reset->GetUint64(kRSEQ, &packet.rejected_sequence_number) !=
+      QUIC_NO_ERROR) {
     set_detailed_error("Unable to read rejected sequence number.");
     return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
+
+  StringPiece address;
+  if (reset->GetStringPiece(kCADR, &address)) {
+    QuicSocketAddressCoder address_coder;
+    if (address_coder.Decode(address.data(), address.length())) {
+      packet.client_address = IPEndPoint(address_coder.ip(),
+                                         address_coder.port());
+    }
+  }
+
   visitor_->OnPublicResetPacket(packet);
   return true;
 }
 
 bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
                                       StringPiece payload) {
   DCHECK(!reader_.get());
 
   visitor_->OnRevivedPacket();
 
@@ skipping 1444 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net