Home | History | Annotate | Download | only in quic 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/quic/quic_protocol.h"
      6 
      7 #include "base/stl_util.h"
      8 #include "net/quic/quic_utils.h"
      9 
     10 using base::StringPiece;
     11 using std::map;
     12 using std::numeric_limits;
     13 using std::ostream;
     14 using std::string;
     15 
     16 namespace net {
     17 
     18 size_t GetPacketHeaderSize(QuicPacketHeader header) {
     19   return GetPacketHeaderSize(header.public_header.guid_length,
     20                              header.public_header.version_flag,
     21                              header.public_header.sequence_number_length,
     22                              header.is_in_fec_group);
     23 }
     24 
     25 size_t GetPacketHeaderSize(QuicGuidLength guid_length,
     26                            bool include_version,
     27                            QuicSequenceNumberLength sequence_number_length,
     28                            InFecGroup is_in_fec_group) {
     29   return kPublicFlagsSize + guid_length +
     30       (include_version ? kQuicVersionSize : 0) + sequence_number_length +
     31       kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
     32 }
     33 
     34 size_t GetPublicResetPacketSize() {
     35   return kPublicFlagsSize + PACKET_8BYTE_GUID + kPublicResetNonceSize +
     36       PACKET_6BYTE_SEQUENCE_NUMBER;
     37 }
     38 
     39 size_t GetStartOfFecProtectedData(
     40     QuicGuidLength guid_length,
     41     bool include_version,
     42     QuicSequenceNumberLength sequence_number_length) {
     43   return GetPacketHeaderSize(
     44       guid_length, include_version, sequence_number_length, IN_FEC_GROUP);
     45 }
     46 
     47 size_t GetStartOfEncryptedData(
     48     QuicGuidLength guid_length,
     49     bool include_version,
     50     QuicSequenceNumberLength sequence_number_length) {
     51   // Don't include the fec size, since encryption starts before private flags.
     52   return GetPacketHeaderSize(
     53       guid_length, include_version, sequence_number_length, NOT_IN_FEC_GROUP) -
     54       kPrivateFlagsSize;
     55 }
     56 
     57 QuicPacketPublicHeader::QuicPacketPublicHeader()
     58     : guid(0),
     59       guid_length(PACKET_8BYTE_GUID),
     60       reset_flag(false),
     61       version_flag(false),
     62       sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
     63 }
     64 
     65 QuicPacketPublicHeader::QuicPacketPublicHeader(
     66     const QuicPacketPublicHeader& other)
     67     : guid(other.guid),
     68       guid_length(other.guid_length),
     69       reset_flag(other.reset_flag),
     70       version_flag(other.version_flag),
     71       sequence_number_length(other.sequence_number_length),
     72       versions(other.versions) {
     73 }
     74 
     75 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
     76 
     77 QuicPacketPublicHeader& QuicPacketPublicHeader::operator=(
     78     const QuicPacketPublicHeader& other) {
     79   guid = other.guid;
     80   reset_flag = other.reset_flag;
     81   version_flag = other.version_flag;
     82   versions = other.versions;
     83   return *this;
     84 }
     85 
     86 QuicPacketHeader::QuicPacketHeader()
     87     : fec_flag(false),
     88       entropy_flag(false),
     89       entropy_hash(0),
     90       packet_sequence_number(0),
     91       is_in_fec_group(NOT_IN_FEC_GROUP),
     92       fec_group(0) {
     93 }
     94 
     95 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
     96     : public_header(header),
     97       fec_flag(false),
     98       entropy_flag(false),
     99       entropy_hash(0),
    100       packet_sequence_number(0),
    101       is_in_fec_group(NOT_IN_FEC_GROUP),
    102       fec_group(0) {
    103 }
    104 
    105 QuicStreamFrame::QuicStreamFrame() {}
    106 
    107 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
    108                                  bool fin,
    109                                  QuicStreamOffset offset,
    110                                  StringPiece data)
    111     : stream_id(stream_id),
    112       fin(fin),
    113       offset(offset),
    114       data(data) {
    115 }
    116 
    117 uint32 MakeQuicTag(char a, char b, char c, char d) {
    118   return static_cast<uint32>(a) |
    119          static_cast<uint32>(b) << 8 |
    120          static_cast<uint32>(c) << 16 |
    121          static_cast<uint32>(d) << 24;
    122 }
    123 
    124 QuicVersion QuicVersionMax() { return kSupportedQuicVersions[0]; }
    125 
    126 QuicVersion QuicVersionMin() {
    127   return kSupportedQuicVersions[arraysize(kSupportedQuicVersions) - 1];
    128 }
    129 
    130 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
    131   switch (version) {
    132     case QUIC_VERSION_7:
    133       return MakeQuicTag('Q', '0', '0', '7');
    134     case QUIC_VERSION_8:
    135       return MakeQuicTag('Q', '0', '0', '8');
    136     default:
    137       // This shold be an ERROR because we should never attempt to convert an
    138       // invalid QuicVersion to be written to the wire.
    139       LOG(ERROR) << "Unsupported QuicVersion: " << version;
    140       return 0;
    141   }
    142 }
    143 
    144 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
    145   const QuicTag quic_tag_v7 = MakeQuicTag('Q', '0', '0', '7');
    146   const QuicTag quic_tag_v8 = MakeQuicTag('Q', '0', '0', '8');
    147 
    148   if (version_tag == quic_tag_v7) {
    149     return QUIC_VERSION_7;
    150   } else if (version_tag == quic_tag_v8) {
    151     return QUIC_VERSION_8;
    152   } else {
    153     // Reading from the client so this should not be considered an ERROR.
    154     DLOG(INFO) << "Unsupported QuicTag version: "
    155                << QuicUtils::TagToString(version_tag);
    156     return QUIC_VERSION_UNSUPPORTED;
    157   }
    158 }
    159 
    160 #define RETURN_STRING_LITERAL(x) \
    161 case x: \
    162 return #x
    163 
    164 string QuicVersionToString(const QuicVersion version) {
    165   switch (version) {
    166     RETURN_STRING_LITERAL(QUIC_VERSION_7);
    167     RETURN_STRING_LITERAL(QUIC_VERSION_8);
    168     default:
    169       return "QUIC_VERSION_UNSUPPORTED";
    170   }
    171 }
    172 
    173 string QuicVersionArrayToString(const QuicVersion versions[],
    174                                 int num_versions) {
    175   string result = "";
    176   for (int i = 0; i < num_versions; ++i) {
    177     const QuicVersion& version = versions[i];
    178     result.append(QuicVersionToString(version));
    179     result.append(",");
    180   }
    181   return result;
    182 }
    183 
    184 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
    185   os << "{ guid: " << header.public_header.guid
    186      << ", guid_length:" << header.public_header.guid_length
    187      << ", reset_flag: " << header.public_header.reset_flag
    188      << ", version_flag: " << header.public_header.version_flag;
    189   if (header.public_header.version_flag) {
    190     os << " version: ";
    191     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
    192       os << header.public_header.versions[0] << " ";
    193     }
    194   }
    195   os << ", fec_flag: " << header.fec_flag
    196      << ", entropy_flag: " << header.entropy_flag
    197      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
    198      << ", sequence_number: " << header.packet_sequence_number
    199      << ", is_in_fec_group:" << header.is_in_fec_group
    200      << ", fec_group: " << header.fec_group<< "}\n";
    201   return os;
    202 }
    203 
    204 // TODO(ianswett): Initializing largest_observed to 0 should not be necessary.
    205 ReceivedPacketInfo::ReceivedPacketInfo()
    206     : largest_observed(0),
    207       delta_time_largest_observed(QuicTime::Delta::Infinite()) {
    208 }
    209 
    210 ReceivedPacketInfo::~ReceivedPacketInfo() {}
    211 
    212 bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
    213                       QuicPacketSequenceNumber sequence_number) {
    214   return sequence_number > received_info.largest_observed ||
    215       ContainsKey(received_info.missing_packets, sequence_number);
    216 }
    217 
    218 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
    219                                  QuicPacketSequenceNumber lower,
    220                                  QuicPacketSequenceNumber higher) {
    221   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
    222     received_info->missing_packets.insert(i);
    223   }
    224 }
    225 
    226 SentPacketInfo::SentPacketInfo() {}
    227 
    228 SentPacketInfo::~SentPacketInfo() {}
    229 
    230 // Testing convenience method.
    231 QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_observed,
    232                            QuicTime largest_observed_receive_time,
    233                            QuicPacketSequenceNumber least_unacked) {
    234   received_info.largest_observed = largest_observed;
    235   received_info.entropy_hash = 0;
    236   sent_info.least_unacked = least_unacked;
    237   sent_info.entropy_hash = 0;
    238 }
    239 
    240 ostream& operator<<(ostream& os, const SentPacketInfo& sent_info) {
    241   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
    242      << " least_unacked: " << sent_info.least_unacked;
    243   return os;
    244 }
    245 
    246 ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
    247   os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
    248      << " largest_observed: " << received_info.largest_observed
    249      << " missing_packets: [ ";
    250   for (SequenceNumberSet::const_iterator it =
    251            received_info.missing_packets.begin();
    252        it != received_info.missing_packets.end(); ++it) {
    253     os << *it << " ";
    254   }
    255   os << " ] ";
    256   return os;
    257 }
    258 
    259 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() {
    260 }
    261 
    262 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {
    263 }
    264 
    265 ostream& operator<<(ostream& os,
    266                     const QuicCongestionFeedbackFrame& congestion_frame) {
    267   os << "type: " << congestion_frame.type;
    268   switch (congestion_frame.type) {
    269     case kInterArrival: {
    270       const CongestionFeedbackMessageInterArrival& inter_arrival =
    271           congestion_frame.inter_arrival;
    272       os << " accumulated_number_of_lost_packets: "
    273          << inter_arrival.accumulated_number_of_lost_packets;
    274       os << " received packets: [ ";
    275       for (TimeMap::const_iterator it =
    276                inter_arrival.received_packet_times.begin();
    277            it != inter_arrival.received_packet_times.end(); ++it) {
    278         os << it->first << "@" << it->second.ToDebuggingValue() << " ";
    279       }
    280       os << "]";
    281       break;
    282     }
    283     case kFixRate: {
    284       os << " bitrate_in_bytes_per_second: "
    285          << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
    286       break;
    287     }
    288     case kTCP: {
    289       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
    290       os << " accumulated_number_of_lost_packets: "
    291          << congestion_frame.tcp.accumulated_number_of_lost_packets;
    292       os << " receive_window: " << tcp.receive_window;
    293       break;
    294     }
    295   }
    296  return os;
    297 }
    298 
    299 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
    300   os << "sent info { " << ack_frame.sent_info << " } "
    301      << "received info { " << ack_frame.received_info << " }\n";
    302  return os;
    303 }
    304 
    305 CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
    306     : bitrate(QuicBandwidth::Zero()) {
    307 }
    308 
    309 CongestionFeedbackMessageInterArrival::
    310 CongestionFeedbackMessageInterArrival() {}
    311 
    312 CongestionFeedbackMessageInterArrival::
    313 ~CongestionFeedbackMessageInterArrival() {}
    314 
    315 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
    316                                  QuicStreamId last_good_stream_id,
    317                                  const string& reason)
    318     : error_code(error_code),
    319       last_good_stream_id(last_good_stream_id),
    320       reason_phrase(reason) {
    321   DCHECK_LE(error_code, numeric_limits<uint8>::max());
    322 }
    323 
    324 QuicFecData::QuicFecData() {}
    325 
    326 QuicData::~QuicData() {
    327   if (owns_buffer_) {
    328     delete [] const_cast<char*>(buffer_);
    329   }
    330 }
    331 
    332 StringPiece QuicPacket::FecProtectedData() const {
    333   const size_t start_of_fec = GetStartOfFecProtectedData(
    334       guid_length_, includes_version_, sequence_number_length_);
    335   return StringPiece(data() + start_of_fec, length() - start_of_fec);
    336 }
    337 
    338 StringPiece QuicPacket::AssociatedData() const {
    339   return StringPiece(
    340       data() + kStartOfHashData,
    341       GetStartOfEncryptedData(
    342           guid_length_, includes_version_, sequence_number_length_) -
    343       kStartOfHashData);
    344 }
    345 
    346 StringPiece QuicPacket::BeforePlaintext() const {
    347   return StringPiece(data(), GetStartOfEncryptedData(guid_length_,
    348                                                      includes_version_,
    349                                                      sequence_number_length_));
    350 }
    351 
    352 StringPiece QuicPacket::Plaintext() const {
    353   const size_t start_of_encrypted_data =
    354       GetStartOfEncryptedData(
    355           guid_length_, includes_version_, sequence_number_length_);
    356   return StringPiece(data() + start_of_encrypted_data,
    357                      length() - start_of_encrypted_data);
    358 }
    359 
    360 RetransmittableFrames::RetransmittableFrames()
    361     : encryption_level_(NUM_ENCRYPTION_LEVELS) {
    362 }
    363 
    364 RetransmittableFrames::~RetransmittableFrames() {
    365   for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
    366     switch (it->type) {
    367       case PADDING_FRAME:
    368         delete it->padding_frame;
    369         break;
    370       case STREAM_FRAME:
    371         delete it->stream_frame;
    372         break;
    373       case ACK_FRAME:
    374         delete it->ack_frame;
    375         break;
    376       case CONGESTION_FEEDBACK_FRAME:
    377         delete it->congestion_feedback_frame;
    378         break;
    379       case RST_STREAM_FRAME:
    380         delete it->rst_stream_frame;
    381         break;
    382       case CONNECTION_CLOSE_FRAME:
    383         delete it->connection_close_frame;
    384         break;
    385       case GOAWAY_FRAME:
    386         delete it->goaway_frame;
    387         break;
    388       case NUM_FRAME_TYPES:
    389         DCHECK(false) << "Cannot delete type: " << it->type;
    390     }
    391   }
    392   STLDeleteElements(&stream_data_);
    393 }
    394 
    395 const QuicFrame& RetransmittableFrames::AddStreamFrame(
    396     QuicStreamFrame* stream_frame) {
    397   // Make an owned copy of the StringPiece.
    398   string* stream_data = new string(stream_frame->data.data(),
    399                                    stream_frame->data.size());
    400   // Ensure the frame's StringPiece points to the owned copy of the data.
    401   stream_frame->data = StringPiece(*stream_data);
    402   stream_data_.push_back(stream_data);
    403   frames_.push_back(QuicFrame(stream_frame));
    404   return frames_.back();
    405 }
    406 
    407 const QuicFrame& RetransmittableFrames::AddNonStreamFrame(
    408     const QuicFrame& frame) {
    409   DCHECK_NE(frame.type, STREAM_FRAME);
    410   frames_.push_back(frame);
    411   return frames_.back();
    412 }
    413 
    414 void RetransmittableFrames::set_encryption_level(EncryptionLevel level) {
    415   encryption_level_ = level;
    416 }
    417 
    418 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
    419   os << s.length() << "-byte data";
    420   return os;
    421 }
    422 
    423 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
    424   os << "bytes_consumed: " << s.bytes_consumed
    425      << " fin_consumed: " << s.fin_consumed;
    426   return os;
    427 }
    428 
    429 }  // namespace net
    430