| OLD | NEW |
|---|
| (Empty) |
| 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 <limits> | |
| 9 #include <utility> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/hash_tables.h" | |
| 14 #include "base/logging.h" | |
| 15 #include "base/string_piece.h" | |
| 16 #include "net/base/net_export.h" | |
| 17 #include "net/quic/uint128.h" | |
| 18 | |
| 19 namespace net { | |
| 20 | |
| 21 class QuicPacket; | |
| 22 | |
| 23 typedef uint64 QuicGuid; | |
| 24 typedef uint32 QuicStreamId; | |
| 25 typedef uint64 QuicStreamOffset; | |
| 26 typedef uint64 QuicPacketSequenceNumber; | |
| 27 typedef uint64 QuicTransmissionTime; | |
| 28 typedef uint8 QuicFecGroupNumber; | |
| 29 | |
| 30 // TODO(rch): Consider Quic specific names for these constants. | |
| 31 const size_t kMaxPacketSize = 1200; // Maximum size in bytes of a QUIC packet. | |
| 32 | |
| 33 // Maximum number of open streams per connection. | |
| 34 const size_t kDefaultMaxStreamsPerConnection = 100; | |
| 35 | |
| 36 // Size in bytes of the packet header common across all packets. | |
| 37 const size_t kPacketHeaderSize = 25; | |
| 38 // Index of the first byte in a QUIC packet of FEC protected data. | |
| 39 const size_t kStartOfFecProtectedData = kPacketHeaderSize; | |
| 40 // Index of the first byte in a QUIC packet of encrypted data. | |
| 41 const size_t kStartOfEncryptedData = kPacketHeaderSize - 1; | |
| 42 // Index of the first byte in a QUIC packet which is hashed. | |
| 43 const size_t kStartOfHashData = 0; | |
| 44 // Index into the retransmission offset in the header. | |
| 45 // (After GUID and sequence number.) | |
| 46 const int kRetransmissionOffset = 14; | |
| 47 // Index into the transmission time offset in the header. | |
| 48 const int kTransmissionTimeOffset = 15; | |
| 49 | |
| 50 // Size in bytes of all stream fragment fields. | |
| 51 const size_t kMinStreamFragmentLength = 15; | |
| 52 | |
| 53 // Limit on the delta between stream IDs. | |
| 54 const QuicStreamId kMaxStreamIdDelta = 100; | |
| 55 | |
| 56 // Reserved ID for the crypto stream. | |
| 57 // TODO(rch): ensure that this is not usable by any other streams. | |
| 58 const QuicStreamId kCryptoStreamId = 1; | |
| 59 | |
| 60 typedef std::pair<QuicPacketSequenceNumber, QuicPacket*> PacketPair; | |
| 61 | |
| 62 const int64 kDefaultTimeout = 600000000; // 10 minutes | |
| 63 | |
| 64 enum QuicFragmentType { | |
| 65 STREAM_FRAGMENT = 0, | |
| 66 PDU_FRAGMENT, | |
| 67 ACK_FRAGMENT, | |
| 68 RST_STREAM_FRAGMENT, | |
| 69 CONNECTION_CLOSE_FRAGMENT, | |
| 70 NUM_FRAGMENT_TYPES | |
| 71 }; | |
| 72 | |
| 73 enum QuicPacketFlags { | |
| 74 PACKET_FLAGS_NONE = 0, | |
| 75 PACKET_FLAGS_FEC = 1, // Payload is FEC as opposed to fragments. | |
| 76 | |
| 77 PACKET_FLAGS_MAX = PACKET_FLAGS_FEC | |
| 78 }; | |
| 79 | |
| 80 enum QuicErrorCode { | |
| 81 // Stream errors. | |
| 82 QUIC_NO_ERROR = 0, | |
| 83 | |
| 84 // There were data fragments after the a fin or reset. | |
| 85 QUIC_STREAM_DATA_AFTER_TERMINATION, | |
| 86 // There was some server error which halted stream processing. | |
| 87 QUIC_SERVER_ERROR_PROCESSING_STREAM, | |
| 88 // We got two fin or reset offsets which did not match. | |
| 89 QUIC_MULTIPLE_TERMINATION_OFFSETS, | |
| 90 // We got bad payload and can not respond to it at the protocol level. | |
| 91 QUIC_BAD_APPLICATION_PAYLOAD, | |
| 92 | |
| 93 // Connection errors. | |
| 94 | |
| 95 // Control frame is malformed. | |
| 96 QUIC_INVALID_PACKET_HEADER, | |
| 97 // Fragment data is malformed. | |
| 98 QUIC_INVALID_FRAGMENT_DATA, | |
| 99 // FEC data is malformed. | |
| 100 QUIC_INVALID_FEC_DATA, | |
| 101 // Stream rst data is malformed | |
| 102 QUIC_INVALID_RST_STREAM_DATA, | |
| 103 // Connection close data is malformed. | |
| 104 QUIC_INVALID_CONNECTION_CLOSE_DATA, | |
| 105 // Ack data is malformed. | |
| 106 QUIC_INVALID_ACK_DATA, | |
| 107 // There was an error decrypting. | |
| 108 QUIC_DECRYPTION_FAILURE, | |
| 109 // There was an error encrypting. | |
| 110 QUIC_ENCRYPTION_FAILURE, | |
| 111 // The packet exceeded kMaxPacketSize. | |
| 112 QUIC_PACKET_TOO_LARGE, | |
| 113 // Data was sent for a stream which did not exist. | |
| 114 QUIC_PACKET_FOR_NONEXISTENT_STREAM, | |
| 115 // The client is going away (browser close, etc.) | |
| 116 QUIC_CLIENT_GOING_AWAY, | |
| 117 // The server is going away (restart etc.) | |
| 118 QUIC_SERVER_GOING_AWAY, | |
| 119 // A stream ID was invalid. | |
| 120 QUIC_INVALID_STREAM_ID, | |
| 121 // Too many streams already open. | |
| 122 QUIC_TOO_MANY_OPEN_STREAMS, | |
| 123 | |
| 124 // We hit our prenegotiated (or default) timeout | |
| 125 QUIC_CONNECTION_TIMED_OUT, | |
| 126 | |
| 127 // Crypto errors. | |
| 128 | |
| 129 // Handshake message contained out of order tags. | |
| 130 QUIC_CRYPTO_TAGS_OUT_OF_ORDER, | |
| 131 // Handshake message contained too many entires. | |
| 132 QUIC_CRYPTO_TOO_MANY_ENTRIES, | |
| 133 // Handshake message contained an invalid value length. | |
| 134 QUIC_CRYPTO_INVALID_VALUE_LENGTH, | |
| 135 // A crypto message was received after the handshake was complete. | |
| 136 QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, | |
| 137 // A crypto message was receieved with an illegal message tag. | |
| 138 QUIC_INVALID_CRYPTO_MESSAGE_TYPE, | |
| 139 | |
| 140 }; | |
| 141 | |
| 142 struct NET_EXPORT_PRIVATE QuicPacketHeader { | |
| 143 // Includes the ConnectionHeader and CongestionMonitoredHeader | |
| 144 // from the design docs, as well as some elements of DecryptedData. | |
| 145 QuicGuid guid; | |
| 146 QuicPacketSequenceNumber packet_sequence_number; | |
| 147 uint8 retransmission_count; | |
| 148 QuicTransmissionTime transmission_time; | |
| 149 QuicPacketFlags flags; | |
| 150 QuicFecGroupNumber fec_group; | |
| 151 }; | |
| 152 | |
| 153 struct NET_EXPORT_PRIVATE QuicStreamFragment { | |
| 154 QuicStreamFragment(); | |
| 155 QuicStreamFragment(QuicStreamId stream_id, | |
| 156 bool fin, | |
| 157 uint64 offset, | |
| 158 base::StringPiece data); | |
| 159 | |
| 160 QuicStreamId stream_id; | |
| 161 bool fin; | |
| 162 uint64 offset; | |
| 163 base::StringPiece data; | |
| 164 }; | |
| 165 | |
| 166 struct NET_EXPORT_PRIVATE ReceivedPacketInfo { | |
| 167 ReceivedPacketInfo(); | |
| 168 ~ReceivedPacketInfo(); | |
| 169 // The highest packet sequence number we've received from the peer. | |
| 170 QuicPacketSequenceNumber largest_received; | |
| 171 // The time at which we received the above packet. | |
| 172 QuicTransmissionTime time_received; | |
| 173 // The set of packets which we're expecting and have not received. | |
| 174 // This includes any packets between the lowest and largest_received | |
| 175 // which we have neither seen nor been informed are non-retransmitting. | |
| 176 base::hash_set<QuicPacketSequenceNumber> missing_packets; | |
| 177 }; | |
| 178 | |
| 179 struct NET_EXPORT_PRIVATE SentPacketInfo { | |
| 180 SentPacketInfo(); | |
| 181 ~SentPacketInfo(); | |
| 182 // The lowest packet we've sent which is unacked, and we expect an ack for. | |
| 183 QuicPacketSequenceNumber least_unacked; | |
| 184 // The set of packets between least_unacked and the last packet we have sent | |
| 185 // which we will not resend. | |
| 186 base::hash_set<QuicPacketSequenceNumber> non_retransmiting; | |
| 187 }; | |
| 188 | |
| 189 // Defines for all types of congestion feedback that will be negotiated in QUIC, | |
| 190 // kTCP MUST be supported by all QUIC implementations to guarentee 100% | |
| 191 // compatibility. | |
| 192 enum CongestionFeedbackType { | |
| 193 kNone = 0, // No feedback provided | |
| 194 kTCP, // Used to mimic TCP. | |
| 195 kInterArrival, // Use additional inter arrival information. | |
| 196 kFixRate, // Provided for testing. | |
| 197 }; | |
| 198 | |
| 199 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP { | |
| 200 uint16 accumulated_number_of_lost_packets; | |
| 201 uint16 receive_window; // Number of bytes >> 4. | |
| 202 }; | |
| 203 | |
| 204 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageInterArrival { | |
| 205 uint16 accumulated_number_of_lost_packets; | |
| 206 int16 offset_time; | |
| 207 uint16 delta_time; // delta time is described below. | |
| 208 }; | |
| 209 | |
| 210 /* | |
| 211 * Description of delta time. | |
| 212 * | |
| 213 * 0 1 | |
| 214 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 | |
| 215 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 216 * |D|S| offset_time | | |
| 217 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 218 * | |
| 219 * Where: | |
| 220 * D is the time domain. If set time domain is in milliseconds, else in | |
| 221 * microseconds. | |
| 222 * S is the sign bit. | |
| 223 * offset_time is the time offset where the relative packet size is equal to | |
| 224 * 0. | |
| 225 */ | |
| 226 | |
| 227 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageFixRate { | |
| 228 uint32 bitrate_in_bytes_per_second; | |
| 229 }; | |
| 230 | |
| 231 struct NET_EXPORT_PRIVATE CongestionInfo { | |
| 232 CongestionFeedbackType type; | |
| 233 union { | |
| 234 CongestionFeedbackMessageTCP tcp; | |
| 235 CongestionFeedbackMessageInterArrival inter_arrival; | |
| 236 CongestionFeedbackMessageFixRate fix_rate; | |
| 237 }; | |
| 238 }; | |
| 239 | |
| 240 struct NET_EXPORT_PRIVATE QuicAckFragment { | |
| 241 QuicAckFragment() {} | |
| 242 QuicAckFragment(QuicPacketSequenceNumber largest_received, | |
| 243 QuicTransmissionTime time_received, | |
| 244 QuicPacketSequenceNumber least_unacked) { | |
| 245 received_info.largest_received = largest_received; | |
| 246 received_info.time_received = time_received; | |
| 247 sent_info.least_unacked = least_unacked; | |
| 248 congestion_info.type = kNone; | |
| 249 } | |
| 250 | |
| 251 SentPacketInfo sent_info; | |
| 252 ReceivedPacketInfo received_info; | |
| 253 CongestionInfo congestion_info; | |
| 254 | |
| 255 friend std::ostream& operator<<(std::ostream& os, const QuicAckFragment& s) { | |
| 256 os << "largest_received: " << s.received_info.largest_received | |
| 257 << " time: " << s.received_info.time_received | |
| 258 << " missing: "; | |
| 259 for (base::hash_set<QuicPacketSequenceNumber>::const_iterator it = | |
| 260 s.received_info.missing_packets.begin(); | |
| 261 it != s.received_info.missing_packets.end(); ++it) { | |
| 262 os << *it << " "; | |
| 263 } | |
| 264 | |
| 265 os << " least_waiting: " << s.sent_info.least_unacked | |
| 266 << " no_retransmit: "; | |
| 267 for (base::hash_set<QuicPacketSequenceNumber>::const_iterator it = | |
| 268 s.sent_info.non_retransmiting.begin(); | |
| 269 it != s.sent_info.non_retransmiting.end(); ++it) { | |
| 270 os << *it << " "; | |
| 271 } | |
| 272 os << "\n"; | |
| 273 return os; | |
| 274 } | |
| 275 }; | |
| 276 | |
| 277 struct NET_EXPORT_PRIVATE QuicRstStreamFragment { | |
| 278 QuicRstStreamFragment() {} | |
| 279 QuicRstStreamFragment(QuicStreamId stream_id, uint64 offset, | |
| 280 QuicErrorCode details) | |
| 281 : stream_id(stream_id), offset(offset), details(details) { | |
| 282 DCHECK_LE(details, std::numeric_limits<uint8>::max()); | |
| 283 } | |
| 284 | |
| 285 QuicStreamId stream_id; | |
| 286 uint64 offset; | |
| 287 QuicErrorCode details; | |
| 288 }; | |
| 289 | |
| 290 struct NET_EXPORT_PRIVATE QuicConnectionCloseFragment { | |
| 291 QuicErrorCode details; | |
| 292 QuicAckFragment ack_fragment; | |
| 293 }; | |
| 294 | |
| 295 struct NET_EXPORT_PRIVATE QuicFragment { | |
| 296 QuicFragment() {} | |
| 297 explicit QuicFragment(QuicStreamFragment* stream_fragment) | |
| 298 : type(STREAM_FRAGMENT), stream_fragment(stream_fragment) { | |
| 299 } | |
| 300 explicit QuicFragment(QuicAckFragment* fragment) | |
| 301 : type(ACK_FRAGMENT), ack_fragment(fragment) { | |
| 302 } | |
| 303 explicit QuicFragment(QuicRstStreamFragment* fragment) | |
| 304 : type(RST_STREAM_FRAGMENT), | |
| 305 rst_stream_fragment(fragment) { | |
| 306 } | |
| 307 explicit QuicFragment(QuicConnectionCloseFragment* fragment) | |
| 308 : type(CONNECTION_CLOSE_FRAGMENT), | |
| 309 connection_close_fragment(fragment) { | |
| 310 } | |
| 311 | |
| 312 QuicFragmentType type; | |
| 313 union { | |
| 314 QuicStreamFragment* stream_fragment; | |
| 315 QuicAckFragment* ack_fragment; | |
| 316 QuicRstStreamFragment* rst_stream_fragment; | |
| 317 QuicConnectionCloseFragment* connection_close_fragment; | |
| 318 }; | |
| 319 }; | |
| 320 | |
| 321 typedef std::vector<QuicFragment> QuicFragments; | |
| 322 | |
| 323 struct NET_EXPORT_PRIVATE QuicFecData { | |
| 324 QuicFecData(); | |
| 325 QuicFecGroupNumber fec_group; | |
| 326 QuicPacketSequenceNumber first_protected_packet_sequence_number; | |
| 327 // The last protected packet's sequence number will be one | |
| 328 // less than the sequence number of the FEC packet. | |
| 329 base::StringPiece redundancy; | |
| 330 bool operator==(const QuicFecData& other) const { | |
| 331 if (fec_group != other.fec_group) { | |
| 332 return false; | |
| 333 } | |
| 334 if (first_protected_packet_sequence_number != | |
| 335 other.first_protected_packet_sequence_number) { | |
| 336 return false; | |
| 337 } | |
| 338 if (redundancy != other.redundancy) { | |
| 339 return false; | |
| 340 } | |
| 341 return true; | |
| 342 } | |
| 343 }; | |
| 344 | |
| 345 struct NET_EXPORT_PRIVATE QuicPacketData { | |
| 346 std::string data; | |
| 347 }; | |
| 348 | |
| 349 class NET_EXPORT_PRIVATE QuicData { | |
| 350 public: | |
| 351 QuicData(const char* buffer, size_t length) | |
| 352 : buffer_(buffer), | |
| 353 length_(length), | |
| 354 owns_buffer_(false) { } | |
| 355 | |
| 356 QuicData(char* buffer, size_t length, bool owns_buffer) | |
| 357 : buffer_(buffer), | |
| 358 length_(length), | |
| 359 owns_buffer_(owns_buffer) { } | |
| 360 | |
| 361 virtual ~QuicData(); | |
| 362 | |
| 363 base::StringPiece AsStringPiece() const { | |
| 364 return base::StringPiece(data(), length()); | |
| 365 } | |
| 366 | |
| 367 const char* data() const { return buffer_; } | |
| 368 size_t length() const { return length_; } | |
| 369 | |
| 370 private: | |
| 371 const char* buffer_; | |
| 372 size_t length_; | |
| 373 bool owns_buffer_; | |
| 374 | |
| 375 DISALLOW_COPY_AND_ASSIGN(QuicData); | |
| 376 }; | |
| 377 | |
| 378 class NET_EXPORT_PRIVATE QuicPacket : public QuicData { | |
| 379 public: | |
| 380 QuicPacket(char* buffer, size_t length, bool owns_buffer) | |
| 381 : QuicData(buffer, length, owns_buffer), | |
| 382 buffer_(buffer) { } | |
| 383 | |
| 384 base::StringPiece FecProtectedData() const { | |
| 385 return base::StringPiece(data() + kStartOfFecProtectedData, | |
| 386 length() - kStartOfFecProtectedData); | |
| 387 } | |
| 388 | |
| 389 base::StringPiece AssociatedData() const { | |
| 390 return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData); | |
| 391 } | |
| 392 | |
| 393 base::StringPiece Plaintext() const { | |
| 394 return base::StringPiece(data() + kStartOfEncryptedData, | |
| 395 length() - kStartOfEncryptedData); | |
| 396 } | |
| 397 char* mutable_data() { return buffer_; } | |
| 398 | |
| 399 private: | |
| 400 char* buffer_; | |
| 401 | |
| 402 // TODO(rch): DISALLOW_COPY_AND_ASSIGN | |
| 403 }; | |
| 404 | |
| 405 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData { | |
| 406 public: | |
| 407 QuicEncryptedPacket(const char* buffer, size_t length) | |
| 408 : QuicData(buffer, length) { } | |
| 409 | |
| 410 QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer) | |
| 411 : QuicData(buffer, length, owns_buffer) { } | |
| 412 | |
| 413 base::StringPiece AssociatedData() const { | |
| 414 return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData); | |
| 415 } | |
| 416 | |
| 417 // TODO(rch): DISALLOW_COPY_AND_ASSIGN | |
| 418 }; | |
| 419 | |
| 420 } // namespace net | |
| 421 | |
| 422 #endif // NET_QUIC_QUIC_PROTOCOL_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11191015:
Revert 162259 - Add QuicFramer and friends. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/