src/net/quic/quic_protocol.cc

   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(const QuicPacketHeader& header) {
  19   return GetPacketHeaderSize(header.public_header.connection_id_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(QuicConnectionIdLength connection_id_length,
  26                            bool include_version,
  27                            QuicSequenceNumberLength sequence_number_length,
  28                            InFecGroup is_in_fec_group) {
  29   return kPublicFlagsSize + connection_id_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 GetStartOfFecProtectedData(
  35     QuicConnectionIdLength connection_id_length,
  36     bool include_version,
  37     QuicSequenceNumberLength sequence_number_length) {
  38   return GetPacketHeaderSize(connection_id_length,
  39                              include_version,
  40                              sequence_number_length,
  41                              IN_FEC_GROUP);
  42 }
  43
  44 size_t GetStartOfEncryptedData(
  45     QuicConnectionIdLength connection_id_length,
  46     bool include_version,
  47     QuicSequenceNumberLength sequence_number_length) {
  48   // Don't include the fec size, since encryption starts before private flags.
  49   return GetPacketHeaderSize(connection_id_length,
  50                              include_version,
  51                              sequence_number_length,
  52                              NOT_IN_FEC_GROUP) - kPrivateFlagsSize;
  53 }
  54
  55 QuicPacketPublicHeader::QuicPacketPublicHeader()
  56     : connection_id(0),
  57       connection_id_length(PACKET_8BYTE_CONNECTION_ID),
  58       reset_flag(false),
  59       version_flag(false),
  60       sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
  61 }
  62
  63 QuicPacketPublicHeader::QuicPacketPublicHeader(
  64     const QuicPacketPublicHeader& other)
  65     : connection_id(other.connection_id),
  66       connection_id_length(other.connection_id_length),
  67       reset_flag(other.reset_flag),
  68       version_flag(other.version_flag),
  69       sequence_number_length(other.sequence_number_length),
  70       versions(other.versions) {
  71 }
  72
  73 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
  74
  75 QuicPacketHeader::QuicPacketHeader()
  76     : fec_flag(false),
  77       entropy_flag(false),
  78       entropy_hash(0),
  79       packet_sequence_number(0),
  80       is_in_fec_group(NOT_IN_FEC_GROUP),
  81       fec_group(0) {
  82 }
  83
  84 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
  85     : public_header(header),
  86       fec_flag(false),
  87       entropy_flag(false),
  88       entropy_hash(0),
  89       packet_sequence_number(0),
  90       is_in_fec_group(NOT_IN_FEC_GROUP),
  91       fec_group(0) {
  92 }
  93
  94 QuicPublicResetPacket::QuicPublicResetPacket()
  95     : nonce_proof(0),
  96       rejected_sequence_number(0) {}
  97
  98 QuicPublicResetPacket::QuicPublicResetPacket(
  99     const QuicPacketPublicHeader& header)
 100     : public_header(header),
 101       nonce_proof(0),
 102       rejected_sequence_number(0) {}
 103
 104 QuicStreamFrame::QuicStreamFrame()
 105     : stream_id(0),
 106       fin(false),
 107       offset(0),
 108       notifier(NULL) {}
 109
 110 QuicStreamFrame::QuicStreamFrame(const QuicStreamFrame& frame)
 111     : stream_id(frame.stream_id),
 112       fin(frame.fin),
 113       offset(frame.offset),
 114       data(frame.data),
 115       notifier(frame.notifier) {
 116 }
 117
 118 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
 119                                  bool fin,
 120                                  QuicStreamOffset offset,
 121                                  IOVector data)
 122     : stream_id(stream_id),
 123       fin(fin),
 124       offset(offset),
 125       data(data),
 126       notifier(NULL) {
 127 }
 128
 129 string* QuicStreamFrame::GetDataAsString() const {
 130   string* data_string = new string();
 131   data_string->reserve(data.TotalBufferSize());
 132   for (size_t i = 0; i < data.Size(); ++i) {
 133     data_string->append(static_cast<char*>(data.iovec()[i].iov_base),
 134                         data.iovec()[i].iov_len);
 135   }
 136   DCHECK_EQ(data_string->size(), data.TotalBufferSize());
 137   return data_string;
 138 }
 139
 140 uint32 MakeQuicTag(char a, char b, char c, char d) {
 141   return static_cast<uint32>(a) |
 142          static_cast<uint32>(b) << 8 |
 143          static_cast<uint32>(c) << 16 |
 144          static_cast<uint32>(d) << 24;
 145 }
 146
 147 QuicVersionVector QuicSupportedVersions() {
 148   QuicVersionVector supported_versions;
 149   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
 150     supported_versions.push_back(kSupportedQuicVersions[i]);
 151   }
 152   return supported_versions;
 153 }
 154
 155 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
 156   switch (version) {
 157     case QUIC_VERSION_15:
 158       return MakeQuicTag('Q', '0', '1', '5');
 159     case QUIC_VERSION_16:
 160       return MakeQuicTag('Q', '0', '1', '6');
 161     case QUIC_VERSION_17:
 162       return MakeQuicTag('Q', '0', '1', '7');
 163     case QUIC_VERSION_18:
 164       return MakeQuicTag('Q', '0', '1', '8');
 165     case QUIC_VERSION_19:
 166       return MakeQuicTag('Q', '0', '1', '9');
 167     default:
 168       // This shold be an ERROR because we should never attempt to convert an
 169       // invalid QuicVersion to be written to the wire.
 170       LOG(ERROR) << "Unsupported QuicVersion: " << version;
 171       return 0;
 172   }
 173 }
 174
 175 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
 176   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
 177     if (version_tag == QuicVersionToQuicTag(kSupportedQuicVersions[i])) {
 178       return kSupportedQuicVersions[i];
 179     }
 180   }
 181   // Reading from the client so this should not be considered an ERROR.
 182   DVLOG(1) << "Unsupported QuicTag version: "
 183            << QuicUtils::TagToString(version_tag);
 184   return QUIC_VERSION_UNSUPPORTED;
 185 }
 186
 187 #define RETURN_STRING_LITERAL(x) \
 188 case x: \
 189 return #x
 190
 191 string QuicVersionToString(const QuicVersion version) {
 192   switch (version) {
 193     RETURN_STRING_LITERAL(QUIC_VERSION_15);
 194     RETURN_STRING_LITERAL(QUIC_VERSION_16);
 195     RETURN_STRING_LITERAL(QUIC_VERSION_17);
 196     RETURN_STRING_LITERAL(QUIC_VERSION_18);
 197     RETURN_STRING_LITERAL(QUIC_VERSION_19);
 198     default:
 199       return "QUIC_VERSION_UNSUPPORTED";
 200   }
 201 }
 202
 203 string QuicVersionVectorToString(const QuicVersionVector& versions) {
 204   string result = "";
 205   for (size_t i = 0; i < versions.size(); ++i) {
 206     if (i != 0) {
 207       result.append(",");
 208     }
 209     result.append(QuicVersionToString(versions[i]));
 210   }
 211   return result;
 212 }
 213
 214 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
 215   os << "{ connection_id: " << header.public_header.connection_id
 216      << ", connection_id_length:" << header.public_header.connection_id_length
 217      << ", sequence_number_length:"
 218      << header.public_header.sequence_number_length
 219      << ", reset_flag: " << header.public_header.reset_flag
 220      << ", version_flag: " << header.public_header.version_flag;
 221   if (header.public_header.version_flag) {
 222     os << " version: ";
 223     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
 224       os << header.public_header.versions[0] << " ";
 225     }
 226   }
 227   os << ", fec_flag: " << header.fec_flag
 228      << ", entropy_flag: " << header.entropy_flag
 229      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
 230      << ", sequence_number: " << header.packet_sequence_number
 231      << ", is_in_fec_group:" << header.is_in_fec_group
 232      << ", fec_group: " << header.fec_group<< "}\n";
 233   return os;
 234 }
 235
 236 ReceivedPacketInfo::ReceivedPacketInfo()
 237     : entropy_hash(0),
 238       largest_observed(0),
 239       delta_time_largest_observed(QuicTime::Delta::Infinite()),
 240       is_truncated(false) {}
 241
 242 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 243
 244 bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
 245                       QuicPacketSequenceNumber sequence_number) {
 246   return sequence_number > received_info.largest_observed ||
 247       ContainsKey(received_info.missing_packets, sequence_number);
 248 }
 249
 250 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
 251                                  QuicPacketSequenceNumber lower,
 252                                  QuicPacketSequenceNumber higher) {
 253   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
 254     received_info->missing_packets.insert(i);
 255   }
 256 }
 257
 258 QuicStopWaitingFrame::QuicStopWaitingFrame()
 259     : entropy_hash(0),
 260       least_unacked(0) {
 261 }
 262
 263 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 264
 265 QuicAckFrame::QuicAckFrame() {}
 266
 267 CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
 268     : receive_window(0) {
 269 }
 270
 271 CongestionFeedbackMessageInterArrival::CongestionFeedbackMessageInterArrival() {
 272 }
 273
 274 CongestionFeedbackMessageInterArrival::
 275     ~CongestionFeedbackMessageInterArrival() {}
 276
 277 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
 278
 279 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {}
 280
 281 QuicRstStreamErrorCode AdjustErrorForVersion(
 282     QuicRstStreamErrorCode error_code,
 283     QuicVersion version) {
 284   switch (error_code) {
 285     case QUIC_RST_FLOW_CONTROL_ACCOUNTING:
 286       if (version <= QUIC_VERSION_17) {
 287         return QUIC_STREAM_NO_ERROR;
 288       }
 289       break;
 290     default:
 291       return error_code;
 292   }
 293   return error_code;
 294 }
 295
 296 QuicRstStreamFrame::QuicRstStreamFrame()
 297     : stream_id(0),
 298       error_code(QUIC_STREAM_NO_ERROR) {
 299 }
 300
 301 QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id,
 302                                        QuicRstStreamErrorCode error_code,
 303                                        QuicStreamOffset bytes_written)
 304     : stream_id(stream_id),
 305       error_code(error_code),
 306       byte_offset(bytes_written) {
 307   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 308 }
 309
 310 QuicConnectionCloseFrame::QuicConnectionCloseFrame()
 311     : error_code(QUIC_NO_ERROR) {
 312 }
 313
 314 QuicFrame::QuicFrame() {}
 315
 316 QuicFrame::QuicFrame(QuicPaddingFrame* padding_frame)
 317     : type(PADDING_FRAME),
 318       padding_frame(padding_frame) {
 319 }
 320
 321 QuicFrame::QuicFrame(QuicStreamFrame* stream_frame)
 322     : type(STREAM_FRAME),
 323       stream_frame(stream_frame) {
 324 }
 325
 326 QuicFrame::QuicFrame(QuicAckFrame* frame)
 327     : type(ACK_FRAME),
 328       ack_frame(frame) {
 329 }
 330
 331 QuicFrame::QuicFrame(QuicCongestionFeedbackFrame* frame)
 332     : type(CONGESTION_FEEDBACK_FRAME),
 333       congestion_feedback_frame(frame) {
 334 }
 335
 336 QuicFrame::QuicFrame(QuicStopWaitingFrame* frame)
 337     : type(STOP_WAITING_FRAME),
 338       stop_waiting_frame(frame) {
 339 }
 340
 341 QuicFrame::QuicFrame(QuicPingFrame* frame)
 342     : type(PING_FRAME),
 343       ping_frame(frame) {
 344 }
 345
 346 QuicFrame::QuicFrame(QuicRstStreamFrame* frame)
 347     : type(RST_STREAM_FRAME),
 348       rst_stream_frame(frame) {
 349 }
 350
 351 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
 352     : type(CONNECTION_CLOSE_FRAME),
 353       connection_close_frame(frame) {
 354 }
 355
 356 QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
 357     : type(GOAWAY_FRAME),
 358       goaway_frame(frame) {
 359 }
 360
 361 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
 362     : type(WINDOW_UPDATE_FRAME),
 363       window_update_frame(frame) {
 364 }
 365
 366 QuicFrame::QuicFrame(QuicBlockedFrame* frame)
 367     : type(BLOCKED_FRAME),
 368       blocked_frame(frame) {
 369 }
 370
 371 QuicFecData::QuicFecData() : fec_group(0) {}
 372
 373 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
 374   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
 375      << " least_unacked: " << sent_info.least_unacked;
 376   return os;
 377 }
 378
 379 ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
 380   os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
 381      << " is_truncated: " << received_info.is_truncated
 382      << " largest_observed: " << received_info.largest_observed
 383      << " delta_time_largest_observed: "
 384      << received_info.delta_time_largest_observed.ToMicroseconds()
 385      << " missing_packets: [ ";
 386   for (SequenceNumberSet::const_iterator it =
 387            received_info.missing_packets.begin();
 388        it != received_info.missing_packets.end(); ++it) {
 389     os << *it << " ";
 390   }
 391   os << " ] revived_packets: [ ";
 392   for (SequenceNumberSet::const_iterator it =
 393            received_info.revived_packets.begin();
 394        it != received_info.revived_packets.end(); ++it) {
 395     os << *it << " ";
 396   }
 397   os << " ]";
 398   return os;
 399 }
 400
 401 ostream& operator<<(ostream& os, const QuicFrame& frame) {
 402   switch (frame.type) {
 403   case PADDING_FRAME: {
 404       os << "type { PADDING_FRAME } ";
 405       break;
 406     }
 407     case RST_STREAM_FRAME: {
 408       os << "type { " << RST_STREAM_FRAME << " } " << *(frame.rst_stream_frame);
 409       break;
 410     }
 411     case CONNECTION_CLOSE_FRAME: {
 412       os << "type { CONNECTION_CLOSE_FRAME } "
 413          << *(frame.connection_close_frame);
 414       break;
 415     }
 416     case GOAWAY_FRAME: {
 417       os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame);
 418       break;
 419     }
 420     case WINDOW_UPDATE_FRAME: {
 421       os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame);
 422       break;
 423     }
 424     case BLOCKED_FRAME: {
 425       os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame);
 426       break;
 427     }
 428     case STREAM_FRAME: {
 429       os << "type { STREAM_FRAME } " << *(frame.stream_frame);
 430       break;
 431     }
 432     case ACK_FRAME: {
 433       os << "type { ACK_FRAME } " << *(frame.ack_frame);
 434       break;
 435     }
 436     case CONGESTION_FEEDBACK_FRAME: {
 437       os << "type { CONGESTION_FEEDBACK_FRAME } "
 438          << *(frame.congestion_feedback_frame);
 439       break;
 440     }
 441     case STOP_WAITING_FRAME: {
 442       os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame);
 443       break;
 444     }
 445     default: {
 446       LOG(ERROR) << "Unknown frame type: " << frame.type;
 447       break;
 448     }
 449   }
 450   return os;
 451 }
 452
 453 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) {
 454   os << "stream_id { " << rst_frame.stream_id << " } "
 455      << "error_code { " << rst_frame.error_code << " } "
 456      << "error_details { " << rst_frame.error_details << " }\n";
 457   return os;
 458 }
 459
 460 ostream& operator<<(ostream& os,
 461                     const QuicConnectionCloseFrame& connection_close_frame) {
 462   os << "error_code { " << connection_close_frame.error_code << " } "
 463      << "error_details { " << connection_close_frame.error_details << " }\n";
 464   return os;
 465 }
 466
 467 ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) {
 468   os << "error_code { " << goaway_frame.error_code << " } "
 469      << "last_good_stream_id { " << goaway_frame.last_good_stream_id << " } "
 470      << "reason_phrase { " << goaway_frame.reason_phrase << " }\n";
 471   return os;
 472 }
 473
 474 ostream& operator<<(ostream& os,
 475                     const QuicWindowUpdateFrame& window_update_frame) {
 476   os << "stream_id { " << window_update_frame.stream_id << " } "
 477      << "byte_offset { " << window_update_frame.byte_offset << " }\n";
 478   return os;
 479 }
 480
 481 ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) {
 482   os << "stream_id { " << blocked_frame.stream_id << " }\n";
 483   return os;
 484 }
 485
 486 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
 487   os << "stream_id { " << stream_frame.stream_id << " } "
 488      << "fin { " << stream_frame.fin << " } "
 489      << "offset { " << stream_frame.offset << " } "
 490      << "data { "
 491      << QuicUtils::StringToHexASCIIDump(*(stream_frame.GetDataAsString()))
 492      << " }\n";
 493   return os;
 494 }
 495
 496 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
 497   os << "sent info { " << ack_frame.sent_info << " } "
 498      << "received info { " << ack_frame.received_info << " }\n";
 499   return os;
 500 }
 501
 502 ostream& operator<<(ostream& os,
 503                     const QuicCongestionFeedbackFrame& congestion_frame) {
 504   os << "type: " << congestion_frame.type;
 505   switch (congestion_frame.type) {
 506     case kInterArrival: {
 507       const CongestionFeedbackMessageInterArrival& inter_arrival =
 508           congestion_frame.inter_arrival;
 509       os << " received packets: [ ";
 510       for (TimeMap::const_iterator it =
 511                inter_arrival.received_packet_times.begin();
 512            it != inter_arrival.received_packet_times.end(); ++it) {
 513         os << it->first << "@" << it->second.ToDebuggingValue() << " ";
 514       }
 515       os << "]";
 516       break;
 517     }
 518     case kFixRate: {
 519       os << " bitrate_in_bytes_per_second: "
 520          << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
 521       break;
 522     }
 523     case kTCP: {
 524       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
 525       os << " receive_window: " << tcp.receive_window;
 526       break;
 527     }
 528   }
 529   return os;
 530 }
 531
 532 CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
 533     : bitrate(QuicBandwidth::Zero()) {
 534 }
 535
 536 QuicGoAwayFrame::QuicGoAwayFrame()
 537     : error_code(QUIC_NO_ERROR),
 538       last_good_stream_id(0) {
 539 }
 540
 541 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
 542                                  QuicStreamId last_good_stream_id,
 543                                  const string& reason)
 544     : error_code(error_code),
 545       last_good_stream_id(last_good_stream_id),
 546       reason_phrase(reason) {
 547   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 548 }
 549
 550 QuicData::QuicData(const char* buffer,
 551                    size_t length)
 552     : buffer_(buffer),
 553       length_(length),
 554       owns_buffer_(false) {
 555 }
 556
 557 QuicData::QuicData(char* buffer,
 558                    size_t length,
 559                    bool owns_buffer)
 560     : buffer_(buffer),
 561       length_(length),
 562       owns_buffer_(owns_buffer) {
 563 }
 564
 565 QuicData::~QuicData() {
 566   if (owns_buffer_) {
 567     delete [] const_cast<char*>(buffer_);
 568   }
 569 }
 570
 571 QuicWindowUpdateFrame::QuicWindowUpdateFrame(QuicStreamId stream_id,
 572                                              QuicStreamOffset byte_offset)
 573     : stream_id(stream_id),
 574       byte_offset(byte_offset) {}
 575
 576 QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id)
 577     : stream_id(stream_id) {}
 578
 579 QuicPacket::QuicPacket(char* buffer,
 580                        size_t length,
 581                        bool owns_buffer,
 582                        QuicConnectionIdLength connection_id_length,
 583                        bool includes_version,
 584                        QuicSequenceNumberLength sequence_number_length,
 585                        bool is_fec_packet)
 586     : QuicData(buffer, length, owns_buffer),
 587       buffer_(buffer),
 588       is_fec_packet_(is_fec_packet),
 589       connection_id_length_(connection_id_length),
 590       includes_version_(includes_version),
 591       sequence_number_length_(sequence_number_length) {
 592 }
 593
 594 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer,
 595                                          size_t length)
 596     : QuicData(buffer, length) {
 597 }
 598
 599 QuicEncryptedPacket::QuicEncryptedPacket(char* buffer,
 600                                          size_t length,
 601                                          bool owns_buffer)
 602       : QuicData(buffer, length, owns_buffer) {
 603 }
 604
 605 StringPiece QuicPacket::FecProtectedData() const {
 606   const size_t start_of_fec = GetStartOfFecProtectedData(
 607       connection_id_length_, includes_version_, sequence_number_length_);
 608   return StringPiece(data() + start_of_fec, length() - start_of_fec);
 609 }
 610
 611 StringPiece QuicPacket::AssociatedData() const {
 612   return StringPiece(
 613       data() + kStartOfHashData,
 614       GetStartOfEncryptedData(
 615           connection_id_length_, includes_version_, sequence_number_length_) -
 616       kStartOfHashData);
 617 }
 618
 619 StringPiece QuicPacket::BeforePlaintext() const {
 620   return StringPiece(data(), GetStartOfEncryptedData(connection_id_length_,
 621                                                      includes_version_,
 622                                                      sequence_number_length_));
 623 }
 624
 625 StringPiece QuicPacket::Plaintext() const {
 626   const size_t start_of_encrypted_data =
 627       GetStartOfEncryptedData(
 628           connection_id_length_, includes_version_, sequence_number_length_);
 629   return StringPiece(data() + start_of_encrypted_data,
 630                      length() - start_of_encrypted_data);
 631 }
 632
 633 RetransmittableFrames::RetransmittableFrames()
 634     : encryption_level_(NUM_ENCRYPTION_LEVELS) {
 635 }
 636
 637 RetransmittableFrames::~RetransmittableFrames() {
 638   for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
 639     switch (it->type) {
 640       case PADDING_FRAME:
 641         delete it->padding_frame;
 642         break;
 643       case STREAM_FRAME:
 644         delete it->stream_frame;
 645         break;
 646       case ACK_FRAME:
 647         delete it->ack_frame;
 648         break;
 649       case CONGESTION_FEEDBACK_FRAME:
 650         delete it->congestion_feedback_frame;
 651         break;
 652       case STOP_WAITING_FRAME:
 653         delete it->stop_waiting_frame;
 654         break;
 655       case PING_FRAME:
 656         delete it->ping_frame;
 657         break;
 658       case RST_STREAM_FRAME:
 659         delete it->rst_stream_frame;
 660         break;
 661       case CONNECTION_CLOSE_FRAME:
 662         delete it->connection_close_frame;
 663         break;
 664       case GOAWAY_FRAME:
 665         delete it->goaway_frame;
 666         break;
 667       case WINDOW_UPDATE_FRAME:
 668         delete it->window_update_frame;
 669         break;
 670       case BLOCKED_FRAME:
 671         delete it->blocked_frame;
 672         break;
 673       case NUM_FRAME_TYPES:
 674         DCHECK(false) << "Cannot delete type: " << it->type;
 675     }
 676   }
 677   STLDeleteElements(&stream_data_);
 678 }
 679
 680 const QuicFrame& RetransmittableFrames::AddStreamFrame(
 681     QuicStreamFrame* stream_frame) {
 682   // Make an owned copy of the stream frame's data.
 683   stream_data_.push_back(stream_frame->GetDataAsString());
 684   // Ensure the stream frame's IOVector points to the owned copy of the data.
 685   stream_frame->data.Clear();
 686   stream_frame->data.Append(const_cast<char*>(stream_data_.back()->data()),
 687                             stream_data_.back()->size());
 688   frames_.push_back(QuicFrame(stream_frame));
 689   return frames_.back();
 690 }
 691
 692 const QuicFrame& RetransmittableFrames::AddNonStreamFrame(
 693     const QuicFrame& frame) {
 694   DCHECK_NE(frame.type, STREAM_FRAME);
 695   frames_.push_back(frame);
 696   return frames_.back();
 697 }
 698
 699 IsHandshake RetransmittableFrames::HasCryptoHandshake() const {
 700   for (size_t i = 0; i < frames().size(); ++i) {
 701     if (frames()[i].type == STREAM_FRAME &&
 702         frames()[i].stream_frame->stream_id == kCryptoStreamId) {
 703       return IS_HANDSHAKE;
 704     }
 705   }
 706   return NOT_HANDSHAKE;
 707 }
 708
 709 void RetransmittableFrames::set_encryption_level(EncryptionLevel level) {
 710   encryption_level_ = level;
 711 }
 712
 713 SerializedPacket::SerializedPacket(
 714     QuicPacketSequenceNumber sequence_number,
 715     QuicSequenceNumberLength sequence_number_length,
 716     QuicPacket* packet,
 717     QuicPacketEntropyHash entropy_hash,
 718     RetransmittableFrames* retransmittable_frames)
 719     : sequence_number(sequence_number),
 720       sequence_number_length(sequence_number_length),
 721       packet(packet),
 722       entropy_hash(entropy_hash),
 723       retransmittable_frames(retransmittable_frames) {
 724 }
 725
 726 SerializedPacket::~SerializedPacket() {}
 727
 728 QuicEncryptedPacket* QuicEncryptedPacket::Clone() const {
 729   char* buffer = new char[this->length()];
 730   memcpy(buffer, this->data(), this->length());
 731   return new QuicEncryptedPacket(buffer, this->length(), true);
 732 }
 733
 734 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) {
 735   os << s.length() << "-byte data";
 736   return os;
 737 }
 738
 739 TransmissionInfo::TransmissionInfo()
 740     : retransmittable_frames(NULL),
 741       sequence_number_length(PACKET_1BYTE_SEQUENCE_NUMBER),
 742       sent_time(QuicTime::Zero()),
 743       bytes_sent(0),
 744       nack_count(0),
 745       all_transmissions(NULL),
 746       pending(false) { }
 747
 748 TransmissionInfo::TransmissionInfo(
 749     RetransmittableFrames* retransmittable_frames,
 750     QuicPacketSequenceNumber sequence_number,
 751     QuicSequenceNumberLength sequence_number_length)
 752     : retransmittable_frames(retransmittable_frames),
 753       sequence_number_length(sequence_number_length),
 754       sent_time(QuicTime::Zero()),
 755       bytes_sent(0),
 756       nack_count(0),
 757       all_transmissions(new SequenceNumberSet),
 758       pending(false) {
 759   all_transmissions->insert(sequence_number);
 760 }
 761
 762 TransmissionInfo::TransmissionInfo(
 763     RetransmittableFrames* retransmittable_frames,
 764     QuicPacketSequenceNumber sequence_number,
 765     QuicSequenceNumberLength sequence_number_length,
 766     SequenceNumberSet* all_transmissions)
 767     : retransmittable_frames(retransmittable_frames),
 768       sequence_number_length(sequence_number_length),
 769       sent_time(QuicTime::Zero()),
 770       bytes_sent(0),
 771       nack_count(0),
 772       all_transmissions(all_transmissions),
 773       pending(false) {
 774   all_transmissions->insert(sequence_number);
 775 }
 776
 777 QuicConsumedData::QuicConsumedData(size_t bytes_consumed,
 778                                    bool fin_consumed)
 779       : bytes_consumed(bytes_consumed),
 780         fin_consumed(fin_consumed) {
 781 }
 782
 783 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
 784   os << "bytes_consumed: " << s.bytes_consumed
 785      << " fin_consumed: " << s.fin_consumed;
 786   return os;
 787 }
 788
 789 WriteResult::WriteResult()
 790     : status(WRITE_STATUS_ERROR),
 791       bytes_written(0) {
 792 }
 793
 794 WriteResult::WriteResult(WriteStatus status,
 795                          int bytes_written_or_error_code)
 796     : status(status),
 797       bytes_written(bytes_written_or_error_code) {
 798 }
 799
 800 }  // namespace net