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 <algorithm> | 7 #include <algorithm> |
8 #include <map> | 8 #include <map> |
9 #include <string> | 9 #include <string> |
10 #include <vector> | 10 #include <vector> |
(...skipping 1665 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1676 | 1676 |
1677 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1677 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1678 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1678 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1679 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); | 1679 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); |
1680 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1680 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1681 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), | 1681 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), |
1682 visitor_.stream_frames_[0]->offset); | 1682 visitor_.stream_frames_[0]->offset); |
1683 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); | 1683 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); |
1684 } | 1684 } |
1685 | 1685 |
1686 TEST_P(QuicFramerTest, AckFrame15) { | 1686 TEST_P(QuicFramerTest, AckFrame) { |
1687 if (framer_.version() != QUIC_VERSION_15) { | |
1688 return; | |
1689 } | |
1690 | |
1691 unsigned char packet[] = { | 1687 unsigned char packet[] = { |
1692 // public flags (8 byte connection_id) | 1688 // public flags (8 byte connection_id) |
1693 0x3C, | 1689 0x3C, |
1694 // connection_id | |
1695 0x10, 0x32, 0x54, 0x76, | |
1696 0x98, 0xBA, 0xDC, 0xFE, | |
1697 // packet sequence number | |
1698 0xA8, 0x9A, 0x78, 0x56, | |
1699 0x34, 0x12, | |
1700 // private flags (entropy) | |
1701 0x01, | |
1702 | |
1703 // frame type (ack frame) | |
1704 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | |
1705 0x6C, | |
1706 // entropy hash of sent packets till least awaiting - 1. | |
1707 0xAB, | |
1708 // least packet sequence number awaiting an ack, delta from sequence number. | |
1709 0x08, 0x00, 0x00, 0x00, | |
1710 0x00, 0x00, | |
1711 // entropy hash of all received packets. | |
1712 0xBA, | |
1713 // largest observed packet sequence number | |
1714 0xBF, 0x9A, 0x78, 0x56, | |
1715 0x34, 0x12, | |
1716 // Zero delta time. | |
1717 0x0, 0x0, | |
1718 // num missing packets | |
1719 0x01, | |
1720 // missing packet delta | |
1721 0x01, | |
1722 // 0 more missing packets in range. | |
1723 0x00, | |
1724 // Number of revived packets. | |
1725 0x00, | |
1726 }; | |
1727 | |
1728 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | |
1729 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | |
1730 | |
1731 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | |
1732 ASSERT_TRUE(visitor_.header_.get()); | |
1733 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | |
1734 | |
1735 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | |
1736 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | |
1737 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; | |
1738 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash); | |
1739 EXPECT_EQ(0xBA, frame.received_info.entropy_hash); | |
1740 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed); | |
1741 ASSERT_EQ(1u, frame.received_info.missing_packets.size()); | |
1742 SequenceNumberSet::const_iterator missing_iter = | |
1743 frame.received_info.missing_packets.begin(); | |
1744 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); | |
1745 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); | |
1746 | |
1747 const size_t kSentEntropyOffset = kQuicFrameTypeSize; | |
1748 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize; | |
1749 const size_t kReceivedEntropyOffset = kLeastUnackedOffset + | |
1750 PACKET_6BYTE_SEQUENCE_NUMBER; | |
1751 const size_t kLargestObservedOffset = kReceivedEntropyOffset + | |
1752 kQuicEntropyHashSize; | |
1753 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + | |
1754 PACKET_6BYTE_SEQUENCE_NUMBER; | |
1755 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset + | |
1756 kQuicDeltaTimeLargestObservedSize; | |
1757 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + | |
1758 kNumberOfNackRangesSize; | |
1759 const size_t kMissingPacketsRange = kMissingPacketsOffset + | |
1760 PACKET_1BYTE_SEQUENCE_NUMBER; | |
1761 const size_t kRevivedPacketsLength = kMissingPacketsRange + | |
1762 PACKET_1BYTE_SEQUENCE_NUMBER; | |
1763 // Now test framing boundaries | |
1764 const size_t ack_frame_size = kRevivedPacketsLength + | |
1765 PACKET_1BYTE_SEQUENCE_NUMBER; | |
1766 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { | |
1767 string expected_error; | |
1768 if (i < kLeastUnackedOffset) { | |
1769 expected_error = "Unable to read entropy hash for sent packets."; | |
1770 } else if (i < kReceivedEntropyOffset) { | |
1771 expected_error = "Unable to read least unacked delta."; | |
1772 } else if (i < kLargestObservedOffset) { | |
1773 expected_error = "Unable to read entropy hash for received packets."; | |
1774 } else if (i < kMissingDeltaTimeOffset) { | |
1775 expected_error = "Unable to read largest observed."; | |
1776 } else if (i < kNumMissingPacketOffset) { | |
1777 expected_error = "Unable to read delta time largest observed."; | |
1778 } else if (i < kMissingPacketsOffset) { | |
1779 expected_error = "Unable to read num missing packet ranges."; | |
1780 } else if (i < kMissingPacketsRange) { | |
1781 expected_error = "Unable to read missing sequence number delta."; | |
1782 } else if (i < kRevivedPacketsLength) { | |
1783 expected_error = "Unable to read missing sequence number range."; | |
1784 } else { | |
1785 expected_error = "Unable to read num revived packets."; | |
1786 } | |
1787 CheckProcessingFails( | |
1788 packet, | |
1789 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | |
1790 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), | |
1791 expected_error, QUIC_INVALID_ACK_DATA); | |
1792 } | |
1793 } | |
1794 | |
1795 TEST_P(QuicFramerTest, AckFrame) { | |
1796 if (framer_.version() <= QUIC_VERSION_15) { | |
1797 return; | |
1798 } | |
1799 | |
1800 unsigned char packet[] = { | |
1801 // public flags (8 byte connection_id) | |
1802 0x3C, | |
1803 // connection_id | 1690 // connection_id |
1804 0x10, 0x32, 0x54, 0x76, | 1691 0x10, 0x32, 0x54, 0x76, |
1805 0x98, 0xBA, 0xDC, 0xFE, | 1692 0x98, 0xBA, 0xDC, 0xFE, |
1806 // packet sequence number | 1693 // packet sequence number |
1807 0xA8, 0x9A, 0x78, 0x56, | 1694 0xA8, 0x9A, 0x78, 0x56, |
1808 0x34, 0x12, | 1695 0x34, 0x12, |
1809 // private flags (entropy) | 1696 // private flags (entropy) |
1810 0x01, | 1697 0x01, |
1811 | 1698 |
1812 // frame type (ack frame) | 1699 // frame type (ack frame) |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1881 } | 1768 } |
1882 CheckProcessingFails( | 1769 CheckProcessingFails( |
1883 packet, | 1770 packet, |
1884 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 1771 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
1885 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), | 1772 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), |
1886 expected_error, QUIC_INVALID_ACK_DATA); | 1773 expected_error, QUIC_INVALID_ACK_DATA); |
1887 } | 1774 } |
1888 } | 1775 } |
1889 | 1776 |
1890 TEST_P(QuicFramerTest, AckFrameRevivedPackets) { | 1777 TEST_P(QuicFramerTest, AckFrameRevivedPackets) { |
1891 if (framer_.version() <= QUIC_VERSION_15) { | |
1892 return; | |
1893 } | |
1894 | |
1895 unsigned char packet[] = { | 1778 unsigned char packet[] = { |
1896 // public flags (8 byte connection_id) | 1779 // public flags (8 byte connection_id) |
1897 0x3C, | 1780 0x3C, |
1898 // connection_id | 1781 // connection_id |
1899 0x10, 0x32, 0x54, 0x76, | 1782 0x10, 0x32, 0x54, 0x76, |
1900 0x98, 0xBA, 0xDC, 0xFE, | 1783 0x98, 0xBA, 0xDC, 0xFE, |
1901 // packet sequence number | 1784 // packet sequence number |
1902 0xA8, 0x9A, 0x78, 0x56, | 1785 0xA8, 0x9A, 0x78, 0x56, |
1903 0x34, 0x12, | 1786 0x34, 0x12, |
1904 // private flags (entropy) | 1787 // private flags (entropy) |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1984 expected_error = "Unable to read revived packet."; | 1867 expected_error = "Unable to read revived packet."; |
1985 } | 1868 } |
1986 CheckProcessingFails( | 1869 CheckProcessingFails( |
1987 packet, | 1870 packet, |
1988 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 1871 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
1989 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), | 1872 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), |
1990 expected_error, QUIC_INVALID_ACK_DATA); | 1873 expected_error, QUIC_INVALID_ACK_DATA); |
1991 } | 1874 } |
1992 } | 1875 } |
1993 | 1876 |
1994 TEST_P(QuicFramerTest, AckFrameRevivedPackets15) { | |
1995 if (framer_.version() != QUIC_VERSION_15) { | |
1996 return; | |
1997 } | |
1998 | |
1999 unsigned char packet[] = { | |
2000 // public flags (8 byte connection_id) | |
2001 0x3C, | |
2002 // connection_id | |
2003 0x10, 0x32, 0x54, 0x76, | |
2004 0x98, 0xBA, 0xDC, 0xFE, | |
2005 // packet sequence number | |
2006 0xA8, 0x9A, 0x78, 0x56, | |
2007 0x34, 0x12, | |
2008 // private flags (entropy) | |
2009 0x01, | |
2010 | |
2011 // frame type (ack frame) | |
2012 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | |
2013 0x6C, | |
2014 // entropy hash of sent packets till least awaiting - 1. | |
2015 0xAB, | |
2016 // least packet sequence number awaiting an ack, delta from sequence number. | |
2017 0x08, 0x00, 0x00, 0x00, | |
2018 0x00, 0x00, | |
2019 // entropy hash of all received packets. | |
2020 0xBA, | |
2021 // largest observed packet sequence number | |
2022 0xBF, 0x9A, 0x78, 0x56, | |
2023 0x34, 0x12, | |
2024 // Zero delta time. | |
2025 0x0, 0x0, | |
2026 // num missing packets | |
2027 0x01, | |
2028 // missing packet delta | |
2029 0x01, | |
2030 // 0 more missing packets in range. | |
2031 0x00, | |
2032 // Number of revived packets. | |
2033 0x01, | |
2034 // Revived packet sequence number. | |
2035 0xBE, 0x9A, 0x78, 0x56, | |
2036 0x34, 0x12, | |
2037 }; | |
2038 | |
2039 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | |
2040 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | |
2041 | |
2042 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | |
2043 ASSERT_TRUE(visitor_.header_.get()); | |
2044 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | |
2045 | |
2046 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | |
2047 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | |
2048 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; | |
2049 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash); | |
2050 EXPECT_EQ(0xBA, frame.received_info.entropy_hash); | |
2051 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed); | |
2052 ASSERT_EQ(1u, frame.received_info.missing_packets.size()); | |
2053 SequenceNumberSet::const_iterator missing_iter = | |
2054 frame.received_info.missing_packets.begin(); | |
2055 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); | |
2056 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); | |
2057 | |
2058 const size_t kSentEntropyOffset = kQuicFrameTypeSize; | |
2059 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize; | |
2060 const size_t kReceivedEntropyOffset = kLeastUnackedOffset + | |
2061 PACKET_6BYTE_SEQUENCE_NUMBER; | |
2062 const size_t kLargestObservedOffset = kReceivedEntropyOffset + | |
2063 kQuicEntropyHashSize; | |
2064 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + | |
2065 PACKET_6BYTE_SEQUENCE_NUMBER; | |
2066 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset + | |
2067 kQuicDeltaTimeLargestObservedSize; | |
2068 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + | |
2069 kNumberOfNackRangesSize; | |
2070 const size_t kMissingPacketsRange = kMissingPacketsOffset + | |
2071 PACKET_1BYTE_SEQUENCE_NUMBER; | |
2072 const size_t kRevivedPacketsLength = kMissingPacketsRange + | |
2073 PACKET_1BYTE_SEQUENCE_NUMBER; | |
2074 const size_t kRevivedPacketSequenceNumberLength = kRevivedPacketsLength + | |
2075 PACKET_1BYTE_SEQUENCE_NUMBER; | |
2076 // Now test framing boundaries | |
2077 const size_t ack_frame_size = kRevivedPacketSequenceNumberLength + | |
2078 PACKET_6BYTE_SEQUENCE_NUMBER; | |
2079 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { | |
2080 string expected_error; | |
2081 if (i < kLeastUnackedOffset) { | |
2082 expected_error = "Unable to read entropy hash for sent packets."; | |
2083 } else if (i < kReceivedEntropyOffset) { | |
2084 expected_error = "Unable to read least unacked delta."; | |
2085 } else if (i < kLargestObservedOffset) { | |
2086 expected_error = "Unable to read entropy hash for received packets."; | |
2087 } else if (i < kMissingDeltaTimeOffset) { | |
2088 expected_error = "Unable to read largest observed."; | |
2089 } else if (i < kNumMissingPacketOffset) { | |
2090 expected_error = "Unable to read delta time largest observed."; | |
2091 } else if (i < kMissingPacketsOffset) { | |
2092 expected_error = "Unable to read num missing packet ranges."; | |
2093 } else if (i < kMissingPacketsRange) { | |
2094 expected_error = "Unable to read missing sequence number delta."; | |
2095 } else if (i < kRevivedPacketsLength) { | |
2096 expected_error = "Unable to read missing sequence number range."; | |
2097 } else if (i < kRevivedPacketSequenceNumberLength) { | |
2098 expected_error = "Unable to read num revived packets."; | |
2099 } else { | |
2100 expected_error = "Unable to read revived packet."; | |
2101 } | |
2102 CheckProcessingFails( | |
2103 packet, | |
2104 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | |
2105 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), | |
2106 expected_error, QUIC_INVALID_ACK_DATA); | |
2107 } | |
2108 } | |
2109 | |
2110 TEST_P(QuicFramerTest, AckFrameNoNacks) { | 1877 TEST_P(QuicFramerTest, AckFrameNoNacks) { |
2111 if (framer_.version() <= QUIC_VERSION_15) { | |
2112 return; | |
2113 } | |
2114 unsigned char packet[] = { | 1878 unsigned char packet[] = { |
2115 // public flags (8 byte connection_id) | 1879 // public flags (8 byte connection_id) |
2116 0x3C, | 1880 0x3C, |
2117 // connection_id | |
2118 0x10, 0x32, 0x54, 0x76, | |
2119 0x98, 0xBA, 0xDC, 0xFE, | |
2120 // packet sequence number | |
2121 0xA8, 0x9A, 0x78, 0x56, | |
2122 0x34, 0x12, | |
2123 // private flags (entropy) | |
2124 0x01, | |
2125 | |
2126 // frame type (ack frame) | |
2127 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta) | |
2128 0x4C, | |
2129 // entropy hash of all received packets. | |
2130 0xBA, | |
2131 // largest observed packet sequence number | |
2132 0xBF, 0x9A, 0x78, 0x56, | |
2133 0x34, 0x12, | |
2134 // Zero delta time. | |
2135 0x0, 0x0, | |
2136 }; | |
2137 | |
2138 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | |
2139 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | |
2140 | |
2141 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | |
2142 ASSERT_TRUE(visitor_.header_.get()); | |
2143 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | |
2144 | |
2145 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | |
2146 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | |
2147 QuicAckFrame* frame = visitor_.ack_frames_[0]; | |
2148 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); | |
2149 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), | |
2150 frame->received_info.largest_observed); | |
2151 ASSERT_EQ(0u, frame->received_info.missing_packets.size()); | |
2152 | |
2153 // Verify that the packet re-serializes identically. | |
2154 QuicFrames frames; | |
2155 frames.push_back(QuicFrame(frame)); | |
2156 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); | |
2157 ASSERT_TRUE(data != NULL); | |
2158 | |
2159 test::CompareCharArraysWithHexError("constructed packet", | |
2160 data->data(), data->length(), | |
2161 AsChars(packet), arraysize(packet)); | |
2162 } | |
2163 | |
2164 TEST_P(QuicFramerTest, AckFrameNoNacks15) { | |
2165 if (framer_.version() > QUIC_VERSION_15) { | |
2166 return; | |
2167 } | |
2168 unsigned char packet[] = { | |
2169 // public flags (8 byte connection_id) | |
2170 0x3C, | |
2171 // connection_id | 1881 // connection_id |
2172 0x10, 0x32, 0x54, 0x76, | 1882 0x10, 0x32, 0x54, 0x76, |
2173 0x98, 0xBA, 0xDC, 0xFE, | 1883 0x98, 0xBA, 0xDC, 0xFE, |
2174 // packet sequence number | 1884 // packet sequence number |
2175 0xA8, 0x9A, 0x78, 0x56, | 1885 0xA8, 0x9A, 0x78, 0x56, |
2176 0x34, 0x12, | 1886 0x34, 0x12, |
2177 // private flags (entropy) | 1887 // private flags (entropy) |
2178 0x01, | 1888 0x01, |
2179 | 1889 |
2180 // frame type (ack frame) | 1890 // frame type (ack frame) |
2181 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta) | 1891 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta) |
2182 0x4C, | 1892 0x4C, |
2183 // entropy hash of sent packets till least awaiting - 1. | |
2184 0xAB, | |
2185 // least packet sequence number awaiting an ack, delta from sequence number. | |
2186 0x08, 0x00, 0x00, 0x00, | |
2187 0x00, 0x00, | |
2188 // entropy hash of all received packets. | 1893 // entropy hash of all received packets. |
2189 0xBA, | 1894 0xBA, |
2190 // largest observed packet sequence number | 1895 // largest observed packet sequence number |
2191 0xBF, 0x9A, 0x78, 0x56, | 1896 0xBF, 0x9A, 0x78, 0x56, |
2192 0x34, 0x12, | 1897 0x34, 0x12, |
2193 // Zero delta time. | 1898 // Zero delta time. |
2194 0x0, 0x0, | 1899 0x0, 0x0, |
2195 }; | 1900 }; |
2196 | 1901 |
2197 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | 1902 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); |
2198 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1903 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2199 | 1904 |
2200 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1905 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2201 ASSERT_TRUE(visitor_.header_.get()); | 1906 ASSERT_TRUE(visitor_.header_.get()); |
2202 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | 1907 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); |
2203 | 1908 |
2204 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | 1909 EXPECT_EQ(0u, visitor_.stream_frames_.size()); |
2205 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | 1910 ASSERT_EQ(1u, visitor_.ack_frames_.size()); |
2206 QuicAckFrame* frame = visitor_.ack_frames_[0]; | 1911 QuicAckFrame* frame = visitor_.ack_frames_[0]; |
2207 EXPECT_EQ(0xAB, frame->sent_info.entropy_hash); | |
2208 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); | 1912 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); |
2209 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), | 1913 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), |
2210 frame->received_info.largest_observed); | 1914 frame->received_info.largest_observed); |
2211 ASSERT_EQ(0u, frame->received_info.missing_packets.size()); | 1915 ASSERT_EQ(0u, frame->received_info.missing_packets.size()); |
2212 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame->sent_info.least_unacked); | |
2213 | 1916 |
2214 // Verify that the packet re-serializes identically. | 1917 // Verify that the packet re-serializes identically. |
2215 QuicFrames frames; | 1918 QuicFrames frames; |
2216 frames.push_back(QuicFrame(frame)); | 1919 frames.push_back(QuicFrame(frame)); |
2217 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); | 1920 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); |
2218 ASSERT_TRUE(data != NULL); | 1921 ASSERT_TRUE(data != NULL); |
2219 | 1922 |
2220 test::CompareCharArraysWithHexError("constructed packet", | 1923 test::CompareCharArraysWithHexError("constructed packet", |
2221 data->data(), data->length(), | 1924 data->data(), data->length(), |
2222 AsChars(packet), arraysize(packet)); | 1925 AsChars(packet), arraysize(packet)); |
2223 } | 1926 } |
2224 | 1927 |
2225 TEST_P(QuicFramerTest, AckFrame500Nacks) { | 1928 TEST_P(QuicFramerTest, AckFrame500Nacks) { |
2226 if (framer_.version() <= QUIC_VERSION_15) { | |
2227 return; | |
2228 } | |
2229 unsigned char packet[] = { | 1929 unsigned char packet[] = { |
2230 // public flags (8 byte connection_id) | 1930 // public flags (8 byte connection_id) |
2231 0x3C, | 1931 0x3C, |
2232 // connection_id | |
2233 0x10, 0x32, 0x54, 0x76, | |
2234 0x98, 0xBA, 0xDC, 0xFE, | |
2235 // packet sequence number | |
2236 0xA8, 0x9A, 0x78, 0x56, | |
2237 0x34, 0x12, | |
2238 // private flags (entropy) | |
2239 0x01, | |
2240 | |
2241 // frame type (ack frame) | |
2242 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | |
2243 0x6C, | |
2244 // entropy hash of all received packets. | |
2245 0xBA, | |
2246 // largest observed packet sequence number | |
2247 0xBF, 0x9A, 0x78, 0x56, | |
2248 0x34, 0x12, | |
2249 // Zero delta time. | |
2250 0x0, 0x0, | |
2251 // num missing packet ranges | |
2252 0x02, | |
2253 // missing packet delta | |
2254 0x01, | |
2255 // 243 more missing packets in range. | |
2256 // The ranges are listed in this order so the re-constructed packet matches. | |
2257 0xF3, | |
2258 // No gap between ranges | |
2259 0x00, | |
2260 // 255 more missing packets in range. | |
2261 0xFF, | |
2262 // No revived packets. | |
2263 0x00, | |
2264 }; | |
2265 | |
2266 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | |
2267 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | |
2268 | |
2269 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | |
2270 ASSERT_TRUE(visitor_.header_.get()); | |
2271 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | |
2272 | |
2273 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | |
2274 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | |
2275 QuicAckFrame* frame = visitor_.ack_frames_[0]; | |
2276 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); | |
2277 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), | |
2278 frame->received_info.largest_observed); | |
2279 EXPECT_EQ(0u, frame->received_info.revived_packets.size()); | |
2280 ASSERT_EQ(500u, frame->received_info.missing_packets.size()); | |
2281 SequenceNumberSet::const_iterator first_missing_iter = | |
2282 frame->received_info.missing_packets.begin(); | |
2283 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter); | |
2284 SequenceNumberSet::const_reverse_iterator last_missing_iter = | |
2285 frame->received_info.missing_packets.rbegin(); | |
2286 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter); | |
2287 | |
2288 // Verify that the packet re-serializes identically. | |
2289 QuicFrames frames; | |
2290 frames.push_back(QuicFrame(frame)); | |
2291 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); | |
2292 ASSERT_TRUE(data != NULL); | |
2293 | |
2294 test::CompareCharArraysWithHexError("constructed packet", | |
2295 data->data(), data->length(), | |
2296 AsChars(packet), arraysize(packet)); | |
2297 } | |
2298 | |
2299 TEST_P(QuicFramerTest, AckFrame500Nacks15) { | |
2300 if (framer_.version() != QUIC_VERSION_15) { | |
2301 return; | |
2302 } | |
2303 unsigned char packet[] = { | |
2304 // public flags (8 byte connection_id) | |
2305 0x3C, | |
2306 // connection_id | 1932 // connection_id |
2307 0x10, 0x32, 0x54, 0x76, | 1933 0x10, 0x32, 0x54, 0x76, |
2308 0x98, 0xBA, 0xDC, 0xFE, | 1934 0x98, 0xBA, 0xDC, 0xFE, |
2309 // packet sequence number | 1935 // packet sequence number |
2310 0xA8, 0x9A, 0x78, 0x56, | 1936 0xA8, 0x9A, 0x78, 0x56, |
2311 0x34, 0x12, | 1937 0x34, 0x12, |
2312 // private flags (entropy) | 1938 // private flags (entropy) |
2313 0x01, | 1939 0x01, |
2314 | 1940 |
2315 // frame type (ack frame) | 1941 // frame type (ack frame) |
2316 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | 1942 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) |
2317 0x6C, | 1943 0x6C, |
2318 // entropy hash of sent packets till least awaiting - 1. | |
2319 0xAB, | |
2320 // least packet sequence number awaiting an ack, delta from sequence number. | |
2321 0x08, 0x00, 0x00, 0x00, | |
2322 0x00, 0x00, | |
2323 // entropy hash of all received packets. | 1944 // entropy hash of all received packets. |
2324 0xBA, | 1945 0xBA, |
2325 // largest observed packet sequence number | 1946 // largest observed packet sequence number |
2326 0xBF, 0x9A, 0x78, 0x56, | 1947 0xBF, 0x9A, 0x78, 0x56, |
2327 0x34, 0x12, | 1948 0x34, 0x12, |
2328 // Zero delta time. | 1949 // Zero delta time. |
2329 0x0, 0x0, | 1950 0x0, 0x0, |
2330 // num missing packet ranges | 1951 // num missing packet ranges |
2331 0x02, | 1952 0x02, |
2332 // missing packet delta | 1953 // missing packet delta |
(...skipping 12 matching lines...) Expand all Loading... |
2345 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | 1966 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); |
2346 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1967 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2347 | 1968 |
2348 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1969 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2349 ASSERT_TRUE(visitor_.header_.get()); | 1970 ASSERT_TRUE(visitor_.header_.get()); |
2350 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | 1971 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); |
2351 | 1972 |
2352 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | 1973 EXPECT_EQ(0u, visitor_.stream_frames_.size()); |
2353 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | 1974 ASSERT_EQ(1u, visitor_.ack_frames_.size()); |
2354 QuicAckFrame* frame = visitor_.ack_frames_[0]; | 1975 QuicAckFrame* frame = visitor_.ack_frames_[0]; |
2355 EXPECT_EQ(0xAB, frame->sent_info.entropy_hash); | |
2356 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); | 1976 EXPECT_EQ(0xBA, frame->received_info.entropy_hash); |
2357 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), | 1977 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), |
2358 frame->received_info.largest_observed); | 1978 frame->received_info.largest_observed); |
2359 EXPECT_EQ(0u, frame->received_info.revived_packets.size()); | 1979 EXPECT_EQ(0u, frame->received_info.revived_packets.size()); |
2360 ASSERT_EQ(500u, frame->received_info.missing_packets.size()); | 1980 ASSERT_EQ(500u, frame->received_info.missing_packets.size()); |
2361 SequenceNumberSet::const_iterator first_missing_iter = | 1981 SequenceNumberSet::const_iterator first_missing_iter = |
2362 frame->received_info.missing_packets.begin(); | 1982 frame->received_info.missing_packets.begin(); |
2363 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter); | 1983 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter); |
2364 SequenceNumberSet::const_reverse_iterator last_missing_iter = | 1984 SequenceNumberSet::const_reverse_iterator last_missing_iter = |
2365 frame->received_info.missing_packets.rbegin(); | 1985 frame->received_info.missing_packets.rbegin(); |
2366 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter); | 1986 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter); |
2367 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame->sent_info.least_unacked); | |
2368 | 1987 |
2369 // Verify that the packet re-serializes identically. | 1988 // Verify that the packet re-serializes identically. |
2370 QuicFrames frames; | 1989 QuicFrames frames; |
2371 frames.push_back(QuicFrame(frame)); | 1990 frames.push_back(QuicFrame(frame)); |
2372 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); | 1991 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); |
2373 ASSERT_TRUE(data != NULL); | 1992 ASSERT_TRUE(data != NULL); |
2374 | 1993 |
2375 test::CompareCharArraysWithHexError("constructed packet", | 1994 test::CompareCharArraysWithHexError("constructed packet", |
2376 data->data(), data->length(), | 1995 data->data(), data->length(), |
2377 AsChars(packet), arraysize(packet)); | 1996 AsChars(packet), arraysize(packet)); |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2589 0x03, | 2208 0x03, |
2590 }; | 2209 }; |
2591 | 2210 |
2592 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | 2211 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); |
2593 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 2212 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
2594 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); | 2213 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); |
2595 EXPECT_EQ(QUIC_INVALID_CONGESTION_FEEDBACK_DATA, framer_.error()); | 2214 EXPECT_EQ(QUIC_INVALID_CONGESTION_FEEDBACK_DATA, framer_.error()); |
2596 } | 2215 } |
2597 | 2216 |
2598 TEST_P(QuicFramerTest, StopWaitingFrame) { | 2217 TEST_P(QuicFramerTest, StopWaitingFrame) { |
2599 if (framer_.version() <= QUIC_VERSION_15) { | |
2600 return; | |
2601 } | |
2602 unsigned char packet[] = { | 2218 unsigned char packet[] = { |
2603 // public flags (8 byte connection_id) | 2219 // public flags (8 byte connection_id) |
2604 0x3C, | 2220 0x3C, |
2605 // connection_id | 2221 // connection_id |
2606 0x10, 0x32, 0x54, 0x76, | 2222 0x10, 0x32, 0x54, 0x76, |
2607 0x98, 0xBA, 0xDC, 0xFE, | 2223 0x98, 0xBA, 0xDC, 0xFE, |
2608 // packet sequence number | 2224 // packet sequence number |
2609 0xA8, 0x9A, 0x78, 0x56, | 2225 0xA8, 0x9A, 0x78, 0x56, |
2610 0x34, 0x12, | 2226 0x34, 0x12, |
2611 // private flags (entropy) | 2227 // private flags (entropy) |
(...skipping 963 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3575 versions.push_back(GetParam()); | 3191 versions.push_back(GetParam()); |
3576 scoped_ptr<QuicEncryptedPacket> data( | 3192 scoped_ptr<QuicEncryptedPacket> data( |
3577 framer_.BuildVersionNegotiationPacket(header, versions)); | 3193 framer_.BuildVersionNegotiationPacket(header, versions)); |
3578 | 3194 |
3579 test::CompareCharArraysWithHexError("constructed packet", | 3195 test::CompareCharArraysWithHexError("constructed packet", |
3580 data->data(), data->length(), | 3196 data->data(), data->length(), |
3581 AsChars(packet), arraysize(packet)); | 3197 AsChars(packet), arraysize(packet)); |
3582 } | 3198 } |
3583 | 3199 |
3584 TEST_P(QuicFramerTest, BuildAckFramePacket) { | 3200 TEST_P(QuicFramerTest, BuildAckFramePacket) { |
3585 if (version_ <= QUIC_VERSION_15) { | |
3586 return; | |
3587 } | |
3588 QuicPacketHeader header; | 3201 QuicPacketHeader header; |
3589 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 3202 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
3590 header.public_header.reset_flag = false; | 3203 header.public_header.reset_flag = false; |
3591 header.public_header.version_flag = false; | |
3592 header.fec_flag = false; | |
3593 header.entropy_flag = true; | |
3594 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); | |
3595 header.fec_group = 0; | |
3596 | |
3597 QuicAckFrame ack_frame; | |
3598 ack_frame.received_info.entropy_hash = 0x43; | |
3599 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF); | |
3600 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); | |
3601 ack_frame.received_info.missing_packets.insert( | |
3602 GG_UINT64_C(0x770123456789ABE)); | |
3603 | |
3604 QuicFrames frames; | |
3605 frames.push_back(QuicFrame(&ack_frame)); | |
3606 | |
3607 unsigned char packet[] = { | |
3608 // public flags (8 byte connection_id) | |
3609 0x3C, | |
3610 // connection_id | |
3611 0x10, 0x32, 0x54, 0x76, | |
3612 0x98, 0xBA, 0xDC, 0xFE, | |
3613 // packet sequence number | |
3614 0xA8, 0x9A, 0x78, 0x56, | |
3615 0x34, 0x12, | |
3616 // private flags (entropy) | |
3617 0x01, | |
3618 | |
3619 // frame type (ack frame) | |
3620 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | |
3621 0x6C, | |
3622 // entropy hash of all received packets. | |
3623 0x43, | |
3624 // largest observed packet sequence number | |
3625 0xBF, 0x9A, 0x78, 0x56, | |
3626 0x34, 0x12, | |
3627 // Zero delta time. | |
3628 0x0, 0x0, | |
3629 // num missing packet ranges | |
3630 0x01, | |
3631 // missing packet delta | |
3632 0x01, | |
3633 // 0 more missing packets in range. | |
3634 0x00, | |
3635 // 0 revived packets. | |
3636 0x00, | |
3637 }; | |
3638 | |
3639 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | |
3640 ASSERT_TRUE(data != NULL); | |
3641 | |
3642 test::CompareCharArraysWithHexError("constructed packet", | |
3643 data->data(), data->length(), | |
3644 AsChars(packet), arraysize(packet)); | |
3645 } | |
3646 | |
3647 TEST_P(QuicFramerTest, BuildAckFramePacket15) { | |
3648 if (version_ != QUIC_VERSION_15) { | |
3649 return; | |
3650 } | |
3651 QuicPacketHeader header; | |
3652 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | |
3653 header.public_header.reset_flag = false; | |
3654 header.public_header.version_flag = false; | 3204 header.public_header.version_flag = false; |
3655 header.fec_flag = false; | 3205 header.fec_flag = false; |
3656 header.entropy_flag = true; | 3206 header.entropy_flag = true; |
3657 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); | 3207 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); |
3658 header.fec_group = 0; | 3208 header.fec_group = 0; |
3659 | 3209 |
3660 QuicAckFrame ack_frame; | 3210 QuicAckFrame ack_frame; |
3661 ack_frame.received_info.entropy_hash = 0x43; | 3211 ack_frame.received_info.entropy_hash = 0x43; |
3662 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF); | 3212 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF); |
3663 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); | 3213 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); |
3664 ack_frame.received_info.missing_packets.insert( | 3214 ack_frame.received_info.missing_packets.insert( |
3665 GG_UINT64_C(0x770123456789ABE)); | 3215 GG_UINT64_C(0x770123456789ABE)); |
3666 ack_frame.sent_info.entropy_hash = 0x14; | |
3667 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x770123456789AA0); | |
3668 | 3216 |
3669 QuicFrames frames; | 3217 QuicFrames frames; |
3670 frames.push_back(QuicFrame(&ack_frame)); | 3218 frames.push_back(QuicFrame(&ack_frame)); |
3671 | 3219 |
3672 unsigned char packet[] = { | 3220 unsigned char packet[] = { |
3673 // public flags (8 byte connection_id) | 3221 // public flags (8 byte connection_id) |
3674 0x3C, | 3222 0x3C, |
3675 // connection_id | 3223 // connection_id |
3676 0x10, 0x32, 0x54, 0x76, | 3224 0x10, 0x32, 0x54, 0x76, |
3677 0x98, 0xBA, 0xDC, 0xFE, | 3225 0x98, 0xBA, 0xDC, 0xFE, |
3678 // packet sequence number | 3226 // packet sequence number |
3679 0xA8, 0x9A, 0x78, 0x56, | 3227 0xA8, 0x9A, 0x78, 0x56, |
3680 0x34, 0x12, | 3228 0x34, 0x12, |
3681 // private flags (entropy) | 3229 // private flags (entropy) |
3682 0x01, | 3230 0x01, |
3683 | 3231 |
3684 // frame type (ack frame) | 3232 // frame type (ack frame) |
3685 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) | 3233 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) |
3686 0x6C, | 3234 0x6C, |
3687 // entropy hash of sent packets till least awaiting - 1. | |
3688 0x14, | |
3689 // least packet sequence number awaiting an ack, delta from sequence number. | |
3690 0x08, 0x00, 0x00, 0x00, | |
3691 0x00, 0x00, | |
3692 // entropy hash of all received packets. | 3235 // entropy hash of all received packets. |
3693 0x43, | 3236 0x43, |
3694 // largest observed packet sequence number | 3237 // largest observed packet sequence number |
3695 0xBF, 0x9A, 0x78, 0x56, | 3238 0xBF, 0x9A, 0x78, 0x56, |
3696 0x34, 0x12, | 3239 0x34, 0x12, |
3697 // Zero delta time. | 3240 // Zero delta time. |
3698 0x0, 0x0, | 3241 0x0, 0x0, |
3699 // num missing packet ranges | 3242 // num missing packet ranges |
3700 0x01, | 3243 0x01, |
3701 // missing packet delta | 3244 // missing packet delta |
3702 0x01, | 3245 0x01, |
3703 // 0 more missing packets in range. | 3246 // 0 more missing packets in range. |
3704 0x00, | 3247 0x00, |
3705 // 0 revived packets. | 3248 // 0 revived packets. |
3706 0x00, | 3249 0x00, |
3707 }; | 3250 }; |
3708 | 3251 |
3709 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3252 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3710 ASSERT_TRUE(data != NULL); | 3253 ASSERT_TRUE(data != NULL); |
3711 | 3254 |
3712 test::CompareCharArraysWithHexError("constructed packet", | 3255 test::CompareCharArraysWithHexError("constructed packet", |
3713 data->data(), data->length(), | 3256 data->data(), data->length(), |
3714 AsChars(packet), arraysize(packet)); | 3257 AsChars(packet), arraysize(packet)); |
3715 } | 3258 } |
3716 | 3259 |
3717 // TODO(jri): Add test for tuncated packets in which the original ack frame had | 3260 // TODO(jri): Add test for tuncated packets in which the original ack frame had |
3718 // revived packets. (In both the large and small packet cases below). | 3261 // revived packets. (In both the large and small packet cases below). |
3719 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) { | 3262 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) { |
3720 if (version_ <= QUIC_VERSION_15) { | |
3721 return; | |
3722 } | |
3723 QuicPacketHeader header; | 3263 QuicPacketHeader header; |
3724 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 3264 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
3725 header.public_header.reset_flag = false; | 3265 header.public_header.reset_flag = false; |
3726 header.public_header.version_flag = false; | 3266 header.public_header.version_flag = false; |
3727 header.fec_flag = false; | 3267 header.fec_flag = false; |
3728 header.entropy_flag = true; | 3268 header.entropy_flag = true; |
3729 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); | 3269 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); |
3730 header.fec_group = 0; | 3270 header.fec_group = 0; |
3731 | 3271 |
3732 QuicAckFrame ack_frame; | 3272 QuicAckFrame ack_frame; |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3826 framer_.BuildDataPacket(header, frames, kMaxPacketSize).packet); | 3366 framer_.BuildDataPacket(header, frames, kMaxPacketSize).packet); |
3827 ASSERT_TRUE(data != NULL); | 3367 ASSERT_TRUE(data != NULL); |
3828 | 3368 |
3829 test::CompareCharArraysWithHexError("constructed packet", | 3369 test::CompareCharArraysWithHexError("constructed packet", |
3830 data->data(), data->length(), | 3370 data->data(), data->length(), |
3831 AsChars(packet), arraysize(packet)); | 3371 AsChars(packet), arraysize(packet)); |
3832 } | 3372 } |
3833 | 3373 |
3834 | 3374 |
3835 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) { | 3375 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) { |
3836 if (version_ <= QUIC_VERSION_15) { | |
3837 return; | |
3838 } | |
3839 QuicPacketHeader header; | 3376 QuicPacketHeader header; |
3840 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 3377 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
3841 header.public_header.reset_flag = false; | 3378 header.public_header.reset_flag = false; |
3842 header.public_header.version_flag = false; | 3379 header.public_header.version_flag = false; |
3843 header.fec_flag = false; | 3380 header.fec_flag = false; |
3844 header.entropy_flag = true; | 3381 header.entropy_flag = true; |
3845 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); | 3382 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); |
3846 header.fec_group = 0; | 3383 header.fec_group = 0; |
3847 | 3384 |
3848 QuicAckFrame ack_frame; | 3385 QuicAckFrame ack_frame; |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4009 | 3546 |
4010 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3547 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4011 ASSERT_TRUE(data != NULL); | 3548 ASSERT_TRUE(data != NULL); |
4012 | 3549 |
4013 test::CompareCharArraysWithHexError("constructed packet", | 3550 test::CompareCharArraysWithHexError("constructed packet", |
4014 data->data(), data->length(), | 3551 data->data(), data->length(), |
4015 AsChars(packet), arraysize(packet)); | 3552 AsChars(packet), arraysize(packet)); |
4016 } | 3553 } |
4017 | 3554 |
4018 TEST_P(QuicFramerTest, BuildStopWaitingPacket) { | 3555 TEST_P(QuicFramerTest, BuildStopWaitingPacket) { |
4019 if (version_ <= QUIC_VERSION_15) { | |
4020 return; | |
4021 } | |
4022 QuicPacketHeader header; | 3556 QuicPacketHeader header; |
4023 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 3557 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
4024 header.public_header.reset_flag = false; | 3558 header.public_header.reset_flag = false; |
4025 header.public_header.version_flag = false; | 3559 header.public_header.version_flag = false; |
4026 header.fec_flag = false; | 3560 header.fec_flag = false; |
4027 header.entropy_flag = true; | 3561 header.entropy_flag = true; |
4028 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); | 3562 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); |
4029 header.fec_group = 0; | 3563 header.fec_group = 0; |
4030 | 3564 |
4031 QuicStopWaitingFrame stop_waiting_frame; | 3565 QuicStopWaitingFrame stop_waiting_frame; |
(...skipping 601 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4633 PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, | 4167 PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, |
4634 PACKET_6BYTE_SEQUENCE_NUMBER)); | 4168 PACKET_6BYTE_SEQUENCE_NUMBER)); |
4635 scoped_ptr<QuicEncryptedPacket> encrypted( | 4169 scoped_ptr<QuicEncryptedPacket> encrypted( |
4636 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); | 4170 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); |
4637 | 4171 |
4638 ASSERT_TRUE(encrypted.get() != NULL); | 4172 ASSERT_TRUE(encrypted.get() != NULL); |
4639 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); | 4173 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); |
4640 } | 4174 } |
4641 | 4175 |
4642 TEST_P(QuicFramerTest, AckTruncationLargePacket) { | 4176 TEST_P(QuicFramerTest, AckTruncationLargePacket) { |
4643 if (framer_.version() <= QUIC_VERSION_15) { | |
4644 return; | |
4645 } | |
4646 QuicPacketHeader header; | 4177 QuicPacketHeader header; |
4647 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 4178 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
4648 header.public_header.reset_flag = false; | 4179 header.public_header.reset_flag = false; |
4649 header.public_header.version_flag = false; | 4180 header.public_header.version_flag = false; |
4650 header.fec_flag = false; | 4181 header.fec_flag = false; |
4651 header.entropy_flag = false; | 4182 header.entropy_flag = false; |
4652 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); | 4183 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); |
4653 header.fec_group = 0; | 4184 header.fec_group = 0; |
4654 | 4185 |
4655 // Create a packet with just the ack. | 4186 // Create a packet with just the ack. |
(...skipping 20 matching lines...) Expand all Loading... |
4676 ASSERT_EQ(255u, processed_ack_frame.received_info.missing_packets.size()); | 4207 ASSERT_EQ(255u, processed_ack_frame.received_info.missing_packets.size()); |
4677 SequenceNumberSet::const_iterator missing_iter = | 4208 SequenceNumberSet::const_iterator missing_iter = |
4678 processed_ack_frame.received_info.missing_packets.begin(); | 4209 processed_ack_frame.received_info.missing_packets.begin(); |
4679 EXPECT_EQ(1u, *missing_iter); | 4210 EXPECT_EQ(1u, *missing_iter); |
4680 SequenceNumberSet::const_reverse_iterator last_missing_iter = | 4211 SequenceNumberSet::const_reverse_iterator last_missing_iter = |
4681 processed_ack_frame.received_info.missing_packets.rbegin(); | 4212 processed_ack_frame.received_info.missing_packets.rbegin(); |
4682 EXPECT_EQ(509u, *last_missing_iter); | 4213 EXPECT_EQ(509u, *last_missing_iter); |
4683 } | 4214 } |
4684 | 4215 |
4685 TEST_P(QuicFramerTest, AckTruncationSmallPacket) { | 4216 TEST_P(QuicFramerTest, AckTruncationSmallPacket) { |
4686 if (framer_.version() <= QUIC_VERSION_15) { | |
4687 return; | |
4688 } | |
4689 QuicPacketHeader header; | 4217 QuicPacketHeader header; |
4690 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 4218 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
4691 header.public_header.reset_flag = false; | 4219 header.public_header.reset_flag = false; |
4692 header.public_header.version_flag = false; | 4220 header.public_header.version_flag = false; |
4693 header.fec_flag = false; | 4221 header.fec_flag = false; |
4694 header.entropy_flag = false; | 4222 header.entropy_flag = false; |
4695 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); | 4223 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); |
4696 header.fec_group = 0; | 4224 header.fec_group = 0; |
4697 | 4225 |
4698 // Create a packet with just the ack. | 4226 // Create a packet with just the ack. |
(...skipping 19 matching lines...) Expand all Loading... |
4718 EXPECT_EQ(476u, processed_ack_frame.received_info.largest_observed); | 4246 EXPECT_EQ(476u, processed_ack_frame.received_info.largest_observed); |
4719 ASSERT_EQ(238u, processed_ack_frame.received_info.missing_packets.size()); | 4247 ASSERT_EQ(238u, processed_ack_frame.received_info.missing_packets.size()); |
4720 SequenceNumberSet::const_iterator missing_iter = | 4248 SequenceNumberSet::const_iterator missing_iter = |
4721 processed_ack_frame.received_info.missing_packets.begin(); | 4249 processed_ack_frame.received_info.missing_packets.begin(); |
4722 EXPECT_EQ(1u, *missing_iter); | 4250 EXPECT_EQ(1u, *missing_iter); |
4723 SequenceNumberSet::const_reverse_iterator last_missing_iter = | 4251 SequenceNumberSet::const_reverse_iterator last_missing_iter = |
4724 processed_ack_frame.received_info.missing_packets.rbegin(); | 4252 processed_ack_frame.received_info.missing_packets.rbegin(); |
4725 EXPECT_EQ(475u, *last_missing_iter); | 4253 EXPECT_EQ(475u, *last_missing_iter); |
4726 } | 4254 } |
4727 | 4255 |
4728 TEST_P(QuicFramerTest, Truncation15) { | |
4729 if (framer_.version() > QUIC_VERSION_15) { | |
4730 return; | |
4731 } | |
4732 QuicPacketHeader header; | |
4733 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | |
4734 header.public_header.reset_flag = false; | |
4735 header.public_header.version_flag = false; | |
4736 header.fec_flag = false; | |
4737 header.entropy_flag = false; | |
4738 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); | |
4739 header.fec_group = 0; | |
4740 | |
4741 QuicAckFrame ack_frame; | |
4742 ack_frame.received_info.largest_observed = 601; | |
4743 ack_frame.sent_info.least_unacked = header.packet_sequence_number - 1; | |
4744 for (uint64 i = 1; i < ack_frame.received_info.largest_observed; i += 2) { | |
4745 ack_frame.received_info.missing_packets.insert(i); | |
4746 } | |
4747 | |
4748 // Create a packet with just the ack. | |
4749 QuicFrame frame; | |
4750 frame.type = ACK_FRAME; | |
4751 frame.ack_frame = &ack_frame; | |
4752 QuicFrames frames; | |
4753 frames.push_back(frame); | |
4754 | |
4755 scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames)); | |
4756 ASSERT_TRUE(raw_ack_packet != NULL); | |
4757 | |
4758 scoped_ptr<QuicEncryptedPacket> ack_packet( | |
4759 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, | |
4760 *raw_ack_packet)); | |
4761 | |
4762 // Now make sure we can turn our ack packet back into an ack frame. | |
4763 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); | |
4764 ASSERT_EQ(1u, visitor_.ack_frames_.size()); | |
4765 const QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0]; | |
4766 EXPECT_EQ(header.packet_sequence_number - 1, | |
4767 processed_ack_frame.sent_info.least_unacked); | |
4768 EXPECT_TRUE(processed_ack_frame.received_info.is_truncated); | |
4769 EXPECT_EQ(510u, processed_ack_frame.received_info.largest_observed); | |
4770 ASSERT_EQ(255u, processed_ack_frame.received_info.missing_packets.size()); | |
4771 SequenceNumberSet::const_iterator missing_iter = | |
4772 processed_ack_frame.received_info.missing_packets.begin(); | |
4773 EXPECT_EQ(1u, *missing_iter); | |
4774 SequenceNumberSet::const_reverse_iterator last_missing_iter = | |
4775 processed_ack_frame.received_info.missing_packets.rbegin(); | |
4776 EXPECT_EQ(509u, *last_missing_iter); | |
4777 } | |
4778 | |
4779 TEST_P(QuicFramerTest, CleanTruncation) { | 4256 TEST_P(QuicFramerTest, CleanTruncation) { |
4780 QuicPacketHeader header; | 4257 QuicPacketHeader header; |
4781 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); | 4258 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); |
4782 header.public_header.reset_flag = false; | 4259 header.public_header.reset_flag = false; |
4783 header.public_header.version_flag = false; | 4260 header.public_header.version_flag = false; |
4784 header.fec_flag = false; | 4261 header.fec_flag = false; |
4785 header.entropy_flag = true; | 4262 header.entropy_flag = true; |
4786 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); | 4263 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); |
4787 header.fec_group = 0; | 4264 header.fec_group = 0; |
4788 | 4265 |
4789 QuicAckFrame ack_frame; | 4266 QuicAckFrame ack_frame; |
4790 ack_frame.received_info.largest_observed = 201; | 4267 ack_frame.received_info.largest_observed = 201; |
4791 ack_frame.sent_info.least_unacked = header.packet_sequence_number - 2; | |
4792 for (uint64 i = 1; i < ack_frame.received_info.largest_observed; ++i) { | 4268 for (uint64 i = 1; i < ack_frame.received_info.largest_observed; ++i) { |
4793 ack_frame.received_info.missing_packets.insert(i); | 4269 ack_frame.received_info.missing_packets.insert(i); |
4794 } | 4270 } |
4795 | 4271 |
4796 // Create a packet with just the ack. | 4272 // Create a packet with just the ack. |
4797 QuicFrame frame; | 4273 QuicFrame frame; |
4798 frame.type = ACK_FRAME; | 4274 frame.type = ACK_FRAME; |
4799 frame.ack_frame = &ack_frame; | 4275 frame.ack_frame = &ack_frame; |
4800 QuicFrames frames; | 4276 QuicFrames frames; |
4801 frames.push_back(frame); | 4277 frames.push_back(frame); |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4951 EXPECT_CALL(visitor, OnPacketComplete()); | 4427 EXPECT_CALL(visitor, OnPacketComplete()); |
4952 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true)); | 4428 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true)); |
4953 | 4429 |
4954 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); | 4430 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); |
4955 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 4431 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
4956 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 4432 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
4957 } | 4433 } |
4958 | 4434 |
4959 } // namespace test | 4435 } // namespace test |
4960 } // namespace net | 4436 } // namespace net |
OLD | NEW |