quic_protocol.h revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
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#ifndef NET_QUIC_QUIC_PROTOCOL_H_ 6#define NET_QUIC_QUIC_PROTOCOL_H_ 7 8#include <stddef.h> 9#include <limits> 10#include <map> 11#include <ostream> 12#include <set> 13#include <string> 14#include <utility> 15#include <vector> 16 17#include "base/basictypes.h" 18#include "base/hash_tables.h" 19#include "base/logging.h" 20#include "base/strings/string_piece.h" 21#include "net/base/int128.h" 22#include "net/base/net_export.h" 23#include "net/quic/quic_bandwidth.h" 24#include "net/quic/quic_time.h" 25 26namespace net { 27 28using ::operator<<; 29 30class QuicPacket; 31 32typedef uint64 QuicGuid; 33typedef uint32 QuicStreamId; 34typedef uint64 QuicStreamOffset; 35typedef uint64 QuicPacketSequenceNumber; 36typedef QuicPacketSequenceNumber QuicFecGroupNumber; 37typedef uint64 QuicPublicResetNonceProof; 38typedef uint8 QuicPacketEntropyHash; 39typedef uint32 QuicVersionTag; 40typedef std::vector<QuicVersionTag> QuicVersionTagList; 41 42// TODO(rch): Consider Quic specific names for these constants. 43// Maximum size in bytes of a QUIC packet. 44const QuicByteCount kMaxPacketSize = 1200; 45 46// Maximum number of open streams per connection. 47const size_t kDefaultMaxStreamsPerConnection = 100; 48 49// Number of bytes reserved for guid in the packet header. 50const size_t kQuicGuidSize = 8; 51// Number of bytes reserved for public flags in the packet header. 52const size_t kPublicFlagsSize = 1; 53// Number of bytes reserved for version number in the packet header. 54const size_t kQuicVersionSize = 4; 55// Number of bytes reserved for sequence number in the packet header. 56const size_t kSequenceNumberSize = 6; 57// Number of bytes reserved for private flags in the packet header. 58const size_t kPrivateFlagsSize = 1; 59// Number of bytes reserved for FEC group in the packet header. 60const size_t kFecGroupSize = 1; 61// Number of bytes reserved for the nonce proof in public reset packet. 62const size_t kPublicResetNonceSize = 8; 63 64// Signifies that the QuicPacket will contain version of the protocol. 65const bool kIncludeVersion = true; 66 67// Size in bytes of the data or fec packet header. 68NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(bool include_version); 69// Size in bytes of the public reset packet. 70NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize(); 71 72// Index of the first byte in a QUIC packet of FEC protected data. 73NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(bool include_version); 74// Index of the first byte in a QUIC packet of encrypted data. 75NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(bool include_version); 76// Returns true if |version| is a supported protocol version. 77NET_EXPORT_PRIVATE bool IsSupportedVersion(QuicVersionTag version); 78 79// Index of the first byte in a QUIC packet which is used in hash calculation. 80const size_t kStartOfHashData = 0; 81 82// Limit on the delta between stream IDs. 83const QuicStreamId kMaxStreamIdDelta = 100; 84 85// Reserved ID for the crypto stream. 86// TODO(rch): ensure that this is not usable by any other streams. 87const QuicStreamId kCryptoStreamId = 1; 88 89// Value which indicates this packet is not FEC protected. 90const uint8 kNoFecOffset = 0xFF; 91 92const int64 kDefaultTimeoutUs = 600000000; // 10 minutes. 93 94enum Retransmission { 95 NOT_RETRANSMISSION = 0, 96 IS_RETRANSMISSION = 1, 97}; 98 99enum HasRetransmittableData { 100 HAS_RETRANSMITTABLE_DATA = 0, 101 NO_RETRANSMITTABLE_DATA = 1, 102}; 103 104enum QuicFrameType { 105 PADDING_FRAME = 0, 106 STREAM_FRAME, 107 ACK_FRAME, 108 CONGESTION_FEEDBACK_FRAME, 109 RST_STREAM_FRAME, 110 CONNECTION_CLOSE_FRAME, 111 GOAWAY_FRAME, 112 NUM_FRAME_TYPES 113}; 114 115enum QuicPacketPublicFlags { 116 PACKET_PUBLIC_FLAGS_NONE = 0, 117 PACKET_PUBLIC_FLAGS_VERSION = 1 << 0, // Packet header contains version info. 118 PACKET_PUBLIC_FLAGS_RST = 1 << 1, // Packet is a public reset packet. 119 PACKET_PUBLIC_FLAGS_MAX = (1 << 2) - 1 // All bits set. 120}; 121 122enum QuicPacketPrivateFlags { 123 PACKET_PRIVATE_FLAGS_NONE = 0, 124 PACKET_PRIVATE_FLAGS_FEC = 1 << 0, // Payload is FEC as opposed to frames. 125 PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 1, 126 PACKET_PRIVATE_FLAGS_FEC_ENTROPY = 1 << 2, 127 PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1 // All bits set. 128}; 129 130enum QuicRstStreamErrorCode { 131 QUIC_STREAM_NO_ERROR = 0, 132 133 // There was some server error which halted stream processing. 134 QUIC_SERVER_ERROR_PROCESSING_STREAM, 135 // We got two fin or reset offsets which did not match. 136 QUIC_MULTIPLE_TERMINATION_OFFSETS, 137 // We got bad payload and can not respond to it at the protocol level. 138 QUIC_BAD_APPLICATION_PAYLOAD, 139 // Stream closed due to connection error. No reset frame is sent when this 140 // happens. 141 QUIC_STREAM_CONNECTION_ERROR, 142 // GoAway frame sent. No more stream can be created. 143 QUIC_STREAM_PEER_GOING_AWAY, 144 145 // No error. Used as bound while iterating. 146 QUIC_STREAM_LAST_ERROR, 147}; 148 149enum QuicErrorCode { 150 QUIC_NO_ERROR = 0, 151 152 // Connection has reached an invalid state. 153 QUIC_INTERNAL_ERROR, 154 // There were data frames after the a fin or reset. 155 QUIC_STREAM_DATA_AFTER_TERMINATION, 156 // Control frame is malformed. 157 QUIC_INVALID_PACKET_HEADER, 158 // Frame data is malformed. 159 QUIC_INVALID_FRAME_DATA, 160 // FEC data is malformed. 161 QUIC_INVALID_FEC_DATA, 162 // Stream rst data is malformed 163 QUIC_INVALID_RST_STREAM_DATA, 164 // Connection close data is malformed. 165 QUIC_INVALID_CONNECTION_CLOSE_DATA, 166 // GoAway data is malformed. 167 QUIC_INVALID_GOAWAY_DATA, 168 // Ack data is malformed. 169 QUIC_INVALID_ACK_DATA, 170 // Version negotiation packet is malformed. 171 QUIC_INVALID_VERSION_NEGOTIATION_PACKET, 172 // There was an error decrypting. 173 QUIC_DECRYPTION_FAILURE, 174 // There was an error encrypting. 175 QUIC_ENCRYPTION_FAILURE, 176 // The packet exceeded kMaxPacketSize. 177 QUIC_PACKET_TOO_LARGE, 178 // Data was sent for a stream which did not exist. 179 QUIC_PACKET_FOR_NONEXISTENT_STREAM, 180 // The peer is going away. May be a client or server. 181 QUIC_PEER_GOING_AWAY, 182 // A stream ID was invalid. 183 QUIC_INVALID_STREAM_ID, 184 // Too many streams already open. 185 QUIC_TOO_MANY_OPEN_STREAMS, 186 // Received public reset for this connection. 187 QUIC_PUBLIC_RESET, 188 // Invalid protocol version 189 QUIC_INVALID_VERSION, 190 191 // We hit our prenegotiated (or default) timeout 192 QUIC_CONNECTION_TIMED_OUT, 193 194 // Crypto errors. 195 196 // Handshake message contained out of order tags. 197 QUIC_CRYPTO_TAGS_OUT_OF_ORDER, 198 // Handshake message contained too many entries. 199 QUIC_CRYPTO_TOO_MANY_ENTRIES, 200 // Handshake message contained an invalid value length. 201 QUIC_CRYPTO_INVALID_VALUE_LENGTH, 202 // A crypto message was received after the handshake was complete. 203 QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, 204 // A crypto message was received with an illegal message tag. 205 QUIC_INVALID_CRYPTO_MESSAGE_TYPE, 206 // A crypto message was received with an illegal parameter. 207 QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, 208 // A crypto message was received with a mandatory parameter missing. 209 QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND, 210 // A crypto message was received with a parameter that has no overlap 211 // with the local parameter. 212 QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP, 213 // A crypto message was received that contained a parameter with too few 214 // values. 215 QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND, 216 // An internal error occured in crypto processing. 217 QUIC_CRYPTO_INTERNAL_ERROR, 218 // A crypto handshake message specified an unsupported version. 219 QUIC_CRYPTO_VERSION_NOT_SUPPORTED, 220 // There was no intersection between the crypto primitives supported by the 221 // peer and ourselves. 222 QUIC_CRYPTO_NO_SUPPORT, 223 // The server rejected our client hello messages too many times. 224 QUIC_CRYPTO_TOO_MANY_REJECTS, 225 // The client rejected the server's certificate chain or signature. 226 QUIC_PROOF_INVALID, 227 // A crypto message was received with a duplicate tag. 228 QUIC_CRYPTO_DUPLICATE_TAG, 229 230 // No error. Used as bound while iterating. 231 QUIC_LAST_ERROR, 232}; 233 234// Version and Crypto tags are written to the wire with a big-endian 235// representation of the name of the tag. For example 236// the client hello tag (CHLO) will be written as the 237// following 4 bytes: 'C' 'H' 'L' 'O'. Since it is 238// stored in memory as a little endian uint32, we need 239// to reverse the order of the bytes. 240// 241// The TAG macro is used in header files to ensure that we don't create static 242// initialisers. In normal code, the MakeQuicTag function should be used. 243#define TAG(a, b, c, d) ((d << 24) + (c << 16) + (b << 8) + a) 244const QuicVersionTag kUnsupportedVersion = -1; 245const QuicVersionTag kQuicVersion1 = TAG('Q', '1', '.', '0'); 246#undef TAG 247 248// MakeQuicTag returns a value given the four bytes. For example: 249// MakeQuicTag('C', 'H', 'L', 'O'); 250uint32 NET_EXPORT_PRIVATE MakeQuicTag(char a, char b, char c, char d); 251 252struct NET_EXPORT_PRIVATE QuicPacketPublicHeader { 253 QuicPacketPublicHeader(); 254 explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other); 255 ~QuicPacketPublicHeader(); 256 257 QuicPacketPublicHeader& operator=(const QuicPacketPublicHeader& other); 258 259 // Universal header. All QuicPacket headers will have a guid and public flags. 260 QuicGuid guid; 261 bool reset_flag; 262 bool version_flag; 263 QuicVersionTagList versions; 264}; 265 266// Header for Data or FEC packets. 267struct NET_EXPORT_PRIVATE QuicPacketHeader { 268 QuicPacketHeader(); 269 explicit QuicPacketHeader(const QuicPacketPublicHeader& header); 270 271 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 272 std::ostream& os, const QuicPacketHeader& s); 273 274 QuicPacketPublicHeader public_header; 275 bool fec_flag; 276 bool fec_entropy_flag; 277 bool entropy_flag; 278 QuicPacketEntropyHash entropy_hash; 279 QuicPacketSequenceNumber packet_sequence_number; 280 QuicFecGroupNumber fec_group; 281}; 282 283struct NET_EXPORT_PRIVATE QuicPublicResetPacket { 284 QuicPublicResetPacket() {} 285 explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header) 286 : public_header(header) {} 287 QuicPacketPublicHeader public_header; 288 QuicPacketSequenceNumber rejected_sequence_number; 289 QuicPublicResetNonceProof nonce_proof; 290}; 291 292enum QuicVersionNegotiationState { 293 START_NEGOTIATION = 0, 294 SENT_NEGOTIATION_PACKET, 295 NEGOTIATED_VERSION 296}; 297 298typedef QuicPacketPublicHeader QuicVersionNegotiationPacket; 299 300// A padding frame contains no payload. 301struct NET_EXPORT_PRIVATE QuicPaddingFrame { 302}; 303 304struct NET_EXPORT_PRIVATE QuicStreamFrame { 305 QuicStreamFrame(); 306 QuicStreamFrame(QuicStreamId stream_id, 307 bool fin, 308 QuicStreamOffset offset, 309 base::StringPiece data); 310 311 QuicStreamId stream_id; 312 bool fin; 313 QuicStreamOffset offset; // Location of this data in the stream. 314 base::StringPiece data; 315}; 316 317// TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing 318// is finalized. 319typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet; 320// TODO(pwestin): Add a way to enforce the max size of this map. 321typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap; 322 323struct NET_EXPORT_PRIVATE ReceivedPacketInfo { 324 ReceivedPacketInfo(); 325 ~ReceivedPacketInfo(); 326 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 327 std::ostream& os, const ReceivedPacketInfo& s); 328 329 // Entropy hash of all packets up to largest observed not including missing 330 // packets. 331 QuicPacketEntropyHash entropy_hash; 332 333 // The highest packet sequence number we've observed from the peer. 334 // 335 // In general, this should be the largest packet number we've received. In 336 // the case of truncated acks, we may have to advertise a lower "upper bound" 337 // than largest received, to avoid implicitly acking missing packets that 338 // don't fit in the missing packet list due to size limitations. In this 339 // case, largest_observed may be a packet which is also in the missing packets 340 // list. 341 QuicPacketSequenceNumber largest_observed; 342 343 // Time elapsed since largest_observed was received until this Ack frame was 344 // sent. 345 QuicTime::Delta delta_time_largest_observed; 346 347 // TODO(satyamshekhar): Can be optimized using an interval set like data 348 // structure. 349 // The set of packets which we're expecting and have not received. 350 SequenceNumberSet missing_packets; 351}; 352 353// True if the sequence number is greater than largest_observed or is listed 354// as missing. 355// Always returns false for sequence numbers less than least_unacked. 356bool NET_EXPORT_PRIVATE IsAwaitingPacket( 357 const ReceivedPacketInfo& received_info, 358 QuicPacketSequenceNumber sequence_number); 359 360// Inserts missing packets between [lower, higher). 361void NET_EXPORT_PRIVATE InsertMissingPacketsBetween( 362 ReceivedPacketInfo* received_info, 363 QuicPacketSequenceNumber lower, 364 QuicPacketSequenceNumber higher); 365 366struct NET_EXPORT_PRIVATE SentPacketInfo { 367 SentPacketInfo(); 368 ~SentPacketInfo(); 369 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 370 std::ostream& os, const SentPacketInfo& s); 371 372 // Entropy hash of all packets up to, but not including, the least unacked 373 // packet. 374 QuicPacketEntropyHash entropy_hash; 375 // The lowest packet we've sent which is unacked, and we expect an ack for. 376 QuicPacketSequenceNumber least_unacked; 377}; 378 379struct NET_EXPORT_PRIVATE QuicAckFrame { 380 QuicAckFrame() {} 381 // Testing convenience method to construct a QuicAckFrame with all packets 382 // from least_unacked to largest_observed acked. 383 QuicAckFrame(QuicPacketSequenceNumber largest_observed, 384 QuicTime largest_observed_receive_time, 385 QuicPacketSequenceNumber least_unacked); 386 387 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 388 std::ostream& os, const QuicAckFrame& s); 389 390 SentPacketInfo sent_info; 391 ReceivedPacketInfo received_info; 392}; 393 394// Defines for all types of congestion feedback that will be negotiated in QUIC, 395// kTCP MUST be supported by all QUIC implementations to guarentee 100% 396// compatibility. 397enum CongestionFeedbackType { 398 kTCP, // Used to mimic TCP. 399 kInterArrival, // Use additional inter arrival information. 400 kFixRate, // Provided for testing. 401}; 402 403struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP { 404 uint16 accumulated_number_of_lost_packets; 405 QuicByteCount receive_window; 406}; 407 408struct NET_EXPORT_PRIVATE CongestionFeedbackMessageInterArrival { 409 CongestionFeedbackMessageInterArrival(); 410 ~CongestionFeedbackMessageInterArrival(); 411 uint16 accumulated_number_of_lost_packets; 412 // The set of received packets since the last feedback was sent, along with 413 // their arrival times. 414 TimeMap received_packet_times; 415}; 416 417struct NET_EXPORT_PRIVATE CongestionFeedbackMessageFixRate { 418 CongestionFeedbackMessageFixRate(); 419 QuicBandwidth bitrate; 420}; 421 422struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame { 423 QuicCongestionFeedbackFrame(); 424 ~QuicCongestionFeedbackFrame(); 425 426 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 427 std::ostream& os, const QuicCongestionFeedbackFrame& c); 428 429 CongestionFeedbackType type; 430 // This should really be a union, but since the inter arrival struct 431 // is non-trivial, C++ prohibits it. 432 CongestionFeedbackMessageTCP tcp; 433 CongestionFeedbackMessageInterArrival inter_arrival; 434 CongestionFeedbackMessageFixRate fix_rate; 435}; 436 437struct NET_EXPORT_PRIVATE QuicRstStreamFrame { 438 QuicRstStreamFrame() {} 439 QuicRstStreamFrame(QuicStreamId stream_id, QuicRstStreamErrorCode error_code) 440 : stream_id(stream_id), error_code(error_code) { 441 DCHECK_LE(error_code, std::numeric_limits<uint8>::max()); 442 } 443 444 QuicStreamId stream_id; 445 QuicRstStreamErrorCode error_code; 446 std::string error_details; 447}; 448 449struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame { 450 QuicErrorCode error_code; 451 std::string error_details; 452 QuicAckFrame ack_frame; 453}; 454 455struct NET_EXPORT_PRIVATE QuicGoAwayFrame { 456 QuicGoAwayFrame() {} 457 QuicGoAwayFrame(QuicErrorCode error_code, 458 QuicStreamId last_good_stream_id, 459 const std::string& reason); 460 461 QuicErrorCode error_code; 462 QuicStreamId last_good_stream_id; 463 std::string reason_phrase; 464}; 465 466// EncryptionLevel enumerates the stages of encryption that a QUIC connection 467// progresses through. When retransmitting a packet, the encryption level needs 468// to be specified so that it is retransmitted at a level which the peer can 469// understand. 470enum EncryptionLevel { 471 ENCRYPTION_NONE = 0, 472 ENCRYPTION_INITIAL = 1, 473 ENCRYPTION_FORWARD_SECURE = 2, 474 475 NUM_ENCRYPTION_LEVELS, 476}; 477 478struct NET_EXPORT_PRIVATE QuicFrame { 479 QuicFrame() {} 480 explicit QuicFrame(QuicPaddingFrame* padding_frame) 481 : type(PADDING_FRAME), 482 padding_frame(padding_frame) { 483 } 484 explicit QuicFrame(QuicStreamFrame* stream_frame) 485 : type(STREAM_FRAME), 486 stream_frame(stream_frame) { 487 } 488 explicit QuicFrame(QuicAckFrame* frame) 489 : type(ACK_FRAME), 490 ack_frame(frame) { 491 } 492 explicit QuicFrame(QuicCongestionFeedbackFrame* frame) 493 : type(CONGESTION_FEEDBACK_FRAME), 494 congestion_feedback_frame(frame) { 495 } 496 explicit QuicFrame(QuicRstStreamFrame* frame) 497 : type(RST_STREAM_FRAME), 498 rst_stream_frame(frame) { 499 } 500 explicit QuicFrame(QuicConnectionCloseFrame* frame) 501 : type(CONNECTION_CLOSE_FRAME), 502 connection_close_frame(frame) { 503 } 504 explicit QuicFrame(QuicGoAwayFrame* frame) 505 : type(GOAWAY_FRAME), 506 goaway_frame(frame) { 507 } 508 509 QuicFrameType type; 510 union { 511 QuicPaddingFrame* padding_frame; 512 QuicStreamFrame* stream_frame; 513 QuicAckFrame* ack_frame; 514 QuicCongestionFeedbackFrame* congestion_feedback_frame; 515 QuicRstStreamFrame* rst_stream_frame; 516 QuicConnectionCloseFrame* connection_close_frame; 517 QuicGoAwayFrame* goaway_frame; 518 }; 519}; 520 521typedef std::vector<QuicFrame> QuicFrames; 522 523struct NET_EXPORT_PRIVATE QuicFecData { 524 QuicFecData(); 525 526 bool operator==(const QuicFecData& other) const; 527 528 // The FEC group number is also the sequence number of the first 529 // FEC protected packet. The last protected packet's sequence number will 530 // be one less than the sequence number of the FEC packet. 531 QuicFecGroupNumber fec_group; 532 base::StringPiece redundancy; 533}; 534 535struct NET_EXPORT_PRIVATE QuicPacketData { 536 std::string data; 537}; 538 539class NET_EXPORT_PRIVATE QuicData { 540 public: 541 QuicData(const char* buffer, size_t length) 542 : buffer_(buffer), 543 length_(length), 544 owns_buffer_(false) {} 545 546 QuicData(char* buffer, size_t length, bool owns_buffer) 547 : buffer_(buffer), 548 length_(length), 549 owns_buffer_(owns_buffer) {} 550 551 virtual ~QuicData(); 552 553 base::StringPiece AsStringPiece() const { 554 return base::StringPiece(data(), length()); 555 } 556 557 const char* data() const { return buffer_; } 558 size_t length() const { return length_; } 559 560 private: 561 const char* buffer_; 562 size_t length_; 563 bool owns_buffer_; 564 565 DISALLOW_COPY_AND_ASSIGN(QuicData); 566}; 567 568class NET_EXPORT_PRIVATE QuicPacket : public QuicData { 569 public: 570 static QuicPacket* NewDataPacket(char* buffer, 571 size_t length, 572 bool owns_buffer, 573 bool includes_version) { 574 return new QuicPacket(buffer, length, owns_buffer, includes_version, false); 575 } 576 577 static QuicPacket* NewFecPacket(char* buffer, 578 size_t length, 579 bool owns_buffer, 580 bool includes_version) { 581 return new QuicPacket(buffer, length, owns_buffer, includes_version, true); 582 } 583 584 base::StringPiece FecProtectedData() const; 585 base::StringPiece AssociatedData() const; 586 base::StringPiece BeforePlaintext() const; 587 base::StringPiece Plaintext() const; 588 589 bool is_fec_packet() const { return is_fec_packet_; } 590 591 bool includes_version() const { return includes_version_; } 592 593 char* mutable_data() { return buffer_; } 594 595 private: 596 QuicPacket(char* buffer, 597 size_t length, 598 bool owns_buffer, 599 bool includes_version, 600 bool is_fec_packet) 601 : QuicData(buffer, length, owns_buffer), 602 buffer_(buffer), 603 is_fec_packet_(is_fec_packet), 604 includes_version_(includes_version) {} 605 606 char* buffer_; 607 const bool is_fec_packet_; 608 const bool includes_version_; 609 610 DISALLOW_COPY_AND_ASSIGN(QuicPacket); 611}; 612 613class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData { 614 public: 615 QuicEncryptedPacket(const char* buffer, size_t length) 616 : QuicData(buffer, length) {} 617 618 QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer) 619 : QuicData(buffer, length, owns_buffer) {} 620 621 // By default, gtest prints the raw bytes of an object. The bool data 622 // member (in the base class QuicData) causes this object to have padding 623 // bytes, which causes the default gtest object printer to read 624 // uninitialize memory. So we need to teach gtest how to print this object. 625 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 626 std::ostream& os, const QuicEncryptedPacket& s); 627 628 private: 629 DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket); 630}; 631 632class NET_EXPORT_PRIVATE RetransmittableFrames { 633 public: 634 RetransmittableFrames(); 635 ~RetransmittableFrames(); 636 637 // Allocates a local copy of the referenced StringPiece has QuicStreamFrame 638 // use it. 639 // Takes ownership of |stream_frame|. 640 const QuicFrame& AddStreamFrame(QuicStreamFrame* stream_frame); 641 // Takes ownership of the frame inside |frame|. 642 const QuicFrame& AddNonStreamFrame(const QuicFrame& frame); 643 const QuicFrames& frames() const { return frames_; } 644 645 void set_encryption_level(EncryptionLevel level); 646 EncryptionLevel encryption_level() const { 647 return encryption_level_; 648 } 649 650 private: 651 QuicFrames frames_; 652 EncryptionLevel encryption_level_; 653 // Data referenced by the StringPiece of a QuicStreamFrame. 654 std::vector<std::string*> stream_data_; 655 656 DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames); 657}; 658 659struct NET_EXPORT_PRIVATE SerializedPacket { 660 SerializedPacket(QuicPacketSequenceNumber sequence_number, 661 QuicPacket* packet, 662 QuicPacketEntropyHash entropy_hash, 663 RetransmittableFrames* retransmittable_frames) 664 : sequence_number(sequence_number), 665 packet(packet), 666 entropy_hash(entropy_hash), 667 retransmittable_frames(retransmittable_frames) {} 668 669 QuicPacketSequenceNumber sequence_number; 670 QuicPacket* packet; 671 QuicPacketEntropyHash entropy_hash; 672 RetransmittableFrames* retransmittable_frames; 673}; 674 675// A struct for functions which consume data payloads and fins. 676// The first member of the pair indicates bytes consumed. 677// The second member of the pair indicates if an incoming fin was consumed. 678struct QuicConsumedData { 679 QuicConsumedData(size_t bytes_consumed, bool fin_consumed) 680 : bytes_consumed(bytes_consumed), 681 fin_consumed(fin_consumed) {} 682 683 // By default, gtest prints the raw bytes of an object. The bool data 684 // member causes this object to have padding bytes, which causes the 685 // default gtest object printer to read uninitialize memory. So we need 686 // to teach gtest how to print this object. 687 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 688 std::ostream& os, const QuicConsumedData& s); 689 690 size_t bytes_consumed; 691 bool fin_consumed; 692}; 693 694} // namespace net 695 696#endif // NET_QUIC_QUIC_PROTOCOL_H_ 697