| 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 #include "net/quic/quic_protocol.h" | |
| 6 | |
| 7 #include "base/stl_util.h" | |
| 8 #include "base/strings/string_number_conversions.h" | |
| 9 #include "net/quic/quic_flags.h" | |
| 10 #include "net/quic/quic_utils.h" | |
| 11 | |
| 12 using base::StringPiece; | |
| 13 using std::map; | |
| 14 using std::numeric_limits; | |
| 15 using std::ostream; | |
| 16 using std::string; | |
| 17 | |
| 18 namespace net { | |
| 19 | |
| 20 const char* const kFinalOffsetHeaderKey = ":final-offset"; | |
| 21 | |
| 22 size_t GetPacketHeaderSize(QuicVersion version, | |
| 23 const QuicPacketHeader& header) { | |
| 24 return GetPacketHeaderSize(version, header.public_header.connection_id_length, | |
| 25 header.public_header.version_flag, | |
| 26 header.public_header.multipath_flag, | |
| 27 header.public_header.nonce != nullptr, | |
| 28 header.public_header.packet_number_length); | |
| 29 } | |
| 30 | |
| 31 size_t GetPacketHeaderSize(QuicVersion version, | |
| 32 QuicConnectionIdLength connection_id_length, | |
| 33 bool include_version, | |
| 34 bool include_path_id, | |
| 35 bool include_diversification_nonce, | |
| 36 QuicPacketNumberLength packet_number_length) { | |
| 37 return kPublicFlagsSize + connection_id_length + | |
| 38 (include_version ? kQuicVersionSize : 0) + | |
| 39 (include_path_id ? kQuicPathIdSize : 0) + packet_number_length + | |
| 40 (include_diversification_nonce ? kDiversificationNonceSize : 0) + | |
| 41 (version <= QUIC_VERSION_33 ? kPrivateFlagsSize : 0); | |
| 42 } | |
| 43 | |
| 44 size_t GetStartOfEncryptedData(QuicVersion version, | |
| 45 const QuicPacketHeader& header) { | |
| 46 return GetPacketHeaderSize(version, header) - | |
| 47 (version <= QUIC_VERSION_33 ? kPrivateFlagsSize : 0); | |
| 48 } | |
| 49 | |
| 50 size_t GetStartOfEncryptedData(QuicVersion version, | |
| 51 QuicConnectionIdLength connection_id_length, | |
| 52 bool include_version, | |
| 53 bool include_path_id, | |
| 54 bool include_diversification_nonce, | |
| 55 QuicPacketNumberLength packet_number_length) { | |
| 56 // Encryption starts before private flags. | |
| 57 return GetPacketHeaderSize(version, connection_id_length, include_version, | |
| 58 include_path_id, include_diversification_nonce, | |
| 59 packet_number_length) - | |
| 60 (version <= QUIC_VERSION_33 ? kPrivateFlagsSize : 0); | |
| 61 } | |
| 62 | |
| 63 QuicPacketPublicHeader::QuicPacketPublicHeader() | |
| 64 : connection_id(0), | |
| 65 connection_id_length(PACKET_8BYTE_CONNECTION_ID), | |
| 66 multipath_flag(false), | |
| 67 reset_flag(false), | |
| 68 version_flag(false), | |
| 69 packet_number_length(PACKET_6BYTE_PACKET_NUMBER), | |
| 70 nonce(nullptr) {} | |
| 71 | |
| 72 QuicPacketPublicHeader::QuicPacketPublicHeader( | |
| 73 const QuicPacketPublicHeader& other) = default; | |
| 74 | |
| 75 QuicPacketPublicHeader::~QuicPacketPublicHeader() {} | |
| 76 | |
| 77 QuicPacketHeader::QuicPacketHeader() | |
| 78 : packet_number(0), | |
| 79 path_id(kDefaultPathId), | |
| 80 entropy_flag(false), | |
| 81 entropy_hash(0), | |
| 82 fec_flag(false) {} | |
| 83 | |
| 84 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header) | |
| 85 : public_header(header), | |
| 86 packet_number(0), | |
| 87 path_id(kDefaultPathId), | |
| 88 entropy_flag(false), | |
| 89 entropy_hash(0), | |
| 90 fec_flag(false) {} | |
| 91 | |
| 92 QuicPacketHeader::QuicPacketHeader(const QuicPacketHeader& other) = default; | |
| 93 | |
| 94 QuicPublicResetPacket::QuicPublicResetPacket() | |
| 95 : nonce_proof(0), rejected_packet_number(0) {} | |
| 96 | |
| 97 QuicPublicResetPacket::QuicPublicResetPacket( | |
| 98 const QuicPacketPublicHeader& header) | |
| 99 : public_header(header), nonce_proof(0), rejected_packet_number(0) {} | |
| 100 | |
| 101 QuicBufferAllocator::~QuicBufferAllocator() = default; | |
| 102 | |
| 103 void StreamBufferDeleter::operator()(char* buffer) const { | |
| 104 if (allocator_ != nullptr && buffer != nullptr) { | |
| 105 allocator_->Delete(buffer); | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 UniqueStreamBuffer NewStreamBuffer(QuicBufferAllocator* allocator, | |
| 110 size_t size) { | |
| 111 return UniqueStreamBuffer(allocator->New(size), | |
| 112 StreamBufferDeleter(allocator)); | |
| 113 } | |
| 114 | |
| 115 QuicStreamFrame::QuicStreamFrame() | |
| 116 : QuicStreamFrame(0, false, 0, nullptr, 0, nullptr) {} | |
| 117 | |
| 118 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 119 bool fin, | |
| 120 QuicStreamOffset offset, | |
| 121 StringPiece data) | |
| 122 : QuicStreamFrame(stream_id, | |
| 123 fin, | |
| 124 offset, | |
| 125 data.data(), | |
| 126 data.length(), | |
| 127 nullptr) {} | |
| 128 | |
| 129 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 130 bool fin, | |
| 131 QuicStreamOffset offset, | |
| 132 QuicPacketLength data_length, | |
| 133 UniqueStreamBuffer buffer) | |
| 134 : QuicStreamFrame(stream_id, | |
| 135 fin, | |
| 136 offset, | |
| 137 nullptr, | |
| 138 data_length, | |
| 139 std::move(buffer)) { | |
| 140 DCHECK(this->buffer != nullptr); | |
| 141 DCHECK_EQ(data_buffer, this->buffer.get()); | |
| 142 } | |
| 143 | |
| 144 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 145 bool fin, | |
| 146 QuicStreamOffset offset, | |
| 147 const char* data_buffer, | |
| 148 QuicPacketLength data_length, | |
| 149 UniqueStreamBuffer buffer) | |
| 150 : stream_id(stream_id), | |
| 151 fin(fin), | |
| 152 data_length(data_length), | |
| 153 data_buffer(data_buffer), | |
| 154 offset(offset), | |
| 155 buffer(std::move(buffer)) { | |
| 156 if (this->buffer != nullptr) { | |
| 157 DCHECK(data_buffer == nullptr); | |
| 158 this->data_buffer = this->buffer.get(); | |
| 159 } | |
| 160 } | |
| 161 | |
| 162 QuicStreamFrame::~QuicStreamFrame() {} | |
| 163 | |
| 164 uint32_t MakeQuicTag(char a, char b, char c, char d) { | |
| 165 return static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 | | |
| 166 static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24; | |
| 167 } | |
| 168 | |
| 169 bool ContainsQuicTag(const QuicTagVector& tag_vector, QuicTag tag) { | |
| 170 return std::find(tag_vector.begin(), tag_vector.end(), tag) != | |
| 171 tag_vector.end(); | |
| 172 } | |
| 173 | |
| 174 QuicVersionVector QuicSupportedVersions() { | |
| 175 QuicVersionVector supported_versions; | |
| 176 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | |
| 177 supported_versions.push_back(kSupportedQuicVersions[i]); | |
| 178 } | |
| 179 return supported_versions; | |
| 180 } | |
| 181 | |
| 182 QuicVersionVector FilterSupportedVersions(QuicVersionVector versions) { | |
| 183 QuicVersionVector filtered_versions(versions.size()); | |
| 184 filtered_versions.clear(); // Guaranteed by spec not to change capacity. | |
| 185 for (QuicVersion version : versions) { | |
| 186 if (version == QUIC_VERSION_35) { | |
| 187 if (FLAGS_quic_enable_version_35) { | |
| 188 filtered_versions.push_back(version); | |
| 189 } | |
| 190 } else if (version == QUIC_VERSION_36) { | |
| 191 if (FLAGS_quic_enable_version_35 && FLAGS_quic_enable_version_36) { | |
| 192 filtered_versions.push_back(version); | |
| 193 } | |
| 194 } else { | |
| 195 filtered_versions.push_back(version); | |
| 196 } | |
| 197 } | |
| 198 return filtered_versions; | |
| 199 } | |
| 200 | |
| 201 QuicTag QuicVersionToQuicTag(const QuicVersion version) { | |
| 202 switch (version) { | |
| 203 case QUIC_VERSION_30: | |
| 204 return MakeQuicTag('Q', '0', '3', '0'); | |
| 205 case QUIC_VERSION_31: | |
| 206 return MakeQuicTag('Q', '0', '3', '1'); | |
| 207 case QUIC_VERSION_32: | |
| 208 return MakeQuicTag('Q', '0', '3', '2'); | |
| 209 case QUIC_VERSION_33: | |
| 210 return MakeQuicTag('Q', '0', '3', '3'); | |
| 211 case QUIC_VERSION_34: | |
| 212 return MakeQuicTag('Q', '0', '3', '4'); | |
| 213 case QUIC_VERSION_35: | |
| 214 return MakeQuicTag('Q', '0', '3', '5'); | |
| 215 case QUIC_VERSION_36: | |
| 216 return MakeQuicTag('Q', '0', '3', '6'); | |
| 217 default: | |
| 218 // This shold be an ERROR because we should never attempt to convert an | |
| 219 // invalid QuicVersion to be written to the wire. | |
| 220 LOG(ERROR) << "Unsupported QuicVersion: " << version; | |
| 221 return 0; | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) { | |
| 226 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | |
| 227 if (version_tag == QuicVersionToQuicTag(kSupportedQuicVersions[i])) { | |
| 228 return kSupportedQuicVersions[i]; | |
| 229 } | |
| 230 } | |
| 231 // Reading from the client so this should not be considered an ERROR. | |
| 232 DVLOG(1) << "Unsupported QuicTag version: " | |
| 233 << QuicUtils::TagToString(version_tag); | |
| 234 return QUIC_VERSION_UNSUPPORTED; | |
| 235 } | |
| 236 | |
| 237 #define RETURN_STRING_LITERAL(x) \ | |
| 238 case x: \ | |
| 239 return #x | |
| 240 | |
| 241 string QuicVersionToString(const QuicVersion version) { | |
| 242 switch (version) { | |
| 243 RETURN_STRING_LITERAL(QUIC_VERSION_30); | |
| 244 RETURN_STRING_LITERAL(QUIC_VERSION_31); | |
| 245 RETURN_STRING_LITERAL(QUIC_VERSION_32); | |
| 246 RETURN_STRING_LITERAL(QUIC_VERSION_33); | |
| 247 RETURN_STRING_LITERAL(QUIC_VERSION_34); | |
| 248 RETURN_STRING_LITERAL(QUIC_VERSION_35); | |
| 249 RETURN_STRING_LITERAL(QUIC_VERSION_36); | |
| 250 default: | |
| 251 return "QUIC_VERSION_UNSUPPORTED"; | |
| 252 } | |
| 253 } | |
| 254 | |
| 255 string QuicVersionVectorToString(const QuicVersionVector& versions) { | |
| 256 string result = ""; | |
| 257 for (size_t i = 0; i < versions.size(); ++i) { | |
| 258 if (i != 0) { | |
| 259 result.append(","); | |
| 260 } | |
| 261 result.append(QuicVersionToString(versions[i])); | |
| 262 } | |
| 263 return result; | |
| 264 } | |
| 265 | |
| 266 ostream& operator<<(ostream& os, const Perspective& s) { | |
| 267 if (s == Perspective::IS_SERVER) { | |
| 268 os << "IS_SERVER"; | |
| 269 } else { | |
| 270 os << "IS_CLIENT"; | |
| 271 } | |
| 272 return os; | |
| 273 } | |
| 274 | |
| 275 ostream& operator<<(ostream& os, const QuicPacketHeader& header) { | |
| 276 os << "{ connection_id: " << header.public_header.connection_id | |
| 277 << ", connection_id_length: " << header.public_header.connection_id_length | |
| 278 << ", packet_number_length: " << header.public_header.packet_number_length | |
| 279 << ", multipath_flag: " << header.public_header.multipath_flag | |
| 280 << ", reset_flag: " << header.public_header.reset_flag | |
| 281 << ", version_flag: " << header.public_header.version_flag; | |
| 282 if (header.public_header.version_flag) { | |
| 283 os << ", version:"; | |
| 284 for (size_t i = 0; i < header.public_header.versions.size(); ++i) { | |
| 285 os << " "; | |
| 286 os << QuicVersionToString(header.public_header.versions[i]); | |
| 287 } | |
| 288 } | |
| 289 if (header.public_header.nonce != nullptr) { | |
| 290 os << ", diversification_nonce: " | |
| 291 << net::QuicUtils::HexDecode(*header.public_header.nonce); | |
| 292 } | |
| 293 os << ", fec_flag: " << header.fec_flag | |
| 294 << ", entropy_flag: " << header.entropy_flag | |
| 295 << ", entropy hash: " << static_cast<int>(header.entropy_hash) | |
| 296 << ", path_id: " << static_cast<int>(header.path_id) | |
| 297 << ", packet_number: " << header.packet_number << " }\n"; | |
| 298 return os; | |
| 299 } | |
| 300 | |
| 301 bool IsAwaitingPacket(const QuicAckFrame& ack_frame, | |
| 302 QuicPacketNumber packet_number, | |
| 303 QuicPacketNumber peer_least_packet_awaiting_ack) { | |
| 304 if (ack_frame.missing) { | |
| 305 return packet_number > ack_frame.largest_observed || | |
| 306 ack_frame.packets.Contains(packet_number); | |
| 307 } | |
| 308 return packet_number >= peer_least_packet_awaiting_ack && | |
| 309 !ack_frame.packets.Contains(packet_number); | |
| 310 } | |
| 311 | |
| 312 QuicStopWaitingFrame::QuicStopWaitingFrame() | |
| 313 : path_id(kDefaultPathId), entropy_hash(0), least_unacked(0) {} | |
| 314 | |
| 315 QuicStopWaitingFrame::~QuicStopWaitingFrame() {} | |
| 316 | |
| 317 QuicAckFrame::QuicAckFrame() | |
| 318 : largest_observed(0), | |
| 319 ack_delay_time(QuicTime::Delta::Infinite()), | |
| 320 path_id(kDefaultPathId), | |
| 321 entropy_hash(0), | |
| 322 is_truncated(false), | |
| 323 missing(true) {} | |
| 324 | |
| 325 QuicAckFrame::QuicAckFrame(const QuicAckFrame& other) = default; | |
| 326 | |
| 327 QuicAckFrame::~QuicAckFrame() {} | |
| 328 | |
| 329 QuicRstStreamErrorCode AdjustErrorForVersion(QuicRstStreamErrorCode error_code, | |
| 330 QuicVersion /*version*/) { | |
| 331 return error_code; | |
| 332 } | |
| 333 | |
| 334 QuicRstStreamFrame::QuicRstStreamFrame() | |
| 335 : stream_id(0), error_code(QUIC_STREAM_NO_ERROR), byte_offset(0) {} | |
| 336 | |
| 337 QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id, | |
| 338 QuicRstStreamErrorCode error_code, | |
| 339 QuicStreamOffset bytes_written) | |
| 340 : stream_id(stream_id), | |
| 341 error_code(error_code), | |
| 342 byte_offset(bytes_written) {} | |
| 343 | |
| 344 QuicConnectionCloseFrame::QuicConnectionCloseFrame() | |
| 345 : error_code(QUIC_NO_ERROR) {} | |
| 346 | |
| 347 QuicFrame::QuicFrame() {} | |
| 348 | |
| 349 QuicFrame::QuicFrame(QuicPaddingFrame padding_frame) | |
| 350 : type(PADDING_FRAME), padding_frame(padding_frame) {} | |
| 351 | |
| 352 QuicFrame::QuicFrame(QuicStreamFrame* stream_frame) | |
| 353 : type(STREAM_FRAME), stream_frame(stream_frame) {} | |
| 354 | |
| 355 QuicFrame::QuicFrame(QuicAckFrame* frame) : type(ACK_FRAME), ack_frame(frame) {} | |
| 356 | |
| 357 QuicFrame::QuicFrame(QuicMtuDiscoveryFrame frame) | |
| 358 : type(MTU_DISCOVERY_FRAME), mtu_discovery_frame(frame) {} | |
| 359 | |
| 360 QuicFrame::QuicFrame(QuicStopWaitingFrame* frame) | |
| 361 : type(STOP_WAITING_FRAME), stop_waiting_frame(frame) {} | |
| 362 | |
| 363 QuicFrame::QuicFrame(QuicPingFrame frame) | |
| 364 : type(PING_FRAME), ping_frame(frame) {} | |
| 365 | |
| 366 QuicFrame::QuicFrame(QuicRstStreamFrame* frame) | |
| 367 : type(RST_STREAM_FRAME), rst_stream_frame(frame) {} | |
| 368 | |
| 369 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame) | |
| 370 : type(CONNECTION_CLOSE_FRAME), connection_close_frame(frame) {} | |
| 371 | |
| 372 QuicFrame::QuicFrame(QuicGoAwayFrame* frame) | |
| 373 : type(GOAWAY_FRAME), goaway_frame(frame) {} | |
| 374 | |
| 375 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame) | |
| 376 : type(WINDOW_UPDATE_FRAME), window_update_frame(frame) {} | |
| 377 | |
| 378 QuicFrame::QuicFrame(QuicBlockedFrame* frame) | |
| 379 : type(BLOCKED_FRAME), blocked_frame(frame) {} | |
| 380 | |
| 381 QuicFrame::QuicFrame(QuicPathCloseFrame* frame) | |
| 382 : type(PATH_CLOSE_FRAME), path_close_frame(frame) {} | |
| 383 | |
| 384 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) { | |
| 385 os << "{ entropy_hash: " << static_cast<int>(sent_info.entropy_hash) | |
| 386 << ", least_unacked: " << sent_info.least_unacked << " }\n"; | |
| 387 return os; | |
| 388 } | |
| 389 | |
| 390 PacketNumberQueue::const_iterator::const_iterator( | |
| 391 IntervalSet<QuicPacketNumber>::const_iterator interval_set_iter, | |
| 392 QuicPacketNumber first, | |
| 393 QuicPacketNumber last) | |
| 394 : interval_set_iter_(std::move(interval_set_iter)), | |
| 395 current_(first), | |
| 396 last_(last) {} | |
| 397 | |
| 398 PacketNumberQueue::const_iterator::const_iterator(const const_iterator& other) = | |
| 399 default; | |
| 400 // TODO(rtenneti): on windows RValue reference gives errors. | |
| 401 // PacketNumberQueue::const_iterator::const_iterator(const_iterator&& other) = | |
| 402 // default; | |
| 403 PacketNumberQueue::const_iterator::~const_iterator() {} | |
| 404 | |
| 405 PacketNumberQueue::const_iterator& PacketNumberQueue::const_iterator::operator=( | |
| 406 const const_iterator& other) = default; | |
| 407 // TODO(rtenneti): on windows RValue reference gives errors. | |
| 408 // PacketNumberQueue::const_iterator& | |
| 409 // PacketNumberQueue::const_iterator::operator=( | |
| 410 // const_iterator&& other) = default; | |
| 411 | |
| 412 bool PacketNumberQueue::const_iterator::operator!=( | |
| 413 const const_iterator& other) const { | |
| 414 return current_ != other.current_; | |
| 415 } | |
| 416 | |
| 417 bool PacketNumberQueue::const_iterator::operator==( | |
| 418 const const_iterator& other) const { | |
| 419 return current_ == other.current_; | |
| 420 } | |
| 421 | |
| 422 PacketNumberQueue::const_iterator::value_type | |
| 423 PacketNumberQueue::const_iterator::operator*() const { | |
| 424 return current_; | |
| 425 } | |
| 426 | |
| 427 PacketNumberQueue::const_iterator& PacketNumberQueue::const_iterator:: | |
| 428 operator++() { | |
| 429 ++current_; | |
| 430 if (current_ < last_) { | |
| 431 if (current_ >= interval_set_iter_->max()) { | |
| 432 ++interval_set_iter_; | |
| 433 current_ = interval_set_iter_->min(); | |
| 434 } | |
| 435 } else { | |
| 436 current_ = last_; | |
| 437 } | |
| 438 return *this; | |
| 439 } | |
| 440 | |
| 441 PacketNumberQueue::const_iterator PacketNumberQueue::const_iterator::operator++( | |
| 442 int /* postincrement */) { | |
| 443 PacketNumberQueue::const_iterator preincrement(*this); | |
| 444 operator++(); | |
| 445 return preincrement; | |
| 446 } | |
| 447 | |
| 448 PacketNumberQueue::PacketNumberQueue() = default; | |
| 449 PacketNumberQueue::PacketNumberQueue(const PacketNumberQueue& other) = default; | |
| 450 // TODO(rtenneti): on windows RValue reference gives errors. | |
| 451 // PacketNumberQueue::PacketNumberQueue(PacketNumberQueue&& other) = default; | |
| 452 PacketNumberQueue::~PacketNumberQueue() {} | |
| 453 | |
| 454 PacketNumberQueue& PacketNumberQueue::operator=( | |
| 455 const PacketNumberQueue& other) = default; | |
| 456 // TODO(rtenneti): on windows RValue reference gives errors. | |
| 457 // PacketNumberQueue& PacketNumberQueue::operator=(PacketNumberQueue&& other) = | |
| 458 // default; | |
| 459 | |
| 460 void PacketNumberQueue::Add(QuicPacketNumber packet_number) { | |
| 461 packet_number_intervals_.Add(packet_number, packet_number + 1); | |
| 462 } | |
| 463 | |
| 464 void PacketNumberQueue::Add(QuicPacketNumber lower, QuicPacketNumber higher) { | |
| 465 packet_number_intervals_.Add(lower, higher); | |
| 466 } | |
| 467 | |
| 468 void PacketNumberQueue::Remove(QuicPacketNumber packet_number) { | |
| 469 packet_number_intervals_.Difference(packet_number, packet_number + 1); | |
| 470 } | |
| 471 | |
| 472 void PacketNumberQueue::Remove(QuicPacketNumber lower, | |
| 473 QuicPacketNumber higher) { | |
| 474 packet_number_intervals_.Difference(lower, higher); | |
| 475 } | |
| 476 | |
| 477 bool PacketNumberQueue::RemoveUpTo(QuicPacketNumber higher) { | |
| 478 if (Empty()) { | |
| 479 return false; | |
| 480 } | |
| 481 const QuicPacketNumber old_min = Min(); | |
| 482 packet_number_intervals_.Difference(0, higher); | |
| 483 return Empty() || old_min != Min(); | |
| 484 } | |
| 485 | |
| 486 void PacketNumberQueue::Complement() { | |
| 487 if (Empty()) { | |
| 488 return; | |
| 489 } | |
| 490 packet_number_intervals_.Complement(Min(), Max() + 1); | |
| 491 } | |
| 492 | |
| 493 bool PacketNumberQueue::Contains(QuicPacketNumber packet_number) const { | |
| 494 return packet_number_intervals_.Contains(packet_number); | |
| 495 } | |
| 496 | |
| 497 bool PacketNumberQueue::Empty() const { | |
| 498 return packet_number_intervals_.Empty(); | |
| 499 } | |
| 500 | |
| 501 QuicPacketNumber PacketNumberQueue::Min() const { | |
| 502 DCHECK(!Empty()); | |
| 503 return packet_number_intervals_.begin()->min(); | |
| 504 } | |
| 505 | |
| 506 QuicPacketNumber PacketNumberQueue::Max() const { | |
| 507 DCHECK(!Empty()); | |
| 508 return packet_number_intervals_.rbegin()->max() - 1; | |
| 509 } | |
| 510 | |
| 511 size_t PacketNumberQueue::NumPacketsSlow() const { | |
| 512 size_t num_packets = 0; | |
| 513 for (const auto& interval : packet_number_intervals_) { | |
| 514 num_packets += interval.Length(); | |
| 515 } | |
| 516 return num_packets; | |
| 517 } | |
| 518 | |
| 519 size_t PacketNumberQueue::NumIntervals() const { | |
| 520 return packet_number_intervals_.Size(); | |
| 521 } | |
| 522 | |
| 523 QuicPacketNumber PacketNumberQueue::LastIntervalLength() const { | |
| 524 DCHECK(!Empty()); | |
| 525 return packet_number_intervals_.rbegin()->Length(); | |
| 526 } | |
| 527 | |
| 528 PacketNumberQueue::const_iterator PacketNumberQueue::begin() const { | |
| 529 QuicPacketNumber first; | |
| 530 QuicPacketNumber last; | |
| 531 if (packet_number_intervals_.Empty()) { | |
| 532 first = 0; | |
| 533 last = 0; | |
| 534 } else { | |
| 535 first = packet_number_intervals_.begin()->min(); | |
| 536 last = packet_number_intervals_.rbegin()->max(); | |
| 537 } | |
| 538 return const_iterator(packet_number_intervals_.begin(), first, last); | |
| 539 } | |
| 540 | |
| 541 PacketNumberQueue::const_iterator PacketNumberQueue::end() const { | |
| 542 QuicPacketNumber last = packet_number_intervals_.Empty() | |
| 543 ? 0 | |
| 544 : packet_number_intervals_.rbegin()->max(); | |
| 545 return const_iterator(packet_number_intervals_.end(), last, last); | |
| 546 } | |
| 547 | |
| 548 PacketNumberQueue::const_iterator PacketNumberQueue::lower_bound( | |
| 549 QuicPacketNumber packet_number) const { | |
| 550 QuicPacketNumber first; | |
| 551 QuicPacketNumber last; | |
| 552 if (packet_number_intervals_.Empty()) { | |
| 553 first = 0; | |
| 554 last = 0; | |
| 555 return const_iterator(packet_number_intervals_.begin(), first, last); | |
| 556 } | |
| 557 if (!packet_number_intervals_.Contains(packet_number)) { | |
| 558 return end(); | |
| 559 } | |
| 560 IntervalSet<QuicPacketNumber>::const_iterator it = | |
| 561 packet_number_intervals_.Find(packet_number); | |
| 562 first = packet_number; | |
| 563 last = packet_number_intervals_.rbegin()->max(); | |
| 564 return const_iterator(it, first, last); | |
| 565 } | |
| 566 | |
| 567 PacketNumberQueue::const_interval_iterator PacketNumberQueue::begin_intervals() | |
| 568 const { | |
| 569 return packet_number_intervals_.begin(); | |
| 570 } | |
| 571 | |
| 572 PacketNumberQueue::const_interval_iterator PacketNumberQueue::end_intervals() | |
| 573 const { | |
| 574 return packet_number_intervals_.end(); | |
| 575 } | |
| 576 | |
| 577 PacketNumberQueue::const_reverse_interval_iterator | |
| 578 PacketNumberQueue::rbegin_intervals() const { | |
| 579 return packet_number_intervals_.rbegin(); | |
| 580 } | |
| 581 | |
| 582 PacketNumberQueue::const_reverse_interval_iterator | |
| 583 PacketNumberQueue::rend_intervals() const { | |
| 584 return packet_number_intervals_.rend(); | |
| 585 } | |
| 586 | |
| 587 ostream& operator<<(ostream& os, const PacketNumberQueue& q) { | |
| 588 for (QuicPacketNumber packet_number : q) { | |
| 589 os << packet_number << " "; | |
| 590 } | |
| 591 return os; | |
| 592 } | |
| 593 | |
| 594 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) { | |
| 595 os << "{ entropy_hash: " << static_cast<int>(ack_frame.entropy_hash) | |
| 596 << ", largest_observed: " << ack_frame.largest_observed | |
| 597 << ", ack_delay_time: " << ack_frame.ack_delay_time.ToMicroseconds() | |
| 598 << ", packets: [ " << ack_frame.packets << " ]" | |
| 599 << ", is_truncated: " << ack_frame.is_truncated | |
| 600 << ", received_packets: [ "; | |
| 601 for (const std::pair<QuicPacketNumber, QuicTime>& p : | |
| 602 ack_frame.received_packet_times) { | |
| 603 os << p.first << " at " << p.second.ToDebuggingValue() << " "; | |
| 604 } | |
| 605 os << " ] }\n"; | |
| 606 return os; | |
| 607 } | |
| 608 | |
| 609 ostream& operator<<(ostream& os, const QuicFrame& frame) { | |
| 610 switch (frame.type) { | |
| 611 case PADDING_FRAME: { | |
| 612 os << "type { PADDING_FRAME } " << frame.padding_frame; | |
| 613 break; | |
| 614 } | |
| 615 case RST_STREAM_FRAME: { | |
| 616 os << "type { RST_STREAM_FRAME } " << *(frame.rst_stream_frame); | |
| 617 break; | |
| 618 } | |
| 619 case CONNECTION_CLOSE_FRAME: { | |
| 620 os << "type { CONNECTION_CLOSE_FRAME } " | |
| 621 << *(frame.connection_close_frame); | |
| 622 break; | |
| 623 } | |
| 624 case GOAWAY_FRAME: { | |
| 625 os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame); | |
| 626 break; | |
| 627 } | |
| 628 case WINDOW_UPDATE_FRAME: { | |
| 629 os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame); | |
| 630 break; | |
| 631 } | |
| 632 case BLOCKED_FRAME: { | |
| 633 os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame); | |
| 634 break; | |
| 635 } | |
| 636 case STREAM_FRAME: { | |
| 637 os << "type { STREAM_FRAME } " << *(frame.stream_frame); | |
| 638 break; | |
| 639 } | |
| 640 case ACK_FRAME: { | |
| 641 os << "type { ACK_FRAME } " << *(frame.ack_frame); | |
| 642 break; | |
| 643 } | |
| 644 case STOP_WAITING_FRAME: { | |
| 645 os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame); | |
| 646 break; | |
| 647 } | |
| 648 case PING_FRAME: { | |
| 649 os << "type { PING_FRAME } "; | |
| 650 break; | |
| 651 } | |
| 652 case MTU_DISCOVERY_FRAME: { | |
| 653 os << "type { MTU_DISCOVERY_FRAME } "; | |
| 654 break; | |
| 655 } | |
| 656 case PATH_CLOSE_FRAME: { | |
| 657 os << "type { PATH_CLOSE_FRAME } " << *(frame.path_close_frame); | |
| 658 break; | |
| 659 } | |
| 660 default: { | |
| 661 LOG(ERROR) << "Unknown frame type: " << frame.type; | |
| 662 break; | |
| 663 } | |
| 664 } | |
| 665 return os; | |
| 666 } | |
| 667 | |
| 668 ostream& operator<<(ostream& os, const QuicPaddingFrame& padding_frame) { | |
| 669 os << "{ num_padding_bytes: " << padding_frame.num_padding_bytes << " }\n"; | |
| 670 return os; | |
| 671 } | |
| 672 | |
| 673 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) { | |
| 674 os << "{ stream_id: " << rst_frame.stream_id | |
| 675 << ", error_code: " << rst_frame.error_code << " }\n"; | |
| 676 return os; | |
| 677 } | |
| 678 | |
| 679 ostream& operator<<(ostream& os, | |
| 680 const QuicConnectionCloseFrame& connection_close_frame) { | |
| 681 os << "{ error_code: " << connection_close_frame.error_code | |
| 682 << ", error_details: '" << connection_close_frame.error_details << "' }\n"; | |
| 683 return os; | |
| 684 } | |
| 685 | |
| 686 ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) { | |
| 687 os << "{ error_code: " << goaway_frame.error_code | |
| 688 << ", last_good_stream_id: " << goaway_frame.last_good_stream_id | |
| 689 << ", reason_phrase: '" << goaway_frame.reason_phrase << "' }\n"; | |
| 690 return os; | |
| 691 } | |
| 692 | |
| 693 ostream& operator<<(ostream& os, | |
| 694 const QuicWindowUpdateFrame& window_update_frame) { | |
| 695 os << "{ stream_id: " << window_update_frame.stream_id | |
| 696 << ", byte_offset: " << window_update_frame.byte_offset << " }\n"; | |
| 697 return os; | |
| 698 } | |
| 699 | |
| 700 ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) { | |
| 701 os << "{ stream_id: " << blocked_frame.stream_id << " }\n"; | |
| 702 return os; | |
| 703 } | |
| 704 | |
| 705 ostream& operator<<(ostream& os, const QuicPathCloseFrame& path_close_frame) { | |
| 706 os << "{ path_id: " << static_cast<int>(path_close_frame.path_id) << " }\n"; | |
| 707 return os; | |
| 708 } | |
| 709 | |
| 710 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) { | |
| 711 os << "{ stream_id: " << stream_frame.stream_id | |
| 712 << ", fin: " << stream_frame.fin << ", offset: " << stream_frame.offset | |
| 713 << ", length: " << stream_frame.data_length << " }\n"; | |
| 714 return os; | |
| 715 } | |
| 716 | |
| 717 QuicGoAwayFrame::QuicGoAwayFrame() | |
| 718 : error_code(QUIC_NO_ERROR), last_good_stream_id(0) {} | |
| 719 | |
| 720 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code, | |
| 721 QuicStreamId last_good_stream_id, | |
| 722 const string& reason) | |
| 723 : error_code(error_code), | |
| 724 last_good_stream_id(last_good_stream_id), | |
| 725 reason_phrase(reason) {} | |
| 726 | |
| 727 QuicData::QuicData(const char* buffer, size_t length) | |
| 728 : buffer_(buffer), length_(length), owns_buffer_(false) {} | |
| 729 | |
| 730 QuicData::QuicData(char* buffer, size_t length, bool owns_buffer) | |
| 731 : buffer_(buffer), length_(length), owns_buffer_(owns_buffer) {} | |
| 732 | |
| 733 QuicData::~QuicData() { | |
| 734 if (owns_buffer_) { | |
| 735 delete[] const_cast<char*>(buffer_); | |
| 736 } | |
| 737 } | |
| 738 | |
| 739 QuicWindowUpdateFrame::QuicWindowUpdateFrame(QuicStreamId stream_id, | |
| 740 QuicStreamOffset byte_offset) | |
| 741 : stream_id(stream_id), byte_offset(byte_offset) {} | |
| 742 | |
| 743 QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id) | |
| 744 : stream_id(stream_id) {} | |
| 745 | |
| 746 QuicPathCloseFrame::QuicPathCloseFrame(QuicPathId path_id) : path_id(path_id) {} | |
| 747 | |
| 748 QuicPacket::QuicPacket(char* buffer, | |
| 749 size_t length, | |
| 750 bool owns_buffer, | |
| 751 QuicConnectionIdLength connection_id_length, | |
| 752 bool includes_version, | |
| 753 bool includes_path_id, | |
| 754 bool includes_diversification_nonce, | |
| 755 QuicPacketNumberLength packet_number_length) | |
| 756 : QuicData(buffer, length, owns_buffer), | |
| 757 buffer_(buffer), | |
| 758 connection_id_length_(connection_id_length), | |
| 759 includes_version_(includes_version), | |
| 760 includes_path_id_(includes_path_id), | |
| 761 includes_diversification_nonce_(includes_diversification_nonce), | |
| 762 packet_number_length_(packet_number_length) {} | |
| 763 | |
| 764 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer, size_t length) | |
| 765 : QuicData(buffer, length) {} | |
| 766 | |
| 767 QuicEncryptedPacket::QuicEncryptedPacket(char* buffer, | |
| 768 size_t length, | |
| 769 bool owns_buffer) | |
| 770 : QuicData(buffer, length, owns_buffer) {} | |
| 771 | |
| 772 QuicEncryptedPacket* QuicEncryptedPacket::Clone() const { | |
| 773 char* buffer = new char[this->length()]; | |
| 774 memcpy(buffer, this->data(), this->length()); | |
| 775 return new QuicEncryptedPacket(buffer, this->length(), true); | |
| 776 } | |
| 777 | |
| 778 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) { | |
| 779 os << s.length() << "-byte data"; | |
| 780 return os; | |
| 781 } | |
| 782 | |
| 783 QuicReceivedPacket::QuicReceivedPacket(const char* buffer, | |
| 784 size_t length, | |
| 785 QuicTime receipt_time) | |
| 786 : QuicEncryptedPacket(buffer, length), receipt_time_(receipt_time) {} | |
| 787 | |
| 788 QuicReceivedPacket::QuicReceivedPacket(char* buffer, | |
| 789 size_t length, | |
| 790 QuicTime receipt_time, | |
| 791 bool owns_buffer) | |
| 792 : QuicEncryptedPacket(buffer, length, owns_buffer), | |
| 793 receipt_time_(receipt_time) {} | |
| 794 | |
| 795 QuicReceivedPacket* QuicReceivedPacket::Clone() const { | |
| 796 char* buffer = new char[this->length()]; | |
| 797 memcpy(buffer, this->data(), this->length()); | |
| 798 return new QuicReceivedPacket(buffer, this->length(), receipt_time(), true); | |
| 799 } | |
| 800 | |
| 801 ostream& operator<<(ostream& os, const QuicReceivedPacket& s) { | |
| 802 os << s.length() << "-byte data"; | |
| 803 return os; | |
| 804 } | |
| 805 | |
| 806 StringPiece QuicPacket::AssociatedData(QuicVersion version) const { | |
| 807 return StringPiece( | |
| 808 data(), GetStartOfEncryptedData(version, connection_id_length_, | |
| 809 includes_version_, includes_path_id_, | |
| 810 includes_diversification_nonce_, | |
| 811 packet_number_length_)); | |
| 812 } | |
| 813 | |
| 814 StringPiece QuicPacket::Plaintext(QuicVersion version) const { | |
| 815 const size_t start_of_encrypted_data = GetStartOfEncryptedData( | |
| 816 version, connection_id_length_, includes_version_, includes_path_id_, | |
| 817 includes_diversification_nonce_, packet_number_length_); | |
| 818 return StringPiece(data() + start_of_encrypted_data, | |
| 819 length() - start_of_encrypted_data); | |
| 820 } | |
| 821 | |
| 822 AckListenerWrapper::AckListenerWrapper(QuicAckListenerInterface* listener, | |
| 823 QuicPacketLength data_length) | |
| 824 : ack_listener(listener), length(data_length) { | |
| 825 DCHECK(listener != nullptr); | |
| 826 } | |
| 827 | |
| 828 AckListenerWrapper::AckListenerWrapper(const AckListenerWrapper& other) = | |
| 829 default; | |
| 830 | |
| 831 AckListenerWrapper::~AckListenerWrapper() {} | |
| 832 | |
| 833 SerializedPacket::SerializedPacket(QuicPathId path_id, | |
| 834 QuicPacketNumber packet_number, | |
| 835 QuicPacketNumberLength packet_number_length, | |
| 836 const char* encrypted_buffer, | |
| 837 QuicPacketLength encrypted_length, | |
| 838 QuicPacketEntropyHash entropy_hash, | |
| 839 bool has_ack, | |
| 840 bool has_stop_waiting) | |
| 841 : encrypted_buffer(encrypted_buffer), | |
| 842 encrypted_length(encrypted_length), | |
| 843 has_crypto_handshake(NOT_HANDSHAKE), | |
| 844 num_padding_bytes(0), | |
| 845 path_id(path_id), | |
| 846 packet_number(packet_number), | |
| 847 packet_number_length(packet_number_length), | |
| 848 encryption_level(ENCRYPTION_NONE), | |
| 849 entropy_hash(entropy_hash), | |
| 850 has_ack(has_ack), | |
| 851 has_stop_waiting(has_stop_waiting), | |
| 852 transmission_type(NOT_RETRANSMISSION), | |
| 853 original_path_id(kInvalidPathId), | |
| 854 original_packet_number(0) {} | |
| 855 | |
| 856 SerializedPacket::SerializedPacket(const SerializedPacket& other) = default; | |
| 857 | |
| 858 SerializedPacket::~SerializedPacket() {} | |
| 859 | |
| 860 TransmissionInfo::TransmissionInfo() | |
| 861 : encryption_level(ENCRYPTION_NONE), | |
| 862 packet_number_length(PACKET_1BYTE_PACKET_NUMBER), | |
| 863 bytes_sent(0), | |
| 864 sent_time(QuicTime::Zero()), | |
| 865 transmission_type(NOT_RETRANSMISSION), | |
| 866 in_flight(false), | |
| 867 is_unackable(false), | |
| 868 has_crypto_handshake(false), | |
| 869 num_padding_bytes(0), | |
| 870 retransmission(0) {} | |
| 871 | |
| 872 TransmissionInfo::TransmissionInfo(EncryptionLevel level, | |
| 873 QuicPacketNumberLength packet_number_length, | |
| 874 TransmissionType transmission_type, | |
| 875 QuicTime sent_time, | |
| 876 QuicPacketLength bytes_sent, | |
| 877 bool has_crypto_handshake, | |
| 878 int num_padding_bytes) | |
| 879 : encryption_level(level), | |
| 880 packet_number_length(packet_number_length), | |
| 881 bytes_sent(bytes_sent), | |
| 882 sent_time(sent_time), | |
| 883 transmission_type(transmission_type), | |
| 884 in_flight(false), | |
| 885 is_unackable(false), | |
| 886 has_crypto_handshake(has_crypto_handshake), | |
| 887 num_padding_bytes(num_padding_bytes), | |
| 888 retransmission(0) {} | |
| 889 | |
| 890 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default; | |
| 891 | |
| 892 TransmissionInfo::~TransmissionInfo() {} | |
| 893 | |
| 894 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2193073003:
Move shared files in net/quic/ into net/quic/core/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master