| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2016 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/core/quic_frames.h" | |
| 6 | |
| 7 using base::StringPiece; | |
| 8 using std::ostream; | |
| 9 using std::string; | |
| 10 | |
| 11 namespace net { | |
| 12 | |
| 13 void StreamBufferDeleter::operator()(char* buffer) const { | |
| 14 if (allocator_ != nullptr && buffer != nullptr) { | |
| 15 allocator_->Delete(buffer); | |
| 16 } | |
| 17 } | |
| 18 | |
| 19 UniqueStreamBuffer NewStreamBuffer(QuicBufferAllocator* allocator, | |
| 20 size_t size) { | |
| 21 return UniqueStreamBuffer(allocator->New(size), | |
| 22 StreamBufferDeleter(allocator)); | |
| 23 } | |
| 24 | |
| 25 QuicStreamFrame::QuicStreamFrame() | |
| 26 : QuicStreamFrame(0, false, 0, nullptr, 0, nullptr) {} | |
| 27 | |
| 28 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 29 bool fin, | |
| 30 QuicStreamOffset offset, | |
| 31 StringPiece data) | |
| 32 : QuicStreamFrame(stream_id, | |
| 33 fin, | |
| 34 offset, | |
| 35 data.data(), | |
| 36 data.length(), | |
| 37 nullptr) {} | |
| 38 | |
| 39 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 40 bool fin, | |
| 41 QuicStreamOffset offset, | |
| 42 QuicPacketLength data_length, | |
| 43 UniqueStreamBuffer buffer) | |
| 44 : QuicStreamFrame(stream_id, | |
| 45 fin, | |
| 46 offset, | |
| 47 nullptr, | |
| 48 data_length, | |
| 49 std::move(buffer)) { | |
| 50 DCHECK(this->buffer != nullptr); | |
| 51 DCHECK_EQ(data_buffer, this->buffer.get()); | |
| 52 } | |
| 53 | |
| 54 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, | |
| 55 bool fin, | |
| 56 QuicStreamOffset offset, | |
| 57 const char* data_buffer, | |
| 58 QuicPacketLength data_length, | |
| 59 UniqueStreamBuffer buffer) | |
| 60 : stream_id(stream_id), | |
| 61 fin(fin), | |
| 62 data_length(data_length), | |
| 63 data_buffer(data_buffer), | |
| 64 offset(offset), | |
| 65 buffer(std::move(buffer)) { | |
| 66 if (this->buffer != nullptr) { | |
| 67 DCHECK(data_buffer == nullptr); | |
| 68 this->data_buffer = this->buffer.get(); | |
| 69 } | |
| 70 } | |
| 71 | |
| 72 QuicStreamFrame::~QuicStreamFrame() {} | |
| 73 | |
| 74 bool IsAwaitingPacket(const QuicAckFrame& ack_frame, | |
| 75 QuicPacketNumber packet_number, | |
| 76 QuicPacketNumber peer_least_packet_awaiting_ack) { | |
| 77 return packet_number >= peer_least_packet_awaiting_ack && | |
| 78 !ack_frame.packets.Contains(packet_number); | |
| 79 } | |
| 80 | |
| 81 QuicStopWaitingFrame::QuicStopWaitingFrame() | |
| 82 : path_id(kDefaultPathId), least_unacked(0) {} | |
| 83 | |
| 84 QuicStopWaitingFrame::~QuicStopWaitingFrame() {} | |
| 85 | |
| 86 QuicAckFrame::QuicAckFrame() | |
| 87 : largest_observed(0), | |
| 88 ack_delay_time(QuicTime::Delta::Infinite()), | |
| 89 path_id(kDefaultPathId) {} | |
| 90 | |
| 91 QuicAckFrame::QuicAckFrame(const QuicAckFrame& other) = default; | |
| 92 | |
| 93 QuicAckFrame::~QuicAckFrame() {} | |
| 94 | |
| 95 QuicRstStreamFrame::QuicRstStreamFrame() | |
| 96 : stream_id(0), error_code(QUIC_STREAM_NO_ERROR), byte_offset(0) {} | |
| 97 | |
| 98 QuicRstStreamFrame::QuicRstStreamFrame(QuicStreamId stream_id, | |
| 99 QuicRstStreamErrorCode error_code, | |
| 100 QuicStreamOffset bytes_written) | |
| 101 : stream_id(stream_id), | |
| 102 error_code(error_code), | |
| 103 byte_offset(bytes_written) {} | |
| 104 | |
| 105 QuicConnectionCloseFrame::QuicConnectionCloseFrame() | |
| 106 : error_code(QUIC_NO_ERROR) {} | |
| 107 | |
| 108 QuicFrame::QuicFrame() {} | |
| 109 | |
| 110 QuicFrame::QuicFrame(QuicPaddingFrame padding_frame) | |
| 111 : type(PADDING_FRAME), padding_frame(padding_frame) {} | |
| 112 | |
| 113 QuicFrame::QuicFrame(QuicStreamFrame* stream_frame) | |
| 114 : type(STREAM_FRAME), stream_frame(stream_frame) {} | |
| 115 | |
| 116 QuicFrame::QuicFrame(QuicAckFrame* frame) : type(ACK_FRAME), ack_frame(frame) {} | |
| 117 | |
| 118 QuicFrame::QuicFrame(QuicMtuDiscoveryFrame frame) | |
| 119 : type(MTU_DISCOVERY_FRAME), mtu_discovery_frame(frame) {} | |
| 120 | |
| 121 QuicFrame::QuicFrame(QuicStopWaitingFrame* frame) | |
| 122 : type(STOP_WAITING_FRAME), stop_waiting_frame(frame) {} | |
| 123 | |
| 124 QuicFrame::QuicFrame(QuicPingFrame frame) | |
| 125 : type(PING_FRAME), ping_frame(frame) {} | |
| 126 | |
| 127 QuicFrame::QuicFrame(QuicRstStreamFrame* frame) | |
| 128 : type(RST_STREAM_FRAME), rst_stream_frame(frame) {} | |
| 129 | |
| 130 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame) | |
| 131 : type(CONNECTION_CLOSE_FRAME), connection_close_frame(frame) {} | |
| 132 | |
| 133 QuicFrame::QuicFrame(QuicGoAwayFrame* frame) | |
| 134 : type(GOAWAY_FRAME), goaway_frame(frame) {} | |
| 135 | |
| 136 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame) | |
| 137 : type(WINDOW_UPDATE_FRAME), window_update_frame(frame) {} | |
| 138 | |
| 139 QuicFrame::QuicFrame(QuicBlockedFrame* frame) | |
| 140 : type(BLOCKED_FRAME), blocked_frame(frame) {} | |
| 141 | |
| 142 QuicFrame::QuicFrame(QuicPathCloseFrame* frame) | |
| 143 : type(PATH_CLOSE_FRAME), path_close_frame(frame) {} | |
| 144 | |
| 145 void DeleteFrames(QuicFrames* frames) { | |
| 146 for (QuicFrame& frame : *frames) { | |
| 147 switch (frame.type) { | |
| 148 // Frames smaller than a pointer are inlined, so don't need to be deleted. | |
| 149 case PADDING_FRAME: | |
| 150 case MTU_DISCOVERY_FRAME: | |
| 151 case PING_FRAME: | |
| 152 break; | |
| 153 case STREAM_FRAME: | |
| 154 delete frame.stream_frame; | |
| 155 break; | |
| 156 case ACK_FRAME: | |
| 157 delete frame.ack_frame; | |
| 158 break; | |
| 159 case STOP_WAITING_FRAME: | |
| 160 delete frame.stop_waiting_frame; | |
| 161 break; | |
| 162 case RST_STREAM_FRAME: | |
| 163 delete frame.rst_stream_frame; | |
| 164 break; | |
| 165 case CONNECTION_CLOSE_FRAME: | |
| 166 delete frame.connection_close_frame; | |
| 167 break; | |
| 168 case GOAWAY_FRAME: | |
| 169 delete frame.goaway_frame; | |
| 170 break; | |
| 171 case BLOCKED_FRAME: | |
| 172 delete frame.blocked_frame; | |
| 173 break; | |
| 174 case WINDOW_UPDATE_FRAME: | |
| 175 delete frame.window_update_frame; | |
| 176 break; | |
| 177 case PATH_CLOSE_FRAME: | |
| 178 delete frame.path_close_frame; | |
| 179 break; | |
| 180 case NUM_FRAME_TYPES: | |
| 181 DCHECK(false) << "Cannot delete type: " << frame.type; | |
| 182 } | |
| 183 } | |
| 184 frames->clear(); | |
| 185 } | |
| 186 | |
| 187 void RemoveFramesForStream(QuicFrames* frames, QuicStreamId stream_id) { | |
| 188 QuicFrames::iterator it = frames->begin(); | |
| 189 while (it != frames->end()) { | |
| 190 if (it->type != STREAM_FRAME || it->stream_frame->stream_id != stream_id) { | |
| 191 ++it; | |
| 192 continue; | |
| 193 } | |
| 194 delete it->stream_frame; | |
| 195 it = frames->erase(it); | |
| 196 } | |
| 197 } | |
| 198 | |
| 199 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) { | |
| 200 os << "{ least_unacked: " << sent_info.least_unacked << " }\n"; | |
| 201 return os; | |
| 202 } | |
| 203 | |
| 204 PacketNumberQueue::PacketNumberQueue() = default; | |
| 205 PacketNumberQueue::PacketNumberQueue(const PacketNumberQueue& other) = default; | |
| 206 PacketNumberQueue::PacketNumberQueue(PacketNumberQueue&& other) = default; | |
| 207 PacketNumberQueue::~PacketNumberQueue() {} | |
| 208 | |
| 209 PacketNumberQueue& PacketNumberQueue::operator=( | |
| 210 const PacketNumberQueue& other) = default; | |
| 211 PacketNumberQueue& PacketNumberQueue::operator=(PacketNumberQueue&& other) = | |
| 212 default; | |
| 213 | |
| 214 void PacketNumberQueue::Add(QuicPacketNumber packet_number) { | |
| 215 packet_number_intervals_.Add(packet_number, packet_number + 1); | |
| 216 } | |
| 217 | |
| 218 void PacketNumberQueue::Add(QuicPacketNumber lower, QuicPacketNumber higher) { | |
| 219 packet_number_intervals_.Add(lower, higher); | |
| 220 } | |
| 221 | |
| 222 void PacketNumberQueue::Remove(QuicPacketNumber packet_number) { | |
| 223 packet_number_intervals_.Difference(packet_number, packet_number + 1); | |
| 224 } | |
| 225 | |
| 226 void PacketNumberQueue::Remove(QuicPacketNumber lower, | |
| 227 QuicPacketNumber higher) { | |
| 228 packet_number_intervals_.Difference(lower, higher); | |
| 229 } | |
| 230 | |
| 231 bool PacketNumberQueue::RemoveUpTo(QuicPacketNumber higher) { | |
| 232 if (Empty()) { | |
| 233 return false; | |
| 234 } | |
| 235 const QuicPacketNumber old_min = Min(); | |
| 236 packet_number_intervals_.Difference(0, higher); | |
| 237 return Empty() || old_min != Min(); | |
| 238 } | |
| 239 | |
| 240 void PacketNumberQueue::Complement() { | |
| 241 if (Empty()) { | |
| 242 return; | |
| 243 } | |
| 244 packet_number_intervals_.Complement(Min(), Max() + 1); | |
| 245 } | |
| 246 | |
| 247 bool PacketNumberQueue::Contains(QuicPacketNumber packet_number) const { | |
| 248 return packet_number_intervals_.Contains(packet_number); | |
| 249 } | |
| 250 | |
| 251 bool PacketNumberQueue::Empty() const { | |
| 252 return packet_number_intervals_.Empty(); | |
| 253 } | |
| 254 | |
| 255 QuicPacketNumber PacketNumberQueue::Min() const { | |
| 256 DCHECK(!Empty()); | |
| 257 return packet_number_intervals_.begin()->min(); | |
| 258 } | |
| 259 | |
| 260 QuicPacketNumber PacketNumberQueue::Max() const { | |
| 261 DCHECK(!Empty()); | |
| 262 return packet_number_intervals_.rbegin()->max() - 1; | |
| 263 } | |
| 264 | |
| 265 size_t PacketNumberQueue::NumPacketsSlow() const { | |
| 266 size_t num_packets = 0; | |
| 267 for (const auto& interval : packet_number_intervals_) { | |
| 268 num_packets += interval.Length(); | |
| 269 } | |
| 270 return num_packets; | |
| 271 } | |
| 272 | |
| 273 size_t PacketNumberQueue::NumIntervals() const { | |
| 274 return packet_number_intervals_.Size(); | |
| 275 } | |
| 276 | |
| 277 QuicPacketNumber PacketNumberQueue::LastIntervalLength() const { | |
| 278 DCHECK(!Empty()); | |
| 279 return packet_number_intervals_.rbegin()->Length(); | |
| 280 } | |
| 281 | |
| 282 PacketNumberQueue::const_iterator PacketNumberQueue::lower_bound( | |
| 283 QuicPacketNumber packet_number) const { | |
| 284 // lower_bound returns the first interval that contains |packet_number| or the | |
| 285 // first interval after |packet_number|. | |
| 286 auto itr = packet_number_intervals_.Find(packet_number); | |
| 287 if (itr != packet_number_intervals_.end()) { | |
| 288 return itr; | |
| 289 } | |
| 290 for (itr = packet_number_intervals_.begin(); | |
| 291 itr != packet_number_intervals_.end(); ++itr) { | |
| 292 if (packet_number < itr->min()) { | |
| 293 return itr; | |
| 294 } | |
| 295 } | |
| 296 return packet_number_intervals_.end(); | |
| 297 } | |
| 298 | |
| 299 PacketNumberQueue::const_iterator PacketNumberQueue::begin() const { | |
| 300 return packet_number_intervals_.begin(); | |
| 301 } | |
| 302 | |
| 303 PacketNumberQueue::const_iterator PacketNumberQueue::end() const { | |
| 304 return packet_number_intervals_.end(); | |
| 305 } | |
| 306 | |
| 307 PacketNumberQueue::const_reverse_iterator PacketNumberQueue::rbegin() const { | |
| 308 return packet_number_intervals_.rbegin(); | |
| 309 } | |
| 310 | |
| 311 PacketNumberQueue::const_reverse_iterator PacketNumberQueue::rend() const { | |
| 312 return packet_number_intervals_.rend(); | |
| 313 } | |
| 314 | |
| 315 ostream& operator<<(ostream& os, const PacketNumberQueue& q) { | |
| 316 for (const Interval<QuicPacketNumber>& interval : q) { | |
| 317 for (QuicPacketNumber packet_number = interval.min(); | |
| 318 packet_number < interval.max(); ++packet_number) { | |
| 319 os << packet_number << " "; | |
| 320 } | |
| 321 } | |
| 322 return os; | |
| 323 } | |
| 324 | |
| 325 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) { | |
| 326 os << "{ largest_observed: " << ack_frame.largest_observed | |
| 327 << ", ack_delay_time: " << ack_frame.ack_delay_time.ToMicroseconds() | |
| 328 << ", packets: [ " << ack_frame.packets << " ]" | |
| 329 << ", received_packets: [ "; | |
| 330 for (const std::pair<QuicPacketNumber, QuicTime>& p : | |
| 331 ack_frame.received_packet_times) { | |
| 332 os << p.first << " at " << p.second.ToDebuggingValue() << " "; | |
| 333 } | |
| 334 os << " ] }\n"; | |
| 335 return os; | |
| 336 } | |
| 337 | |
| 338 ostream& operator<<(ostream& os, const QuicFrame& frame) { | |
| 339 switch (frame.type) { | |
| 340 case PADDING_FRAME: { | |
| 341 os << "type { PADDING_FRAME } " << frame.padding_frame; | |
| 342 break; | |
| 343 } | |
| 344 case RST_STREAM_FRAME: { | |
| 345 os << "type { RST_STREAM_FRAME } " << *(frame.rst_stream_frame); | |
| 346 break; | |
| 347 } | |
| 348 case CONNECTION_CLOSE_FRAME: { | |
| 349 os << "type { CONNECTION_CLOSE_FRAME } " | |
| 350 << *(frame.connection_close_frame); | |
| 351 break; | |
| 352 } | |
| 353 case GOAWAY_FRAME: { | |
| 354 os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame); | |
| 355 break; | |
| 356 } | |
| 357 case WINDOW_UPDATE_FRAME: { | |
| 358 os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame); | |
| 359 break; | |
| 360 } | |
| 361 case BLOCKED_FRAME: { | |
| 362 os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame); | |
| 363 break; | |
| 364 } | |
| 365 case STREAM_FRAME: { | |
| 366 os << "type { STREAM_FRAME } " << *(frame.stream_frame); | |
| 367 break; | |
| 368 } | |
| 369 case ACK_FRAME: { | |
| 370 os << "type { ACK_FRAME } " << *(frame.ack_frame); | |
| 371 break; | |
| 372 } | |
| 373 case STOP_WAITING_FRAME: { | |
| 374 os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame); | |
| 375 break; | |
| 376 } | |
| 377 case PING_FRAME: { | |
| 378 os << "type { PING_FRAME } "; | |
| 379 break; | |
| 380 } | |
| 381 case MTU_DISCOVERY_FRAME: { | |
| 382 os << "type { MTU_DISCOVERY_FRAME } "; | |
| 383 break; | |
| 384 } | |
| 385 case PATH_CLOSE_FRAME: { | |
| 386 os << "type { PATH_CLOSE_FRAME } " << *(frame.path_close_frame); | |
| 387 break; | |
| 388 } | |
| 389 default: { | |
| 390 LOG(ERROR) << "Unknown frame type: " << frame.type; | |
| 391 break; | |
| 392 } | |
| 393 } | |
| 394 return os; | |
| 395 } | |
| 396 | |
| 397 ostream& operator<<(ostream& os, const QuicPaddingFrame& padding_frame) { | |
| 398 os << "{ num_padding_bytes: " << padding_frame.num_padding_bytes << " }\n"; | |
| 399 return os; | |
| 400 } | |
| 401 | |
| 402 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) { | |
| 403 os << "{ stream_id: " << rst_frame.stream_id | |
| 404 << ", error_code: " << rst_frame.error_code << " }\n"; | |
| 405 return os; | |
| 406 } | |
| 407 | |
| 408 ostream& operator<<(ostream& os, | |
| 409 const QuicConnectionCloseFrame& connection_close_frame) { | |
| 410 os << "{ error_code: " << connection_close_frame.error_code | |
| 411 << ", error_details: '" << connection_close_frame.error_details << "' }\n"; | |
| 412 return os; | |
| 413 } | |
| 414 | |
| 415 ostream& operator<<(ostream& os, const QuicGoAwayFrame& goaway_frame) { | |
| 416 os << "{ error_code: " << goaway_frame.error_code | |
| 417 << ", last_good_stream_id: " << goaway_frame.last_good_stream_id | |
| 418 << ", reason_phrase: '" << goaway_frame.reason_phrase << "' }\n"; | |
| 419 return os; | |
| 420 } | |
| 421 | |
| 422 ostream& operator<<(ostream& os, | |
| 423 const QuicWindowUpdateFrame& window_update_frame) { | |
| 424 os << "{ stream_id: " << window_update_frame.stream_id | |
| 425 << ", byte_offset: " << window_update_frame.byte_offset << " }\n"; | |
| 426 return os; | |
| 427 } | |
| 428 | |
| 429 ostream& operator<<(ostream& os, const QuicBlockedFrame& blocked_frame) { | |
| 430 os << "{ stream_id: " << blocked_frame.stream_id << " }\n"; | |
| 431 return os; | |
| 432 } | |
| 433 | |
| 434 ostream& operator<<(ostream& os, const QuicPathCloseFrame& path_close_frame) { | |
| 435 os << "{ path_id: " << static_cast<int>(path_close_frame.path_id) << " }\n"; | |
| 436 return os; | |
| 437 } | |
| 438 | |
| 439 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) { | |
| 440 os << "{ stream_id: " << stream_frame.stream_id | |
| 441 << ", fin: " << stream_frame.fin << ", offset: " << stream_frame.offset | |
| 442 << ", length: " << stream_frame.data_length << " }\n"; | |
| 443 return os; | |
| 444 } | |
| 445 | |
| 446 QuicGoAwayFrame::QuicGoAwayFrame() | |
| 447 : error_code(QUIC_NO_ERROR), last_good_stream_id(0) {} | |
| 448 | |
| 449 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code, | |
| 450 QuicStreamId last_good_stream_id, | |
| 451 const string& reason) | |
| 452 : error_code(error_code), | |
| 453 last_good_stream_id(last_good_stream_id), | |
| 454 reason_phrase(reason) {} | |
| 455 | |
| 456 QuicWindowUpdateFrame::QuicWindowUpdateFrame(QuicStreamId stream_id, | |
| 457 QuicStreamOffset byte_offset) | |
| 458 : stream_id(stream_id), byte_offset(byte_offset) {} | |
| 459 | |
| 460 QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id) | |
| 461 : stream_id(stream_id) {} | |
| 462 | |
| 463 QuicPathCloseFrame::QuicPathCloseFrame(QuicPathId path_id) : path_id(path_id) {} | |
| 464 | |
| 465 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2545543003:
Split up quic_frames.{h,cc} into files for each frame type. (Closed)
