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/core/quic_framer.h" | 5 #include "net/quic/core/quic_framer.h" |
6 | 6 |
7 #include <cstdint> | 7 #include <cstdint> |
8 #include <memory> | 8 #include <memory> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 979 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
990 const QuicAckFrame& frame) { | 990 const QuicAckFrame& frame) { |
991 AckFrameInfo ack_info; | 991 AckFrameInfo ack_info; |
992 if (frame.packets.Empty()) { | 992 if (frame.packets.Empty()) { |
993 return ack_info; | 993 return ack_info; |
994 } | 994 } |
995 DCHECK_GE(frame.largest_observed, frame.packets.Max()); | 995 DCHECK_GE(frame.largest_observed, frame.packets.Max()); |
996 QuicPacketNumber last_largest_missing = 0; | 996 QuicPacketNumber last_largest_missing = 0; |
997 for (const Interval<QuicPacketNumber>& interval : frame.packets) { | 997 for (const Interval<QuicPacketNumber>& interval : frame.packets) { |
998 for (QuicPacketNumber interval_start = interval.min(); | 998 for (QuicPacketNumber interval_start = interval.min(); |
999 interval_start < interval.max(); | 999 interval_start < interval.max(); |
1000 interval_start += (1ull + numeric_limits<uint8_t>::max())) { | 1000 interval_start += (1ull + std::numeric_limits<uint8_t>::max())) { |
1001 uint8_t cur_range_length = | 1001 uint8_t cur_range_length = |
1002 interval.max() - interval_start > numeric_limits<uint8_t>::max() | 1002 interval.max() - interval_start > std::numeric_limits<uint8_t>::max() |
1003 ? numeric_limits<uint8_t>::max() | 1003 ? std::numeric_limits<uint8_t>::max() |
1004 : (interval.max() - interval_start) - 1; | 1004 : (interval.max() - interval_start) - 1; |
1005 ack_info.nack_ranges[interval_start] = cur_range_length; | 1005 ack_info.nack_ranges[interval_start] = cur_range_length; |
1006 } | 1006 } |
1007 ack_info.max_delta = | 1007 ack_info.max_delta = |
1008 max(ack_info.max_delta, last_largest_missing == 0 | 1008 max(ack_info.max_delta, last_largest_missing == 0 |
1009 ? QuicPacketNumber{0} | 1009 ? QuicPacketNumber{0} |
1010 : (interval.min() - last_largest_missing)); | 1010 : (interval.min() - last_largest_missing)); |
1011 last_largest_missing = interval.max() - 1; | 1011 last_largest_missing = interval.max() - 1; |
1012 } | 1012 } |
1013 // Include the range to the largest observed. | 1013 // Include the range to the largest observed. |
(...skipping 13 matching lines...) Expand all Loading... |
1027 // encoding, so skip it. | 1027 // encoding, so skip it. |
1028 new_ack_info.first_block_length = frame.packets.LastIntervalLength(); | 1028 new_ack_info.first_block_length = frame.packets.LastIntervalLength(); |
1029 auto itr = frame.packets.rbegin(); | 1029 auto itr = frame.packets.rbegin(); |
1030 QuicPacketNumber previous_start = itr->min(); | 1030 QuicPacketNumber previous_start = itr->min(); |
1031 new_ack_info.max_block_length = itr->Length(); | 1031 new_ack_info.max_block_length = itr->Length(); |
1032 ++itr; | 1032 ++itr; |
1033 | 1033 |
1034 // Don't do any more work after getting information for 256 ACK blocks; any | 1034 // Don't do any more work after getting information for 256 ACK blocks; any |
1035 // more can't be encoded anyway. | 1035 // more can't be encoded anyway. |
1036 for (; itr != frame.packets.rend() && | 1036 for (; itr != frame.packets.rend() && |
1037 new_ack_info.num_ack_blocks < numeric_limits<uint8_t>::max(); | 1037 new_ack_info.num_ack_blocks < std::numeric_limits<uint8_t>::max(); |
1038 previous_start = itr->min(), ++itr) { | 1038 previous_start = itr->min(), ++itr) { |
1039 const auto& interval = *itr; | 1039 const auto& interval = *itr; |
1040 const QuicPacketNumber total_gap = previous_start - interval.max(); | 1040 const QuicPacketNumber total_gap = previous_start - interval.max(); |
1041 new_ack_info.num_ack_blocks += | 1041 new_ack_info.num_ack_blocks += |
1042 (total_gap + numeric_limits<uint8_t>::max() - 1) / | 1042 (total_gap + std::numeric_limits<uint8_t>::max() - 1) / |
1043 numeric_limits<uint8_t>::max(); | 1043 std::numeric_limits<uint8_t>::max(); |
1044 new_ack_info.max_block_length = | 1044 new_ack_info.max_block_length = |
1045 max(new_ack_info.max_block_length, interval.Length()); | 1045 max(new_ack_info.max_block_length, interval.Length()); |
1046 } | 1046 } |
1047 return new_ack_info; | 1047 return new_ack_info; |
1048 } | 1048 } |
1049 | 1049 |
1050 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader, | 1050 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader, |
1051 QuicPacketHeader* header) { | 1051 QuicPacketHeader* header) { |
1052 header->path_id = kDefaultPathId; | 1052 header->path_id = kDefaultPathId; |
1053 if (header->public_header.multipath_flag && | 1053 if (header->public_header.multipath_flag && |
(...skipping 1024 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2078 QuicDataWriter* writer) { | 2078 QuicDataWriter* writer) { |
2079 if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) { | 2079 if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) { |
2080 QUIC_BUG << "Writing stream id size failed."; | 2080 QUIC_BUG << "Writing stream id size failed."; |
2081 return false; | 2081 return false; |
2082 } | 2082 } |
2083 if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) { | 2083 if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) { |
2084 QUIC_BUG << "Writing offset size failed."; | 2084 QUIC_BUG << "Writing offset size failed."; |
2085 return false; | 2085 return false; |
2086 } | 2086 } |
2087 if (!no_stream_frame_length) { | 2087 if (!no_stream_frame_length) { |
2088 if ((frame.data_length > numeric_limits<uint16_t>::max()) || | 2088 if ((frame.data_length > std::numeric_limits<uint16_t>::max()) || |
2089 !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) { | 2089 !writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) { |
2090 QUIC_BUG << "Writing stream frame length failed"; | 2090 QUIC_BUG << "Writing stream frame length failed"; |
2091 return false; | 2091 return false; |
2092 } | 2092 } |
2093 } | 2093 } |
2094 | 2094 |
2095 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) { | 2095 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) { |
2096 QUIC_BUG << "Writing frame data failed."; | 2096 QUIC_BUG << "Writing frame data failed."; |
2097 return false; | 2097 return false; |
2098 } | 2098 } |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2289 } | 2289 } |
2290 if (!writer->WriteUFloat16(ack_delay_time_us)) { | 2290 if (!writer->WriteUFloat16(ack_delay_time_us)) { |
2291 return false; | 2291 return false; |
2292 } | 2292 } |
2293 | 2293 |
2294 size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes / | 2294 size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes / |
2295 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER); | 2295 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER); |
2296 | 2296 |
2297 // Number of ack blocks. | 2297 // Number of ack blocks. |
2298 size_t num_ack_blocks = min(new_ack_info.num_ack_blocks, max_num_ack_blocks); | 2298 size_t num_ack_blocks = min(new_ack_info.num_ack_blocks, max_num_ack_blocks); |
2299 if (num_ack_blocks > numeric_limits<uint8_t>::max()) { | 2299 if (num_ack_blocks > std::numeric_limits<uint8_t>::max()) { |
2300 num_ack_blocks = numeric_limits<uint8_t>::max(); | 2300 num_ack_blocks = std::numeric_limits<uint8_t>::max(); |
2301 } | 2301 } |
2302 | 2302 |
2303 if (num_ack_blocks > 0) { | 2303 if (num_ack_blocks > 0) { |
2304 if (!writer->WriteBytes(&num_ack_blocks, 1)) { | 2304 if (!writer->WriteBytes(&num_ack_blocks, 1)) { |
2305 return false; | 2305 return false; |
2306 } | 2306 } |
2307 } | 2307 } |
2308 | 2308 |
2309 // First ack block length. | 2309 // First ack block length. |
2310 if (!AppendPacketSequenceNumber(ack_block_length, | 2310 if (!AppendPacketSequenceNumber(ack_block_length, |
(...skipping 15 matching lines...) Expand all Loading... |
2326 auto itr = frame.packets.rbegin(); | 2326 auto itr = frame.packets.rbegin(); |
2327 QuicPacketNumber previous_start = itr->min(); | 2327 QuicPacketNumber previous_start = itr->min(); |
2328 ++itr; | 2328 ++itr; |
2329 | 2329 |
2330 for (; | 2330 for (; |
2331 itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks; | 2331 itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks; |
2332 previous_start = itr->min(), ++itr) { | 2332 previous_start = itr->min(), ++itr) { |
2333 const auto& interval = *itr; | 2333 const auto& interval = *itr; |
2334 const QuicPacketNumber total_gap = previous_start - interval.max(); | 2334 const QuicPacketNumber total_gap = previous_start - interval.max(); |
2335 const size_t num_encoded_gaps = | 2335 const size_t num_encoded_gaps = |
2336 (total_gap + numeric_limits<uint8_t>::max() - 1) / | 2336 (total_gap + std::numeric_limits<uint8_t>::max() - 1) / |
2337 numeric_limits<uint8_t>::max(); | 2337 std::numeric_limits<uint8_t>::max(); |
2338 DCHECK_GT(num_encoded_gaps, 0u); | 2338 DCHECK_GT(num_encoded_gaps, 0u); |
2339 | 2339 |
2340 // Append empty ACK blocks because the gap is longer than a single gap. | 2340 // Append empty ACK blocks because the gap is longer than a single gap. |
2341 for (size_t i = 1; | 2341 for (size_t i = 1; |
2342 i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks; | 2342 i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks; |
2343 ++i) { | 2343 ++i) { |
2344 if (!AppendAckBlock(numeric_limits<uint8_t>::max(), ack_block_length, 0, | 2344 if (!AppendAckBlock(std::numeric_limits<uint8_t>::max(), |
2345 writer)) { | 2345 ack_block_length, 0, writer)) { |
2346 return false; | 2346 return false; |
2347 } | 2347 } |
2348 ++num_ack_blocks_written; | 2348 ++num_ack_blocks_written; |
2349 } | 2349 } |
2350 if (num_ack_blocks_written >= num_ack_blocks) { | 2350 if (num_ack_blocks_written >= num_ack_blocks) { |
2351 if (PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) { | 2351 if (PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) { |
2352 QUIC_BUG << "Wrote " << num_ack_blocks_written | 2352 QUIC_BUG << "Wrote " << num_ack_blocks_written |
2353 << ", expected to write " << num_ack_blocks; | 2353 << ", expected to write " << num_ack_blocks; |
2354 } | 2354 } |
2355 break; | 2355 break; |
2356 } | 2356 } |
2357 | 2357 |
2358 const uint8_t last_gap = | 2358 const uint8_t last_gap = |
2359 total_gap - (num_encoded_gaps - 1) * numeric_limits<uint8_t>::max(); | 2359 total_gap - |
| 2360 (num_encoded_gaps - 1) * std::numeric_limits<uint8_t>::max(); |
2360 // Append the final ACK block with a non-empty size. | 2361 // Append the final ACK block with a non-empty size. |
2361 if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(), | 2362 if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(), |
2362 writer)) { | 2363 writer)) { |
2363 return false; | 2364 return false; |
2364 } | 2365 } |
2365 ++num_ack_blocks_written; | 2366 ++num_ack_blocks_written; |
2366 } | 2367 } |
2367 DCHECK_EQ(num_ack_blocks, num_ack_blocks_written); | 2368 DCHECK_EQ(num_ack_blocks, num_ack_blocks_written); |
2368 } | 2369 } |
2369 | 2370 |
(...skipping 10 matching lines...) Expand all Loading... |
2380 if (!writer->WriteBytes(&num_received_packets, 1)) { | 2381 if (!writer->WriteBytes(&num_received_packets, 1)) { |
2381 return false; | 2382 return false; |
2382 } | 2383 } |
2383 } | 2384 } |
2384 | 2385 |
2385 return true; | 2386 return true; |
2386 } | 2387 } |
2387 | 2388 |
2388 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame, | 2389 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame, |
2389 QuicDataWriter* writer) { | 2390 QuicDataWriter* writer) { |
2390 DCHECK_GE(numeric_limits<uint8_t>::max(), frame.received_packet_times.size()); | 2391 DCHECK_GE(std::numeric_limits<uint8_t>::max(), |
| 2392 frame.received_packet_times.size()); |
2391 // num_received_packets is only 1 byte. | 2393 // num_received_packets is only 1 byte. |
2392 if (frame.received_packet_times.size() > numeric_limits<uint8_t>::max()) { | 2394 if (frame.received_packet_times.size() > |
| 2395 std::numeric_limits<uint8_t>::max()) { |
2393 return false; | 2396 return false; |
2394 } | 2397 } |
2395 | 2398 |
2396 uint8_t num_received_packets = frame.received_packet_times.size(); | 2399 uint8_t num_received_packets = frame.received_packet_times.size(); |
2397 if (!writer->WriteBytes(&num_received_packets, 1)) { | 2400 if (!writer->WriteBytes(&num_received_packets, 1)) { |
2398 return false; | 2401 return false; |
2399 } | 2402 } |
2400 if (num_received_packets == 0) { | 2403 if (num_received_packets == 0) { |
2401 return true; | 2404 return true; |
2402 } | 2405 } |
2403 | 2406 |
2404 PacketTimeVector::const_iterator it = frame.received_packet_times.begin(); | 2407 PacketTimeVector::const_iterator it = frame.received_packet_times.begin(); |
2405 QuicPacketNumber packet_number = it->first; | 2408 QuicPacketNumber packet_number = it->first; |
2406 QuicPacketNumber delta_from_largest_observed = | 2409 QuicPacketNumber delta_from_largest_observed = |
2407 frame.largest_observed - packet_number; | 2410 frame.largest_observed - packet_number; |
2408 | 2411 |
2409 DCHECK_GE(numeric_limits<uint8_t>::max(), delta_from_largest_observed); | 2412 DCHECK_GE(std::numeric_limits<uint8_t>::max(), delta_from_largest_observed); |
2410 if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) { | 2413 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) { |
2411 return false; | 2414 return false; |
2412 } | 2415 } |
2413 | 2416 |
2414 if (!writer->WriteUInt8(delta_from_largest_observed & | 2417 if (!writer->WriteUInt8(delta_from_largest_observed & |
2415 k1ByteSequenceNumberMask)) { | 2418 k1ByteSequenceNumberMask)) { |
2416 return false; | 2419 return false; |
2417 } | 2420 } |
2418 | 2421 |
2419 // Use the lowest 4 bytes of the time delta from the creation_time_. | 2422 // Use the lowest 4 bytes of the time delta from the creation_time_. |
2420 const uint64_t time_epoch_delta_us = UINT64_C(1) << 32; | 2423 const uint64_t time_epoch_delta_us = UINT64_C(1) << 32; |
2421 uint32_t time_delta_us = | 2424 uint32_t time_delta_us = |
2422 static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() & | 2425 static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() & |
2423 (time_epoch_delta_us - 1)); | 2426 (time_epoch_delta_us - 1)); |
2424 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { | 2427 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { |
2425 return false; | 2428 return false; |
2426 } | 2429 } |
2427 | 2430 |
2428 QuicTime prev_time = it->second; | 2431 QuicTime prev_time = it->second; |
2429 | 2432 |
2430 for (++it; it != frame.received_packet_times.end(); ++it) { | 2433 for (++it; it != frame.received_packet_times.end(); ++it) { |
2431 packet_number = it->first; | 2434 packet_number = it->first; |
2432 delta_from_largest_observed = frame.largest_observed - packet_number; | 2435 delta_from_largest_observed = frame.largest_observed - packet_number; |
2433 | 2436 |
2434 if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) { | 2437 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) { |
2435 return false; | 2438 return false; |
2436 } | 2439 } |
2437 | 2440 |
2438 if (!writer->WriteUInt8(delta_from_largest_observed & | 2441 if (!writer->WriteUInt8(delta_from_largest_observed & |
2439 k1ByteSequenceNumberMask)) { | 2442 k1ByteSequenceNumberMask)) { |
2440 return false; | 2443 return false; |
2441 } | 2444 } |
2442 | 2445 |
2443 uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds(); | 2446 uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds(); |
2444 prev_time = it->second; | 2447 prev_time = it->second; |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2561 | 2564 |
2562 bool QuicFramer::RaiseError(QuicErrorCode error) { | 2565 bool QuicFramer::RaiseError(QuicErrorCode error) { |
2563 DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error) | 2566 DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error) |
2564 << " detail: " << detailed_error_; | 2567 << " detail: " << detailed_error_; |
2565 set_error(error); | 2568 set_error(error); |
2566 visitor_->OnError(this); | 2569 visitor_->OnError(this); |
2567 return false; | 2570 return false; |
2568 } | 2571 } |
2569 | 2572 |
2570 } // namespace net | 2573 } // namespace net |
OLD | NEW |