OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_framer.h" | 5 #include "net/quic/quic_framer.h" |
6 | 6 |
7 #include "base/containers/hash_tables.h" | 7 #include "base/containers/hash_tables.h" |
8 #include "base/stl_util.h" | 8 #include "base/stl_util.h" |
9 #include "net/quic/crypto/crypto_framer.h" | 9 #include "net/quic/crypto/crypto_framer.h" |
10 #include "net/quic/crypto/crypto_handshake_message.h" | 10 #include "net/quic/crypto/crypto_handshake_message.h" |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
125 case PACKET_FLAGS_2BYTE_SEQUENCE: | 125 case PACKET_FLAGS_2BYTE_SEQUENCE: |
126 return PACKET_2BYTE_SEQUENCE_NUMBER; | 126 return PACKET_2BYTE_SEQUENCE_NUMBER; |
127 case PACKET_FLAGS_1BYTE_SEQUENCE: | 127 case PACKET_FLAGS_1BYTE_SEQUENCE: |
128 return PACKET_1BYTE_SEQUENCE_NUMBER; | 128 return PACKET_1BYTE_SEQUENCE_NUMBER; |
129 default: | 129 default: |
130 LOG(DFATAL) << "Unreachable case statement."; | 130 LOG(DFATAL) << "Unreachable case statement."; |
131 return PACKET_6BYTE_SEQUENCE_NUMBER; | 131 return PACKET_6BYTE_SEQUENCE_NUMBER; |
132 } | 132 } |
133 } | 133 } |
134 | 134 |
135 bool CanTruncate( | 135 bool CanTruncate(const QuicFrame& frame, size_t free_bytes) { |
136 QuicVersion version, const QuicFrame& frame, size_t free_bytes) { | |
137 if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) && | 136 if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) && |
138 free_bytes >= | 137 free_bytes >= |
139 QuicFramer::GetMinAckFrameSize(version, | 138 QuicFramer::GetMinAckFrameSize(PACKET_6BYTE_SEQUENCE_NUMBER, |
140 PACKET_6BYTE_SEQUENCE_NUMBER, | |
141 PACKET_6BYTE_SEQUENCE_NUMBER)) { | 139 PACKET_6BYTE_SEQUENCE_NUMBER)) { |
142 return true; | 140 return true; |
143 } | 141 } |
144 return false; | 142 return false; |
145 } | 143 } |
146 | 144 |
147 } // namespace | 145 } // namespace |
148 | 146 |
149 bool QuicFramerVisitorInterface::OnWindowUpdateFrame( | 147 bool QuicFramerVisitorInterface::OnWindowUpdateFrame( |
150 const QuicWindowUpdateFrame& frame) { | 148 const QuicWindowUpdateFrame& frame) { |
(...skipping 23 matching lines...) Expand all Loading... |
174 DCHECK(!supported_versions.empty()); | 172 DCHECK(!supported_versions.empty()); |
175 quic_version_ = supported_versions_[0]; | 173 quic_version_ = supported_versions_[0]; |
176 decrypter_.reset(QuicDecrypter::Create(kNULL)); | 174 decrypter_.reset(QuicDecrypter::Create(kNULL)); |
177 encrypter_[ENCRYPTION_NONE].reset( | 175 encrypter_[ENCRYPTION_NONE].reset( |
178 QuicEncrypter::Create(kNULL)); | 176 QuicEncrypter::Create(kNULL)); |
179 } | 177 } |
180 | 178 |
181 QuicFramer::~QuicFramer() {} | 179 QuicFramer::~QuicFramer() {} |
182 | 180 |
183 // static | 181 // static |
184 size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version, | 182 size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id, |
185 QuicStreamId stream_id, | |
186 QuicStreamOffset offset, | 183 QuicStreamOffset offset, |
187 bool last_frame_in_packet, | 184 bool last_frame_in_packet, |
188 InFecGroup is_in_fec_group) { | 185 InFecGroup is_in_fec_group) { |
189 bool no_stream_frame_length = last_frame_in_packet && | 186 bool no_stream_frame_length = last_frame_in_packet && |
190 is_in_fec_group == NOT_IN_FEC_GROUP; | 187 is_in_fec_group == NOT_IN_FEC_GROUP; |
191 return kQuicFrameTypeSize + GetStreamIdSize(stream_id) + | 188 return kQuicFrameTypeSize + GetStreamIdSize(stream_id) + |
192 GetStreamOffsetSize(offset) + | 189 GetStreamOffsetSize(offset) + |
193 (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize); | 190 (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize); |
194 } | 191 } |
195 | 192 |
196 // static | 193 // static |
197 size_t QuicFramer::GetMinAckFrameSize( | 194 size_t QuicFramer::GetMinAckFrameSize( |
198 QuicVersion version, | |
199 QuicSequenceNumberLength sequence_number_length, | 195 QuicSequenceNumberLength sequence_number_length, |
200 QuicSequenceNumberLength largest_observed_length) { | 196 QuicSequenceNumberLength largest_observed_length) { |
201 size_t len = kQuicFrameTypeSize + kQuicEntropyHashSize + | 197 return kQuicFrameTypeSize + kQuicEntropyHashSize + |
202 largest_observed_length + kQuicDeltaTimeLargestObservedSize; | 198 largest_observed_length + kQuicDeltaTimeLargestObservedSize; |
203 if (version <= QUIC_VERSION_15) { | |
204 len += sequence_number_length + kQuicEntropyHashSize; | |
205 } | |
206 return len; | |
207 } | 199 } |
208 | 200 |
209 // static | 201 // static |
210 size_t QuicFramer::GetStopWaitingFrameSize( | 202 size_t QuicFramer::GetStopWaitingFrameSize( |
211 QuicSequenceNumberLength sequence_number_length) { | 203 QuicSequenceNumberLength sequence_number_length) { |
212 return kQuicFrameTypeSize + kQuicEntropyHashSize + | 204 return kQuicFrameTypeSize + kQuicEntropyHashSize + |
213 sequence_number_length; | 205 sequence_number_length; |
214 } | 206 } |
215 | 207 |
216 // static | 208 // static |
217 size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version) { | 209 size_t QuicFramer::GetMinRstStreamFrameSize() { |
218 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + | 210 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + |
219 kQuicMaxStreamOffsetSize + kQuicErrorCodeSize + | 211 kQuicMaxStreamOffsetSize + kQuicErrorCodeSize + |
220 kQuicErrorDetailsLengthSize; | 212 kQuicErrorDetailsLengthSize; |
221 } | 213 } |
222 | 214 |
223 // static | 215 // static |
224 size_t QuicFramer::GetMinConnectionCloseFrameSize() { | 216 size_t QuicFramer::GetMinConnectionCloseFrameSize() { |
225 return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize; | 217 return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize; |
226 } | 218 } |
227 | 219 |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 sequence_number_length); | 295 sequence_number_length); |
304 if (frame_len <= free_bytes) { | 296 if (frame_len <= free_bytes) { |
305 // Frame fits within packet. Note that acks may be truncated. | 297 // Frame fits within packet. Note that acks may be truncated. |
306 return frame_len; | 298 return frame_len; |
307 } | 299 } |
308 // Only truncate the first frame in a packet, so if subsequent ones go | 300 // Only truncate the first frame in a packet, so if subsequent ones go |
309 // over, stop including more frames. | 301 // over, stop including more frames. |
310 if (!first_frame) { | 302 if (!first_frame) { |
311 return 0; | 303 return 0; |
312 } | 304 } |
313 if (CanTruncate(quic_version_, frame, free_bytes)) { | 305 if (CanTruncate(frame, free_bytes)) { |
314 // Truncate the frame so the packet will not exceed kMaxPacketSize. | 306 // Truncate the frame so the packet will not exceed kMaxPacketSize. |
315 // Note that we may not use every byte of the writer in this case. | 307 // Note that we may not use every byte of the writer in this case. |
316 DVLOG(1) << "Truncating large frame, free bytes: " << free_bytes; | 308 DVLOG(1) << "Truncating large frame, free bytes: " << free_bytes; |
317 return free_bytes; | 309 return free_bytes; |
318 } | 310 } |
319 if (!FLAGS_quic_allow_oversized_packets_for_test) { | 311 if (!FLAGS_quic_allow_oversized_packets_for_test) { |
320 return 0; | 312 return 0; |
321 } | 313 } |
322 LOG(DFATAL) << "Packet size too small to fit frame."; | 314 LOG(DFATAL) << "Packet size too small to fit frame."; |
323 return frame_len; | 315 return frame_len; |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
375 } | 367 } |
376 break; | 368 break; |
377 case CONGESTION_FEEDBACK_FRAME: | 369 case CONGESTION_FEEDBACK_FRAME: |
378 if (!AppendCongestionFeedbackFrame( | 370 if (!AppendCongestionFeedbackFrame( |
379 *frame.congestion_feedback_frame, &writer)) { | 371 *frame.congestion_feedback_frame, &writer)) { |
380 LOG(DFATAL) << "AppendCongestionFeedbackFrame failed"; | 372 LOG(DFATAL) << "AppendCongestionFeedbackFrame failed"; |
381 return kNoPacket; | 373 return kNoPacket; |
382 } | 374 } |
383 break; | 375 break; |
384 case STOP_WAITING_FRAME: | 376 case STOP_WAITING_FRAME: |
385 if (quic_version_ <= QUIC_VERSION_15) { | |
386 LOG(DFATAL) << "Attempt to add a StopWaitingFrame in " | |
387 << QuicVersionToString(quic_version_); | |
388 return kNoPacket; | |
389 } | |
390 if (!AppendStopWaitingFrame( | 377 if (!AppendStopWaitingFrame( |
391 header, *frame.stop_waiting_frame, &writer)) { | 378 header, *frame.stop_waiting_frame, &writer)) { |
392 LOG(DFATAL) << "AppendStopWaitingFrame failed"; | 379 LOG(DFATAL) << "AppendStopWaitingFrame failed"; |
393 return kNoPacket; | 380 return kNoPacket; |
394 } | 381 } |
395 break; | 382 break; |
396 case PING_FRAME: | 383 case PING_FRAME: |
397 if (quic_version_ <= QUIC_VERSION_16) { | 384 if (quic_version_ == QUIC_VERSION_16) { |
398 LOG(DFATAL) << "Attempt to add a PingFrame in " | 385 LOG(DFATAL) << "Attempt to add a PingFrame in " |
399 << QuicVersionToString(quic_version_); | 386 << QuicVersionToString(quic_version_); |
400 return kNoPacket; | 387 return kNoPacket; |
401 } | 388 } |
402 // Ping has no payload. | 389 // Ping has no payload. |
403 break; | 390 break; |
404 case RST_STREAM_FRAME: | 391 case RST_STREAM_FRAME: |
405 if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) { | 392 if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) { |
406 LOG(DFATAL) << "AppendRstStreamFrame failed"; | 393 LOG(DFATAL) << "AppendRstStreamFrame failed"; |
407 return kNoPacket; | 394 return kNoPacket; |
(...skipping 561 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
969 return PACKET_FLAGS_6BYTE_SEQUENCE; | 956 return PACKET_FLAGS_6BYTE_SEQUENCE; |
970 default: | 957 default: |
971 LOG(DFATAL) << "Unreachable case statement."; | 958 LOG(DFATAL) << "Unreachable case statement."; |
972 return PACKET_FLAGS_6BYTE_SEQUENCE; | 959 return PACKET_FLAGS_6BYTE_SEQUENCE; |
973 } | 960 } |
974 } | 961 } |
975 | 962 |
976 // static | 963 // static |
977 QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo( | 964 QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo( |
978 const QuicAckFrame& frame) { | 965 const QuicAckFrame& frame) { |
979 const ReceivedPacketInfo& received_info = frame.received_info; | |
980 | |
981 AckFrameInfo ack_info; | 966 AckFrameInfo ack_info; |
982 if (!received_info.missing_packets.empty()) { | 967 if (!frame.missing_packets.empty()) { |
983 DCHECK_GE(received_info.largest_observed, | 968 DCHECK_GE(frame.largest_observed, *frame.missing_packets.rbegin()); |
984 *received_info.missing_packets.rbegin()); | |
985 size_t cur_range_length = 0; | 969 size_t cur_range_length = 0; |
986 SequenceNumberSet::const_iterator iter = | 970 SequenceNumberSet::const_iterator iter = frame.missing_packets.begin(); |
987 received_info.missing_packets.begin(); | |
988 QuicPacketSequenceNumber last_missing = *iter; | 971 QuicPacketSequenceNumber last_missing = *iter; |
989 ++iter; | 972 ++iter; |
990 for (; iter != received_info.missing_packets.end(); ++iter) { | 973 for (; iter != frame.missing_packets.end(); ++iter) { |
991 if (cur_range_length != numeric_limits<uint8>::max() && | 974 if (cur_range_length != numeric_limits<uint8>::max() && |
992 *iter == (last_missing + 1)) { | 975 *iter == (last_missing + 1)) { |
993 ++cur_range_length; | 976 ++cur_range_length; |
994 } else { | 977 } else { |
995 ack_info.nack_ranges[last_missing - cur_range_length] | 978 ack_info.nack_ranges[last_missing - cur_range_length] |
996 = cur_range_length; | 979 = cur_range_length; |
997 cur_range_length = 0; | 980 cur_range_length = 0; |
998 } | 981 } |
999 ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing); | 982 ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing); |
1000 last_missing = *iter; | 983 last_missing = *iter; |
1001 } | 984 } |
1002 // Include the last nack range. | 985 // Include the last nack range. |
1003 ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length; | 986 ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length; |
1004 // Include the range to the largest observed. | 987 // Include the range to the largest observed. |
1005 ack_info.max_delta = max(ack_info.max_delta, | 988 ack_info.max_delta = max(ack_info.max_delta, |
1006 received_info.largest_observed - last_missing); | 989 frame.largest_observed - last_missing); |
1007 } | 990 } |
1008 return ack_info; | 991 return ack_info; |
1009 } | 992 } |
1010 | 993 |
1011 bool QuicFramer::ProcessPacketHeader( | 994 bool QuicFramer::ProcessPacketHeader( |
1012 QuicPacketHeader* header, | 995 QuicPacketHeader* header, |
1013 const QuicEncryptedPacket& packet) { | 996 const QuicEncryptedPacket& packet) { |
1014 if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length, | 997 if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length, |
1015 &header->packet_sequence_number)) { | 998 &header->packet_sequence_number)) { |
1016 set_detailed_error("Unable to read sequence number."); | 999 set_detailed_error("Unable to read sequence number."); |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1107 DVLOG(1) << "Visitor asked to stop further processing."; | 1090 DVLOG(1) << "Visitor asked to stop further processing."; |
1108 // Returning true since there was no parsing error. | 1091 // Returning true since there was no parsing error. |
1109 return true; | 1092 return true; |
1110 } | 1093 } |
1111 continue; | 1094 continue; |
1112 } | 1095 } |
1113 | 1096 |
1114 // Ack Frame | 1097 // Ack Frame |
1115 if (frame_type & kQuicFrameTypeAckMask) { | 1098 if (frame_type & kQuicFrameTypeAckMask) { |
1116 QuicAckFrame frame; | 1099 QuicAckFrame frame; |
1117 if (!ProcessAckFrame(header, frame_type, &frame)) { | 1100 if (!ProcessAckFrame(frame_type, &frame)) { |
1118 return RaiseError(QUIC_INVALID_ACK_DATA); | 1101 return RaiseError(QUIC_INVALID_ACK_DATA); |
1119 } | 1102 } |
1120 if (!visitor_->OnAckFrame(frame)) { | 1103 if (!visitor_->OnAckFrame(frame)) { |
1121 DVLOG(1) << "Visitor asked to stop further processing."; | 1104 DVLOG(1) << "Visitor asked to stop further processing."; |
1122 // Returning true since there was no parsing error. | 1105 // Returning true since there was no parsing error. |
1123 return true; | 1106 return true; |
1124 } | 1107 } |
1125 continue; | 1108 continue; |
1126 } | 1109 } |
1127 | 1110 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1212 } | 1195 } |
1213 if (!visitor_->OnBlockedFrame(blocked_frame)) { | 1196 if (!visitor_->OnBlockedFrame(blocked_frame)) { |
1214 DVLOG(1) << "Visitor asked to stop further processing."; | 1197 DVLOG(1) << "Visitor asked to stop further processing."; |
1215 // Returning true since there was no parsing error. | 1198 // Returning true since there was no parsing error. |
1216 return true; | 1199 return true; |
1217 } | 1200 } |
1218 continue; | 1201 continue; |
1219 } | 1202 } |
1220 | 1203 |
1221 case STOP_WAITING_FRAME: { | 1204 case STOP_WAITING_FRAME: { |
1222 if (quic_version_ <= QUIC_VERSION_15) { | |
1223 LOG(DFATAL) << "Trying to read a StopWaiting in " | |
1224 << QuicVersionToString(quic_version_); | |
1225 return RaiseError(QUIC_INTERNAL_ERROR); | |
1226 } | |
1227 QuicStopWaitingFrame stop_waiting_frame; | 1205 QuicStopWaitingFrame stop_waiting_frame; |
1228 if (!ProcessStopWaitingFrame(header, &stop_waiting_frame)) { | 1206 if (!ProcessStopWaitingFrame(header, &stop_waiting_frame)) { |
1229 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA); | 1207 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA); |
1230 } | 1208 } |
1231 if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) { | 1209 if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) { |
1232 DVLOG(1) << "Visitor asked to stop further processing."; | 1210 DVLOG(1) << "Visitor asked to stop further processing."; |
1233 // Returning true since there was no parsing error. | 1211 // Returning true since there was no parsing error. |
1234 return true; | 1212 return true; |
1235 } | 1213 } |
1236 continue; | 1214 continue; |
1237 } | 1215 } |
1238 case PING_FRAME: { | 1216 case PING_FRAME: { |
1239 if (quic_version_ <= QUIC_VERSION_16) { | 1217 if (quic_version_ == QUIC_VERSION_16) { |
1240 LOG(DFATAL) << "Trying to read a Ping in " | 1218 LOG(DFATAL) << "Trying to read a Ping in " |
1241 << QuicVersionToString(quic_version_); | 1219 << QuicVersionToString(quic_version_); |
1242 return RaiseError(QUIC_INTERNAL_ERROR); | 1220 return RaiseError(QUIC_INTERNAL_ERROR); |
1243 } | 1221 } |
1244 // Ping has no payload. | 1222 // Ping has no payload. |
1245 QuicPingFrame ping_frame; | 1223 QuicPingFrame ping_frame; |
1246 if (!visitor_->OnPingFrame(ping_frame)) { | 1224 if (!visitor_->OnPingFrame(ping_frame)) { |
1247 DVLOG(1) << "Visitor asked to stop further processing."; | 1225 DVLOG(1) << "Visitor asked to stop further processing."; |
1248 // Returning true since there was no parsing error. | 1226 // Returning true since there was no parsing error. |
1249 return true; | 1227 return true; |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1311 } | 1289 } |
1312 // Point frame to the right data. | 1290 // Point frame to the right data. |
1313 frame->data.Clear(); | 1291 frame->data.Clear(); |
1314 if (!frame_data.empty()) { | 1292 if (!frame_data.empty()) { |
1315 frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size()); | 1293 frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size()); |
1316 } | 1294 } |
1317 | 1295 |
1318 return true; | 1296 return true; |
1319 } | 1297 } |
1320 | 1298 |
1321 bool QuicFramer::ProcessAckFrame(const QuicPacketHeader& header, | 1299 bool QuicFramer::ProcessAckFrame(uint8 frame_type, QuicAckFrame* ack_frame) { |
1322 uint8 frame_type, | |
1323 QuicAckFrame* frame) { | |
1324 if (quic_version_ <= QUIC_VERSION_15) { | |
1325 if (!ProcessStopWaitingFrame(header, &frame->sent_info)) { | |
1326 return false; | |
1327 } | |
1328 } | |
1329 if (!ProcessReceivedInfo(frame_type, &frame->received_info)) { | |
1330 return false; | |
1331 } | |
1332 return true; | |
1333 } | |
1334 | |
1335 bool QuicFramer::ProcessReceivedInfo(uint8 frame_type, | |
1336 ReceivedPacketInfo* received_info) { | |
1337 // Determine the three lengths from the frame type: largest observed length, | 1300 // Determine the three lengths from the frame type: largest observed length, |
1338 // missing sequence number length, and missing range length. | 1301 // missing sequence number length, and missing range length. |
1339 const QuicSequenceNumberLength missing_sequence_number_length = | 1302 const QuicSequenceNumberLength missing_sequence_number_length = |
1340 ReadSequenceNumberLength(frame_type); | 1303 ReadSequenceNumberLength(frame_type); |
1341 frame_type >>= kQuicSequenceNumberLengthShift; | 1304 frame_type >>= kQuicSequenceNumberLengthShift; |
1342 const QuicSequenceNumberLength largest_observed_sequence_number_length = | 1305 const QuicSequenceNumberLength largest_observed_sequence_number_length = |
1343 ReadSequenceNumberLength(frame_type); | 1306 ReadSequenceNumberLength(frame_type); |
1344 frame_type >>= kQuicSequenceNumberLengthShift; | 1307 frame_type >>= kQuicSequenceNumberLengthShift; |
1345 received_info->is_truncated = frame_type & kQuicAckTruncatedMask; | 1308 ack_frame->is_truncated = frame_type & kQuicAckTruncatedMask; |
1346 frame_type >>= kQuicAckTruncatedShift; | 1309 frame_type >>= kQuicAckTruncatedShift; |
1347 bool has_nacks = frame_type & kQuicHasNacksMask; | 1310 bool has_nacks = frame_type & kQuicHasNacksMask; |
1348 | 1311 |
1349 if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) { | 1312 if (!reader_->ReadBytes(&ack_frame->entropy_hash, 1)) { |
1350 set_detailed_error("Unable to read entropy hash for received packets."); | 1313 set_detailed_error("Unable to read entropy hash for received packets."); |
1351 return false; | 1314 return false; |
1352 } | 1315 } |
1353 | 1316 |
1354 if (!reader_->ReadBytes(&received_info->largest_observed, | 1317 if (!reader_->ReadBytes(&ack_frame->largest_observed, |
1355 largest_observed_sequence_number_length)) { | 1318 largest_observed_sequence_number_length)) { |
1356 set_detailed_error("Unable to read largest observed."); | 1319 set_detailed_error("Unable to read largest observed."); |
1357 return false; | 1320 return false; |
1358 } | 1321 } |
1359 | 1322 |
1360 uint64 delta_time_largest_observed_us; | 1323 uint64 delta_time_largest_observed_us; |
1361 if (!reader_->ReadUFloat16(&delta_time_largest_observed_us)) { | 1324 if (!reader_->ReadUFloat16(&delta_time_largest_observed_us)) { |
1362 set_detailed_error("Unable to read delta time largest observed."); | 1325 set_detailed_error("Unable to read delta time largest observed."); |
1363 return false; | 1326 return false; |
1364 } | 1327 } |
1365 | 1328 |
1366 if (delta_time_largest_observed_us == kUFloat16MaxValue) { | 1329 if (delta_time_largest_observed_us == kUFloat16MaxValue) { |
1367 received_info->delta_time_largest_observed = QuicTime::Delta::Infinite(); | 1330 ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite(); |
1368 } else { | 1331 } else { |
1369 received_info->delta_time_largest_observed = | 1332 ack_frame->delta_time_largest_observed = |
1370 QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us); | 1333 QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us); |
1371 } | 1334 } |
1372 | 1335 |
1373 if (!has_nacks) { | 1336 if (!has_nacks) { |
1374 return true; | 1337 return true; |
1375 } | 1338 } |
1376 | 1339 |
1377 uint8 num_missing_ranges; | 1340 uint8 num_missing_ranges; |
1378 if (!reader_->ReadBytes(&num_missing_ranges, 1)) { | 1341 if (!reader_->ReadBytes(&num_missing_ranges, 1)) { |
1379 set_detailed_error("Unable to read num missing packet ranges."); | 1342 set_detailed_error("Unable to read num missing packet ranges."); |
1380 return false; | 1343 return false; |
1381 } | 1344 } |
1382 | 1345 |
1383 QuicPacketSequenceNumber last_sequence_number = | 1346 QuicPacketSequenceNumber last_sequence_number = ack_frame->largest_observed; |
1384 received_info->largest_observed; | |
1385 for (size_t i = 0; i < num_missing_ranges; ++i) { | 1347 for (size_t i = 0; i < num_missing_ranges; ++i) { |
1386 QuicPacketSequenceNumber missing_delta = 0; | 1348 QuicPacketSequenceNumber missing_delta = 0; |
1387 if (!reader_->ReadBytes(&missing_delta, missing_sequence_number_length)) { | 1349 if (!reader_->ReadBytes(&missing_delta, missing_sequence_number_length)) { |
1388 set_detailed_error("Unable to read missing sequence number delta."); | 1350 set_detailed_error("Unable to read missing sequence number delta."); |
1389 return false; | 1351 return false; |
1390 } | 1352 } |
1391 last_sequence_number -= missing_delta; | 1353 last_sequence_number -= missing_delta; |
1392 QuicPacketSequenceNumber range_length = 0; | 1354 QuicPacketSequenceNumber range_length = 0; |
1393 if (!reader_->ReadBytes(&range_length, PACKET_1BYTE_SEQUENCE_NUMBER)) { | 1355 if (!reader_->ReadBytes(&range_length, PACKET_1BYTE_SEQUENCE_NUMBER)) { |
1394 set_detailed_error("Unable to read missing sequence number range."); | 1356 set_detailed_error("Unable to read missing sequence number range."); |
1395 return false; | 1357 return false; |
1396 } | 1358 } |
1397 for (size_t i = 0; i <= range_length; ++i) { | 1359 for (size_t i = 0; i <= range_length; ++i) { |
1398 received_info->missing_packets.insert(last_sequence_number - i); | 1360 ack_frame->missing_packets.insert(last_sequence_number - i); |
1399 } | 1361 } |
1400 // Subtract an extra 1 to ensure ranges are represented efficiently and | 1362 // Subtract an extra 1 to ensure ranges are represented efficiently and |
1401 // can't overlap by 1 sequence number. This allows a missing_delta of 0 | 1363 // can't overlap by 1 sequence number. This allows a missing_delta of 0 |
1402 // to represent an adjacent nack range. | 1364 // to represent an adjacent nack range. |
1403 last_sequence_number -= (range_length + 1); | 1365 last_sequence_number -= (range_length + 1); |
1404 } | 1366 } |
1405 | 1367 |
1406 // Parse the revived packets list. | 1368 // Parse the revived packets list. |
1407 uint8 num_revived_packets; | 1369 uint8 num_revived_packets; |
1408 if (!reader_->ReadBytes(&num_revived_packets, 1)) { | 1370 if (!reader_->ReadBytes(&num_revived_packets, 1)) { |
1409 set_detailed_error("Unable to read num revived packets."); | 1371 set_detailed_error("Unable to read num revived packets."); |
1410 return false; | 1372 return false; |
1411 } | 1373 } |
1412 | 1374 |
1413 for (size_t i = 0; i < num_revived_packets; ++i) { | 1375 for (size_t i = 0; i < num_revived_packets; ++i) { |
1414 QuicPacketSequenceNumber revived_packet = 0; | 1376 QuicPacketSequenceNumber revived_packet = 0; |
1415 if (!reader_->ReadBytes(&revived_packet, | 1377 if (!reader_->ReadBytes(&revived_packet, |
1416 largest_observed_sequence_number_length)) { | 1378 largest_observed_sequence_number_length)) { |
1417 set_detailed_error("Unable to read revived packet."); | 1379 set_detailed_error("Unable to read revived packet."); |
1418 return false; | 1380 return false; |
1419 } | 1381 } |
1420 | 1382 |
1421 received_info->revived_packets.insert(revived_packet); | 1383 ack_frame->revived_packets.insert(revived_packet); |
1422 } | 1384 } |
1423 | 1385 |
1424 return true; | 1386 return true; |
1425 } | 1387 } |
1426 | 1388 |
1427 bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader& header, | 1389 bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader& header, |
1428 QuicStopWaitingFrame* stop_waiting) { | 1390 QuicStopWaitingFrame* stop_waiting) { |
1429 if (!reader_->ReadBytes(&stop_waiting->entropy_hash, 1)) { | 1391 if (!reader_->ReadBytes(&stop_waiting->entropy_hash, 1)) { |
1430 set_detailed_error("Unable to read entropy hash for sent packets."); | 1392 set_detailed_error("Unable to read entropy hash for sent packets."); |
1431 return false; | 1393 return false; |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1498 return false; | 1460 return false; |
1499 } | 1461 } |
1500 QuicPacketSequenceNumber packet = smallest_received + sequence_delta; | 1462 QuicPacketSequenceNumber packet = smallest_received + sequence_delta; |
1501 inter_arrival->received_packet_times.insert( | 1463 inter_arrival->received_packet_times.insert( |
1502 make_pair(packet, time_received.Add( | 1464 make_pair(packet, time_received.Add( |
1503 QuicTime::Delta::FromMicroseconds(time_delta_us)))); | 1465 QuicTime::Delta::FromMicroseconds(time_delta_us)))); |
1504 } | 1466 } |
1505 } | 1467 } |
1506 break; | 1468 break; |
1507 } | 1469 } |
1508 case kFixRate: { | |
1509 uint32 bitrate = 0; | |
1510 if (!reader_->ReadUInt32(&bitrate)) { | |
1511 set_detailed_error("Unable to read bitrate."); | |
1512 return false; | |
1513 } | |
1514 frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate); | |
1515 break; | |
1516 } | |
1517 case kTCP: { | 1470 case kTCP: { |
1518 CongestionFeedbackMessageTCP* tcp = &frame->tcp; | 1471 CongestionFeedbackMessageTCP* tcp = &frame->tcp; |
1519 // TODO(ianswett): Remove receive window, since it's constant. | 1472 // TODO(ianswett): Remove receive window, since it's constant. |
1520 uint16 receive_window = 0; | 1473 uint16 receive_window = 0; |
1521 if (!reader_->ReadUInt16(&receive_window)) { | 1474 if (!reader_->ReadUInt16(&receive_window)) { |
1522 set_detailed_error("Unable to read receive window."); | 1475 set_detailed_error("Unable to read receive window."); |
1523 return false; | 1476 return false; |
1524 } | 1477 } |
1525 // Simple bit packing, don't send the 4 least significant bits. | 1478 // Simple bit packing, don't send the 4 least significant bits. |
1526 tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4; | 1479 tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4; |
(...skipping 263 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1790 | 1743 |
1791 reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length())); | 1744 reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length())); |
1792 return true; | 1745 return true; |
1793 } | 1746 } |
1794 | 1747 |
1795 size_t QuicFramer::GetAckFrameSize( | 1748 size_t QuicFramer::GetAckFrameSize( |
1796 const QuicAckFrame& ack, | 1749 const QuicAckFrame& ack, |
1797 QuicSequenceNumberLength sequence_number_length) { | 1750 QuicSequenceNumberLength sequence_number_length) { |
1798 AckFrameInfo ack_info = GetAckFrameInfo(ack); | 1751 AckFrameInfo ack_info = GetAckFrameInfo(ack); |
1799 QuicSequenceNumberLength largest_observed_length = | 1752 QuicSequenceNumberLength largest_observed_length = |
1800 GetMinSequenceNumberLength(ack.received_info.largest_observed); | 1753 GetMinSequenceNumberLength(ack.largest_observed); |
1801 QuicSequenceNumberLength missing_sequence_number_length = | 1754 QuicSequenceNumberLength missing_sequence_number_length = |
1802 GetMinSequenceNumberLength(ack_info.max_delta); | 1755 GetMinSequenceNumberLength(ack_info.max_delta); |
1803 | 1756 |
1804 size_t ack_size = GetMinAckFrameSize(quic_version_, | 1757 size_t ack_size = GetMinAckFrameSize(sequence_number_length, |
1805 sequence_number_length, | |
1806 largest_observed_length); | 1758 largest_observed_length); |
1807 if (!ack_info.nack_ranges.empty()) { | 1759 if (!ack_info.nack_ranges.empty()) { |
1808 ack_size += kNumberOfNackRangesSize + kNumberOfRevivedPacketsSize; | 1760 ack_size += kNumberOfNackRangesSize + kNumberOfRevivedPacketsSize; |
1809 ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) * | 1761 ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) * |
1810 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); | 1762 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); |
1811 ack_size += min(ack.received_info.revived_packets.size(), | 1763 ack_size += min(ack.revived_packets.size(), |
1812 kMaxRevivedPackets) * largest_observed_length; | 1764 kMaxRevivedPackets) * largest_observed_length; |
1813 } | 1765 } |
1814 return ack_size; | 1766 return ack_size; |
1815 } | 1767 } |
1816 | 1768 |
1817 size_t QuicFramer::ComputeFrameLength( | 1769 size_t QuicFramer::ComputeFrameLength( |
1818 const QuicFrame& frame, | 1770 const QuicFrame& frame, |
1819 bool last_frame_in_packet, | 1771 bool last_frame_in_packet, |
1820 InFecGroup is_in_fec_group, | 1772 InFecGroup is_in_fec_group, |
1821 QuicSequenceNumberLength sequence_number_length) { | 1773 QuicSequenceNumberLength sequence_number_length) { |
1822 switch (frame.type) { | 1774 switch (frame.type) { |
1823 case STREAM_FRAME: | 1775 case STREAM_FRAME: |
1824 return GetMinStreamFrameSize(quic_version_, | 1776 return GetMinStreamFrameSize(frame.stream_frame->stream_id, |
1825 frame.stream_frame->stream_id, | |
1826 frame.stream_frame->offset, | 1777 frame.stream_frame->offset, |
1827 last_frame_in_packet, | 1778 last_frame_in_packet, |
1828 is_in_fec_group) + | 1779 is_in_fec_group) + |
1829 frame.stream_frame->data.TotalBufferSize(); | 1780 frame.stream_frame->data.TotalBufferSize(); |
1830 case ACK_FRAME: { | 1781 case ACK_FRAME: { |
1831 return GetAckFrameSize(*frame.ack_frame, sequence_number_length); | 1782 return GetAckFrameSize(*frame.ack_frame, sequence_number_length); |
1832 } | 1783 } |
1833 case CONGESTION_FEEDBACK_FRAME: { | 1784 case CONGESTION_FEEDBACK_FRAME: { |
1834 size_t len = kQuicFrameTypeSize; | 1785 size_t len = kQuicFrameTypeSize; |
1835 const QuicCongestionFeedbackFrame& congestion_feedback = | 1786 const QuicCongestionFeedbackFrame& congestion_feedback = |
1836 *frame.congestion_feedback_frame; | 1787 *frame.congestion_feedback_frame; |
1837 len += 1; // Congestion feedback type. | 1788 len += 1; // Congestion feedback type. |
1838 | 1789 |
1839 switch (congestion_feedback.type) { | 1790 switch (congestion_feedback.type) { |
1840 case kInterArrival: { | 1791 case kInterArrival: { |
1841 const CongestionFeedbackMessageInterArrival& inter_arrival = | 1792 const CongestionFeedbackMessageInterArrival& inter_arrival = |
1842 congestion_feedback.inter_arrival; | 1793 congestion_feedback.inter_arrival; |
1843 len += 1; // Number received packets. | 1794 len += 1; // Number received packets. |
1844 if (inter_arrival.received_packet_times.size() > 0) { | 1795 if (inter_arrival.received_packet_times.size() > 0) { |
1845 len += PACKET_6BYTE_SEQUENCE_NUMBER; // Smallest received. | 1796 len += PACKET_6BYTE_SEQUENCE_NUMBER; // Smallest received. |
1846 len += 8; // Time. | 1797 len += 8; // Time. |
1847 // 2 bytes per sequence number delta plus 4 bytes per delta time. | 1798 // 2 bytes per sequence number delta plus 4 bytes per delta time. |
1848 len += PACKET_6BYTE_SEQUENCE_NUMBER * | 1799 len += PACKET_6BYTE_SEQUENCE_NUMBER * |
1849 (inter_arrival.received_packet_times.size() - 1); | 1800 (inter_arrival.received_packet_times.size() - 1); |
1850 } | 1801 } |
1851 break; | 1802 break; |
1852 } | 1803 } |
1853 case kFixRate: | |
1854 len += 4; // Bitrate. | |
1855 break; | |
1856 case kTCP: | 1804 case kTCP: |
1857 len += 2; // Receive window. | 1805 len += 2; // Receive window. |
1858 break; | 1806 break; |
1859 default: | 1807 default: |
1860 set_detailed_error("Illegal feedback type."); | 1808 set_detailed_error("Illegal feedback type."); |
1861 DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type; | 1809 DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type; |
1862 break; | 1810 break; |
1863 } | 1811 } |
1864 return len; | 1812 return len; |
1865 } | 1813 } |
1866 case STOP_WAITING_FRAME: | 1814 case STOP_WAITING_FRAME: |
1867 return GetStopWaitingFrameSize(sequence_number_length); | 1815 return GetStopWaitingFrameSize(sequence_number_length); |
1868 case PING_FRAME: | 1816 case PING_FRAME: |
1869 // Ping has no payload. | 1817 // Ping has no payload. |
1870 return kQuicFrameTypeSize; | 1818 return kQuicFrameTypeSize; |
1871 case RST_STREAM_FRAME: | 1819 case RST_STREAM_FRAME: |
1872 return GetMinRstStreamFrameSize(quic_version_) + | 1820 return GetMinRstStreamFrameSize() + |
1873 frame.rst_stream_frame->error_details.size(); | 1821 frame.rst_stream_frame->error_details.size(); |
1874 case CONNECTION_CLOSE_FRAME: | 1822 case CONNECTION_CLOSE_FRAME: |
1875 return GetMinConnectionCloseFrameSize() + | 1823 return GetMinConnectionCloseFrameSize() + |
1876 frame.connection_close_frame->error_details.size(); | 1824 frame.connection_close_frame->error_details.size(); |
1877 case GOAWAY_FRAME: | 1825 case GOAWAY_FRAME: |
1878 return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size(); | 1826 return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size(); |
1879 case WINDOW_UPDATE_FRAME: | 1827 case WINDOW_UPDATE_FRAME: |
1880 return GetWindowUpdateFrameSize(); | 1828 return GetWindowUpdateFrameSize(); |
1881 case BLOCKED_FRAME: | 1829 case BLOCKED_FRAME: |
1882 return GetBlockedFrameSize(); | 1830 return GetBlockedFrameSize(); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2000 void QuicFramer::set_version(const QuicVersion version) { | 1948 void QuicFramer::set_version(const QuicVersion version) { |
2001 DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version); | 1949 DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version); |
2002 quic_version_ = version; | 1950 quic_version_ = version; |
2003 } | 1951 } |
2004 | 1952 |
2005 bool QuicFramer::AppendAckFrameAndTypeByte( | 1953 bool QuicFramer::AppendAckFrameAndTypeByte( |
2006 const QuicPacketHeader& header, | 1954 const QuicPacketHeader& header, |
2007 const QuicAckFrame& frame, | 1955 const QuicAckFrame& frame, |
2008 QuicDataWriter* writer) { | 1956 QuicDataWriter* writer) { |
2009 AckFrameInfo ack_info = GetAckFrameInfo(frame); | 1957 AckFrameInfo ack_info = GetAckFrameInfo(frame); |
2010 QuicPacketSequenceNumber ack_largest_observed = | 1958 QuicPacketSequenceNumber ack_largest_observed = frame.largest_observed; |
2011 frame.received_info.largest_observed; | |
2012 QuicSequenceNumberLength largest_observed_length = | 1959 QuicSequenceNumberLength largest_observed_length = |
2013 GetMinSequenceNumberLength(ack_largest_observed); | 1960 GetMinSequenceNumberLength(ack_largest_observed); |
2014 QuicSequenceNumberLength missing_sequence_number_length = | 1961 QuicSequenceNumberLength missing_sequence_number_length = |
2015 GetMinSequenceNumberLength(ack_info.max_delta); | 1962 GetMinSequenceNumberLength(ack_info.max_delta); |
2016 // Determine whether we need to truncate ranges. | 1963 // Determine whether we need to truncate ranges. |
2017 size_t available_range_bytes = writer->capacity() - writer->length() - | 1964 size_t available_range_bytes = writer->capacity() - writer->length() - |
2018 kNumberOfRevivedPacketsSize - kNumberOfNackRangesSize - | 1965 kNumberOfRevivedPacketsSize - kNumberOfNackRangesSize - |
2019 GetMinAckFrameSize(quic_version_, | 1966 GetMinAckFrameSize(header.public_header.sequence_number_length, |
2020 header.public_header.sequence_number_length, | |
2021 largest_observed_length); | 1967 largest_observed_length); |
2022 size_t max_num_ranges = available_range_bytes / | 1968 size_t max_num_ranges = available_range_bytes / |
2023 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); | 1969 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); |
2024 max_num_ranges = min(kMaxNackRanges, max_num_ranges); | 1970 max_num_ranges = min(kMaxNackRanges, max_num_ranges); |
2025 bool truncated = ack_info.nack_ranges.size() > max_num_ranges; | 1971 bool truncated = ack_info.nack_ranges.size() > max_num_ranges; |
2026 DVLOG_IF(1, truncated) << "Truncating ack from " | 1972 DVLOG_IF(1, truncated) << "Truncating ack from " |
2027 << ack_info.nack_ranges.size() << " ranges to " | 1973 << ack_info.nack_ranges.size() << " ranges to " |
2028 << max_num_ranges; | 1974 << max_num_ranges; |
2029 // Write out the type byte by setting the low order bits and doing shifts | 1975 // Write out the type byte by setting the low order bits and doing shifts |
2030 // to make room for the next bit flags to be set. | 1976 // to make room for the next bit flags to be set. |
(...skipping 11 matching lines...) Expand all Loading... |
2042 // Missing sequence number length. | 1988 // Missing sequence number length. |
2043 type_byte <<= kQuicSequenceNumberLengthShift; | 1989 type_byte <<= kQuicSequenceNumberLengthShift; |
2044 type_byte |= GetSequenceNumberFlags(missing_sequence_number_length); | 1990 type_byte |= GetSequenceNumberFlags(missing_sequence_number_length); |
2045 | 1991 |
2046 type_byte |= kQuicFrameTypeAckMask; | 1992 type_byte |= kQuicFrameTypeAckMask; |
2047 | 1993 |
2048 if (!writer->WriteUInt8(type_byte)) { | 1994 if (!writer->WriteUInt8(type_byte)) { |
2049 return false; | 1995 return false; |
2050 } | 1996 } |
2051 | 1997 |
2052 if (quic_version_ <= QUIC_VERSION_15) { | 1998 QuicPacketEntropyHash ack_entropy_hash = frame.entropy_hash; |
2053 if (!AppendStopWaitingFrame(header, frame.sent_info, writer)) { | |
2054 return false; | |
2055 } | |
2056 } | |
2057 | |
2058 const ReceivedPacketInfo& received_info = frame.received_info; | |
2059 QuicPacketEntropyHash ack_entropy_hash = received_info.entropy_hash; | |
2060 NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin(); | 1999 NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin(); |
2061 if (truncated) { | 2000 if (truncated) { |
2062 // Skip the nack ranges which the truncated ack won't include and set | 2001 // Skip the nack ranges which the truncated ack won't include and set |
2063 // a correct largest observed for the truncated ack. | 2002 // a correct largest observed for the truncated ack. |
2064 for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges); | 2003 for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges); |
2065 ++i) { | 2004 ++i) { |
2066 ++ack_iter; | 2005 ++ack_iter; |
2067 } | 2006 } |
2068 // If the last range is followed by acks, include them. | 2007 // If the last range is followed by acks, include them. |
2069 // If the last range is followed by another range, specify the end of the | 2008 // If the last range is followed by another range, specify the end of the |
2070 // range as the largest_observed. | 2009 // range as the largest_observed. |
2071 ack_largest_observed = ack_iter->first - 1; | 2010 ack_largest_observed = ack_iter->first - 1; |
2072 // Also update the entropy so it matches the largest observed. | 2011 // Also update the entropy so it matches the largest observed. |
2073 ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed); | 2012 ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed); |
2074 ++ack_iter; | 2013 ++ack_iter; |
2075 } | 2014 } |
2076 | 2015 |
2077 if (!writer->WriteUInt8(ack_entropy_hash)) { | 2016 if (!writer->WriteUInt8(ack_entropy_hash)) { |
2078 return false; | 2017 return false; |
2079 } | 2018 } |
2080 | 2019 |
2081 if (!AppendPacketSequenceNumber(largest_observed_length, | 2020 if (!AppendPacketSequenceNumber(largest_observed_length, |
2082 ack_largest_observed, writer)) { | 2021 ack_largest_observed, writer)) { |
2083 return false; | 2022 return false; |
2084 } | 2023 } |
2085 | 2024 |
2086 uint64 delta_time_largest_observed_us = kUFloat16MaxValue; | 2025 uint64 delta_time_largest_observed_us = kUFloat16MaxValue; |
2087 if (!received_info.delta_time_largest_observed.IsInfinite()) { | 2026 if (!frame.delta_time_largest_observed.IsInfinite()) { |
2088 DCHECK_LE(0u, | 2027 DCHECK_LE(0u, frame.delta_time_largest_observed.ToMicroseconds()); |
2089 frame.received_info.delta_time_largest_observed.ToMicroseconds()); | |
2090 delta_time_largest_observed_us = | 2028 delta_time_largest_observed_us = |
2091 received_info.delta_time_largest_observed.ToMicroseconds(); | 2029 frame.delta_time_largest_observed.ToMicroseconds(); |
2092 } | 2030 } |
2093 | 2031 |
2094 if (!writer->WriteUFloat16(delta_time_largest_observed_us)) { | 2032 if (!writer->WriteUFloat16(delta_time_largest_observed_us)) { |
2095 return false; | 2033 return false; |
2096 } | 2034 } |
2097 | 2035 |
2098 if (ack_info.nack_ranges.empty()) { | 2036 if (ack_info.nack_ranges.empty()) { |
2099 return true; | 2037 return true; |
2100 } | 2038 } |
2101 | 2039 |
(...skipping 18 matching lines...) Expand all Loading... |
2120 return false; | 2058 return false; |
2121 } | 2059 } |
2122 // Subtract 1 so a missing_delta of 0 means an adjacent range. | 2060 // Subtract 1 so a missing_delta of 0 means an adjacent range. |
2123 last_sequence_written = ack_iter->first - 1; | 2061 last_sequence_written = ack_iter->first - 1; |
2124 ++num_ranges_written; | 2062 ++num_ranges_written; |
2125 } | 2063 } |
2126 DCHECK_EQ(num_missing_ranges, num_ranges_written); | 2064 DCHECK_EQ(num_missing_ranges, num_ranges_written); |
2127 | 2065 |
2128 // Append revived packets. | 2066 // Append revived packets. |
2129 // If not all the revived packets fit, only mention the ones that do. | 2067 // If not all the revived packets fit, only mention the ones that do. |
2130 uint8 num_revived_packets = min(received_info.revived_packets.size(), | 2068 uint8 num_revived_packets = min(frame.revived_packets.size(), |
2131 kMaxRevivedPackets); | 2069 kMaxRevivedPackets); |
2132 num_revived_packets = min( | 2070 num_revived_packets = min( |
2133 static_cast<size_t>(num_revived_packets), | 2071 static_cast<size_t>(num_revived_packets), |
2134 (writer->capacity() - writer->length()) / largest_observed_length); | 2072 (writer->capacity() - writer->length()) / largest_observed_length); |
2135 if (!writer->WriteBytes(&num_revived_packets, 1)) { | 2073 if (!writer->WriteBytes(&num_revived_packets, 1)) { |
2136 return false; | 2074 return false; |
2137 } | 2075 } |
2138 | 2076 |
2139 SequenceNumberSet::const_iterator iter = | 2077 SequenceNumberSet::const_iterator iter = frame.revived_packets.begin(); |
2140 received_info.revived_packets.begin(); | |
2141 for (int i = 0; i < num_revived_packets; ++i, ++iter) { | 2078 for (int i = 0; i < num_revived_packets; ++i, ++iter) { |
2142 LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter)); | 2079 LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter)); |
2143 if (!AppendPacketSequenceNumber(largest_observed_length, | 2080 if (!AppendPacketSequenceNumber(largest_observed_length, |
2144 *iter, writer)) { | 2081 *iter, writer)) { |
2145 return false; | 2082 return false; |
2146 } | 2083 } |
2147 } | 2084 } |
2148 | 2085 |
2149 return true; | 2086 return true; |
2150 } | 2087 } |
2151 | 2088 |
2152 bool QuicFramer::AppendCongestionFeedbackFrame( | 2089 bool QuicFramer::AppendCongestionFeedbackFrame( |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2200 | 2137 |
2201 int32 time_delta_us = | 2138 int32 time_delta_us = |
2202 it->second.Subtract(lowest_time).ToMicroseconds(); | 2139 it->second.Subtract(lowest_time).ToMicroseconds(); |
2203 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { | 2140 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { |
2204 return false; | 2141 return false; |
2205 } | 2142 } |
2206 } | 2143 } |
2207 } | 2144 } |
2208 break; | 2145 break; |
2209 } | 2146 } |
2210 case kFixRate: { | |
2211 const CongestionFeedbackMessageFixRate& fix_rate = | |
2212 frame.fix_rate; | |
2213 if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) { | |
2214 return false; | |
2215 } | |
2216 break; | |
2217 } | |
2218 case kTCP: { | 2147 case kTCP: { |
2219 const CongestionFeedbackMessageTCP& tcp = frame.tcp; | 2148 const CongestionFeedbackMessageTCP& tcp = frame.tcp; |
2220 DCHECK_LE(tcp.receive_window, 1u << 20); | 2149 DCHECK_LE(tcp.receive_window, 1u << 20); |
2221 // Simple bit packing, don't send the 4 least significant bits. | 2150 // Simple bit packing, don't send the 4 least significant bits. |
2222 uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4); | 2151 uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4); |
2223 if (!writer->WriteUInt16(receive_window)) { | 2152 if (!writer->WriteUInt16(receive_window)) { |
2224 return false; | 2153 return false; |
2225 } | 2154 } |
2226 break; | 2155 break; |
2227 } | 2156 } |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2337 | 2266 |
2338 bool QuicFramer::RaiseError(QuicErrorCode error) { | 2267 bool QuicFramer::RaiseError(QuicErrorCode error) { |
2339 DVLOG(1) << "Error detail: " << detailed_error_; | 2268 DVLOG(1) << "Error detail: " << detailed_error_; |
2340 set_error(error); | 2269 set_error(error); |
2341 visitor_->OnError(this); | 2270 visitor_->OnError(this); |
2342 reader_.reset(NULL); | 2271 reader_.reset(NULL); |
2343 return false; | 2272 return false; |
2344 } | 2273 } |
2345 | 2274 |
2346 } // namespace net | 2275 } // namespace net |
OLD | NEW |