quic_protocol.h revision 1e9bf3e0803691d0a228da41fc608347b6db4340
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/containers/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 QuicAckNotifier; 31class QuicPacket; 32struct QuicPacketHeader; 33 34typedef uint64 QuicGuid; 35typedef uint32 QuicStreamId; 36typedef uint64 QuicStreamOffset; 37typedef uint64 QuicPacketSequenceNumber; 38typedef QuicPacketSequenceNumber QuicFecGroupNumber; 39typedef uint64 QuicPublicResetNonceProof; 40typedef uint8 QuicPacketEntropyHash; 41typedef uint32 QuicHeaderId; 42// QuicTag is the type of a tag in the wire protocol. 43typedef uint32 QuicTag; 44typedef std::vector<QuicTag> QuicTagVector; 45typedef uint32 QuicPriority; 46 47// TODO(rch): Consider Quic specific names for these constants. 48// Maximum size in bytes of a QUIC packet. 49const QuicByteCount kMaxPacketSize = 1200; 50 51// Maximum number of open streams per connection. 52const size_t kDefaultMaxStreamsPerConnection = 100; 53 54// Number of bytes reserved for public flags in the packet header. 55const size_t kPublicFlagsSize = 1; 56// Number of bytes reserved for version number in the packet header. 57const size_t kQuicVersionSize = 4; 58// Number of bytes reserved for private flags in the packet header. 59const size_t kPrivateFlagsSize = 1; 60// Number of bytes reserved for FEC group in the packet header. 61const size_t kFecGroupSize = 1; 62// Number of bytes reserved for the nonce proof in public reset packet. 63const size_t kPublicResetNonceSize = 8; 64 65// Signifies that the QuicPacket will contain version of the protocol. 66const bool kIncludeVersion = true; 67 68// Index of the first byte in a QUIC packet which is used in hash calculation. 69const size_t kStartOfHashData = 0; 70 71// Limit on the delta between stream IDs. 72const QuicStreamId kMaxStreamIdDelta = 100; 73// Limit on the delta between header IDs. 74const QuicHeaderId kMaxHeaderIdDelta = 100; 75 76// Reserved ID for the crypto stream. 77// TODO(rch): ensure that this is not usable by any other streams. 78const QuicStreamId kCryptoStreamId = 1; 79 80// This is the default network timeout a for connection till the crypto 81// handshake succeeds and the negotiated timeout from the handshake is received. 82const int64 kDefaultInitialTimeoutSecs = 120; // 2 mins. 83const int64 kDefaultTimeoutSecs = 60 * 10; // 10 minutes. 84const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 5; // 5 secs. 85 86// We define an unsigned 16-bit floating point value, inspired by IEEE floats 87// (http://en.wikipedia.org/wiki/Half_precision_floating-point_format), 88// with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden 89// bit) and denormals, but without signs, transfinites or fractions. Wire format 90// 16 bits (little-endian byte order) are split into exponent (high 5) and 91// mantissa (low 11) and decoded as: 92// uint64 value; 93// if (exponent == 0) value = mantissa; 94// else value = (mantissa | 1 << 11) << (exponent - 1) 95const int kUFloat16ExponentBits = 5; 96const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2; // 30 97const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits; // 11 98const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1; // 12 99const uint64 kUFloat16MaxValue = // 0x3FFC0000000 100 ((GG_UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1) << 101 kUFloat16MaxExponent; 102 103enum TransmissionType { 104 NOT_RETRANSMISSION, 105 NACK_RETRANSMISSION, 106 RTO_RETRANSMISSION, 107}; 108 109enum HasRetransmittableData { 110 NO_RETRANSMITTABLE_DATA, 111 HAS_RETRANSMITTABLE_DATA, 112}; 113 114enum IsHandshake { 115 NOT_HANDSHAKE, 116 IS_HANDSHAKE 117}; 118 119enum QuicFrameType { 120 PADDING_FRAME = 0, 121 RST_STREAM_FRAME, 122 CONNECTION_CLOSE_FRAME, 123 GOAWAY_FRAME, 124 STREAM_FRAME, 125 ACK_FRAME, 126 CONGESTION_FEEDBACK_FRAME, 127 NUM_FRAME_TYPES 128}; 129 130enum QuicGuidLength { 131 PACKET_0BYTE_GUID = 0, 132 PACKET_1BYTE_GUID = 1, 133 PACKET_4BYTE_GUID = 4, 134 PACKET_8BYTE_GUID = 8 135}; 136 137enum InFecGroup { 138 NOT_IN_FEC_GROUP, 139 IN_FEC_GROUP, 140}; 141 142enum QuicSequenceNumberLength { 143 PACKET_1BYTE_SEQUENCE_NUMBER = 1, 144 PACKET_2BYTE_SEQUENCE_NUMBER = 2, 145 PACKET_4BYTE_SEQUENCE_NUMBER = 4, 146 PACKET_6BYTE_SEQUENCE_NUMBER = 6 147}; 148 149// The public flags are specified in one byte. 150enum QuicPacketPublicFlags { 151 PACKET_PUBLIC_FLAGS_NONE = 0, 152 153 // Bit 0: Does the packet header contains version info? 154 PACKET_PUBLIC_FLAGS_VERSION = 1 << 0, 155 156 // Bit 1: Is this packet a public reset packet? 157 PACKET_PUBLIC_FLAGS_RST = 1 << 1, 158 159 // Bits 2 and 3 specify the length of the GUID as follows: 160 // ----00--: 0 bytes 161 // ----01--: 1 byte 162 // ----10--: 4 bytes 163 // ----11--: 8 bytes 164 PACKET_PUBLIC_FLAGS_0BYTE_GUID = 0, 165 PACKET_PUBLIC_FLAGS_1BYTE_GUID = 1 << 2, 166 PACKET_PUBLIC_FLAGS_4BYTE_GUID = 1 << 3, 167 PACKET_PUBLIC_FLAGS_8BYTE_GUID = 1 << 3 | 1 << 2, 168 169 // Bits 4 and 5 describe the packet sequence number length as follows: 170 // --00----: 1 byte 171 // --01----: 2 bytes 172 // --10----: 4 bytes 173 // --11----: 6 bytes 174 PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE = 0, 175 PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE = 1 << 4, 176 PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE = 1 << 5, 177 PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE = 1 << 5 | 1 << 4, 178 179 // All bits set (bits 6 and 7 are not currently used): 00111111 180 PACKET_PUBLIC_FLAGS_MAX = (1 << 6) - 1 181}; 182 183// The private flags are specified in one byte. 184enum QuicPacketPrivateFlags { 185 PACKET_PRIVATE_FLAGS_NONE = 0, 186 187 // Bit 0: Does this packet contain an entropy bit? 188 PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 0, 189 190 // Bit 1: Payload is part of an FEC group? 191 PACKET_PRIVATE_FLAGS_FEC_GROUP = 1 << 1, 192 193 // Bit 2: Payload is FEC as opposed to frames? 194 PACKET_PRIVATE_FLAGS_FEC = 1 << 2, 195 196 // All bits set (bits 3-7 are not currently used): 00000111 197 PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1 198}; 199 200// The available versions of QUIC. Guaranteed that the integer value of the enum 201// will match the version number. 202// When adding a new version to this enum you should add it to 203// kSupportedQuicVersions (if appropriate), and also add a new case to the 204// helper methods QuicVersionToQuicTag, QuicTagToQuicVersion, and 205// QuicVersionToString. 206enum QuicVersion { 207 // Special case to indicate unknown/unsupported QUIC version. 208 QUIC_VERSION_UNSUPPORTED = 0, 209 210 QUIC_VERSION_10 = 10, 211 QUIC_VERSION_11 = 11, // Current version. 212}; 213 214// This vector contains QUIC versions which we currently support. 215// This should be ordered such that the highest supported version is the first 216// element, with subsequent elements in descending order (versions can be 217// skipped as necessary). 218static const QuicVersion kSupportedQuicVersions[] = 219 {QUIC_VERSION_11}; 220 221typedef std::vector<QuicVersion> QuicVersionVector; 222 223// Returns a vector of QUIC versions in kSupportedQuicVersions. 224NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions(); 225 226// QuicTag is written to and read from the wire, but we prefer to use 227// the more readable QuicVersion at other levels. 228// Helper function which translates from a QuicVersion to a QuicTag. Returns 0 229// if QuicVersion is unsupported. 230NET_EXPORT_PRIVATE QuicTag QuicVersionToQuicTag(const QuicVersion version); 231 232// Returns appropriate QuicVersion from a QuicTag. 233// Returns QUIC_VERSION_UNSUPPORTED if version_tag cannot be understood. 234NET_EXPORT_PRIVATE QuicVersion QuicTagToQuicVersion(const QuicTag version_tag); 235 236// Helper function which translates from a QuicVersion to a string. 237// Returns strings corresponding to enum names (e.g. QUIC_VERSION_6). 238NET_EXPORT_PRIVATE std::string QuicVersionToString(const QuicVersion version); 239 240// Returns comma separated list of string representations of QuicVersion enum 241// values in the supplied |versions| vector. 242NET_EXPORT_PRIVATE std::string QuicVersionVectorToString( 243 const QuicVersionVector& versions); 244 245// Version and Crypto tags are written to the wire with a big-endian 246// representation of the name of the tag. For example 247// the client hello tag (CHLO) will be written as the 248// following 4 bytes: 'C' 'H' 'L' 'O'. Since it is 249// stored in memory as a little endian uint32, we need 250// to reverse the order of the bytes. 251 252// MakeQuicTag returns a value given the four bytes. For example: 253// MakeQuicTag('C', 'H', 'L', 'O'); 254NET_EXPORT_PRIVATE QuicTag MakeQuicTag(char a, char b, char c, char d); 255 256// Size in bytes of the data or fec packet header. 257NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicPacketHeader header); 258 259NET_EXPORT_PRIVATE size_t GetPacketHeaderSize( 260 QuicGuidLength guid_length, 261 bool include_version, 262 QuicSequenceNumberLength sequence_number_length, 263 InFecGroup is_in_fec_group); 264 265// Size in bytes of the public reset packet. 266NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize(); 267 268// Index of the first byte in a QUIC packet of FEC protected data. 269NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData( 270 QuicGuidLength guid_length, 271 bool include_version, 272 QuicSequenceNumberLength sequence_number_length); 273// Index of the first byte in a QUIC packet of encrypted data. 274NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData( 275 QuicGuidLength guid_length, 276 bool include_version, 277 QuicSequenceNumberLength sequence_number_length); 278 279enum QuicRstStreamErrorCode { 280 QUIC_STREAM_NO_ERROR = 0, 281 282 // There was some error which halted stream processing. 283 QUIC_ERROR_PROCESSING_STREAM, 284 // We got two fin or reset offsets which did not match. 285 QUIC_MULTIPLE_TERMINATION_OFFSETS, 286 // We got bad payload and can not respond to it at the protocol level. 287 QUIC_BAD_APPLICATION_PAYLOAD, 288 // Stream closed due to connection error. No reset frame is sent when this 289 // happens. 290 QUIC_STREAM_CONNECTION_ERROR, 291 // GoAway frame sent. No more stream can be created. 292 QUIC_STREAM_PEER_GOING_AWAY, 293 // The stream has been cancelled. 294 QUIC_STREAM_CANCELLED, 295 296 // No error. Used as bound while iterating. 297 QUIC_STREAM_LAST_ERROR, 298}; 299 300// These values must remain stable as they are uploaded to UMA histograms. 301// To add a new error code, use the current value of QUIC_LAST_ERROR and 302// increment QUIC_LAST_ERROR. 303enum QuicErrorCode { 304 QUIC_NO_ERROR = 0, 305 306 // Connection has reached an invalid state. 307 QUIC_INTERNAL_ERROR = 1, 308 // There were data frames after the a fin or reset. 309 QUIC_STREAM_DATA_AFTER_TERMINATION = 2, 310 // Control frame is malformed. 311 QUIC_INVALID_PACKET_HEADER = 3, 312 // Frame data is malformed. 313 QUIC_INVALID_FRAME_DATA = 4, 314 // The packet contained no payload. 315 QUIC_MISSING_PAYLOAD = 48, 316 // FEC data is malformed. 317 QUIC_INVALID_FEC_DATA = 5, 318 // STREAM frame data is malformed. 319 QUIC_INVALID_STREAM_DATA = 46, 320 // RST_STREAM frame data is malformed. 321 QUIC_INVALID_RST_STREAM_DATA = 6, 322 // CONNECTION_CLOSE frame data is malformed. 323 QUIC_INVALID_CONNECTION_CLOSE_DATA = 7, 324 // GOAWAY frame data is malformed. 325 QUIC_INVALID_GOAWAY_DATA = 8, 326 // ACK frame data is malformed. 327 QUIC_INVALID_ACK_DATA = 9, 328 // CONGESTION_FEEDBACK frame data is malformed. 329 QUIC_INVALID_CONGESTION_FEEDBACK_DATA = 47, 330 // Version negotiation packet is malformed. 331 QUIC_INVALID_VERSION_NEGOTIATION_PACKET = 10, 332 // Public RST packet is malformed. 333 QUIC_INVALID_PUBLIC_RST_PACKET = 11, 334 // There was an error decrypting. 335 QUIC_DECRYPTION_FAILURE = 12, 336 // There was an error encrypting. 337 QUIC_ENCRYPTION_FAILURE = 13, 338 // The packet exceeded kMaxPacketSize. 339 QUIC_PACKET_TOO_LARGE = 14, 340 // Data was sent for a stream which did not exist. 341 QUIC_PACKET_FOR_NONEXISTENT_STREAM = 15, 342 // The peer is going away. May be a client or server. 343 QUIC_PEER_GOING_AWAY = 16, 344 // A stream ID was invalid. 345 QUIC_INVALID_STREAM_ID = 17, 346 // A priority was invalid. 347 QUIC_INVALID_PRIORITY = 49, 348 // Too many streams already open. 349 QUIC_TOO_MANY_OPEN_STREAMS = 18, 350 // Received public reset for this connection. 351 QUIC_PUBLIC_RESET = 19, 352 // Invalid protocol version. 353 QUIC_INVALID_VERSION = 20, 354 // Stream reset before headers decompressed. 355 QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED = 21, 356 // The Header ID for a stream was too far from the previous. 357 QUIC_INVALID_HEADER_ID = 22, 358 // Negotiable parameter received during handshake had invalid value. 359 QUIC_INVALID_NEGOTIATED_VALUE = 23, 360 // There was an error decompressing data. 361 QUIC_DECOMPRESSION_FAILURE = 24, 362 // We hit our prenegotiated (or default) timeout 363 QUIC_CONNECTION_TIMED_OUT = 25, 364 // There was an error encountered migrating addresses 365 QUIC_ERROR_MIGRATING_ADDRESS = 26, 366 // There was an error while writing to the socket. 367 QUIC_PACKET_WRITE_ERROR = 27, 368 // There was an error while reading from the socket. 369 QUIC_PACKET_READ_ERROR = 51, 370 // We received a STREAM_FRAME with no data and no fin flag set. 371 QUIC_INVALID_STREAM_FRAME = 50, 372 373 374 // Crypto errors. 375 376 // Hanshake failed. 377 QUIC_HANDSHAKE_FAILED = 28, 378 // Handshake message contained out of order tags. 379 QUIC_CRYPTO_TAGS_OUT_OF_ORDER = 29, 380 // Handshake message contained too many entries. 381 QUIC_CRYPTO_TOO_MANY_ENTRIES = 30, 382 // Handshake message contained an invalid value length. 383 QUIC_CRYPTO_INVALID_VALUE_LENGTH = 31, 384 // A crypto message was received after the handshake was complete. 385 QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE = 32, 386 // A crypto message was received with an illegal message tag. 387 QUIC_INVALID_CRYPTO_MESSAGE_TYPE = 33, 388 // A crypto message was received with an illegal parameter. 389 QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER = 34, 390 // An invalid channel id signature was supplied. 391 QUIC_INVALID_CHANNEL_ID_SIGNATURE = 52, 392 // A crypto message was received with a mandatory parameter missing. 393 QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND = 35, 394 // A crypto message was received with a parameter that has no overlap 395 // with the local parameter. 396 QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP = 36, 397 // A crypto message was received that contained a parameter with too few 398 // values. 399 QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND = 37, 400 // An internal error occured in crypto processing. 401 QUIC_CRYPTO_INTERNAL_ERROR = 38, 402 // A crypto handshake message specified an unsupported version. 403 QUIC_CRYPTO_VERSION_NOT_SUPPORTED = 39, 404 // There was no intersection between the crypto primitives supported by the 405 // peer and ourselves. 406 QUIC_CRYPTO_NO_SUPPORT = 40, 407 // The server rejected our client hello messages too many times. 408 QUIC_CRYPTO_TOO_MANY_REJECTS = 41, 409 // The client rejected the server's certificate chain or signature. 410 QUIC_PROOF_INVALID = 42, 411 // A crypto message was received with a duplicate tag. 412 QUIC_CRYPTO_DUPLICATE_TAG = 43, 413 // A crypto message was received with the wrong encryption level (i.e. it 414 // should have been encrypted but was not.) 415 QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT = 44, 416 // The server config for a server has expired. 417 QUIC_CRYPTO_SERVER_CONFIG_EXPIRED = 45, 418 // We failed to setup the symmetric keys for a connection. 419 QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED = 53, 420 421 // No error. Used as bound while iterating. 422 QUIC_LAST_ERROR = 54, 423}; 424 425struct NET_EXPORT_PRIVATE QuicPacketPublicHeader { 426 QuicPacketPublicHeader(); 427 explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other); 428 ~QuicPacketPublicHeader(); 429 430 // Universal header. All QuicPacket headers will have a guid and public flags. 431 QuicGuid guid; 432 QuicGuidLength guid_length; 433 bool reset_flag; 434 bool version_flag; 435 QuicSequenceNumberLength sequence_number_length; 436 QuicVersionVector versions; 437}; 438 439// Header for Data or FEC packets. 440struct NET_EXPORT_PRIVATE QuicPacketHeader { 441 QuicPacketHeader(); 442 explicit QuicPacketHeader(const QuicPacketPublicHeader& header); 443 444 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 445 std::ostream& os, const QuicPacketHeader& s); 446 447 QuicPacketPublicHeader public_header; 448 bool fec_flag; 449 bool entropy_flag; 450 QuicPacketEntropyHash entropy_hash; 451 QuicPacketSequenceNumber packet_sequence_number; 452 InFecGroup is_in_fec_group; 453 QuicFecGroupNumber fec_group; 454}; 455 456struct NET_EXPORT_PRIVATE QuicPublicResetPacket { 457 QuicPublicResetPacket() {} 458 explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header) 459 : public_header(header) {} 460 QuicPacketPublicHeader public_header; 461 QuicPacketSequenceNumber rejected_sequence_number; 462 QuicPublicResetNonceProof nonce_proof; 463}; 464 465enum QuicVersionNegotiationState { 466 START_NEGOTIATION = 0, 467 // Server-side this implies we've sent a version negotiation packet and are 468 // waiting on the client to select a compatible version. Client-side this 469 // implies we've gotten a version negotiation packet, are retransmitting the 470 // initial packets with a supported version and are waiting for our first 471 // packet from the server. 472 NEGOTIATION_IN_PROGRESS, 473 // This indicates this endpoint has received a packet from the peer with a 474 // version this endpoint supports. Version negotiation is complete, and the 475 // version number will no longer be sent with future packets. 476 NEGOTIATED_VERSION 477}; 478 479typedef QuicPacketPublicHeader QuicVersionNegotiationPacket; 480 481// A padding frame contains no payload. 482struct NET_EXPORT_PRIVATE QuicPaddingFrame { 483}; 484 485struct NET_EXPORT_PRIVATE QuicStreamFrame { 486 QuicStreamFrame(); 487 QuicStreamFrame(QuicStreamId stream_id, 488 bool fin, 489 QuicStreamOffset offset, 490 base::StringPiece data); 491 492 QuicStreamId stream_id; 493 bool fin; 494 QuicStreamOffset offset; // Location of this data in the stream. 495 base::StringPiece data; 496 497 // If this is set, then when this packet is ACKed the AckNotifier will be 498 // informed. 499 QuicAckNotifier* notifier; 500}; 501 502// TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing 503// is finalized. 504typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet; 505// TODO(pwestin): Add a way to enforce the max size of this map. 506typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap; 507 508struct NET_EXPORT_PRIVATE ReceivedPacketInfo { 509 ReceivedPacketInfo(); 510 ~ReceivedPacketInfo(); 511 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 512 std::ostream& os, const ReceivedPacketInfo& s); 513 514 // Entropy hash of all packets up to largest observed not including missing 515 // packets. 516 QuicPacketEntropyHash entropy_hash; 517 518 // The highest packet sequence number we've observed from the peer. 519 // 520 // In general, this should be the largest packet number we've received. In 521 // the case of truncated acks, we may have to advertise a lower "upper bound" 522 // than largest received, to avoid implicitly acking missing packets that 523 // don't fit in the missing packet list due to size limitations. In this 524 // case, largest_observed may be a packet which is also in the missing packets 525 // list. 526 QuicPacketSequenceNumber largest_observed; 527 528 // Time elapsed since largest_observed was received until this Ack frame was 529 // sent. 530 QuicTime::Delta delta_time_largest_observed; 531 532 // TODO(satyamshekhar): Can be optimized using an interval set like data 533 // structure. 534 // The set of packets which we're expecting and have not received. 535 SequenceNumberSet missing_packets; 536}; 537 538// True if the sequence number is greater than largest_observed or is listed 539// as missing. 540// Always returns false for sequence numbers less than least_unacked. 541bool NET_EXPORT_PRIVATE IsAwaitingPacket( 542 const ReceivedPacketInfo& received_info, 543 QuicPacketSequenceNumber sequence_number); 544 545// Inserts missing packets between [lower, higher). 546void NET_EXPORT_PRIVATE InsertMissingPacketsBetween( 547 ReceivedPacketInfo* received_info, 548 QuicPacketSequenceNumber lower, 549 QuicPacketSequenceNumber higher); 550 551struct NET_EXPORT_PRIVATE SentPacketInfo { 552 SentPacketInfo(); 553 ~SentPacketInfo(); 554 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 555 std::ostream& os, const SentPacketInfo& s); 556 557 // Entropy hash of all packets up to, but not including, the least unacked 558 // packet. 559 QuicPacketEntropyHash entropy_hash; 560 // The lowest packet we've sent which is unacked, and we expect an ack for. 561 QuicPacketSequenceNumber least_unacked; 562}; 563 564struct NET_EXPORT_PRIVATE QuicAckFrame { 565 QuicAckFrame() {} 566 // Testing convenience method to construct a QuicAckFrame with all packets 567 // from least_unacked to largest_observed acked. 568 QuicAckFrame(QuicPacketSequenceNumber largest_observed, 569 QuicTime largest_observed_receive_time, 570 QuicPacketSequenceNumber least_unacked); 571 572 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 573 std::ostream& os, const QuicAckFrame& s); 574 575 SentPacketInfo sent_info; 576 ReceivedPacketInfo received_info; 577}; 578 579// Defines for all types of congestion feedback that will be negotiated in QUIC, 580// kTCP MUST be supported by all QUIC implementations to guarantee 100% 581// compatibility. 582enum CongestionFeedbackType { 583 kTCP, // Used to mimic TCP. 584 kInterArrival, // Use additional inter arrival information. 585 kFixRate, // Provided for testing. 586}; 587 588struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP { 589 uint16 accumulated_number_of_lost_packets; 590 QuicByteCount receive_window; 591}; 592 593struct NET_EXPORT_PRIVATE CongestionFeedbackMessageInterArrival { 594 CongestionFeedbackMessageInterArrival(); 595 ~CongestionFeedbackMessageInterArrival(); 596 uint16 accumulated_number_of_lost_packets; 597 // The set of received packets since the last feedback was sent, along with 598 // their arrival times. 599 TimeMap received_packet_times; 600}; 601 602struct NET_EXPORT_PRIVATE CongestionFeedbackMessageFixRate { 603 CongestionFeedbackMessageFixRate(); 604 QuicBandwidth bitrate; 605}; 606 607struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame { 608 QuicCongestionFeedbackFrame(); 609 ~QuicCongestionFeedbackFrame(); 610 611 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 612 std::ostream& os, const QuicCongestionFeedbackFrame& c); 613 614 CongestionFeedbackType type; 615 // This should really be a union, but since the inter arrival struct 616 // is non-trivial, C++ prohibits it. 617 CongestionFeedbackMessageTCP tcp; 618 CongestionFeedbackMessageInterArrival inter_arrival; 619 CongestionFeedbackMessageFixRate fix_rate; 620}; 621 622struct NET_EXPORT_PRIVATE QuicRstStreamFrame { 623 QuicRstStreamFrame() {} 624 QuicRstStreamFrame(QuicStreamId stream_id, QuicRstStreamErrorCode error_code) 625 : stream_id(stream_id), error_code(error_code) { 626 DCHECK_LE(error_code, std::numeric_limits<uint8>::max()); 627 } 628 629 QuicStreamId stream_id; 630 QuicRstStreamErrorCode error_code; 631 std::string error_details; 632}; 633 634struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame { 635 QuicErrorCode error_code; 636 std::string error_details; 637 QuicAckFrame ack_frame; 638}; 639 640struct NET_EXPORT_PRIVATE QuicGoAwayFrame { 641 QuicGoAwayFrame() {} 642 QuicGoAwayFrame(QuicErrorCode error_code, 643 QuicStreamId last_good_stream_id, 644 const std::string& reason); 645 646 QuicErrorCode error_code; 647 QuicStreamId last_good_stream_id; 648 std::string reason_phrase; 649}; 650 651// EncryptionLevel enumerates the stages of encryption that a QUIC connection 652// progresses through. When retransmitting a packet, the encryption level needs 653// to be specified so that it is retransmitted at a level which the peer can 654// understand. 655enum EncryptionLevel { 656 ENCRYPTION_NONE = 0, 657 ENCRYPTION_INITIAL = 1, 658 ENCRYPTION_FORWARD_SECURE = 2, 659 660 NUM_ENCRYPTION_LEVELS, 661}; 662 663struct NET_EXPORT_PRIVATE QuicFrame { 664 QuicFrame() {} 665 explicit QuicFrame(QuicPaddingFrame* padding_frame) 666 : type(PADDING_FRAME), 667 padding_frame(padding_frame) { 668 } 669 explicit QuicFrame(QuicStreamFrame* stream_frame) 670 : type(STREAM_FRAME), 671 stream_frame(stream_frame) { 672 } 673 explicit QuicFrame(QuicAckFrame* frame) 674 : type(ACK_FRAME), 675 ack_frame(frame) { 676 } 677 explicit QuicFrame(QuicCongestionFeedbackFrame* frame) 678 : type(CONGESTION_FEEDBACK_FRAME), 679 congestion_feedback_frame(frame) { 680 } 681 explicit QuicFrame(QuicRstStreamFrame* frame) 682 : type(RST_STREAM_FRAME), 683 rst_stream_frame(frame) { 684 } 685 explicit QuicFrame(QuicConnectionCloseFrame* frame) 686 : type(CONNECTION_CLOSE_FRAME), 687 connection_close_frame(frame) { 688 } 689 explicit QuicFrame(QuicGoAwayFrame* frame) 690 : type(GOAWAY_FRAME), 691 goaway_frame(frame) { 692 } 693 694 QuicFrameType type; 695 union { 696 QuicPaddingFrame* padding_frame; 697 QuicStreamFrame* stream_frame; 698 QuicAckFrame* ack_frame; 699 QuicCongestionFeedbackFrame* congestion_feedback_frame; 700 QuicRstStreamFrame* rst_stream_frame; 701 QuicConnectionCloseFrame* connection_close_frame; 702 QuicGoAwayFrame* goaway_frame; 703 }; 704}; 705 706typedef std::vector<QuicFrame> QuicFrames; 707 708struct NET_EXPORT_PRIVATE QuicFecData { 709 QuicFecData(); 710 711 // The FEC group number is also the sequence number of the first 712 // FEC protected packet. The last protected packet's sequence number will 713 // be one less than the sequence number of the FEC packet. 714 QuicFecGroupNumber fec_group; 715 base::StringPiece redundancy; 716}; 717 718class NET_EXPORT_PRIVATE QuicData { 719 public: 720 QuicData(const char* buffer, size_t length) 721 : buffer_(buffer), 722 length_(length), 723 owns_buffer_(false) {} 724 725 QuicData(char* buffer, size_t length, bool owns_buffer) 726 : buffer_(buffer), 727 length_(length), 728 owns_buffer_(owns_buffer) {} 729 730 virtual ~QuicData(); 731 732 base::StringPiece AsStringPiece() const { 733 return base::StringPiece(data(), length()); 734 } 735 736 const char* data() const { return buffer_; } 737 size_t length() const { return length_; } 738 739 private: 740 const char* buffer_; 741 size_t length_; 742 bool owns_buffer_; 743 744 DISALLOW_COPY_AND_ASSIGN(QuicData); 745}; 746 747class NET_EXPORT_PRIVATE QuicPacket : public QuicData { 748 public: 749 static QuicPacket* NewDataPacket( 750 char* buffer, 751 size_t length, 752 bool owns_buffer, 753 QuicGuidLength guid_length, 754 bool includes_version, 755 QuicSequenceNumberLength sequence_number_length) { 756 return new QuicPacket(buffer, length, owns_buffer, guid_length, 757 includes_version, sequence_number_length, false); 758 } 759 760 static QuicPacket* NewFecPacket( 761 char* buffer, 762 size_t length, 763 bool owns_buffer, 764 QuicGuidLength guid_length, 765 bool includes_version, 766 QuicSequenceNumberLength sequence_number_length) { 767 return new QuicPacket(buffer, length, owns_buffer, guid_length, 768 includes_version, sequence_number_length, true); 769 } 770 771 base::StringPiece FecProtectedData() const; 772 base::StringPiece AssociatedData() const; 773 base::StringPiece BeforePlaintext() const; 774 base::StringPiece Plaintext() const; 775 776 bool is_fec_packet() const { return is_fec_packet_; } 777 778 char* mutable_data() { return buffer_; } 779 780 private: 781 QuicPacket(char* buffer, 782 size_t length, 783 bool owns_buffer, 784 QuicGuidLength guid_length, 785 bool includes_version, 786 QuicSequenceNumberLength sequence_number_length, 787 bool is_fec_packet) 788 : QuicData(buffer, length, owns_buffer), 789 buffer_(buffer), 790 is_fec_packet_(is_fec_packet), 791 guid_length_(guid_length), 792 includes_version_(includes_version), 793 sequence_number_length_(sequence_number_length) {} 794 795 char* buffer_; 796 const bool is_fec_packet_; 797 const QuicGuidLength guid_length_; 798 const bool includes_version_; 799 const QuicSequenceNumberLength sequence_number_length_; 800 801 DISALLOW_COPY_AND_ASSIGN(QuicPacket); 802}; 803 804class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData { 805 public: 806 QuicEncryptedPacket(const char* buffer, size_t length) 807 : QuicData(buffer, length) {} 808 809 QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer) 810 : QuicData(buffer, length, owns_buffer) {} 811 812 // By default, gtest prints the raw bytes of an object. The bool data 813 // member (in the base class QuicData) causes this object to have padding 814 // bytes, which causes the default gtest object printer to read 815 // uninitialize memory. So we need to teach gtest how to print this object. 816 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 817 std::ostream& os, const QuicEncryptedPacket& s); 818 819 private: 820 DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket); 821}; 822 823class NET_EXPORT_PRIVATE RetransmittableFrames { 824 public: 825 RetransmittableFrames(); 826 ~RetransmittableFrames(); 827 828 // Allocates a local copy of the referenced StringPiece has QuicStreamFrame 829 // use it. 830 // Takes ownership of |stream_frame|. 831 const QuicFrame& AddStreamFrame(QuicStreamFrame* stream_frame); 832 // Takes ownership of the frame inside |frame|. 833 const QuicFrame& AddNonStreamFrame(const QuicFrame& frame); 834 const QuicFrames& frames() const { return frames_; } 835 836 void set_encryption_level(EncryptionLevel level); 837 EncryptionLevel encryption_level() const { 838 return encryption_level_; 839 } 840 841 private: 842 QuicFrames frames_; 843 EncryptionLevel encryption_level_; 844 // Data referenced by the StringPiece of a QuicStreamFrame. 845 std::vector<std::string*> stream_data_; 846 847 DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames); 848}; 849 850struct NET_EXPORT_PRIVATE SerializedPacket { 851 SerializedPacket(QuicPacketSequenceNumber sequence_number, 852 QuicSequenceNumberLength sequence_number_length, 853 QuicPacket* packet, 854 QuicPacketEntropyHash entropy_hash, 855 RetransmittableFrames* retransmittable_frames); 856 ~SerializedPacket(); 857 858 QuicPacketSequenceNumber sequence_number; 859 QuicSequenceNumberLength sequence_number_length; 860 QuicPacket* packet; 861 QuicPacketEntropyHash entropy_hash; 862 RetransmittableFrames* retransmittable_frames; 863 864 // If set, these will be called when this packet is ACKed by the peer. 865 std::set<QuicAckNotifier*> notifiers; 866}; 867 868// A struct for functions which consume data payloads and fins. 869struct QuicConsumedData { 870 QuicConsumedData(size_t bytes_consumed, bool fin_consumed) 871 : bytes_consumed(bytes_consumed), 872 fin_consumed(fin_consumed) {} 873 // By default, gtest prints the raw bytes of an object. The bool data 874 // member causes this object to have padding bytes, which causes the 875 // default gtest object printer to read uninitialize memory. So we need 876 // to teach gtest how to print this object. 877 NET_EXPORT_PRIVATE friend std::ostream& operator<<( 878 std::ostream& os, const QuicConsumedData& s); 879 880 // How many bytes were consumed. 881 size_t bytes_consumed; 882 883 // True if an incoming fin was consumed. 884 bool fin_consumed; 885}; 886 887enum WriteStatus { 888 WRITE_STATUS_OK, 889 WRITE_STATUS_BLOCKED, 890 WRITE_STATUS_ERROR, 891}; 892 893// A struct used to return the result of write calls including either the number 894// of bytes written or the error code, depending upon the status. 895struct NET_EXPORT_PRIVATE WriteResult { 896 WriteResult(WriteStatus status, int bytes_written_or_error_code) : 897 status(status), bytes_written(bytes_written_or_error_code) { 898 } 899 900 WriteStatus status; 901 union { 902 int bytes_written; // only valid when status is OK 903 int error_code; // only valid when status is ERROR 904 }; 905}; 906 907} // namespace net 908 909#endif // NET_QUIC_QUIC_PROTOCOL_H_ 910