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_stream_sequencer.h" |
| 6 |
| 7 #include <algorithm> |
| 8 #include <limits> |
| 9 |
| 10 #include "base/logging.h" |
| 11 #include "net/quic/reliable_quic_stream.h" |
| 12 |
| 13 using std::min; |
| 14 using std::numeric_limits; |
| 15 |
| 16 namespace net { |
| 17 |
| 18 QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream) |
| 19 : stream_(quic_stream), |
| 20 num_bytes_consumed_(0), |
| 21 max_frame_memory_(numeric_limits<size_t>::max()), |
| 22 close_offset_(numeric_limits<QuicStreamOffset>::max()), |
| 23 half_close_(true) { |
| 24 } |
| 25 |
| 26 QuicStreamSequencer::QuicStreamSequencer(size_t max_frame_memory, |
| 27 ReliableQuicStream* quic_stream) |
| 28 : stream_(quic_stream), |
| 29 num_bytes_consumed_(0), |
| 30 max_frame_memory_(max_frame_memory), |
| 31 close_offset_(numeric_limits<QuicStreamOffset>::max()), |
| 32 half_close_(true) { |
| 33 if (max_frame_memory < kMaxPacketSize) { |
| 34 LOG(DFATAL) << "Setting max frame memory to " << max_frame_memory |
| 35 << ". Some frames will be impossible to handle."; |
| 36 } |
| 37 } |
| 38 |
| 39 QuicStreamSequencer::~QuicStreamSequencer() { |
| 40 } |
| 41 |
| 42 bool QuicStreamSequencer::WillAcceptStreamFrame( |
| 43 const QuicStreamFrame& frame) const { |
| 44 QuicStreamOffset byte_offset = frame.offset; |
| 45 size_t data_len = frame.data.size(); |
| 46 DCHECK_LE(data_len, max_frame_memory_); |
| 47 |
| 48 if (byte_offset < num_bytes_consumed_ || |
| 49 frames_.find(byte_offset) != frames_.end()) { |
| 50 return false; |
| 51 } |
| 52 if (data_len > max_frame_memory_) { |
| 53 // We're never going to buffer this frame and we can't pass it up the |
| 54 // stream might only consume part of it and we'd need a partial ack. |
| 55 // |
| 56 // Ideally this should never happen, as we check that |
| 57 // max_frame_memory_ > kMaxPacketSize and lower levels should reject |
| 58 // frames larger than that. |
| 59 return false; |
| 60 } |
| 61 if (byte_offset + data_len - num_bytes_consumed_ > max_frame_memory_) { |
| 62 // We can buffer this but not right now. Toss it. |
| 63 // It might be worth trying an experiment where we try best-effort buffering |
| 64 return false; |
| 65 } |
| 66 return true; |
| 67 } |
| 68 |
| 69 bool QuicStreamSequencer::OnStreamFrame(const QuicStreamFrame& frame) { |
| 70 QuicStreamOffset byte_offset = frame.offset; |
| 71 const char* data = frame.data.data(); |
| 72 size_t data_len = frame.data.size(); |
| 73 |
| 74 if (!WillAcceptStreamFrame(frame)) { |
| 75 // This should not happen, as WillAcceptFrame should be called before |
| 76 // OnStreamFrame. Error handling should be done by the caller. |
| 77 return false; |
| 78 } |
| 79 |
| 80 if (byte_offset == num_bytes_consumed_) { |
| 81 DVLOG(1) << "Processing byte offset " << byte_offset; |
| 82 size_t bytes_consumed = stream_->ProcessData(data, data_len); |
| 83 num_bytes_consumed_ += bytes_consumed; |
| 84 |
| 85 if (MaybeCloseStream()) { |
| 86 return true; |
| 87 } |
| 88 if (bytes_consumed > data_len) { |
| 89 stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM); |
| 90 return false; |
| 91 } else if (bytes_consumed == data_len) { |
| 92 FlushBufferedFrames(); |
| 93 return true; // it's safe to ack this frame. |
| 94 } else { |
| 95 // Set ourselves up to buffer what's left |
| 96 data_len -= bytes_consumed; |
| 97 data += bytes_consumed; |
| 98 byte_offset += bytes_consumed; |
| 99 } |
| 100 } |
| 101 |
| 102 DVLOG(1) << "Buffering packet at offset " << byte_offset; |
| 103 frames_.insert(make_pair(byte_offset, string(data, data_len))); |
| 104 return true; |
| 105 } |
| 106 |
| 107 void QuicStreamSequencer::CloseStreamAtOffset(QuicStreamOffset offset, |
| 108 bool half_close) { |
| 109 const QuicStreamOffset kMaxOffset = numeric_limits<QuicStreamOffset>::max(); |
| 110 |
| 111 // If we have a scheduled termination or close, any new offset should match |
| 112 // it. |
| 113 if (close_offset_ != kMaxOffset && offset != close_offset_) { |
| 114 stream_->Close(QUIC_MULTIPLE_TERMINATION_OFFSETS); |
| 115 return; |
| 116 } |
| 117 |
| 118 close_offset_ = offset; |
| 119 // Full close overrides half close. |
| 120 if (half_close == false) { |
| 121 half_close_ = false; |
| 122 } |
| 123 |
| 124 MaybeCloseStream(); |
| 125 } |
| 126 |
| 127 bool QuicStreamSequencer::MaybeCloseStream() { |
| 128 if (IsHalfClosed()) { |
| 129 DVLOG(1) << "Passing up termination, as we've processed " |
| 130 << num_bytes_consumed_ << " of " << close_offset_ |
| 131 << " bytes."; |
| 132 // Technically it's an error if num_bytes_consumed isn't exactly |
| 133 // equal, but error handling seems silly at this point. |
| 134 stream_->TerminateFromPeer(half_close_); |
| 135 return true; |
| 136 } |
| 137 return false; |
| 138 } |
| 139 |
| 140 void QuicStreamSequencer::AdvanceReadablePtr(size_t data_read) { |
| 141 FrameMap::iterator it = frames_.begin(); |
| 142 |
| 143 while (data_read) { |
| 144 if (it->first != num_bytes_consumed_ || it == frames_.end()) { |
| 145 stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM); // Programming error |
| 146 return; |
| 147 } |
| 148 |
| 149 if (data_read >= it->second.size()) { |
| 150 data_read -= it->second.size(); |
| 151 num_bytes_consumed_ += it->second.size(); |
| 152 frames_.erase(it); |
| 153 it = frames_.begin(); |
| 154 } else { |
| 155 frames_.insert(make_pair(it->first + data_read, |
| 156 it->second.substr(data_read))); |
| 157 frames_.erase(frames_.begin()); |
| 158 num_bytes_consumed_ += data_read; |
| 159 data_read = 0; |
| 160 } |
| 161 } |
| 162 } |
| 163 |
| 164 bool QuicStreamSequencer::HasBytesToRead() { |
| 165 FrameMap::iterator it = frames_.begin(); |
| 166 |
| 167 return it != frames_.end() && it->first == num_bytes_consumed_; |
| 168 } |
| 169 |
| 170 bool QuicStreamSequencer::IsHalfClosed() { |
| 171 return num_bytes_consumed_ >= close_offset_; |
| 172 } |
| 173 |
| 174 bool QuicStreamSequencer::IsClosed() { |
| 175 return num_bytes_consumed_ >= close_offset_ && half_close_ == false; |
| 176 } |
| 177 |
| 178 void QuicStreamSequencer::FlushBufferedFrames() { |
| 179 FrameMap::iterator it = frames_.find(num_bytes_consumed_); |
| 180 while (it != frames_.end()) { |
| 181 DVLOG(1) << "Flushing buffered packet at offset " << it->first; |
| 182 string* data = &it->second; |
| 183 size_t bytes_consumed = stream_->ProcessData(data->c_str(), data->size()); |
| 184 num_bytes_consumed_ += bytes_consumed; |
| 185 if (MaybeCloseStream()) { |
| 186 return; |
| 187 } |
| 188 if (bytes_consumed > data->size()) { |
| 189 stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM); // Programming error |
| 190 return; |
| 191 } else if (bytes_consumed == data->size()) { |
| 192 frames_.erase(it); |
| 193 it = frames_.find(num_bytes_consumed_); |
| 194 } else { |
| 195 string new_data = it->second.substr(bytes_consumed); |
| 196 frames_.erase(it); |
| 197 frames_.insert(make_pair(num_bytes_consumed_, new_data)); |
| 198 return; |
| 199 } |
| 200 } |
| 201 } |
| 202 |
| 203 } // namespace net |
OLD | NEW |