Landing Recent QUIC changes until 9:41 AM, Oct 10, 2016 UTC-7

net/quic/core/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/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 448 matching lines @@
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
 
   CryptoHandshakeMessage reset;
   reset.set_tag(kPRST);
   reset.SetValue(kRNON, packet.nonce_proof);
-  reset.SetValue(kRSEQ, packet.rejected_packet_number);
+  if (!FLAGS_quic_remove_packet_number_from_public_reset) {
+    reset.SetValue(kRSEQ, packet.rejected_packet_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 nullptr;
     }
     reset.SetStringPiece(kCADR, serialized_address);
   }
   const QuicData& reset_serialized = reset.GetSerialized();
@@ skipping 55 matching lines @@
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   QuicDataReader reader(packet.data(), packet.length());
 
   visitor_->OnPacket();
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&reader, &public_header)) {
-    DLOG(WARNING) << "Unable to process public header.";
+    DVLOG(1) << "Unable to process public header.";
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
   if (perspective_ == Perspective::IS_SERVER && public_header.version_flag &&
@@ skipping 46 matching lines @@
   return true;
 }
 
 bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
                                    const QuicPacketPublicHeader& public_header,
                                    const QuicEncryptedPacket& packet,
                                    char* decrypted_buffer,
                                    size_t buffer_length) {
   QuicPacketHeader header(public_header);
   if (!ProcessUnauthenticatedHeader(encrypted_reader, &header)) {
-    DLOG(WARNING) << "Unable to process packet header.  Stopping parsing.";
+    DVLOG(1) << "Unable to process packet header.  Stopping parsing.";
     return false;
   }
 
   size_t decrypted_length = 0;
   if (!DecryptPayload(encrypted_reader, header, packet, decrypted_buffer,
                       buffer_length, &decrypted_length)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   QuicDataReader reader(decrypted_buffer, decrypted_length);
   if (quic_version_ <= QUIC_VERSION_33) {
     if (!ProcessAuthenticatedHeader(&reader, &header)) {
-      DLOG(WARNING) << "Unable to process packet header.  Stopping parsing.";
+      DVLOG(1) << "Unable to process packet header.  Stopping parsing.";
       return false;
     }
   }
 
   // Set the last packet number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   SetLastPacketNumber(header);
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
   if (packet.length() > kMaxPacketSize) {
     // If the packet has gotten this far, it should not be too large.
     QUIC_BUG << "Packet too large:" << packet.length();
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
-  DCHECK(!header.fec_flag);
   // Handle the payload.
   if (!ProcessFrameData(&reader, header)) {
     DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
     DLOG(WARNING) << "Unable to process frame data.";
     return false;
   }
 
   visitor_->OnPacketComplete();
   return true;
 }
@@ skipping 438 matching lines @@
 }
 
 bool QuicFramer::ProcessAuthenticatedHeader(QuicDataReader* reader,
                                             QuicPacketHeader* header) {
   uint8_t private_flags;
   if (!reader->ReadBytes(&private_flags, 1)) {
     set_detailed_error("Unable to read private flags.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    if (private_flags > PACKET_PRIVATE_FLAGS_MAX_VERSION_32) {
-      set_detailed_error("Illegal private flags value.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
-  } else {
-    if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
-      set_detailed_error("Illegal private flags value.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
+  if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
+    set_detailed_error("Illegal private flags value.");
+    return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
-  header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
-
-  if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) {
-    uint8_t first_fec_protected_packet_offset;
-    if (!reader->ReadBytes(&first_fec_protected_packet_offset, 1)) {
-      set_detailed_error("Unable to read first fec protected packet offset.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
-    if (first_fec_protected_packet_offset >= header->packet_number) {
-      set_detailed_error(
-          "First fec protected packet offset must be less "
-          "than the packet number.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
-  }
-
   header->entropy_hash = GetPacketEntropyHash(*header);
   return true;
 }
 
 bool QuicFramer::ProcessPathId(QuicDataReader* reader, QuicPathId* path_id) {
   if (!reader->ReadBytes(path_id, 1)) {
     return false;
   }
 
   return true;
@@ skipping 314 matching lines @@
       return false;
     }
     ack_frame->packets.Add(last_packet_number - range_length,
                            last_packet_number + 1);
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 packet number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_packet_number -= (range_length + 1);
   }
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    return true;
-  }
-
-  // Parse the revived packets list.
-  // TODO(ianswett): Change the ack frame so it only expresses one revived.
-  uint8_t num_revived_packets;
-  if (!reader->ReadBytes(&num_revived_packets, 1)) {
-    set_detailed_error("Unable to read num revived packets.");
-    return false;
-  }
-
-  for (size_t i = 0; i < num_revived_packets; ++i) {
-    QuicPacketNumber revived_packet = 0;
-    if (!reader->ReadBytes(&revived_packet,
-                           largest_observed_packet_number_length)) {
-      set_detailed_error("Unable to read revived packet.");
-      return false;
-    }
-  }
-
   return true;
 }
 
 bool QuicFramer::ProcessNewAckFrame(QuicDataReader* reader,
                                     uint8_t frame_type,
                                     QuicAckFrame* ack_frame) {
   // Determine the two lengths from the frame type: largest acked length,
   // ack block length.
   const QuicPacketNumberLength ack_block_length =
       ReadSequenceNumberLength(frame_type);
@@ skipping 432 matching lines @@
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
         EncryptionLevel level = alternative_decrypter_level_;
         alternative_decrypter_level_ = decrypter_level_;
         decrypter_level_ = level;
       }
     }
   }
 
   if (!success) {
-    DLOG(WARNING) << "DecryptPacket failed for packet_number:"
-                  << header.packet_number;
+    DVLOG(1) << "DecryptPacket failed for packet_number:"
+             << header.packet_number;
     return false;
   }
 
   return true;
 }
 
 size_t QuicFramer::GetAckFrameTimeStampSize(const QuicAckFrame& ack) {
   if (ack.received_packet_times.empty()) {
     return 0;
   }
 
   return 5 + 3 * (ack.received_packet_times.size() - 1);
 }
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicPacketNumberLength packet_number_length) {
   size_t ack_size = 0;
   if (quic_version_ <= QUIC_VERSION_33) {
     AckFrameInfo ack_info = GetAckFrameInfo(ack);
     QuicPacketNumberLength largest_observed_length =
         GetMinSequenceNumberLength(ack.largest_observed);
     QuicPacketNumberLength missing_packet_number_length =
         GetMinSequenceNumberLength(ack_info.max_delta);
 
     ack_size = GetMinAckFrameSize(quic_version_, largest_observed_length);
     if (!ack_info.nack_ranges.empty()) {
       ack_size += kNumberOfNackRangesSize;
-      if (quic_version_ <= QUIC_VERSION_31) {
-        ack_size += kNumberOfRevivedPacketsSize;
-      }
       ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
                   (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
     }
 
     // In version 23, if the ack will be truncated due to too many nack ranges,
     // then do not include the number of timestamps (1 byte).
     if (ack_info.nack_ranges.size() <= kMaxNackRanges) {
       // 1 byte for the number of timestamps.
       ack_size += 1;
       ack_size += GetAckFrameTimeStampSize(ack);
@@ skipping 186 matching lines @@
   AckFrameInfo ack_info = GetAckFrameInfo(frame);
   QuicPacketNumber ack_largest_observed = frame.largest_observed;
   QuicPacketNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicPacketNumberLength missing_packet_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
   size_t available_range_bytes =
       writer->capacity() - writer->length() - kNumberOfNackRangesSize -
       GetMinAckFrameSize(quic_version_, largest_observed_length);
-  if (quic_version_ <= QUIC_VERSION_31) {
-    available_range_bytes -= kNumberOfRevivedPacketsSize;
-  }
   size_t max_num_ranges =
       available_range_bytes /
       (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
   max_num_ranges = min(kMaxNackRanges, max_num_ranges);
   bool truncated = ack_info.nack_ranges.size() > max_num_ranges;
   DVLOG_IF(1, truncated) << "Truncating ack from "
                          << ack_info.nack_ranges.size() << " ranges to "
                          << max_num_ranges;
   // Write out the type byte by setting the low order bits and doing shifts
   // to make room for the next bit flags to be set.
@@ skipping 99 matching lines @@
                                     ack_iter->second, writer)) {
       QUIC_BUG << "AppendPacketSequenceNumber failed";
       return false;
     }
     // Subtract 1 so a missing_delta of 0 means an adjacent range.
     last_sequence_written = ack_iter->first - 1;
     ++num_ranges_written;
   }
   DCHECK_EQ(num_missing_ranges, num_ranges_written);
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    return true;
-  }
-
-  // Append revived packets.
-  // FEC is not supported.
-  uint8_t num_revived_packets = 0;
-  if (!writer->WriteBytes(&num_revived_packets, 1)) {
-    QUIC_BUG << "num_revived_packets failed: " << num_revived_packets;
-    return false;
-  }
-
   return true;
 }
 
 bool QuicFramer::AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
                                               QuicDataWriter* writer) {
   const NewAckFrameInfo new_ack_info = GetNewAckFrameInfo(frame);
   QuicPacketNumber largest_acked = frame.largest_observed;
   QuicPacketNumberLength largest_acked_length =
       GetMinSequenceNumberLength(largest_acked);
   QuicPacketNumberLength ack_block_length =
@@ skipping 312 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net