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 <algorithm> | 7 #include <algorithm> |
8 #include <cstdint> | 8 #include <cstdint> |
9 #include <map> | 9 #include <map> |
10 #include <memory> | 10 #include <memory> |
(...skipping 573 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
584 }; | 584 }; |
585 // clang-format on | 585 // clang-format on |
586 | 586 |
587 const size_t header_size = GetPacketHeaderSize( | 587 const size_t header_size = GetPacketHeaderSize( |
588 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 588 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
589 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER); | 589 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER); |
590 | 590 |
591 memset(packet + header_size, 0, kMaxPacketSize - header_size); | 591 memset(packet + header_size, 0, kMaxPacketSize - header_size); |
592 | 592 |
593 QuicEncryptedPacket encrypted( | 593 QuicEncryptedPacket encrypted( |
594 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 594 AsChars( |
595 ? packet_cid_be | 595 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
596 : packet), | 596 ? packet_cid_be |
597 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 597 : packet), |
| 598 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
598 ? arraysize(packet_cid_be) | 599 ? arraysize(packet_cid_be) |
599 : arraysize(packet), | 600 : arraysize(packet), |
600 false); | 601 false); |
601 EXPECT_QUIC_BUG(framer_.ProcessPacket(encrypted), "Packet too large:1"); | 602 EXPECT_QUIC_BUG(framer_.ProcessPacket(encrypted), "Packet too large:1"); |
602 | 603 |
603 ASSERT_TRUE(visitor_.header_.get()); | 604 ASSERT_TRUE(visitor_.header_.get()); |
604 // Make sure we've parsed the packet header, so we can send an error. | 605 // Make sure we've parsed the packet header, so we can send an error. |
605 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 606 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
606 // Make sure the correct error is propagated. | 607 // Make sure the correct error is propagated. |
607 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error()); | 608 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error()); |
(...skipping 14 matching lines...) Expand all Loading... |
622 // public flags (8 byte connection_id) | 623 // public flags (8 byte connection_id) |
623 0x38, | 624 0x38, |
624 // connection_id | 625 // connection_id |
625 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 626 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
626 // packet number | 627 // packet number |
627 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, | 628 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, |
628 }; | 629 }; |
629 // clang-format on | 630 // clang-format on |
630 | 631 |
631 QuicEncryptedPacket encrypted( | 632 QuicEncryptedPacket encrypted( |
632 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 633 AsChars( |
633 ? packet_cid_be | 634 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
634 : packet), | 635 ? packet_cid_be |
635 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 636 : packet), |
| 637 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
636 ? arraysize(packet_cid_be) | 638 ? arraysize(packet_cid_be) |
637 : arraysize(packet), | 639 : arraysize(packet), |
638 false); | 640 false); |
639 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 641 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
640 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); | 642 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); |
641 ASSERT_TRUE(visitor_.header_.get()); | 643 ASSERT_TRUE(visitor_.header_.get()); |
642 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 644 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
643 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); | 645 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); |
644 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); | 646 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); |
645 EXPECT_FALSE(visitor_.header_->public_header.version_flag); | 647 EXPECT_FALSE(visitor_.header_->public_header.version_flag); |
646 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); | 648 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); |
647 | 649 |
648 // Now test framing boundaries. | 650 // Now test framing boundaries. |
649 for (size_t i = 0; | 651 for (size_t i = 0; |
650 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 652 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
651 !kIncludeVersion, !kIncludeDiversificationNonce, | 653 !kIncludeVersion, !kIncludeDiversificationNonce, |
652 PACKET_6BYTE_PACKET_NUMBER); | 654 PACKET_6BYTE_PACKET_NUMBER); |
653 ++i) { | 655 ++i) { |
654 string expected_error; | 656 string expected_error; |
655 if (i < kConnectionIdOffset) { | 657 if (i < kConnectionIdOffset) { |
656 expected_error = "Unable to read public flags."; | 658 expected_error = "Unable to read public flags."; |
657 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { | 659 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { |
658 expected_error = "Unable to read ConnectionId."; | 660 expected_error = "Unable to read ConnectionId."; |
659 } else { | 661 } else { |
660 expected_error = "Unable to read packet number."; | 662 expected_error = "Unable to read packet number."; |
661 } | 663 } |
662 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 664 CheckProcessingFails( |
663 ? packet_cid_be | 665 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
664 : packet, | 666 ? packet_cid_be |
665 i, expected_error, QUIC_INVALID_PACKET_HEADER); | 667 : packet, |
| 668 i, expected_error, QUIC_INVALID_PACKET_HEADER); |
666 } | 669 } |
667 } | 670 } |
668 | 671 |
669 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) { | 672 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) { |
670 QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId); | 673 QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId); |
671 | 674 |
672 // clang-format off | 675 // clang-format off |
673 unsigned char packet[] = { | 676 unsigned char packet[] = { |
674 // public flags (0 byte connection_id) | 677 // public flags (0 byte connection_id) |
675 0x30, | 678 0x30, |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
728 // connection_id | 731 // connection_id |
729 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 732 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
730 // version tag | 733 // version tag |
731 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), | 734 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), |
732 // packet number | 735 // packet number |
733 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, | 736 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, |
734 }; | 737 }; |
735 // clang-format on | 738 // clang-format on |
736 | 739 |
737 QuicEncryptedPacket encrypted( | 740 QuicEncryptedPacket encrypted( |
738 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 741 AsChars( |
739 ? packet_cid_be | 742 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
740 : packet), | 743 ? packet_cid_be |
741 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 744 : packet), |
| 745 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
742 ? arraysize(packet_cid_be) | 746 ? arraysize(packet_cid_be) |
743 : arraysize(packet), | 747 : arraysize(packet), |
744 false); | 748 false); |
745 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 749 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
746 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); | 750 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); |
747 ASSERT_TRUE(visitor_.header_.get()); | 751 ASSERT_TRUE(visitor_.header_.get()); |
748 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 752 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
749 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); | 753 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); |
750 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); | 754 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); |
751 EXPECT_TRUE(visitor_.header_->public_header.version_flag); | 755 EXPECT_TRUE(visitor_.header_->public_header.version_flag); |
752 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); | 756 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); |
753 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); | 757 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); |
754 | 758 |
755 // Now test framing boundaries. | 759 // Now test framing boundaries. |
756 for (size_t i = 0; | 760 for (size_t i = 0; |
757 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 761 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
758 kIncludeVersion, !kIncludeDiversificationNonce, | 762 kIncludeVersion, !kIncludeDiversificationNonce, |
759 PACKET_6BYTE_PACKET_NUMBER); | 763 PACKET_6BYTE_PACKET_NUMBER); |
760 ++i) { | 764 ++i) { |
761 string expected_error; | 765 string expected_error; |
762 if (i < kConnectionIdOffset) { | 766 if (i < kConnectionIdOffset) { |
763 expected_error = "Unable to read public flags."; | 767 expected_error = "Unable to read public flags."; |
764 } else if (i < kVersionOffset) { | 768 } else if (i < kVersionOffset) { |
765 expected_error = "Unable to read ConnectionId."; | 769 expected_error = "Unable to read ConnectionId."; |
766 } else if (i < GetPacketNumberOffset(kIncludeVersion)) { | 770 } else if (i < GetPacketNumberOffset(kIncludeVersion)) { |
767 expected_error = "Unable to read protocol version."; | 771 expected_error = "Unable to read protocol version."; |
768 } else { | 772 } else { |
769 expected_error = "Unable to read packet number."; | 773 expected_error = "Unable to read packet number."; |
770 } | 774 } |
771 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 775 CheckProcessingFails( |
772 ? packet_cid_be | 776 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
773 : packet, | 777 ? packet_cid_be |
774 i, expected_error, QUIC_INVALID_PACKET_HEADER); | 778 : packet, |
| 779 i, expected_error, QUIC_INVALID_PACKET_HEADER); |
775 } | 780 } |
776 } | 781 } |
777 | 782 |
778 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) { | 783 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) { |
779 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); | 784 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); |
780 | 785 |
781 // clang-format off | 786 // clang-format off |
782 unsigned char packet[] = { | 787 unsigned char packet[] = { |
783 // public flags (8 byte connection_id and 4 byte packet number) | 788 // public flags (8 byte connection_id and 4 byte packet number) |
784 0x28, | 789 0x28, |
785 // connection_id | 790 // connection_id |
786 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, | 791 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, |
787 // packet number | 792 // packet number |
788 0xBC, 0x9A, 0x78, 0x56, | 793 0xBC, 0x9A, 0x78, 0x56, |
789 }; | 794 }; |
790 | 795 |
791 unsigned char packet_cid_be[] = { | 796 unsigned char packet_cid_be[] = { |
792 // public flags (8 byte connection_id and 4 byte packet number) | 797 // public flags (8 byte connection_id and 4 byte packet number) |
793 0x28, | 798 0x28, |
794 // connection_id | 799 // connection_id |
795 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 800 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
796 // packet number | 801 // packet number |
797 0xBC, 0x9A, 0x78, 0x56, | 802 0xBC, 0x9A, 0x78, 0x56, |
798 }; | 803 }; |
799 // clang-format on | 804 // clang-format on |
800 | 805 |
801 QuicEncryptedPacket encrypted( | 806 QuicEncryptedPacket encrypted( |
802 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 807 AsChars( |
803 ? packet_cid_be | 808 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
804 : packet), | 809 ? packet_cid_be |
805 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 810 : packet), |
| 811 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
806 ? arraysize(packet_cid_be) | 812 ? arraysize(packet_cid_be) |
807 : arraysize(packet), | 813 : arraysize(packet), |
808 false); | 814 false); |
809 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 815 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
810 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); | 816 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); |
811 ASSERT_TRUE(visitor_.header_.get()); | 817 ASSERT_TRUE(visitor_.header_.get()); |
812 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 818 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
813 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); | 819 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); |
814 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); | 820 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); |
815 EXPECT_FALSE(visitor_.header_->public_header.version_flag); | 821 EXPECT_FALSE(visitor_.header_->public_header.version_flag); |
816 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); | 822 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); |
817 | 823 |
818 // Now test framing boundaries. | 824 // Now test framing boundaries. |
819 for (size_t i = 0; | 825 for (size_t i = 0; |
820 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 826 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
821 !kIncludeVersion, !kIncludeDiversificationNonce, | 827 !kIncludeVersion, !kIncludeDiversificationNonce, |
822 PACKET_4BYTE_PACKET_NUMBER); | 828 PACKET_4BYTE_PACKET_NUMBER); |
823 ++i) { | 829 ++i) { |
824 string expected_error; | 830 string expected_error; |
825 if (i < kConnectionIdOffset) { | 831 if (i < kConnectionIdOffset) { |
826 expected_error = "Unable to read public flags."; | 832 expected_error = "Unable to read public flags."; |
827 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { | 833 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { |
828 expected_error = "Unable to read ConnectionId."; | 834 expected_error = "Unable to read ConnectionId."; |
829 } else { | 835 } else { |
830 expected_error = "Unable to read packet number."; | 836 expected_error = "Unable to read packet number."; |
831 } | 837 } |
832 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 838 CheckProcessingFails( |
833 ? packet_cid_be | 839 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
834 : packet, | 840 ? packet_cid_be |
835 i, expected_error, QUIC_INVALID_PACKET_HEADER); | 841 : packet, |
| 842 i, expected_error, QUIC_INVALID_PACKET_HEADER); |
836 } | 843 } |
837 } | 844 } |
838 | 845 |
839 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) { | 846 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) { |
840 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); | 847 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); |
841 | 848 |
842 // clang-format off | 849 // clang-format off |
843 unsigned char packet[] = { | 850 unsigned char packet[] = { |
844 // public flags (8 byte connection_id and 2 byte packet number) | 851 // public flags (8 byte connection_id and 2 byte packet number) |
845 0x18, | 852 0x18, |
846 // connection_id | 853 // connection_id |
847 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, | 854 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, |
848 // packet number | 855 // packet number |
849 0xBC, 0x9A, | 856 0xBC, 0x9A, |
850 }; | 857 }; |
851 | 858 |
852 unsigned char packet_cid_be[] = { | 859 unsigned char packet_cid_be[] = { |
853 // public flags (8 byte connection_id and 2 byte packet number) | 860 // public flags (8 byte connection_id and 2 byte packet number) |
854 0x18, | 861 0x18, |
855 // connection_id | 862 // connection_id |
856 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 863 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
857 // packet number | 864 // packet number |
858 0xBC, 0x9A, | 865 0xBC, 0x9A, |
859 }; | 866 }; |
860 // clang-format on | 867 // clang-format on |
861 | 868 |
862 QuicEncryptedPacket encrypted( | 869 QuicEncryptedPacket encrypted( |
863 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 870 AsChars( |
864 ? packet_cid_be | 871 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
865 : packet), | 872 ? packet_cid_be |
866 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 873 : packet), |
| 874 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
867 ? arraysize(packet_cid_be) | 875 ? arraysize(packet_cid_be) |
868 : arraysize(packet), | 876 : arraysize(packet), |
869 false); | 877 false); |
870 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 878 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
871 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); | 879 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); |
872 ASSERT_TRUE(visitor_.header_.get()); | 880 ASSERT_TRUE(visitor_.header_.get()); |
873 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 881 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
874 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); | 882 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); |
875 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); | 883 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); |
876 EXPECT_FALSE(visitor_.header_->public_header.version_flag); | 884 EXPECT_FALSE(visitor_.header_->public_header.version_flag); |
877 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, | 885 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
878 visitor_.header_->public_header.packet_number_length); | 886 visitor_.header_->public_header.packet_number_length); |
879 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); | 887 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); |
880 | 888 |
881 // Now test framing boundaries. | 889 // Now test framing boundaries. |
882 for (size_t i = 0; | 890 for (size_t i = 0; |
883 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 891 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
884 !kIncludeVersion, !kIncludeDiversificationNonce, | 892 !kIncludeVersion, !kIncludeDiversificationNonce, |
885 PACKET_2BYTE_PACKET_NUMBER); | 893 PACKET_2BYTE_PACKET_NUMBER); |
886 ++i) { | 894 ++i) { |
887 string expected_error; | 895 string expected_error; |
888 if (i < kConnectionIdOffset) { | 896 if (i < kConnectionIdOffset) { |
889 expected_error = "Unable to read public flags."; | 897 expected_error = "Unable to read public flags."; |
890 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { | 898 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { |
891 expected_error = "Unable to read ConnectionId."; | 899 expected_error = "Unable to read ConnectionId."; |
892 } else { | 900 } else { |
893 expected_error = "Unable to read packet number."; | 901 expected_error = "Unable to read packet number."; |
894 } | 902 } |
895 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 903 CheckProcessingFails( |
896 ? packet_cid_be | 904 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
897 : packet, | 905 ? packet_cid_be |
898 i, expected_error, QUIC_INVALID_PACKET_HEADER); | 906 : packet, |
| 907 i, expected_error, QUIC_INVALID_PACKET_HEADER); |
899 } | 908 } |
900 } | 909 } |
901 | 910 |
902 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) { | 911 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) { |
903 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); | 912 QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2); |
904 | 913 |
905 // clang-format off | 914 // clang-format off |
906 unsigned char packet[] = { | 915 unsigned char packet[] = { |
907 // public flags (8 byte connection_id and 1 byte packet number) | 916 // public flags (8 byte connection_id and 1 byte packet number) |
908 0x08, | 917 0x08, |
909 // connection_id | 918 // connection_id |
910 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, | 919 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, |
911 // packet number | 920 // packet number |
912 0xBC, | 921 0xBC, |
913 }; | 922 }; |
914 | 923 |
915 unsigned char packet_cid_be[] = { | 924 unsigned char packet_cid_be[] = { |
916 // public flags (8 byte connection_id and 1 byte packet number) | 925 // public flags (8 byte connection_id and 1 byte packet number) |
917 0x08, | 926 0x08, |
918 // connection_id | 927 // connection_id |
919 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 928 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
920 // packet number | 929 // packet number |
921 0xBC, | 930 0xBC, |
922 }; | 931 }; |
923 // clang-format on | 932 // clang-format on |
924 | 933 |
925 QuicEncryptedPacket encrypted( | 934 QuicEncryptedPacket encrypted( |
926 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 935 AsChars( |
927 ? packet_cid_be | 936 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
928 : packet), | 937 ? packet_cid_be |
929 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 938 : packet), |
| 939 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
930 ? arraysize(packet_cid_be) | 940 ? arraysize(packet_cid_be) |
931 : arraysize(packet), | 941 : arraysize(packet), |
932 false); | 942 false); |
933 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 943 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
934 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); | 944 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); |
935 ASSERT_TRUE(visitor_.header_.get()); | 945 ASSERT_TRUE(visitor_.header_.get()); |
936 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); | 946 EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id); |
937 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); | 947 EXPECT_FALSE(visitor_.header_->public_header.multipath_flag); |
938 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); | 948 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); |
939 EXPECT_FALSE(visitor_.header_->public_header.version_flag); | 949 EXPECT_FALSE(visitor_.header_->public_header.version_flag); |
940 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, | 950 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
941 visitor_.header_->public_header.packet_number_length); | 951 visitor_.header_->public_header.packet_number_length); |
942 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); | 952 EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number); |
943 | 953 |
944 // Now test framing boundaries. | 954 // Now test framing boundaries. |
945 for (size_t i = 0; | 955 for (size_t i = 0; |
946 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 956 i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
947 !kIncludeVersion, !kIncludeDiversificationNonce, | 957 !kIncludeVersion, !kIncludeDiversificationNonce, |
948 PACKET_1BYTE_PACKET_NUMBER); | 958 PACKET_1BYTE_PACKET_NUMBER); |
949 ++i) { | 959 ++i) { |
950 string expected_error; | 960 string expected_error; |
951 if (i < kConnectionIdOffset) { | 961 if (i < kConnectionIdOffset) { |
952 expected_error = "Unable to read public flags."; | 962 expected_error = "Unable to read public flags."; |
953 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { | 963 } else if (i < GetPacketNumberOffset(!kIncludeVersion)) { |
954 expected_error = "Unable to read ConnectionId."; | 964 expected_error = "Unable to read ConnectionId."; |
955 } else { | 965 } else { |
956 expected_error = "Unable to read packet number."; | 966 expected_error = "Unable to read packet number."; |
957 } | 967 } |
958 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 968 CheckProcessingFails( |
959 ? packet_cid_be | 969 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
960 : packet, | 970 ? packet_cid_be |
961 i, expected_error, QUIC_INVALID_PACKET_HEADER); | 971 : packet, |
| 972 i, expected_error, QUIC_INVALID_PACKET_HEADER); |
962 } | 973 } |
963 } | 974 } |
964 | 975 |
965 TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) { | 976 TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) { |
966 // Test the case when a packet is received from the past and future packet | 977 // Test the case when a packet is received from the past and future packet |
967 // numbers are still calculated relative to the largest received packet. | 978 // numbers are still calculated relative to the largest received packet. |
968 QuicPacketHeader header; | 979 QuicPacketHeader header; |
969 header.public_header.connection_id = kConnectionId; | 980 header.public_header.connection_id = kConnectionId; |
970 header.public_header.reset_flag = false; | 981 header.public_header.reset_flag = false; |
971 header.public_header.version_flag = false; | 982 header.public_header.version_flag = false; |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1055 // packet number | 1066 // packet number |
1056 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, | 1067 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, |
1057 | 1068 |
1058 // frame type (padding) | 1069 // frame type (padding) |
1059 0x00, | 1070 0x00, |
1060 0x00, 0x00, 0x00, 0x00 | 1071 0x00, 0x00, 0x00, 0x00 |
1061 }; | 1072 }; |
1062 // clang-format on | 1073 // clang-format on |
1063 | 1074 |
1064 QuicEncryptedPacket encrypted( | 1075 QuicEncryptedPacket encrypted( |
1065 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1076 AsChars( |
1066 ? packet_cid_be | 1077 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1067 : packet), | 1078 ? packet_cid_be |
1068 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1079 : packet), |
| 1080 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1069 ? arraysize(packet_cid_be) | 1081 ? arraysize(packet_cid_be) |
1070 : arraysize(packet), | 1082 : arraysize(packet), |
1071 false); | 1083 false); |
1072 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); | 1084 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); |
1073 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1085 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1074 ASSERT_TRUE(visitor_.public_header_->nonce != nullptr); | 1086 ASSERT_TRUE(visitor_.public_header_->nonce != nullptr); |
1075 for (char i = 0; i < 32; ++i) { | 1087 for (char i = 0; i < 32; ++i) { |
1076 EXPECT_EQ(i, (*visitor_.public_header_->nonce)[static_cast<size_t>(i)]); | 1088 EXPECT_EQ(i, (*visitor_.public_header_->nonce)[static_cast<size_t>(i)]); |
1077 } | 1089 } |
| 1090 EXPECT_EQ(1u, visitor_.padding_frames_.size()); |
| 1091 EXPECT_EQ(5, visitor_.padding_frames_[0]->num_padding_bytes); |
1078 }; | 1092 }; |
1079 | 1093 |
1080 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) { | 1094 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) { |
1081 // clang-format off | 1095 // clang-format off |
1082 unsigned char packet[] = { | 1096 unsigned char packet[] = { |
1083 // public flags (8 byte connection_id, version flag and an unknown flag) | 1097 // public flags (8 byte connection_id, version flag and an unknown flag) |
1084 static_cast<unsigned char>( | 1098 static_cast<unsigned char>( |
1085 FLAGS_quic_reloadable_flag_quic_remove_multipath_bit ? 0x39 : 0x79), | 1099 FLAGS_quic_reloadable_flag_quic_remove_multipath_bit ? 0x39 : 0x79), |
1086 // connection_id | 1100 // connection_id |
1087 0x10, 0x32, 0x54, 0x76, | 1101 0x10, 0x32, 0x54, 0x76, |
(...skipping 20 matching lines...) Expand all Loading... |
1108 // packet number | 1122 // packet number |
1109 0xBC, 0x9A, 0x78, 0x56, | 1123 0xBC, 0x9A, 0x78, 0x56, |
1110 0x34, 0x12, | 1124 0x34, 0x12, |
1111 | 1125 |
1112 // frame type (padding frame) | 1126 // frame type (padding frame) |
1113 0x00, | 1127 0x00, |
1114 0x00, 0x00, 0x00, 0x00 | 1128 0x00, 0x00, 0x00, 0x00 |
1115 }; | 1129 }; |
1116 // clang-format on | 1130 // clang-format on |
1117 QuicEncryptedPacket encrypted( | 1131 QuicEncryptedPacket encrypted( |
1118 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1132 AsChars( |
1119 ? packet_cid_be | 1133 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1120 : packet), | 1134 ? packet_cid_be |
1121 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1135 : packet), |
| 1136 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1122 ? arraysize(packet_cid_be) | 1137 ? arraysize(packet_cid_be) |
1123 : arraysize(packet), | 1138 : arraysize(packet), |
1124 false); | 1139 false); |
1125 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1140 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1126 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1141 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1127 ASSERT_TRUE(visitor_.header_.get()); | 1142 ASSERT_TRUE(visitor_.header_.get()); |
1128 EXPECT_EQ(0, visitor_.frame_count_); | 1143 EXPECT_EQ(0, visitor_.frame_count_); |
1129 EXPECT_EQ(1, visitor_.version_mismatch_); | 1144 EXPECT_EQ(1, visitor_.version_mismatch_); |
| 1145 EXPECT_EQ(1u, visitor_.padding_frames_.size()); |
| 1146 EXPECT_EQ(5, visitor_.padding_frames_[0]->num_padding_bytes); |
1130 }; | 1147 }; |
1131 | 1148 |
1132 TEST_P(QuicFramerTest, PaddingFrame) { | 1149 TEST_P(QuicFramerTest, PaddingFrame) { |
1133 // clang-format off | 1150 // clang-format off |
1134 unsigned char packet[] = { | 1151 unsigned char packet[] = { |
1135 // public flags (8 byte connection_id) | 1152 // public flags (8 byte connection_id) |
1136 0x38, | 1153 0x38, |
1137 // connection_id | 1154 // connection_id |
1138 0x10, 0x32, 0x54, 0x76, | 1155 0x10, 0x32, 0x54, 0x76, |
1139 0x98, 0xBA, 0xDC, 0xFE, | 1156 0x98, 0xBA, 0xDC, 0xFE, |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1180 0xDC, 0xFE, 0x98, 0xBA, | 1197 0xDC, 0xFE, 0x98, 0xBA, |
1181 // data length | 1198 // data length |
1182 0x0c, 0x00, | 1199 0x0c, 0x00, |
1183 // data | 1200 // data |
1184 'h', 'e', 'l', 'l', | 1201 'h', 'e', 'l', 'l', |
1185 'o', ' ', 'w', 'o', | 1202 'o', ' ', 'w', 'o', |
1186 'r', 'l', 'd', '!', | 1203 'r', 'l', 'd', '!', |
1187 }; | 1204 }; |
1188 // clang-format on | 1205 // clang-format on |
1189 | 1206 |
| 1207 if (framer_.version() > QUIC_VERSION_37) { |
| 1208 return; |
| 1209 } |
| 1210 |
1190 QuicEncryptedPacket encrypted( | 1211 QuicEncryptedPacket encrypted( |
1191 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1212 AsChars( |
1192 ? packet_cid_be | 1213 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1193 : packet), | 1214 ? packet_cid_be |
1194 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1215 : packet), |
| 1216 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1195 ? arraysize(packet_cid_be) | 1217 ? arraysize(packet_cid_be) |
1196 : arraysize(packet), | 1218 : arraysize(packet), |
1197 false); | 1219 false); |
1198 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1220 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1199 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1221 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1200 ASSERT_TRUE(visitor_.header_.get()); | 1222 ASSERT_TRUE(visitor_.header_.get()); |
1201 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1223 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1202 !kIncludeDiversificationNonce)); | 1224 !kIncludeDiversificationNonce)); |
1203 | 1225 |
1204 ASSERT_EQ(0u, visitor_.stream_frames_.size()); | 1226 ASSERT_EQ(0u, visitor_.stream_frames_.size()); |
1205 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1227 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
| 1228 EXPECT_EQ(1u, visitor_.padding_frames_.size()); |
| 1229 EXPECT_EQ(28, visitor_.padding_frames_[0]->num_padding_bytes); |
1206 // A packet with no frames is not acceptable. | 1230 // A packet with no frames is not acceptable. |
1207 CheckProcessingFails( | 1231 CheckProcessingFails( |
1208 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1232 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1209 : packet, | 1233 ? packet_cid_be |
| 1234 : packet, |
1210 GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 1235 GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
1211 !kIncludeVersion, !kIncludeDiversificationNonce, | 1236 !kIncludeVersion, !kIncludeDiversificationNonce, |
1212 PACKET_6BYTE_PACKET_NUMBER), | 1237 PACKET_6BYTE_PACKET_NUMBER), |
1213 "Packet has no frames.", QUIC_MISSING_PAYLOAD); | 1238 "Packet has no frames.", QUIC_MISSING_PAYLOAD); |
1214 } | 1239 } |
1215 | 1240 |
| 1241 TEST_P(QuicFramerTest, NewPaddingFrame) { |
| 1242 // clang-format off |
| 1243 unsigned char packet[] = { |
| 1244 // public flags (8 byte connection_id) |
| 1245 0x38, |
| 1246 // connection_id |
| 1247 0x10, 0x32, 0x54, 0x76, |
| 1248 0x98, 0xBA, 0xDC, 0xFE, |
| 1249 // packet number |
| 1250 0xBC, 0x9A, 0x78, 0x56, |
| 1251 0x34, 0x12, |
| 1252 |
| 1253 // paddings |
| 1254 0x00, 0x00, |
| 1255 // frame type (stream frame with fin) |
| 1256 0xFF, |
| 1257 // stream id |
| 1258 0x04, 0x03, 0x02, 0x01, |
| 1259 // offset |
| 1260 0x54, 0x76, 0x10, 0x32, |
| 1261 0xDC, 0xFE, 0x98, 0xBA, |
| 1262 // data length |
| 1263 0x0c, 0x00, |
| 1264 // data |
| 1265 'h', 'e', 'l', 'l', |
| 1266 'o', ' ', 'w', 'o', |
| 1267 'r', 'l', 'd', '!', |
| 1268 // paddings |
| 1269 0x00, 0x00, |
| 1270 }; |
| 1271 |
| 1272 unsigned char packet_cid_be[] = { |
| 1273 // public flags (8 byte connection_id) |
| 1274 0x38, |
| 1275 // connection_id |
| 1276 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
| 1277 // packet number |
| 1278 0xBC, 0x9A, 0x78, 0x56, |
| 1279 0x34, 0x12, |
| 1280 |
| 1281 // paddings |
| 1282 0x00, 0x00, |
| 1283 // frame type (stream frame with fin) |
| 1284 0xFF, |
| 1285 // stream id |
| 1286 0x04, 0x03, 0x02, 0x01, |
| 1287 // offset |
| 1288 0x54, 0x76, 0x10, 0x32, |
| 1289 0xDC, 0xFE, 0x98, 0xBA, |
| 1290 // data length |
| 1291 0x0c, 0x00, |
| 1292 // data |
| 1293 'h', 'e', 'l', 'l', |
| 1294 'o', ' ', 'w', 'o', |
| 1295 'r', 'l', 'd', '!', |
| 1296 // paddings |
| 1297 0x00, 0x00, |
| 1298 }; |
| 1299 // clang-format on |
| 1300 |
| 1301 if (framer_.version() <= QUIC_VERSION_37) { |
| 1302 return; |
| 1303 } |
| 1304 |
| 1305 QuicEncryptedPacket encrypted( |
| 1306 AsChars( |
| 1307 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
| 1308 ? packet_cid_be |
| 1309 : packet), |
| 1310 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
| 1311 ? arraysize(packet_cid_be) |
| 1312 : arraysize(packet), |
| 1313 false); |
| 1314 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
| 1315 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
| 1316 ASSERT_TRUE(visitor_.header_.get()); |
| 1317 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
| 1318 !kIncludeDiversificationNonce)); |
| 1319 |
| 1320 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
| 1321 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
| 1322 EXPECT_EQ(2u, visitor_.padding_frames_.size()); |
| 1323 EXPECT_EQ(2, visitor_.padding_frames_[0]->num_padding_bytes); |
| 1324 EXPECT_EQ(2, visitor_.padding_frames_[1]->num_padding_bytes); |
| 1325 EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id); |
| 1326 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
| 1327 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
| 1328 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
| 1329 } |
| 1330 |
1216 TEST_P(QuicFramerTest, StreamFrame) { | 1331 TEST_P(QuicFramerTest, StreamFrame) { |
1217 // clang-format off | 1332 // clang-format off |
1218 unsigned char packet[] = { | 1333 unsigned char packet[] = { |
1219 // public flags (8 byte connection_id) | 1334 // public flags (8 byte connection_id) |
1220 0x38, | 1335 0x38, |
1221 // connection_id | 1336 // connection_id |
1222 0x10, 0x32, 0x54, 0x76, | 1337 0x10, 0x32, 0x54, 0x76, |
1223 0x98, 0xBA, 0xDC, 0xFE, | 1338 0x98, 0xBA, 0xDC, 0xFE, |
1224 // packet number | 1339 // packet number |
1225 0xBC, 0x9A, 0x78, 0x56, | 1340 0xBC, 0x9A, 0x78, 0x56, |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1259 // data length | 1374 // data length |
1260 0x0c, 0x00, | 1375 0x0c, 0x00, |
1261 // data | 1376 // data |
1262 'h', 'e', 'l', 'l', | 1377 'h', 'e', 'l', 'l', |
1263 'o', ' ', 'w', 'o', | 1378 'o', ' ', 'w', 'o', |
1264 'r', 'l', 'd', '!', | 1379 'r', 'l', 'd', '!', |
1265 }; | 1380 }; |
1266 // clang-format on | 1381 // clang-format on |
1267 | 1382 |
1268 QuicEncryptedPacket encrypted( | 1383 QuicEncryptedPacket encrypted( |
1269 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1384 AsChars( |
1270 ? packet_cid_be | 1385 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1271 : packet), | 1386 ? packet_cid_be |
1272 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1387 : packet), |
| 1388 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1273 ? arraysize(packet_cid_be) | 1389 ? arraysize(packet_cid_be) |
1274 : arraysize(packet), | 1390 : arraysize(packet), |
1275 false); | 1391 false); |
1276 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1392 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1277 | 1393 |
1278 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1394 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1279 ASSERT_TRUE(visitor_.header_.get()); | 1395 ASSERT_TRUE(visitor_.header_.get()); |
1280 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1396 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1281 !kIncludeDiversificationNonce)); | 1397 !kIncludeDiversificationNonce)); |
1282 | 1398 |
1283 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1399 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1284 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1400 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1285 EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id); | 1401 EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id); |
1286 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1402 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1287 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); | 1403 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
1288 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); | 1404 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
1289 | 1405 |
1290 // Now test framing boundaries. | 1406 // Now test framing boundaries. |
1291 CheckStreamFrameBoundaries( | 1407 CheckStreamFrameBoundaries( |
1292 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1408 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1293 : packet, | 1409 ? packet_cid_be |
| 1410 : packet, |
1294 kQuicMaxStreamIdSize, !kIncludeVersion); | 1411 kQuicMaxStreamIdSize, !kIncludeVersion); |
1295 } | 1412 } |
1296 | 1413 |
1297 TEST_P(QuicFramerTest, MissingDiversificationNonce) { | 1414 TEST_P(QuicFramerTest, MissingDiversificationNonce) { |
1298 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); | 1415 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); |
1299 framer_.SetDecrypter(ENCRYPTION_NONE, | 1416 framer_.SetDecrypter(ENCRYPTION_NONE, |
1300 new NullDecrypter(Perspective::IS_CLIENT)); | 1417 new NullDecrypter(Perspective::IS_CLIENT)); |
1301 decrypter_ = new test::TestDecrypter(); | 1418 decrypter_ = new test::TestDecrypter(); |
1302 framer_.SetAlternativeDecrypter(ENCRYPTION_INITIAL, decrypter_, false); | 1419 framer_.SetAlternativeDecrypter(ENCRYPTION_INITIAL, decrypter_, false); |
1303 | 1420 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1346 // data length | 1463 // data length |
1347 0x0c, 0x00, | 1464 0x0c, 0x00, |
1348 // data | 1465 // data |
1349 'h', 'e', 'l', 'l', | 1466 'h', 'e', 'l', 'l', |
1350 'o', ' ', 'w', 'o', | 1467 'o', ' ', 'w', 'o', |
1351 'r', 'l', 'd', '!', | 1468 'r', 'l', 'd', '!', |
1352 }; | 1469 }; |
1353 // clang-format on | 1470 // clang-format on |
1354 | 1471 |
1355 QuicEncryptedPacket encrypted( | 1472 QuicEncryptedPacket encrypted( |
1356 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1473 AsChars( |
1357 ? packet_cid_be | 1474 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1358 : packet), | 1475 ? packet_cid_be |
1359 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1476 : packet), |
| 1477 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1360 ? arraysize(packet_cid_be) | 1478 ? arraysize(packet_cid_be) |
1361 : arraysize(packet), | 1479 : arraysize(packet), |
1362 false); | 1480 false); |
1363 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); | 1481 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); |
1364 EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error()); | 1482 EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error()); |
1365 } | 1483 } |
1366 | 1484 |
1367 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) { | 1485 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) { |
1368 // clang-format off | 1486 // clang-format off |
1369 unsigned char packet[] = { | 1487 unsigned char packet[] = { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1410 // data length | 1528 // data length |
1411 0x0c, 0x00, | 1529 0x0c, 0x00, |
1412 // data | 1530 // data |
1413 'h', 'e', 'l', 'l', | 1531 'h', 'e', 'l', 'l', |
1414 'o', ' ', 'w', 'o', | 1532 'o', ' ', 'w', 'o', |
1415 'r', 'l', 'd', '!', | 1533 'r', 'l', 'd', '!', |
1416 }; | 1534 }; |
1417 // clang-format on | 1535 // clang-format on |
1418 | 1536 |
1419 QuicEncryptedPacket encrypted( | 1537 QuicEncryptedPacket encrypted( |
1420 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1538 AsChars( |
1421 ? packet_cid_be | 1539 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1422 : packet), | 1540 ? packet_cid_be |
1423 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1541 : packet), |
| 1542 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1424 ? arraysize(packet_cid_be) | 1543 ? arraysize(packet_cid_be) |
1425 : arraysize(packet), | 1544 : arraysize(packet), |
1426 false); | 1545 false); |
1427 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1546 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1428 | 1547 |
1429 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1548 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1430 ASSERT_TRUE(visitor_.header_.get()); | 1549 ASSERT_TRUE(visitor_.header_.get()); |
1431 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1550 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1432 !kIncludeDiversificationNonce)); | 1551 !kIncludeDiversificationNonce)); |
1433 | 1552 |
1434 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1553 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1435 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1554 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1436 // Stream ID should be the last 3 bytes of kStreamId. | 1555 // Stream ID should be the last 3 bytes of kStreamId. |
1437 EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id); | 1556 EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id); |
1438 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1557 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1439 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); | 1558 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
1440 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); | 1559 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
1441 | 1560 |
1442 // Now test framing boundaries. | 1561 // Now test framing boundaries. |
1443 const size_t stream_id_size = 3; | 1562 const size_t stream_id_size = 3; |
1444 CheckStreamFrameBoundaries( | 1563 CheckStreamFrameBoundaries( |
1445 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1564 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1446 : packet, | 1565 ? packet_cid_be |
| 1566 : packet, |
1447 stream_id_size, !kIncludeVersion); | 1567 stream_id_size, !kIncludeVersion); |
1448 } | 1568 } |
1449 | 1569 |
1450 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) { | 1570 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) { |
1451 // clang-format off | 1571 // clang-format off |
1452 unsigned char packet[] = { | 1572 unsigned char packet[] = { |
1453 // public flags (8 byte connection_id) | 1573 // public flags (8 byte connection_id) |
1454 0x38, | 1574 0x38, |
1455 // connection_id | 1575 // connection_id |
1456 0x10, 0x32, 0x54, 0x76, | 1576 0x10, 0x32, 0x54, 0x76, |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1493 // data length | 1613 // data length |
1494 0x0c, 0x00, | 1614 0x0c, 0x00, |
1495 // data | 1615 // data |
1496 'h', 'e', 'l', 'l', | 1616 'h', 'e', 'l', 'l', |
1497 'o', ' ', 'w', 'o', | 1617 'o', ' ', 'w', 'o', |
1498 'r', 'l', 'd', '!', | 1618 'r', 'l', 'd', '!', |
1499 }; | 1619 }; |
1500 // clang-format on | 1620 // clang-format on |
1501 | 1621 |
1502 QuicEncryptedPacket encrypted( | 1622 QuicEncryptedPacket encrypted( |
1503 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1623 AsChars( |
1504 ? packet_cid_be | 1624 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1505 : packet), | 1625 ? packet_cid_be |
1506 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1626 : packet), |
| 1627 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1507 ? arraysize(packet_cid_be) | 1628 ? arraysize(packet_cid_be) |
1508 : arraysize(packet), | 1629 : arraysize(packet), |
1509 false); | 1630 false); |
1510 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1631 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1511 | 1632 |
1512 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1633 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1513 ASSERT_TRUE(visitor_.header_.get()); | 1634 ASSERT_TRUE(visitor_.header_.get()); |
1514 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1635 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1515 !kIncludeDiversificationNonce)); | 1636 !kIncludeDiversificationNonce)); |
1516 | 1637 |
1517 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1638 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1518 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1639 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1519 // Stream ID should be the last 2 bytes of kStreamId. | 1640 // Stream ID should be the last 2 bytes of kStreamId. |
1520 EXPECT_EQ(0x0000FFFF & kStreamId, visitor_.stream_frames_[0]->stream_id); | 1641 EXPECT_EQ(0x0000FFFF & kStreamId, visitor_.stream_frames_[0]->stream_id); |
1521 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1642 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1522 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); | 1643 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
1523 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); | 1644 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
1524 | 1645 |
1525 // Now test framing boundaries. | 1646 // Now test framing boundaries. |
1526 const size_t stream_id_size = 2; | 1647 const size_t stream_id_size = 2; |
1527 CheckStreamFrameBoundaries( | 1648 CheckStreamFrameBoundaries( |
1528 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1649 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1529 : packet, | 1650 ? packet_cid_be |
| 1651 : packet, |
1530 stream_id_size, !kIncludeVersion); | 1652 stream_id_size, !kIncludeVersion); |
1531 } | 1653 } |
1532 | 1654 |
1533 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) { | 1655 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) { |
1534 // clang-format off | 1656 // clang-format off |
1535 unsigned char packet[] = { | 1657 unsigned char packet[] = { |
1536 // public flags (8 byte connection_id) | 1658 // public flags (8 byte connection_id) |
1537 0x38, | 1659 0x38, |
1538 // connection_id | 1660 // connection_id |
1539 0x10, 0x32, 0x54, 0x76, | 1661 0x10, 0x32, 0x54, 0x76, |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1576 // data length | 1698 // data length |
1577 0x0c, 0x00, | 1699 0x0c, 0x00, |
1578 // data | 1700 // data |
1579 'h', 'e', 'l', 'l', | 1701 'h', 'e', 'l', 'l', |
1580 'o', ' ', 'w', 'o', | 1702 'o', ' ', 'w', 'o', |
1581 'r', 'l', 'd', '!', | 1703 'r', 'l', 'd', '!', |
1582 }; | 1704 }; |
1583 // clang-format on | 1705 // clang-format on |
1584 | 1706 |
1585 QuicEncryptedPacket encrypted( | 1707 QuicEncryptedPacket encrypted( |
1586 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1708 AsChars( |
1587 ? packet_cid_be | 1709 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1588 : packet), | 1710 ? packet_cid_be |
1589 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1711 : packet), |
| 1712 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1590 ? arraysize(packet_cid_be) | 1713 ? arraysize(packet_cid_be) |
1591 : arraysize(packet), | 1714 : arraysize(packet), |
1592 false); | 1715 false); |
1593 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1716 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1594 | 1717 |
1595 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1718 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1596 ASSERT_TRUE(visitor_.header_.get()); | 1719 ASSERT_TRUE(visitor_.header_.get()); |
1597 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1720 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1598 !kIncludeDiversificationNonce)); | 1721 !kIncludeDiversificationNonce)); |
1599 | 1722 |
1600 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1723 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1601 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1724 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1602 // Stream ID should be the last byte of kStreamId. | 1725 // Stream ID should be the last byte of kStreamId. |
1603 EXPECT_EQ(0x000000FF & kStreamId, visitor_.stream_frames_[0]->stream_id); | 1726 EXPECT_EQ(0x000000FF & kStreamId, visitor_.stream_frames_[0]->stream_id); |
1604 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1727 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1605 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); | 1728 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
1606 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); | 1729 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
1607 | 1730 |
1608 // Now test framing boundaries. | 1731 // Now test framing boundaries. |
1609 const size_t stream_id_size = 1; | 1732 const size_t stream_id_size = 1; |
1610 CheckStreamFrameBoundaries( | 1733 CheckStreamFrameBoundaries( |
1611 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1734 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1612 : packet, | 1735 ? packet_cid_be |
| 1736 : packet, |
1613 stream_id_size, !kIncludeVersion); | 1737 stream_id_size, !kIncludeVersion); |
1614 } | 1738 } |
1615 | 1739 |
1616 TEST_P(QuicFramerTest, StreamFrameWithVersion) { | 1740 TEST_P(QuicFramerTest, StreamFrameWithVersion) { |
1617 // clang-format off | 1741 // clang-format off |
1618 unsigned char packet[] = { | 1742 unsigned char packet[] = { |
1619 // public flags (version, 8 byte connection_id) | 1743 // public flags (version, 8 byte connection_id) |
1620 0x39, | 1744 0x39, |
1621 // connection_id | 1745 // connection_id |
1622 0x10, 0x32, 0x54, 0x76, | 1746 0x10, 0x32, 0x54, 0x76, |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1663 // data length | 1787 // data length |
1664 0x0c, 0x00, | 1788 0x0c, 0x00, |
1665 // data | 1789 // data |
1666 'h', 'e', 'l', 'l', | 1790 'h', 'e', 'l', 'l', |
1667 'o', ' ', 'w', 'o', | 1791 'o', ' ', 'w', 'o', |
1668 'r', 'l', 'd', '!', | 1792 'r', 'l', 'd', '!', |
1669 }; | 1793 }; |
1670 // clang-format on | 1794 // clang-format on |
1671 | 1795 |
1672 QuicEncryptedPacket encrypted( | 1796 QuicEncryptedPacket encrypted( |
1673 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1797 AsChars( |
1674 ? packet_cid_be | 1798 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1675 : packet), | 1799 ? packet_cid_be |
1676 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1800 : packet), |
| 1801 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1677 ? arraysize(packet_cid_be) | 1802 ? arraysize(packet_cid_be) |
1678 : arraysize(packet), | 1803 : arraysize(packet), |
1679 false); | 1804 false); |
1680 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1805 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1681 | 1806 |
1682 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1807 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1683 ASSERT_TRUE(visitor_.header_.get()); | 1808 ASSERT_TRUE(visitor_.header_.get()); |
1684 EXPECT_TRUE(visitor_.header_->public_header.version_flag); | 1809 EXPECT_TRUE(visitor_.header_->public_header.version_flag); |
1685 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); | 1810 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); |
1686 EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion, | 1811 EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion, |
1687 !kIncludeDiversificationNonce)); | 1812 !kIncludeDiversificationNonce)); |
1688 | 1813 |
1689 ASSERT_EQ(1u, visitor_.stream_frames_.size()); | 1814 ASSERT_EQ(1u, visitor_.stream_frames_.size()); |
1690 EXPECT_EQ(0u, visitor_.ack_frames_.size()); | 1815 EXPECT_EQ(0u, visitor_.ack_frames_.size()); |
1691 EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id); | 1816 EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id); |
1692 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); | 1817 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); |
1693 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); | 1818 EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset); |
1694 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); | 1819 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get()); |
1695 | 1820 |
1696 // Now test framing boundaries. | 1821 // Now test framing boundaries. |
1697 CheckStreamFrameBoundaries( | 1822 CheckStreamFrameBoundaries( |
1698 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 1823 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1699 : packet, | 1824 ? packet_cid_be |
| 1825 : packet, |
1700 kQuicMaxStreamIdSize, kIncludeVersion); | 1826 kQuicMaxStreamIdSize, kIncludeVersion); |
1701 } | 1827 } |
1702 | 1828 |
1703 TEST_P(QuicFramerTest, RejectPacket) { | 1829 TEST_P(QuicFramerTest, RejectPacket) { |
1704 visitor_.accept_packet_ = false; | 1830 visitor_.accept_packet_ = false; |
1705 | 1831 |
1706 // clang-format off | 1832 // clang-format off |
1707 unsigned char packet[] = { | 1833 unsigned char packet[] = { |
1708 // public flags (8 byte connection_id) | 1834 // public flags (8 byte connection_id) |
1709 0x38, | 1835 0x38, |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1748 // data length | 1874 // data length |
1749 0x0c, 0x00, | 1875 0x0c, 0x00, |
1750 // data | 1876 // data |
1751 'h', 'e', 'l', 'l', | 1877 'h', 'e', 'l', 'l', |
1752 'o', ' ', 'w', 'o', | 1878 'o', ' ', 'w', 'o', |
1753 'r', 'l', 'd', '!', | 1879 'r', 'l', 'd', '!', |
1754 }; | 1880 }; |
1755 // clang-format on | 1881 // clang-format on |
1756 | 1882 |
1757 QuicEncryptedPacket encrypted( | 1883 QuicEncryptedPacket encrypted( |
1758 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1884 AsChars( |
1759 ? packet_cid_be | 1885 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1760 : packet), | 1886 ? packet_cid_be |
1761 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1887 : packet), |
| 1888 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1762 ? arraysize(packet_cid_be) | 1889 ? arraysize(packet_cid_be) |
1763 : arraysize(packet), | 1890 : arraysize(packet), |
1764 false); | 1891 false); |
1765 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1892 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1766 | 1893 |
1767 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1894 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1768 ASSERT_TRUE(visitor_.header_.get()); | 1895 ASSERT_TRUE(visitor_.header_.get()); |
1769 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1896 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1770 !kIncludeDiversificationNonce)); | 1897 !kIncludeDiversificationNonce)); |
1771 | 1898 |
(...skipping 14 matching lines...) Expand all Loading... |
1786 | 1913 |
1787 unsigned char packet_cid_be[] = { | 1914 unsigned char packet_cid_be[] = { |
1788 // public flags (8 byte connection_id) | 1915 // public flags (8 byte connection_id) |
1789 0x38, | 1916 0x38, |
1790 // connection_id | 1917 // connection_id |
1791 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 1918 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
1792 }; | 1919 }; |
1793 // clang-format on | 1920 // clang-format on |
1794 | 1921 |
1795 QuicEncryptedPacket encrypted( | 1922 QuicEncryptedPacket encrypted( |
1796 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1923 AsChars( |
1797 ? packet_cid_be | 1924 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1798 : packet), | 1925 ? packet_cid_be |
1799 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1926 : packet), |
| 1927 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1800 ? arraysize(packet_cid_be) | 1928 ? arraysize(packet_cid_be) |
1801 : arraysize(packet), | 1929 : arraysize(packet), |
1802 false); | 1930 false); |
1803 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1931 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1804 | 1932 |
1805 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1933 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1806 ASSERT_TRUE(visitor_.public_header_.get()); | 1934 ASSERT_TRUE(visitor_.public_header_.get()); |
1807 ASSERT_FALSE(visitor_.header_.get()); | 1935 ASSERT_FALSE(visitor_.header_.get()); |
1808 } | 1936 } |
1809 | 1937 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1846 // Zero delta time. | 1974 // Zero delta time. |
1847 0x00, 0x00, | 1975 0x00, 0x00, |
1848 // first ack block length. | 1976 // first ack block length. |
1849 0x34, 0x12, | 1977 0x34, 0x12, |
1850 // num timestamps. | 1978 // num timestamps. |
1851 0x00, | 1979 0x00, |
1852 }; | 1980 }; |
1853 // clang-format on | 1981 // clang-format on |
1854 | 1982 |
1855 QuicEncryptedPacket encrypted( | 1983 QuicEncryptedPacket encrypted( |
1856 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1984 AsChars( |
1857 ? packet_cid_be | 1985 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1858 : packet), | 1986 ? packet_cid_be |
1859 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 1987 : packet), |
| 1988 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1860 ? arraysize(packet_cid_be) | 1989 ? arraysize(packet_cid_be) |
1861 : arraysize(packet), | 1990 : arraysize(packet), |
1862 false); | 1991 false); |
1863 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 1992 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
1864 | 1993 |
1865 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 1994 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
1866 ASSERT_TRUE(visitor_.header_.get()); | 1995 ASSERT_TRUE(visitor_.header_.get()); |
1867 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 1996 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
1868 !kIncludeDiversificationNonce)); | 1997 !kIncludeDiversificationNonce)); |
1869 | 1998 |
(...skipping 18 matching lines...) Expand all Loading... |
1888 if (i < kLargestAckedDeltaTimeOffset) { | 2017 if (i < kLargestAckedDeltaTimeOffset) { |
1889 expected_error = "Unable to read largest acked."; | 2018 expected_error = "Unable to read largest acked."; |
1890 } else if (i < kFirstAckBlockLengthOffset) { | 2019 } else if (i < kFirstAckBlockLengthOffset) { |
1891 expected_error = "Unable to read ack delay time."; | 2020 expected_error = "Unable to read ack delay time."; |
1892 } else if (i < kNumTimestampsOffset) { | 2021 } else if (i < kNumTimestampsOffset) { |
1893 expected_error = "Unable to read first ack block length."; | 2022 expected_error = "Unable to read first ack block length."; |
1894 } else { | 2023 } else { |
1895 expected_error = "Unable to read num received packets."; | 2024 expected_error = "Unable to read num received packets."; |
1896 } | 2025 } |
1897 CheckProcessingFails( | 2026 CheckProcessingFails( |
1898 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2027 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
1899 : packet, | 2028 ? packet_cid_be |
| 2029 : packet, |
1900 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2030 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
1901 !kIncludeVersion, !kIncludeDiversificationNonce, | 2031 !kIncludeVersion, !kIncludeDiversificationNonce, |
1902 PACKET_6BYTE_PACKET_NUMBER), | 2032 PACKET_6BYTE_PACKET_NUMBER), |
1903 expected_error, QUIC_INVALID_ACK_DATA); | 2033 expected_error, QUIC_INVALID_ACK_DATA); |
1904 } | 2034 } |
1905 } | 2035 } |
1906 | 2036 |
1907 TEST_P(QuicFramerTest, AckFrameTwoTimeStampsMultipleAckBlocks) { | 2037 TEST_P(QuicFramerTest, AckFrameTwoTimeStampsMultipleAckBlocks) { |
1908 // clang-format off | 2038 // clang-format off |
1909 unsigned char packet[] = { | 2039 unsigned char packet[] = { |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1995 // Delta time. | 2125 // Delta time. |
1996 0x10, 0x32, 0x54, 0x76, | 2126 0x10, 0x32, 0x54, 0x76, |
1997 // Delta from largest observed. | 2127 // Delta from largest observed. |
1998 0x02, | 2128 0x02, |
1999 // Delta time. | 2129 // Delta time. |
2000 0x10, 0x32, | 2130 0x10, 0x32, |
2001 }; | 2131 }; |
2002 // clang-format on | 2132 // clang-format on |
2003 | 2133 |
2004 QuicEncryptedPacket encrypted( | 2134 QuicEncryptedPacket encrypted( |
2005 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2135 AsChars( |
2006 ? packet_cid_be | 2136 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2007 : packet), | 2137 ? packet_cid_be |
2008 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2138 : packet), |
| 2139 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2009 ? arraysize(packet_cid_be) | 2140 ? arraysize(packet_cid_be) |
2010 : arraysize(packet), | 2141 : arraysize(packet), |
2011 false); | 2142 false); |
2012 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2143 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2013 | 2144 |
2014 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2145 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2015 ASSERT_TRUE(visitor_.header_.get()); | 2146 ASSERT_TRUE(visitor_.header_.get()); |
2016 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2147 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2017 !kIncludeDiversificationNonce)); | 2148 !kIncludeDiversificationNonce)); |
2018 | 2149 |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2088 } else if (i < kTimestampDeltaLargestObserved2) { | 2219 } else if (i < kTimestampDeltaLargestObserved2) { |
2089 expected_error = "Unable to read time delta in received packets."; | 2220 expected_error = "Unable to read time delta in received packets."; |
2090 } else if (i < kTimestampTimeDeltaLargestObserved2) { | 2221 } else if (i < kTimestampTimeDeltaLargestObserved2) { |
2091 expected_error = "Unable to read sequence delta in received packets."; | 2222 expected_error = "Unable to read sequence delta in received packets."; |
2092 } else { | 2223 } else { |
2093 expected_error = | 2224 expected_error = |
2094 "Unable to read incremental time delta in received packets."; | 2225 "Unable to read incremental time delta in received packets."; |
2095 } | 2226 } |
2096 | 2227 |
2097 CheckProcessingFails( | 2228 CheckProcessingFails( |
2098 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2229 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2099 : packet, | 2230 ? packet_cid_be |
| 2231 : packet, |
2100 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2232 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2101 !kIncludeVersion, !kIncludeDiversificationNonce, | 2233 !kIncludeVersion, !kIncludeDiversificationNonce, |
2102 PACKET_6BYTE_PACKET_NUMBER), | 2234 PACKET_6BYTE_PACKET_NUMBER), |
2103 expected_error, QUIC_INVALID_ACK_DATA); | 2235 expected_error, QUIC_INVALID_ACK_DATA); |
2104 } | 2236 } |
2105 } | 2237 } |
2106 | 2238 |
2107 TEST_P(QuicFramerTest, NewStopWaitingFrame) { | 2239 TEST_P(QuicFramerTest, NewStopWaitingFrame) { |
2108 // clang-format off | 2240 // clang-format off |
2109 unsigned char packet[] = { | 2241 unsigned char packet[] = { |
(...skipping 22 matching lines...) Expand all Loading... |
2132 0x34, 0x12, | 2264 0x34, 0x12, |
2133 // frame type (stop waiting frame) | 2265 // frame type (stop waiting frame) |
2134 0x06, | 2266 0x06, |
2135 // least packet number awaiting an ack, delta from packet number. | 2267 // least packet number awaiting an ack, delta from packet number. |
2136 0x08, 0x00, 0x00, 0x00, | 2268 0x08, 0x00, 0x00, 0x00, |
2137 0x00, 0x00, | 2269 0x00, 0x00, |
2138 }; | 2270 }; |
2139 // clang-format on | 2271 // clang-format on |
2140 | 2272 |
2141 QuicEncryptedPacket encrypted( | 2273 QuicEncryptedPacket encrypted( |
2142 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2274 AsChars( |
2143 ? packet_cid_be | 2275 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2144 : packet), | 2276 ? packet_cid_be |
2145 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2277 : packet), |
| 2278 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2146 ? arraysize(packet_cid_be) | 2279 ? arraysize(packet_cid_be) |
2147 : arraysize(packet), | 2280 : arraysize(packet), |
2148 false); | 2281 false); |
2149 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2282 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2150 | 2283 |
2151 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2284 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2152 ASSERT_TRUE(visitor_.header_.get()); | 2285 ASSERT_TRUE(visitor_.header_.get()); |
2153 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2286 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2154 !kIncludeDiversificationNonce)); | 2287 !kIncludeDiversificationNonce)); |
2155 | 2288 |
2156 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | 2289 EXPECT_EQ(0u, visitor_.stream_frames_.size()); |
2157 ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size()); | 2290 ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size()); |
2158 const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0]; | 2291 const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0]; |
2159 EXPECT_EQ(kLeastUnacked, frame.least_unacked); | 2292 EXPECT_EQ(kLeastUnacked, frame.least_unacked); |
2160 | 2293 |
2161 const size_t frame_size = 7; | 2294 const size_t frame_size = 7; |
2162 for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) { | 2295 for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) { |
2163 string expected_error; | 2296 string expected_error; |
2164 expected_error = "Unable to read least unacked delta."; | 2297 expected_error = "Unable to read least unacked delta."; |
2165 CheckProcessingFails( | 2298 CheckProcessingFails( |
2166 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2299 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2167 : packet, | 2300 ? packet_cid_be |
| 2301 : packet, |
2168 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2302 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2169 !kIncludeVersion, !kIncludeDiversificationNonce, | 2303 !kIncludeVersion, !kIncludeDiversificationNonce, |
2170 PACKET_6BYTE_PACKET_NUMBER), | 2304 PACKET_6BYTE_PACKET_NUMBER), |
2171 expected_error, QUIC_INVALID_STOP_WAITING_DATA); | 2305 expected_error, QUIC_INVALID_STOP_WAITING_DATA); |
2172 } | 2306 } |
2173 } | 2307 } |
2174 | 2308 |
2175 TEST_P(QuicFramerTest, RstStreamFrameQuic) { | 2309 TEST_P(QuicFramerTest, RstStreamFrameQuic) { |
2176 // clang-format off | 2310 // clang-format off |
2177 unsigned char packet[] = { | 2311 unsigned char packet[] = { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2214 // sent byte offset | 2348 // sent byte offset |
2215 0x54, 0x76, 0x10, 0x32, | 2349 0x54, 0x76, 0x10, 0x32, |
2216 0xDC, 0xFE, 0x98, 0xBA, | 2350 0xDC, 0xFE, 0x98, 0xBA, |
2217 | 2351 |
2218 // error code | 2352 // error code |
2219 0x01, 0x00, 0x00, 0x00, | 2353 0x01, 0x00, 0x00, 0x00, |
2220 }; | 2354 }; |
2221 // clang-format on | 2355 // clang-format on |
2222 | 2356 |
2223 QuicEncryptedPacket encrypted( | 2357 QuicEncryptedPacket encrypted( |
2224 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2358 AsChars( |
2225 ? packet_cid_be | 2359 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2226 : packet), | 2360 ? packet_cid_be |
2227 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2361 : packet), |
| 2362 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2228 ? arraysize(packet_cid_be) | 2363 ? arraysize(packet_cid_be) |
2229 : arraysize(packet), | 2364 : arraysize(packet), |
2230 false); | 2365 false); |
2231 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2366 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2232 | 2367 |
2233 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2368 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2234 ASSERT_TRUE(visitor_.header_.get()); | 2369 ASSERT_TRUE(visitor_.header_.get()); |
2235 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2370 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2236 !kIncludeDiversificationNonce)); | 2371 !kIncludeDiversificationNonce)); |
2237 | 2372 |
2238 EXPECT_EQ(kStreamId, visitor_.rst_stream_frame_.stream_id); | 2373 EXPECT_EQ(kStreamId, visitor_.rst_stream_frame_.stream_id); |
2239 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code); | 2374 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code); |
2240 EXPECT_EQ(kStreamOffset, visitor_.rst_stream_frame_.byte_offset); | 2375 EXPECT_EQ(kStreamOffset, visitor_.rst_stream_frame_.byte_offset); |
2241 | 2376 |
2242 // Now test framing boundaries. | 2377 // Now test framing boundaries. |
2243 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetRstStreamFrameSize(); | 2378 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetRstStreamFrameSize(); |
2244 ++i) { | 2379 ++i) { |
2245 string expected_error; | 2380 string expected_error; |
2246 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { | 2381 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { |
2247 expected_error = "Unable to read stream_id."; | 2382 expected_error = "Unable to read stream_id."; |
2248 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + | 2383 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + |
2249 kQuicMaxStreamOffsetSize) { | 2384 kQuicMaxStreamOffsetSize) { |
2250 expected_error = "Unable to read rst stream sent byte offset."; | 2385 expected_error = "Unable to read rst stream sent byte offset."; |
2251 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + | 2386 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + |
2252 kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) { | 2387 kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) { |
2253 expected_error = "Unable to read rst stream error code."; | 2388 expected_error = "Unable to read rst stream error code."; |
2254 } | 2389 } |
2255 CheckProcessingFails( | 2390 CheckProcessingFails( |
2256 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2391 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2257 : packet, | 2392 ? packet_cid_be |
| 2393 : packet, |
2258 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2394 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2259 !kIncludeVersion, !kIncludeDiversificationNonce, | 2395 !kIncludeVersion, !kIncludeDiversificationNonce, |
2260 PACKET_6BYTE_PACKET_NUMBER), | 2396 PACKET_6BYTE_PACKET_NUMBER), |
2261 expected_error, QUIC_INVALID_RST_STREAM_DATA); | 2397 expected_error, QUIC_INVALID_RST_STREAM_DATA); |
2262 } | 2398 } |
2263 } | 2399 } |
2264 | 2400 |
2265 TEST_P(QuicFramerTest, ConnectionCloseFrame) { | 2401 TEST_P(QuicFramerTest, ConnectionCloseFrame) { |
2266 // clang-format off | 2402 // clang-format off |
2267 unsigned char packet[] = { | 2403 unsigned char packet[] = { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2306 0x0d, 0x00, | 2442 0x0d, 0x00, |
2307 // error details | 2443 // error details |
2308 'b', 'e', 'c', 'a', | 2444 'b', 'e', 'c', 'a', |
2309 'u', 's', 'e', ' ', | 2445 'u', 's', 'e', ' ', |
2310 'I', ' ', 'c', 'a', | 2446 'I', ' ', 'c', 'a', |
2311 'n', | 2447 'n', |
2312 }; | 2448 }; |
2313 // clang-format on | 2449 // clang-format on |
2314 | 2450 |
2315 QuicEncryptedPacket encrypted( | 2451 QuicEncryptedPacket encrypted( |
2316 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2452 AsChars( |
2317 ? packet_cid_be | 2453 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2318 : packet), | 2454 ? packet_cid_be |
2319 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2455 : packet), |
| 2456 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2320 ? arraysize(packet_cid_be) | 2457 ? arraysize(packet_cid_be) |
2321 : arraysize(packet), | 2458 : arraysize(packet), |
2322 false); | 2459 false); |
2323 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2460 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2324 | 2461 |
2325 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2462 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2326 ASSERT_TRUE(visitor_.header_.get()); | 2463 ASSERT_TRUE(visitor_.header_.get()); |
2327 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2464 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2328 !kIncludeDiversificationNonce)); | 2465 !kIncludeDiversificationNonce)); |
2329 | 2466 |
2330 EXPECT_EQ(0u, visitor_.stream_frames_.size()); | 2467 EXPECT_EQ(0u, visitor_.stream_frames_.size()); |
2331 | 2468 |
2332 EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code); | 2469 EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code); |
2333 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details); | 2470 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details); |
2334 | 2471 |
2335 ASSERT_EQ(0u, visitor_.ack_frames_.size()); | 2472 ASSERT_EQ(0u, visitor_.ack_frames_.size()); |
2336 | 2473 |
2337 // Now test framing boundaries. | 2474 // Now test framing boundaries. |
2338 for (size_t i = kQuicFrameTypeSize; | 2475 for (size_t i = kQuicFrameTypeSize; |
2339 i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) { | 2476 i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) { |
2340 string expected_error; | 2477 string expected_error; |
2341 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { | 2478 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { |
2342 expected_error = "Unable to read connection close error code."; | 2479 expected_error = "Unable to read connection close error code."; |
2343 } else { | 2480 } else { |
2344 expected_error = "Unable to read connection close error details."; | 2481 expected_error = "Unable to read connection close error details."; |
2345 } | 2482 } |
2346 CheckProcessingFails( | 2483 CheckProcessingFails( |
2347 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2484 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2348 : packet, | 2485 ? packet_cid_be |
| 2486 : packet, |
2349 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2487 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2350 !kIncludeVersion, !kIncludeDiversificationNonce, | 2488 !kIncludeVersion, !kIncludeDiversificationNonce, |
2351 PACKET_6BYTE_PACKET_NUMBER), | 2489 PACKET_6BYTE_PACKET_NUMBER), |
2352 expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA); | 2490 expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA); |
2353 } | 2491 } |
2354 } | 2492 } |
2355 | 2493 |
2356 TEST_P(QuicFramerTest, GoAwayFrame) { | 2494 TEST_P(QuicFramerTest, GoAwayFrame) { |
2357 // clang-format off | 2495 // clang-format off |
2358 unsigned char packet[] = { | 2496 unsigned char packet[] = { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2399 0x0d, 0x00, | 2537 0x0d, 0x00, |
2400 // error details | 2538 // error details |
2401 'b', 'e', 'c', 'a', | 2539 'b', 'e', 'c', 'a', |
2402 'u', 's', 'e', ' ', | 2540 'u', 's', 'e', ' ', |
2403 'I', ' ', 'c', 'a', | 2541 'I', ' ', 'c', 'a', |
2404 'n', | 2542 'n', |
2405 }; | 2543 }; |
2406 // clang-format on | 2544 // clang-format on |
2407 | 2545 |
2408 QuicEncryptedPacket encrypted( | 2546 QuicEncryptedPacket encrypted( |
2409 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2547 AsChars( |
2410 ? packet_cid_be | 2548 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2411 : packet), | 2549 ? packet_cid_be |
2412 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2550 : packet), |
| 2551 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2413 ? arraysize(packet_cid_be) | 2552 ? arraysize(packet_cid_be) |
2414 : arraysize(packet), | 2553 : arraysize(packet), |
2415 false); | 2554 false); |
2416 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2555 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2417 | 2556 |
2418 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2557 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2419 ASSERT_TRUE(visitor_.header_.get()); | 2558 ASSERT_TRUE(visitor_.header_.get()); |
2420 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2559 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2421 !kIncludeDiversificationNonce)); | 2560 !kIncludeDiversificationNonce)); |
2422 | 2561 |
2423 EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id); | 2562 EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id); |
2424 EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code); | 2563 EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code); |
2425 EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase); | 2564 EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase); |
2426 | 2565 |
2427 const size_t reason_size = arraysize("because I can") - 1; | 2566 const size_t reason_size = arraysize("because I can") - 1; |
2428 // Now test framing boundaries. | 2567 // Now test framing boundaries. |
2429 for (size_t i = kQuicFrameTypeSize; | 2568 for (size_t i = kQuicFrameTypeSize; |
2430 i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) { | 2569 i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) { |
2431 string expected_error; | 2570 string expected_error; |
2432 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { | 2571 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { |
2433 expected_error = "Unable to read go away error code."; | 2572 expected_error = "Unable to read go away error code."; |
2434 } else if (i < | 2573 } else if (i < |
2435 kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicMaxStreamIdSize) { | 2574 kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicMaxStreamIdSize) { |
2436 expected_error = "Unable to read last good stream id."; | 2575 expected_error = "Unable to read last good stream id."; |
2437 } else { | 2576 } else { |
2438 expected_error = "Unable to read goaway reason."; | 2577 expected_error = "Unable to read goaway reason."; |
2439 } | 2578 } |
2440 CheckProcessingFails( | 2579 CheckProcessingFails( |
2441 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2580 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2442 : packet, | 2581 ? packet_cid_be |
| 2582 : packet, |
2443 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2583 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2444 !kIncludeVersion, !kIncludeDiversificationNonce, | 2584 !kIncludeVersion, !kIncludeDiversificationNonce, |
2445 PACKET_6BYTE_PACKET_NUMBER), | 2585 PACKET_6BYTE_PACKET_NUMBER), |
2446 expected_error, QUIC_INVALID_GOAWAY_DATA); | 2586 expected_error, QUIC_INVALID_GOAWAY_DATA); |
2447 } | 2587 } |
2448 } | 2588 } |
2449 | 2589 |
2450 TEST_P(QuicFramerTest, WindowUpdateFrame) { | 2590 TEST_P(QuicFramerTest, WindowUpdateFrame) { |
2451 // clang-format off | 2591 // clang-format off |
2452 unsigned char packet[] = { | 2592 unsigned char packet[] = { |
(...skipping 28 matching lines...) Expand all Loading... |
2481 0x04, | 2621 0x04, |
2482 // stream id | 2622 // stream id |
2483 0x04, 0x03, 0x02, 0x01, | 2623 0x04, 0x03, 0x02, 0x01, |
2484 // byte offset | 2624 // byte offset |
2485 0x54, 0x76, 0x10, 0x32, | 2625 0x54, 0x76, 0x10, 0x32, |
2486 0xDC, 0xFE, 0x98, 0xBA, | 2626 0xDC, 0xFE, 0x98, 0xBA, |
2487 }; | 2627 }; |
2488 // clang-format on | 2628 // clang-format on |
2489 | 2629 |
2490 QuicEncryptedPacket encrypted( | 2630 QuicEncryptedPacket encrypted( |
2491 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2631 AsChars( |
2492 ? packet_cid_be | 2632 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2493 : packet), | 2633 ? packet_cid_be |
2494 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2634 : packet), |
| 2635 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2495 ? arraysize(packet_cid_be) | 2636 ? arraysize(packet_cid_be) |
2496 : arraysize(packet), | 2637 : arraysize(packet), |
2497 false); | 2638 false); |
2498 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2639 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2499 | 2640 |
2500 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2641 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2501 ASSERT_TRUE(visitor_.header_.get()); | 2642 ASSERT_TRUE(visitor_.header_.get()); |
2502 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2643 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2503 !kIncludeDiversificationNonce)); | 2644 !kIncludeDiversificationNonce)); |
2504 | 2645 |
2505 EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id); | 2646 EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id); |
2506 EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.byte_offset); | 2647 EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.byte_offset); |
2507 | 2648 |
2508 // Now test framing boundaries. | 2649 // Now test framing boundaries. |
2509 for (size_t i = kQuicFrameTypeSize; | 2650 for (size_t i = kQuicFrameTypeSize; |
2510 i < QuicFramer::GetWindowUpdateFrameSize(); ++i) { | 2651 i < QuicFramer::GetWindowUpdateFrameSize(); ++i) { |
2511 string expected_error; | 2652 string expected_error; |
2512 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { | 2653 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { |
2513 expected_error = "Unable to read stream_id."; | 2654 expected_error = "Unable to read stream_id."; |
2514 } else { | 2655 } else { |
2515 expected_error = "Unable to read window byte_offset."; | 2656 expected_error = "Unable to read window byte_offset."; |
2516 } | 2657 } |
2517 CheckProcessingFails( | 2658 CheckProcessingFails( |
2518 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2659 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2519 : packet, | 2660 ? packet_cid_be |
| 2661 : packet, |
2520 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2662 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2521 !kIncludeVersion, !kIncludeDiversificationNonce, | 2663 !kIncludeVersion, !kIncludeDiversificationNonce, |
2522 PACKET_6BYTE_PACKET_NUMBER), | 2664 PACKET_6BYTE_PACKET_NUMBER), |
2523 expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA); | 2665 expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA); |
2524 } | 2666 } |
2525 } | 2667 } |
2526 | 2668 |
2527 TEST_P(QuicFramerTest, BlockedFrame) { | 2669 TEST_P(QuicFramerTest, BlockedFrame) { |
2528 // clang-format off | 2670 // clang-format off |
2529 unsigned char packet[] = { | 2671 unsigned char packet[] = { |
(...skipping 22 matching lines...) Expand all Loading... |
2552 0x34, 0x12, | 2694 0x34, 0x12, |
2553 | 2695 |
2554 // frame type (blocked frame) | 2696 // frame type (blocked frame) |
2555 0x05, | 2697 0x05, |
2556 // stream id | 2698 // stream id |
2557 0x04, 0x03, 0x02, 0x01, | 2699 0x04, 0x03, 0x02, 0x01, |
2558 }; | 2700 }; |
2559 // clang-format on | 2701 // clang-format on |
2560 | 2702 |
2561 QuicEncryptedPacket encrypted( | 2703 QuicEncryptedPacket encrypted( |
2562 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2704 AsChars( |
2563 ? packet_cid_be | 2705 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2564 : packet), | 2706 ? packet_cid_be |
2565 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2707 : packet), |
| 2708 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2566 ? arraysize(packet_cid_be) | 2709 ? arraysize(packet_cid_be) |
2567 : arraysize(packet), | 2710 : arraysize(packet), |
2568 false); | 2711 false); |
2569 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2712 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2570 | 2713 |
2571 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2714 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2572 ASSERT_TRUE(visitor_.header_.get()); | 2715 ASSERT_TRUE(visitor_.header_.get()); |
2573 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2716 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2574 !kIncludeDiversificationNonce)); | 2717 !kIncludeDiversificationNonce)); |
2575 | 2718 |
2576 EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id); | 2719 EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id); |
2577 | 2720 |
2578 // Now test framing boundaries. | 2721 // Now test framing boundaries. |
2579 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize(); | 2722 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize(); |
2580 ++i) { | 2723 ++i) { |
2581 string expected_error = "Unable to read stream_id."; | 2724 string expected_error = "Unable to read stream_id."; |
2582 CheckProcessingFails( | 2725 CheckProcessingFails( |
2583 FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 2726 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2584 : packet, | 2727 ? packet_cid_be |
| 2728 : packet, |
2585 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, | 2729 i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID, |
2586 !kIncludeVersion, !kIncludeDiversificationNonce, | 2730 !kIncludeVersion, !kIncludeDiversificationNonce, |
2587 PACKET_6BYTE_PACKET_NUMBER), | 2731 PACKET_6BYTE_PACKET_NUMBER), |
2588 expected_error, QUIC_INVALID_BLOCKED_DATA); | 2732 expected_error, QUIC_INVALID_BLOCKED_DATA); |
2589 } | 2733 } |
2590 } | 2734 } |
2591 | 2735 |
2592 TEST_P(QuicFramerTest, PingFrame) { | 2736 TEST_P(QuicFramerTest, PingFrame) { |
2593 // clang-format off | 2737 // clang-format off |
2594 unsigned char packet[] = { | 2738 unsigned char packet[] = { |
(...skipping 18 matching lines...) Expand all Loading... |
2613 // packet number | 2757 // packet number |
2614 0xBC, 0x9A, 0x78, 0x56, | 2758 0xBC, 0x9A, 0x78, 0x56, |
2615 0x34, 0x12, | 2759 0x34, 0x12, |
2616 | 2760 |
2617 // frame type (ping frame) | 2761 // frame type (ping frame) |
2618 0x07, | 2762 0x07, |
2619 }; | 2763 }; |
2620 // clang-format on | 2764 // clang-format on |
2621 | 2765 |
2622 QuicEncryptedPacket encrypted( | 2766 QuicEncryptedPacket encrypted( |
2623 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2767 AsChars( |
2624 ? packet_cid_be | 2768 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2625 : packet), | 2769 ? packet_cid_be |
2626 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2770 : packet), |
| 2771 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2627 ? arraysize(packet_cid_be) | 2772 ? arraysize(packet_cid_be) |
2628 : arraysize(packet), | 2773 : arraysize(packet), |
2629 false); | 2774 false); |
2630 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2775 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2631 | 2776 |
2632 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 2777 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
2633 ASSERT_TRUE(visitor_.header_.get()); | 2778 ASSERT_TRUE(visitor_.header_.get()); |
2634 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, | 2779 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, |
2635 !kIncludeDiversificationNonce)); | 2780 !kIncludeDiversificationNonce)); |
2636 | 2781 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2687 // nonce proof | 2832 // nonce proof |
2688 0x89, 0x67, 0x45, 0x23, | 2833 0x89, 0x67, 0x45, 0x23, |
2689 0x01, 0xEF, 0xCD, 0xAB, | 2834 0x01, 0xEF, 0xCD, 0xAB, |
2690 // rejected packet number | 2835 // rejected packet number |
2691 0xBC, 0x9A, 0x78, 0x56, | 2836 0xBC, 0x9A, 0x78, 0x56, |
2692 0x34, 0x12, 0x00, 0x00, | 2837 0x34, 0x12, 0x00, 0x00, |
2693 }; | 2838 }; |
2694 // clang-format on | 2839 // clang-format on |
2695 | 2840 |
2696 QuicEncryptedPacket encrypted( | 2841 QuicEncryptedPacket encrypted( |
2697 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2842 AsChars( |
2698 ? packet_cid_be | 2843 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2699 : packet), | 2844 ? packet_cid_be |
2700 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2845 : packet), |
| 2846 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2701 ? arraysize(packet_cid_be) | 2847 ? arraysize(packet_cid_be) |
2702 : arraysize(packet), | 2848 : arraysize(packet), |
2703 false); | 2849 false); |
2704 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2850 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2705 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); | 2851 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); |
2706 ASSERT_TRUE(visitor_.public_reset_packet_.get()); | 2852 ASSERT_TRUE(visitor_.public_reset_packet_.get()); |
2707 EXPECT_EQ(kConnectionId, | 2853 EXPECT_EQ(kConnectionId, |
2708 visitor_.public_reset_packet_->public_header.connection_id); | 2854 visitor_.public_reset_packet_->public_header.connection_id); |
2709 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); | 2855 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); |
2710 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); | 2856 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); |
2711 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); | 2857 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); |
2712 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); | 2858 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); |
2713 EXPECT_EQ( | 2859 EXPECT_EQ( |
2714 IpAddressFamily::IP_UNSPEC, | 2860 IpAddressFamily::IP_UNSPEC, |
2715 visitor_.public_reset_packet_->client_address.host().address_family()); | 2861 visitor_.public_reset_packet_->client_address.host().address_family()); |
2716 | 2862 |
2717 // Now test framing boundaries. | 2863 // Now test framing boundaries. |
2718 if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) { | 2864 if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) { |
2719 for (size_t i = 0; i < arraysize(packet); ++i) { | 2865 for (size_t i = 0; i < arraysize(packet); ++i) { |
2720 string expected_error; | 2866 string expected_error; |
2721 QUIC_DLOG(INFO) << "iteration: " << i; | 2867 QUIC_DLOG(INFO) << "iteration: " << i; |
2722 if (i < kConnectionIdOffset) { | 2868 if (i < kConnectionIdOffset) { |
2723 expected_error = "Unable to read public flags."; | 2869 expected_error = "Unable to read public flags."; |
2724 CheckProcessingFails(packet, i, expected_error, | 2870 CheckProcessingFails(packet, i, expected_error, |
2725 QUIC_INVALID_PACKET_HEADER); | 2871 QUIC_INVALID_PACKET_HEADER); |
2726 } else if (i < kPublicResetPacketMessageTagOffset) { | 2872 } else if (i < kPublicResetPacketMessageTagOffset) { |
2727 expected_error = "Unable to read ConnectionId."; | 2873 expected_error = "Unable to read ConnectionId."; |
2728 CheckProcessingFails(packet, i, expected_error, | 2874 CheckProcessingFails(packet, i, expected_error, |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2805 // nonce proof | 2951 // nonce proof |
2806 0x89, 0x67, 0x45, 0x23, | 2952 0x89, 0x67, 0x45, 0x23, |
2807 0x01, 0xEF, 0xCD, 0xAB, | 2953 0x01, 0xEF, 0xCD, 0xAB, |
2808 // rejected packet number | 2954 // rejected packet number |
2809 0xBC, 0x9A, 0x78, 0x56, | 2955 0xBC, 0x9A, 0x78, 0x56, |
2810 0x34, 0x12, 0x00, 0x00, | 2956 0x34, 0x12, 0x00, 0x00, |
2811 }; | 2957 }; |
2812 // clang-format on | 2958 // clang-format on |
2813 | 2959 |
2814 QuicEncryptedPacket encrypted( | 2960 QuicEncryptedPacket encrypted( |
2815 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2961 AsChars( |
2816 ? packet_cid_be | 2962 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2817 : packet), | 2963 ? packet_cid_be |
2818 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 2964 : packet), |
| 2965 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2819 ? arraysize(packet_cid_be) | 2966 ? arraysize(packet_cid_be) |
2820 : arraysize(packet), | 2967 : arraysize(packet), |
2821 false); | 2968 false); |
2822 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 2969 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
2823 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); | 2970 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); |
2824 ASSERT_TRUE(visitor_.public_reset_packet_.get()); | 2971 ASSERT_TRUE(visitor_.public_reset_packet_.get()); |
2825 EXPECT_EQ(kConnectionId, | 2972 EXPECT_EQ(kConnectionId, |
2826 visitor_.public_reset_packet_->public_header.connection_id); | 2973 visitor_.public_reset_packet_->public_header.connection_id); |
2827 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); | 2974 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); |
2828 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); | 2975 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); |
2829 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); | 2976 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); |
2830 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); | 2977 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); |
2831 EXPECT_EQ( | 2978 EXPECT_EQ( |
2832 IpAddressFamily::IP_UNSPEC, | 2979 IpAddressFamily::IP_UNSPEC, |
2833 visitor_.public_reset_packet_->client_address.host().address_family()); | 2980 visitor_.public_reset_packet_->client_address.host().address_family()); |
2834 | 2981 |
2835 // Now test framing boundaries. | 2982 // Now test framing boundaries. |
2836 if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) { | 2983 if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) { |
2837 for (size_t i = 0; i < arraysize(packet); ++i) { | 2984 for (size_t i = 0; i < arraysize(packet); ++i) { |
2838 string expected_error; | 2985 string expected_error; |
2839 QUIC_DLOG(INFO) << "iteration: " << i; | 2986 QUIC_DLOG(INFO) << "iteration: " << i; |
2840 if (i < kConnectionIdOffset) { | 2987 if (i < kConnectionIdOffset) { |
2841 expected_error = "Unable to read public flags."; | 2988 expected_error = "Unable to read public flags."; |
2842 CheckProcessingFails(packet, i, expected_error, | 2989 CheckProcessingFails(packet, i, expected_error, |
2843 QUIC_INVALID_PACKET_HEADER); | 2990 QUIC_INVALID_PACKET_HEADER); |
2844 } else if (i < kPublicResetPacketMessageTagOffset) { | 2991 } else if (i < kPublicResetPacketMessageTagOffset) { |
2845 expected_error = "Unable to read ConnectionId."; | 2992 expected_error = "Unable to read ConnectionId."; |
2846 CheckProcessingFails(packet, i, expected_error, | 2993 CheckProcessingFails(packet, i, expected_error, |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2925 0x01, 0xEF, 0xCD, 0xAB, | 3072 0x01, 0xEF, 0xCD, 0xAB, |
2926 // rejected packet number | 3073 // rejected packet number |
2927 0xBC, 0x9A, 0x78, 0x56, | 3074 0xBC, 0x9A, 0x78, 0x56, |
2928 0x34, 0x12, 0x00, 0x00, | 3075 0x34, 0x12, 0x00, 0x00, |
2929 // trailing junk | 3076 // trailing junk |
2930 'j', 'u', 'n', 'k', | 3077 'j', 'u', 'n', 'k', |
2931 }; | 3078 }; |
2932 // clang-format on | 3079 // clang-format on |
2933 | 3080 |
2934 string expected_error = "Unable to read reset message."; | 3081 string expected_error = "Unable to read reset message."; |
2935 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3082 CheckProcessingFails( |
2936 ? packet_cid_be | 3083 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2937 : packet, | 3084 ? packet_cid_be |
2938 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3085 : packet, |
2939 ? arraysize(packet_cid_be) | 3086 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
2940 : arraysize(packet), | 3087 ? arraysize(packet_cid_be) |
2941 expected_error, QUIC_INVALID_PUBLIC_RST_PACKET); | 3088 : arraysize(packet), |
| 3089 expected_error, QUIC_INVALID_PUBLIC_RST_PACKET); |
2942 } | 3090 } |
2943 | 3091 |
2944 TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) { | 3092 TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) { |
2945 // clang-format off | 3093 // clang-format off |
2946 unsigned char packet[] = { | 3094 unsigned char packet[] = { |
2947 // public flags (public reset, 8 byte connection_id) | 3095 // public flags (public reset, 8 byte connection_id) |
2948 0x0A, | 3096 0x0A, |
2949 // connection_id | 3097 // connection_id |
2950 0x10, 0x32, 0x54, 0x76, | 3098 0x10, 0x32, 0x54, 0x76, |
2951 0x98, 0xBA, 0xDC, 0xFE, | 3099 0x98, 0xBA, 0xDC, 0xFE, |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3005 0xBC, 0x9A, 0x78, 0x56, | 3153 0xBC, 0x9A, 0x78, 0x56, |
3006 0x34, 0x12, 0x00, 0x00, | 3154 0x34, 0x12, 0x00, 0x00, |
3007 // client address: 4.31.198.44:443 | 3155 // client address: 4.31.198.44:443 |
3008 0x02, 0x00, | 3156 0x02, 0x00, |
3009 0x04, 0x1F, 0xC6, 0x2C, | 3157 0x04, 0x1F, 0xC6, 0x2C, |
3010 0xBB, 0x01, | 3158 0xBB, 0x01, |
3011 }; | 3159 }; |
3012 // clang-format on | 3160 // clang-format on |
3013 | 3161 |
3014 QuicEncryptedPacket encrypted( | 3162 QuicEncryptedPacket encrypted( |
3015 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3163 AsChars( |
3016 ? packet_cid_be | 3164 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3017 : packet), | 3165 ? packet_cid_be |
3018 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3166 : packet), |
| 3167 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3019 ? arraysize(packet_cid_be) | 3168 ? arraysize(packet_cid_be) |
3020 : arraysize(packet), | 3169 : arraysize(packet), |
3021 false); | 3170 false); |
3022 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 3171 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
3023 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); | 3172 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); |
3024 ASSERT_TRUE(visitor_.public_reset_packet_.get()); | 3173 ASSERT_TRUE(visitor_.public_reset_packet_.get()); |
3025 EXPECT_EQ(kConnectionId, | 3174 EXPECT_EQ(kConnectionId, |
3026 visitor_.public_reset_packet_->public_header.connection_id); | 3175 visitor_.public_reset_packet_->public_header.connection_id); |
3027 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); | 3176 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); |
3028 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); | 3177 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); |
3029 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); | 3178 EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof); |
3030 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); | 3179 EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number); |
3031 EXPECT_EQ("4.31.198.44", | 3180 EXPECT_EQ("4.31.198.44", |
3032 visitor_.public_reset_packet_->client_address.host().ToString()); | 3181 visitor_.public_reset_packet_->client_address.host().ToString()); |
3033 EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port()); | 3182 EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port()); |
3034 | 3183 |
3035 // Now test framing boundaries. | 3184 // Now test framing boundaries. |
3036 if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) { | 3185 if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) { |
3037 for (size_t i = 0; i < arraysize(packet); ++i) { | 3186 for (size_t i = 0; i < arraysize(packet); ++i) { |
3038 string expected_error; | 3187 string expected_error; |
3039 QUIC_DLOG(INFO) << "iteration: " << i; | 3188 QUIC_DLOG(INFO) << "iteration: " << i; |
3040 if (i < kConnectionIdOffset) { | 3189 if (i < kConnectionIdOffset) { |
3041 expected_error = "Unable to read public flags."; | 3190 expected_error = "Unable to read public flags."; |
3042 CheckProcessingFails(packet, i, expected_error, | 3191 CheckProcessingFails(packet, i, expected_error, |
3043 QUIC_INVALID_PACKET_HEADER); | 3192 QUIC_INVALID_PACKET_HEADER); |
3044 } else if (i < kPublicResetPacketMessageTagOffset) { | 3193 } else if (i < kPublicResetPacketMessageTagOffset) { |
3045 expected_error = "Unable to read ConnectionId."; | 3194 expected_error = "Unable to read ConnectionId."; |
3046 CheckProcessingFails(packet, i, expected_error, | 3195 CheckProcessingFails(packet, i, expected_error, |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3093 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 3242 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
3094 // version tag | 3243 // version tag |
3095 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), | 3244 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), |
3096 'Q', '2', '.', '0', | 3245 'Q', '2', '.', '0', |
3097 }; | 3246 }; |
3098 // clang-format on | 3247 // clang-format on |
3099 | 3248 |
3100 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); | 3249 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); |
3101 | 3250 |
3102 QuicEncryptedPacket encrypted( | 3251 QuicEncryptedPacket encrypted( |
3103 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3252 AsChars( |
3104 ? packet_cid_be | 3253 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3105 : packet), | 3254 ? packet_cid_be |
3106 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3255 : packet), |
| 3256 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3107 ? arraysize(packet_cid_be) | 3257 ? arraysize(packet_cid_be) |
3108 : arraysize(packet), | 3258 : arraysize(packet), |
3109 false); | 3259 false); |
3110 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 3260 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
3111 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); | 3261 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); |
3112 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); | 3262 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); |
3113 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); | 3263 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); |
3114 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]); | 3264 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]); |
3115 | 3265 |
3116 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) { | 3266 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) { |
3117 string expected_error; | 3267 string expected_error; |
3118 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; | 3268 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; |
3119 if (i < kConnectionIdOffset) { | 3269 if (i < kConnectionIdOffset) { |
3120 expected_error = "Unable to read public flags."; | 3270 expected_error = "Unable to read public flags."; |
3121 } else if (i < kVersionOffset) { | 3271 } else if (i < kVersionOffset) { |
3122 expected_error = "Unable to read ConnectionId."; | 3272 expected_error = "Unable to read ConnectionId."; |
3123 } else { | 3273 } else { |
3124 expected_error = "Unable to read supported version in negotiation."; | 3274 expected_error = "Unable to read supported version in negotiation."; |
3125 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; | 3275 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; |
3126 } | 3276 } |
3127 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3277 CheckProcessingFails( |
3128 ? packet_cid_be | 3278 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3129 : packet, | 3279 ? packet_cid_be |
3130 i, expected_error, error_code); | 3280 : packet, |
| 3281 i, expected_error, error_code); |
3131 } | 3282 } |
3132 } | 3283 } |
3133 | 3284 |
3134 TEST_P(QuicFramerTest, OldVersionNegotiationPacket) { | 3285 TEST_P(QuicFramerTest, OldVersionNegotiationPacket) { |
3135 // clang-format off | 3286 // clang-format off |
3136 unsigned char packet[] = { | 3287 unsigned char packet[] = { |
3137 // public flags (version, 8 byte connection_id) | 3288 // public flags (version, 8 byte connection_id) |
3138 0x3D, | 3289 0x3D, |
3139 // connection_id | 3290 // connection_id |
3140 0x10, 0x32, 0x54, 0x76, | 3291 0x10, 0x32, 0x54, 0x76, |
(...skipping 10 matching lines...) Expand all Loading... |
3151 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, | 3302 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
3152 // version tag | 3303 // version tag |
3153 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), | 3304 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), |
3154 'Q', '2', '.', '0', | 3305 'Q', '2', '.', '0', |
3155 }; | 3306 }; |
3156 // clang-format on | 3307 // clang-format on |
3157 | 3308 |
3158 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); | 3309 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); |
3159 | 3310 |
3160 QuicEncryptedPacket encrypted( | 3311 QuicEncryptedPacket encrypted( |
3161 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3312 AsChars( |
3162 ? packet_cid_be | 3313 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3163 : packet), | 3314 ? packet_cid_be |
3164 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3315 : packet), |
| 3316 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3165 ? arraysize(packet_cid_be) | 3317 ? arraysize(packet_cid_be) |
3166 : arraysize(packet), | 3318 : arraysize(packet), |
3167 false); | 3319 false); |
3168 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 3320 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
3169 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); | 3321 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); |
3170 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); | 3322 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); |
3171 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); | 3323 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); |
3172 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]); | 3324 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]); |
3173 | 3325 |
3174 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) { | 3326 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) { |
3175 string expected_error; | 3327 string expected_error; |
3176 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; | 3328 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; |
3177 if (i < kConnectionIdOffset) { | 3329 if (i < kConnectionIdOffset) { |
3178 expected_error = "Unable to read public flags."; | 3330 expected_error = "Unable to read public flags."; |
3179 } else if (i < kVersionOffset) { | 3331 } else if (i < kVersionOffset) { |
3180 expected_error = "Unable to read ConnectionId."; | 3332 expected_error = "Unable to read ConnectionId."; |
3181 } else { | 3333 } else { |
3182 expected_error = "Unable to read supported version in negotiation."; | 3334 expected_error = "Unable to read supported version in negotiation."; |
3183 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; | 3335 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; |
3184 } | 3336 } |
3185 CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3337 CheckProcessingFails( |
3186 ? packet_cid_be | 3338 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3187 : packet, | 3339 ? packet_cid_be |
3188 i, expected_error, error_code); | 3340 : packet, |
| 3341 i, expected_error, error_code); |
3189 } | 3342 } |
3190 } | 3343 } |
3191 | 3344 |
3192 TEST_P(QuicFramerTest, BuildPaddingFramePacket) { | 3345 TEST_P(QuicFramerTest, BuildPaddingFramePacket) { |
3193 QuicPacketHeader header; | 3346 QuicPacketHeader header; |
3194 header.public_header.connection_id = kConnectionId; | 3347 header.public_header.connection_id = kConnectionId; |
3195 header.public_header.reset_flag = false; | 3348 header.public_header.reset_flag = false; |
3196 header.public_header.version_flag = false; | 3349 header.public_header.version_flag = false; |
3197 header.packet_number = kPacketNumber; | 3350 header.packet_number = kPacketNumber; |
3198 | 3351 |
(...skipping 26 matching lines...) Expand all Loading... |
3225 | 3378 |
3226 // frame type (padding frame) | 3379 // frame type (padding frame) |
3227 0x00, | 3380 0x00, |
3228 0x00, 0x00, 0x00, 0x00 | 3381 0x00, 0x00, 0x00, 0x00 |
3229 }; | 3382 }; |
3230 // clang-format on | 3383 // clang-format on |
3231 | 3384 |
3232 uint64_t header_size = GetPacketHeaderSize( | 3385 uint64_t header_size = GetPacketHeaderSize( |
3233 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 3386 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
3234 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER); | 3387 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER); |
3235 memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 3388 memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3236 : packet) + | 3389 ? packet_cid_be |
| 3390 : packet) + |
3237 header_size + 1, | 3391 header_size + 1, |
3238 0x00, kMaxPacketSize - header_size - 1); | 3392 0x00, kMaxPacketSize - header_size - 1); |
3239 | 3393 |
3240 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3394 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3241 ASSERT_TRUE(data != nullptr); | 3395 ASSERT_TRUE(data != nullptr); |
3242 | 3396 |
3243 test::CompareCharArraysWithHexError( | 3397 test::CompareCharArraysWithHexError( |
3244 "constructed packet", data->data(), data->length(), | 3398 "constructed packet", data->data(), data->length(), |
3245 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3399 AsChars( |
3246 ? packet_cid_be | 3400 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3247 : packet), | 3401 ? packet_cid_be |
3248 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3402 : packet), |
| 3403 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3249 ? arraysize(packet_cid_be) | 3404 ? arraysize(packet_cid_be) |
3250 : arraysize(packet)); | 3405 : arraysize(packet)); |
3251 } | 3406 } |
| 3407 |
| 3408 TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) { |
| 3409 if (framer_.version() <= QUIC_VERSION_37) { |
| 3410 return; |
| 3411 } |
| 3412 QuicPacketHeader header; |
| 3413 header.public_header.connection_id = kConnectionId; |
| 3414 header.public_header.reset_flag = false; |
| 3415 header.public_header.version_flag = false; |
| 3416 header.packet_number = kPacketNumber; |
| 3417 |
| 3418 QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset, |
| 3419 QuicStringPiece("hello world!")); |
| 3420 QuicPaddingFrame padding_frame(2); |
| 3421 QuicFrames frames = {QuicFrame(padding_frame), QuicFrame(&stream_frame), |
| 3422 QuicFrame(padding_frame)}; |
| 3423 |
| 3424 // clang-format off |
| 3425 unsigned char packet[] = { |
| 3426 // public flags (8 byte connection_id) |
| 3427 0x38, |
| 3428 // connection_id |
| 3429 0x10, 0x32, 0x54, 0x76, |
| 3430 0x98, 0xBA, 0xDC, 0xFE, |
| 3431 // packet number |
| 3432 0xBC, 0x9A, 0x78, 0x56, |
| 3433 0x34, 0x12, |
| 3434 |
| 3435 // paddings |
| 3436 0x00, 0x00, |
| 3437 // frame type (stream frame with fin) |
| 3438 0xFF, |
| 3439 // stream id |
| 3440 0x04, 0x03, 0x02, 0x01, |
| 3441 // offset |
| 3442 0x54, 0x76, 0x10, 0x32, |
| 3443 0xDC, 0xFE, 0x98, 0xBA, |
| 3444 // data length |
| 3445 0x0c, 0x00, |
| 3446 // data |
| 3447 'h', 'e', 'l', 'l', |
| 3448 'o', ' ', 'w', 'o', |
| 3449 'r', 'l', 'd', '!', |
| 3450 // paddings |
| 3451 0x00, 0x00, |
| 3452 }; |
| 3453 |
| 3454 unsigned char packet_cid_be[] = { |
| 3455 // public flags (8 byte connection_id) |
| 3456 0x38, |
| 3457 // connection_id |
| 3458 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, |
| 3459 // packet number |
| 3460 0xBC, 0x9A, 0x78, 0x56, |
| 3461 0x34, 0x12, |
| 3462 |
| 3463 // paddings |
| 3464 0x00, 0x00, |
| 3465 // frame type (stream frame with fin) |
| 3466 0xFF, |
| 3467 // stream id |
| 3468 0x04, 0x03, 0x02, 0x01, |
| 3469 // offset |
| 3470 0x54, 0x76, 0x10, 0x32, |
| 3471 0xDC, 0xFE, 0x98, 0xBA, |
| 3472 // data length |
| 3473 0x0c, 0x00, |
| 3474 // data |
| 3475 'h', 'e', 'l', 'l', |
| 3476 'o', ' ', 'w', 'o', |
| 3477 'r', 'l', 'd', '!', |
| 3478 // paddings |
| 3479 0x00, 0x00, |
| 3480 }; |
| 3481 // clang-format on |
| 3482 |
| 3483 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
| 3484 ASSERT_TRUE(data != nullptr); |
| 3485 |
| 3486 test::CompareCharArraysWithHexError( |
| 3487 "constructed packet", data->data(), data->length(), |
| 3488 AsChars( |
| 3489 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
| 3490 ? packet_cid_be |
| 3491 : packet), |
| 3492 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
| 3493 ? arraysize(packet_cid_be) |
| 3494 : arraysize(packet)); |
| 3495 } |
3252 | 3496 |
3253 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { | 3497 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { |
3254 QuicPacketHeader header; | 3498 QuicPacketHeader header; |
3255 header.public_header.connection_id = kConnectionId; | 3499 header.public_header.connection_id = kConnectionId; |
3256 header.public_header.reset_flag = false; | 3500 header.public_header.reset_flag = false; |
3257 header.public_header.version_flag = false; | 3501 header.public_header.version_flag = false; |
3258 header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER; | 3502 header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER; |
3259 header.packet_number = kPacketNumber; | 3503 header.packet_number = kPacketNumber; |
3260 | 3504 |
3261 QuicFrames frames = {QuicFrame(QuicPaddingFrame())}; | 3505 QuicFrames frames = {QuicFrame(QuicPaddingFrame())}; |
(...skipping 23 matching lines...) Expand all Loading... |
3285 | 3529 |
3286 // frame type (padding frame) | 3530 // frame type (padding frame) |
3287 0x00, | 3531 0x00, |
3288 0x00, 0x00, 0x00, 0x00 | 3532 0x00, 0x00, 0x00, 0x00 |
3289 }; | 3533 }; |
3290 // clang-format on | 3534 // clang-format on |
3291 | 3535 |
3292 uint64_t header_size = GetPacketHeaderSize( | 3536 uint64_t header_size = GetPacketHeaderSize( |
3293 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 3537 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
3294 !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER); | 3538 !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER); |
3295 memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 3539 memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3296 : packet) + | 3540 ? packet_cid_be |
| 3541 : packet) + |
3297 header_size + 1, | 3542 header_size + 1, |
3298 0x00, kMaxPacketSize - header_size - 1); | 3543 0x00, kMaxPacketSize - header_size - 1); |
3299 | 3544 |
3300 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3545 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3301 ASSERT_TRUE(data != nullptr); | 3546 ASSERT_TRUE(data != nullptr); |
3302 | 3547 |
3303 test::CompareCharArraysWithHexError( | 3548 test::CompareCharArraysWithHexError( |
3304 "constructed packet", data->data(), data->length(), | 3549 "constructed packet", data->data(), data->length(), |
3305 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3550 AsChars( |
3306 ? packet_cid_be | 3551 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3307 : packet), | 3552 ? packet_cid_be |
3308 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3553 : packet), |
| 3554 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3309 ? arraysize(packet_cid_be) | 3555 ? arraysize(packet_cid_be) |
3310 : arraysize(packet)); | 3556 : arraysize(packet)); |
3311 } | 3557 } |
3312 | 3558 |
3313 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) { | 3559 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) { |
3314 QuicPacketHeader header; | 3560 QuicPacketHeader header; |
3315 header.public_header.connection_id = kConnectionId; | 3561 header.public_header.connection_id = kConnectionId; |
3316 header.public_header.reset_flag = false; | 3562 header.public_header.reset_flag = false; |
3317 header.public_header.version_flag = false; | 3563 header.public_header.version_flag = false; |
3318 header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER; | 3564 header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER; |
(...skipping 26 matching lines...) Expand all Loading... |
3345 | 3591 |
3346 // frame type (padding frame) | 3592 // frame type (padding frame) |
3347 0x00, | 3593 0x00, |
3348 0x00, 0x00, 0x00, 0x00 | 3594 0x00, 0x00, 0x00, 0x00 |
3349 }; | 3595 }; |
3350 // clang-format on | 3596 // clang-format on |
3351 | 3597 |
3352 uint64_t header_size = GetPacketHeaderSize( | 3598 uint64_t header_size = GetPacketHeaderSize( |
3353 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 3599 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
3354 !kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER); | 3600 !kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER); |
3355 memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 3601 memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3356 : packet) + | 3602 ? packet_cid_be |
| 3603 : packet) + |
3357 header_size + 1, | 3604 header_size + 1, |
3358 0x00, kMaxPacketSize - header_size - 1); | 3605 0x00, kMaxPacketSize - header_size - 1); |
3359 | 3606 |
3360 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3607 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3361 ASSERT_TRUE(data != nullptr); | 3608 ASSERT_TRUE(data != nullptr); |
3362 | 3609 |
3363 test::CompareCharArraysWithHexError( | 3610 test::CompareCharArraysWithHexError( |
3364 "constructed packet", data->data(), data->length(), | 3611 "constructed packet", data->data(), data->length(), |
3365 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3612 AsChars( |
3366 ? packet_cid_be | 3613 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3367 : packet), | 3614 ? packet_cid_be |
3368 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3615 : packet), |
| 3616 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3369 ? arraysize(packet_cid_be) | 3617 ? arraysize(packet_cid_be) |
3370 : arraysize(packet)); | 3618 : arraysize(packet)); |
3371 } | 3619 } |
3372 | 3620 |
3373 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) { | 3621 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) { |
3374 QuicPacketHeader header; | 3622 QuicPacketHeader header; |
3375 header.public_header.connection_id = kConnectionId; | 3623 header.public_header.connection_id = kConnectionId; |
3376 header.public_header.reset_flag = false; | 3624 header.public_header.reset_flag = false; |
3377 header.public_header.version_flag = false; | 3625 header.public_header.version_flag = false; |
3378 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER; | 3626 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER; |
(...skipping 26 matching lines...) Expand all Loading... |
3405 | 3653 |
3406 // frame type (padding frame) | 3654 // frame type (padding frame) |
3407 0x00, | 3655 0x00, |
3408 0x00, 0x00, 0x00, 0x00 | 3656 0x00, 0x00, 0x00, 0x00 |
3409 }; | 3657 }; |
3410 // clang-format on | 3658 // clang-format on |
3411 | 3659 |
3412 uint64_t header_size = GetPacketHeaderSize( | 3660 uint64_t header_size = GetPacketHeaderSize( |
3413 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 3661 framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
3414 !kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER); | 3662 !kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER); |
3415 memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be | 3663 memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3416 : packet) + | 3664 ? packet_cid_be |
| 3665 : packet) + |
3417 header_size + 1, | 3666 header_size + 1, |
3418 0x00, kMaxPacketSize - header_size - 1); | 3667 0x00, kMaxPacketSize - header_size - 1); |
3419 | 3668 |
3420 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3669 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3421 ASSERT_TRUE(data != nullptr); | 3670 ASSERT_TRUE(data != nullptr); |
3422 | 3671 |
3423 test::CompareCharArraysWithHexError( | 3672 test::CompareCharArraysWithHexError( |
3424 "constructed packet", data->data(), data->length(), | 3673 "constructed packet", data->data(), data->length(), |
3425 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3674 AsChars( |
3426 ? packet_cid_be | 3675 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3427 : packet), | 3676 ? packet_cid_be |
3428 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3677 : packet), |
| 3678 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3429 ? arraysize(packet_cid_be) | 3679 ? arraysize(packet_cid_be) |
3430 : arraysize(packet)); | 3680 : arraysize(packet)); |
3431 } | 3681 } |
3432 | 3682 |
3433 TEST_P(QuicFramerTest, BuildStreamFramePacket) { | 3683 TEST_P(QuicFramerTest, BuildStreamFramePacket) { |
3434 QuicPacketHeader header; | 3684 QuicPacketHeader header; |
3435 header.public_header.connection_id = kConnectionId; | 3685 header.public_header.connection_id = kConnectionId; |
3436 header.public_header.reset_flag = false; | 3686 header.public_header.reset_flag = false; |
3437 header.public_header.version_flag = false; | 3687 header.public_header.version_flag = false; |
3438 header.packet_number = kPacketNumber; | 3688 header.packet_number = kPacketNumber; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3487 'o', ' ', 'w', 'o', | 3737 'o', ' ', 'w', 'o', |
3488 'r', 'l', 'd', '!', | 3738 'r', 'l', 'd', '!', |
3489 }; | 3739 }; |
3490 // clang-format on | 3740 // clang-format on |
3491 | 3741 |
3492 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3742 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3493 ASSERT_TRUE(data != nullptr); | 3743 ASSERT_TRUE(data != nullptr); |
3494 | 3744 |
3495 test::CompareCharArraysWithHexError( | 3745 test::CompareCharArraysWithHexError( |
3496 "constructed packet", data->data(), data->length(), | 3746 "constructed packet", data->data(), data->length(), |
3497 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3747 AsChars( |
3498 ? packet_cid_be | 3748 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3499 : packet), | 3749 ? packet_cid_be |
3500 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3750 : packet), |
| 3751 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3501 ? arraysize(packet_cid_be) | 3752 ? arraysize(packet_cid_be) |
3502 : arraysize(packet)); | 3753 : arraysize(packet)); |
3503 } | 3754 } |
3504 | 3755 |
3505 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { | 3756 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { |
3506 QuicPacketHeader header; | 3757 QuicPacketHeader header; |
3507 header.public_header.connection_id = kConnectionId; | 3758 header.public_header.connection_id = kConnectionId; |
3508 header.public_header.reset_flag = false; | 3759 header.public_header.reset_flag = false; |
3509 header.public_header.version_flag = true; | 3760 header.public_header.version_flag = true; |
3510 header.packet_number = kPacketNumber; | 3761 header.packet_number = kPacketNumber; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3556 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!', | 3807 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!', |
3557 }; | 3808 }; |
3558 // clang-format on | 3809 // clang-format on |
3559 | 3810 |
3560 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); | 3811 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT); |
3561 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3812 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3562 ASSERT_TRUE(data != nullptr); | 3813 ASSERT_TRUE(data != nullptr); |
3563 | 3814 |
3564 test::CompareCharArraysWithHexError( | 3815 test::CompareCharArraysWithHexError( |
3565 "constructed packet", data->data(), data->length(), | 3816 "constructed packet", data->data(), data->length(), |
3566 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3817 AsChars( |
3567 ? packet_cid_be | 3818 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3568 : packet), | 3819 ? packet_cid_be |
3569 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3820 : packet), |
| 3821 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3570 ? arraysize(packet_cid_be) | 3822 ? arraysize(packet_cid_be) |
3571 : arraysize(packet)); | 3823 : arraysize(packet)); |
3572 } | 3824 } |
3573 | 3825 |
3574 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) { | 3826 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) { |
3575 // clang-format off | 3827 // clang-format off |
3576 unsigned char packet[] = { | 3828 unsigned char packet[] = { |
3577 // public flags (version, 8 byte connection_id) | 3829 // public flags (version, 8 byte connection_id) |
3578 0x0D, | 3830 0x0D, |
3579 // connection_id | 3831 // connection_id |
(...skipping 11 matching lines...) Expand all Loading... |
3591 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), | 3843 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), |
3592 }; | 3844 }; |
3593 // clang-format on | 3845 // clang-format on |
3594 | 3846 |
3595 QuicConnectionId connection_id = kConnectionId; | 3847 QuicConnectionId connection_id = kConnectionId; |
3596 std::unique_ptr<QuicEncryptedPacket> data( | 3848 std::unique_ptr<QuicEncryptedPacket> data( |
3597 framer_.BuildVersionNegotiationPacket(connection_id, | 3849 framer_.BuildVersionNegotiationPacket(connection_id, |
3598 SupportedVersions(GetParam()))); | 3850 SupportedVersions(GetParam()))); |
3599 test::CompareCharArraysWithHexError( | 3851 test::CompareCharArraysWithHexError( |
3600 "constructed packet", data->data(), data->length(), | 3852 "constructed packet", data->data(), data->length(), |
3601 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3853 AsChars( |
3602 ? packet_cid_be | 3854 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3603 : packet), | 3855 ? packet_cid_be |
3604 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3856 : packet), |
| 3857 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3605 ? arraysize(packet_cid_be) | 3858 ? arraysize(packet_cid_be) |
3606 : arraysize(packet)); | 3859 : arraysize(packet)); |
3607 } | 3860 } |
3608 | 3861 |
3609 TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) { | 3862 TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) { |
3610 QuicPacketHeader header; | 3863 QuicPacketHeader header; |
3611 header.public_header.connection_id = kConnectionId; | 3864 header.public_header.connection_id = kConnectionId; |
3612 header.public_header.reset_flag = false; | 3865 header.public_header.reset_flag = false; |
3613 header.public_header.version_flag = false; | 3866 header.public_header.version_flag = false; |
3614 header.packet_number = kPacketNumber; | 3867 header.packet_number = kPacketNumber; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3663 // num timestamps. | 3916 // num timestamps. |
3664 0x00, | 3917 0x00, |
3665 }; | 3918 }; |
3666 // clang-format on | 3919 // clang-format on |
3667 | 3920 |
3668 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 3921 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3669 ASSERT_TRUE(data != nullptr); | 3922 ASSERT_TRUE(data != nullptr); |
3670 | 3923 |
3671 test::CompareCharArraysWithHexError( | 3924 test::CompareCharArraysWithHexError( |
3672 "constructed packet", data->data(), data->length(), | 3925 "constructed packet", data->data(), data->length(), |
3673 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3926 AsChars( |
3674 ? packet_cid_be | 3927 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3675 : packet), | 3928 ? packet_cid_be |
3676 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 3929 : packet), |
| 3930 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3677 ? arraysize(packet_cid_be) | 3931 ? arraysize(packet_cid_be) |
3678 : arraysize(packet)); | 3932 : arraysize(packet)); |
3679 } | 3933 } |
3680 | 3934 |
3681 TEST_P(QuicFramerTest, BuildAckFramePacketMultipleAckBlocks) { | 3935 TEST_P(QuicFramerTest, BuildAckFramePacketMultipleAckBlocks) { |
3682 QuicPacketHeader header; | 3936 QuicPacketHeader header; |
3683 header.public_header.connection_id = kConnectionId; | 3937 header.public_header.connection_id = kConnectionId; |
3684 header.public_header.reset_flag = false; | 3938 header.public_header.reset_flag = false; |
3685 header.public_header.version_flag = false; | 3939 header.public_header.version_flag = false; |
3686 header.packet_number = kPacketNumber; | 3940 header.packet_number = kPacketNumber; |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3774 // num timestamps. | 4028 // num timestamps. |
3775 0x00, | 4029 0x00, |
3776 }; | 4030 }; |
3777 // clang-format on | 4031 // clang-format on |
3778 | 4032 |
3779 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4033 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
3780 ASSERT_TRUE(data != nullptr); | 4034 ASSERT_TRUE(data != nullptr); |
3781 | 4035 |
3782 test::CompareCharArraysWithHexError( | 4036 test::CompareCharArraysWithHexError( |
3783 "constructed packet", data->data(), data->length(), | 4037 "constructed packet", data->data(), data->length(), |
3784 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4038 AsChars( |
3785 ? packet_cid_be | 4039 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3786 : packet), | 4040 ? packet_cid_be |
3787 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4041 : packet), |
| 4042 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
3788 ? arraysize(packet_cid_be) | 4043 ? arraysize(packet_cid_be) |
3789 : arraysize(packet)); | 4044 : arraysize(packet)); |
3790 } | 4045 } |
3791 | 4046 |
3792 TEST_P(QuicFramerTest, BuildAckFramePacketMaxAckBlocks) { | 4047 TEST_P(QuicFramerTest, BuildAckFramePacketMaxAckBlocks) { |
3793 QuicPacketHeader header; | 4048 QuicPacketHeader header; |
3794 header.public_header.connection_id = kConnectionId; | 4049 header.public_header.connection_id = kConnectionId; |
3795 header.public_header.reset_flag = false; | 4050 header.public_header.reset_flag = false; |
3796 header.public_header.version_flag = false; | 4051 header.public_header.version_flag = false; |
3797 header.packet_number = kPacketNumber; | 4052 header.packet_number = kPacketNumber; |
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3994 // num timestamps. | 4249 // num timestamps. |
3995 0x00, | 4250 0x00, |
3996 }; | 4251 }; |
3997 // clang-format on | 4252 // clang-format on |
3998 | 4253 |
3999 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4254 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4000 ASSERT_TRUE(data != nullptr); | 4255 ASSERT_TRUE(data != nullptr); |
4001 | 4256 |
4002 test::CompareCharArraysWithHexError( | 4257 test::CompareCharArraysWithHexError( |
4003 "constructed packet", data->data(), data->length(), | 4258 "constructed packet", data->data(), data->length(), |
4004 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4259 AsChars( |
4005 ? packet_cid_be | 4260 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4006 : packet), | 4261 ? packet_cid_be |
4007 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4262 : packet), |
| 4263 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4008 ? arraysize(packet_cid_be) | 4264 ? arraysize(packet_cid_be) |
4009 : arraysize(packet)); | 4265 : arraysize(packet)); |
4010 } | 4266 } |
4011 | 4267 |
4012 TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) { | 4268 TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) { |
4013 QuicPacketHeader header; | 4269 QuicPacketHeader header; |
4014 header.public_header.connection_id = kConnectionId; | 4270 header.public_header.connection_id = kConnectionId; |
4015 header.public_header.reset_flag = false; | 4271 header.public_header.reset_flag = false; |
4016 header.public_header.version_flag = false; | 4272 header.public_header.version_flag = false; |
4017 header.packet_number = kPacketNumber; | 4273 header.packet_number = kPacketNumber; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4052 0x1C, 0x00, 0x00, 0x00, | 4308 0x1C, 0x00, 0x00, 0x00, |
4053 0x00, 0x00, | 4309 0x00, 0x00, |
4054 }; | 4310 }; |
4055 // clang-format on | 4311 // clang-format on |
4056 | 4312 |
4057 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4313 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4058 ASSERT_TRUE(data != nullptr); | 4314 ASSERT_TRUE(data != nullptr); |
4059 | 4315 |
4060 test::CompareCharArraysWithHexError( | 4316 test::CompareCharArraysWithHexError( |
4061 "constructed packet", data->data(), data->length(), | 4317 "constructed packet", data->data(), data->length(), |
4062 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4318 AsChars( |
4063 ? packet_cid_be | 4319 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4064 : packet), | 4320 ? packet_cid_be |
4065 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4321 : packet), |
| 4322 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4066 ? arraysize(packet_cid_be) | 4323 ? arraysize(packet_cid_be) |
4067 : arraysize(packet)); | 4324 : arraysize(packet)); |
4068 } | 4325 } |
4069 | 4326 |
4070 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) { | 4327 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) { |
4071 QuicPacketHeader header; | 4328 QuicPacketHeader header; |
4072 header.public_header.connection_id = kConnectionId; | 4329 header.public_header.connection_id = kConnectionId; |
4073 header.public_header.reset_flag = false; | 4330 header.public_header.reset_flag = false; |
4074 header.public_header.version_flag = false; | 4331 header.public_header.version_flag = false; |
4075 header.packet_number = kPacketNumber; | 4332 header.packet_number = kPacketNumber; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4122 }; | 4379 }; |
4123 // clang-format on | 4380 // clang-format on |
4124 | 4381 |
4125 QuicFrames frames = {QuicFrame(&rst_frame)}; | 4382 QuicFrames frames = {QuicFrame(&rst_frame)}; |
4126 | 4383 |
4127 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4384 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4128 ASSERT_TRUE(data != nullptr); | 4385 ASSERT_TRUE(data != nullptr); |
4129 | 4386 |
4130 test::CompareCharArraysWithHexError( | 4387 test::CompareCharArraysWithHexError( |
4131 "constructed packet", data->data(), data->length(), | 4388 "constructed packet", data->data(), data->length(), |
4132 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4389 AsChars( |
4133 ? packet_cid_be | 4390 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4134 : packet), | 4391 ? packet_cid_be |
4135 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4392 : packet), |
| 4393 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4136 ? arraysize(packet_cid_be) | 4394 ? arraysize(packet_cid_be) |
4137 : arraysize(packet)); | 4395 : arraysize(packet)); |
4138 } | 4396 } |
4139 | 4397 |
4140 TEST_P(QuicFramerTest, BuildCloseFramePacket) { | 4398 TEST_P(QuicFramerTest, BuildCloseFramePacket) { |
4141 QuicPacketHeader header; | 4399 QuicPacketHeader header; |
4142 header.public_header.connection_id = kConnectionId; | 4400 header.public_header.connection_id = kConnectionId; |
4143 header.public_header.reset_flag = false; | 4401 header.public_header.reset_flag = false; |
4144 header.public_header.version_flag = false; | 4402 header.public_header.version_flag = false; |
4145 header.packet_number = kPacketNumber; | 4403 header.packet_number = kPacketNumber; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4195 'I', ' ', 'c', 'a', | 4453 'I', ' ', 'c', 'a', |
4196 'n', | 4454 'n', |
4197 }; | 4455 }; |
4198 // clang-format on | 4456 // clang-format on |
4199 | 4457 |
4200 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4458 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4201 ASSERT_TRUE(data != nullptr); | 4459 ASSERT_TRUE(data != nullptr); |
4202 | 4460 |
4203 test::CompareCharArraysWithHexError( | 4461 test::CompareCharArraysWithHexError( |
4204 "constructed packet", data->data(), data->length(), | 4462 "constructed packet", data->data(), data->length(), |
4205 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4463 AsChars( |
4206 ? packet_cid_be | 4464 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4207 : packet), | 4465 ? packet_cid_be |
4208 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4466 : packet), |
| 4467 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4209 ? arraysize(packet_cid_be) | 4468 ? arraysize(packet_cid_be) |
4210 : arraysize(packet)); | 4469 : arraysize(packet)); |
4211 } | 4470 } |
4212 | 4471 |
4213 TEST_P(QuicFramerTest, BuildGoAwayPacket) { | 4472 TEST_P(QuicFramerTest, BuildGoAwayPacket) { |
4214 QuicPacketHeader header; | 4473 QuicPacketHeader header; |
4215 header.public_header.connection_id = kConnectionId; | 4474 header.public_header.connection_id = kConnectionId; |
4216 header.public_header.reset_flag = false; | 4475 header.public_header.reset_flag = false; |
4217 header.public_header.version_flag = false; | 4476 header.public_header.version_flag = false; |
4218 header.packet_number = kPacketNumber; | 4477 header.packet_number = kPacketNumber; |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4273 'I', ' ', 'c', 'a', | 4532 'I', ' ', 'c', 'a', |
4274 'n', | 4533 'n', |
4275 }; | 4534 }; |
4276 // clang-format on | 4535 // clang-format on |
4277 | 4536 |
4278 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4537 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4279 ASSERT_TRUE(data != nullptr); | 4538 ASSERT_TRUE(data != nullptr); |
4280 | 4539 |
4281 test::CompareCharArraysWithHexError( | 4540 test::CompareCharArraysWithHexError( |
4282 "constructed packet", data->data(), data->length(), | 4541 "constructed packet", data->data(), data->length(), |
4283 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4542 AsChars( |
4284 ? packet_cid_be | 4543 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4285 : packet), | 4544 ? packet_cid_be |
4286 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4545 : packet), |
| 4546 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4287 ? arraysize(packet_cid_be) | 4547 ? arraysize(packet_cid_be) |
4288 : arraysize(packet)); | 4548 : arraysize(packet)); |
4289 } | 4549 } |
4290 | 4550 |
4291 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) { | 4551 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) { |
4292 QuicPacketHeader header; | 4552 QuicPacketHeader header; |
4293 header.public_header.connection_id = kConnectionId; | 4553 header.public_header.connection_id = kConnectionId; |
4294 header.public_header.reset_flag = false; | 4554 header.public_header.reset_flag = false; |
4295 header.public_header.version_flag = false; | 4555 header.public_header.version_flag = false; |
4296 header.packet_number = kPacketNumber; | 4556 header.packet_number = kPacketNumber; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4338 0x88, 0x77, 0x66, 0x55, | 4598 0x88, 0x77, 0x66, 0x55, |
4339 0x44, 0x33, 0x22, 0x11, | 4599 0x44, 0x33, 0x22, 0x11, |
4340 }; | 4600 }; |
4341 // clang-format on | 4601 // clang-format on |
4342 | 4602 |
4343 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4603 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4344 ASSERT_TRUE(data != nullptr); | 4604 ASSERT_TRUE(data != nullptr); |
4345 | 4605 |
4346 test::CompareCharArraysWithHexError( | 4606 test::CompareCharArraysWithHexError( |
4347 "constructed packet", data->data(), data->length(), | 4607 "constructed packet", data->data(), data->length(), |
4348 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4608 AsChars( |
4349 ? packet_cid_be | 4609 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4350 : packet), | 4610 ? packet_cid_be |
4351 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4611 : packet), |
| 4612 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4352 ? arraysize(packet_cid_be) | 4613 ? arraysize(packet_cid_be) |
4353 : arraysize(packet)); | 4614 : arraysize(packet)); |
4354 } | 4615 } |
4355 | 4616 |
4356 TEST_P(QuicFramerTest, BuildBlockedPacket) { | 4617 TEST_P(QuicFramerTest, BuildBlockedPacket) { |
4357 QuicPacketHeader header; | 4618 QuicPacketHeader header; |
4358 header.public_header.connection_id = kConnectionId; | 4619 header.public_header.connection_id = kConnectionId; |
4359 header.public_header.reset_flag = false; | 4620 header.public_header.reset_flag = false; |
4360 header.public_header.version_flag = false; | 4621 header.public_header.version_flag = false; |
4361 header.packet_number = kPacketNumber; | 4622 header.packet_number = kPacketNumber; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4396 // stream id | 4657 // stream id |
4397 0x04, 0x03, 0x02, 0x01, | 4658 0x04, 0x03, 0x02, 0x01, |
4398 }; | 4659 }; |
4399 // clang-format on | 4660 // clang-format on |
4400 | 4661 |
4401 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4662 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4402 ASSERT_TRUE(data != nullptr); | 4663 ASSERT_TRUE(data != nullptr); |
4403 | 4664 |
4404 test::CompareCharArraysWithHexError( | 4665 test::CompareCharArraysWithHexError( |
4405 "constructed packet", data->data(), data->length(), | 4666 "constructed packet", data->data(), data->length(), |
4406 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4667 AsChars( |
4407 ? packet_cid_be | 4668 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4408 : packet), | 4669 ? packet_cid_be |
4409 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4670 : packet), |
| 4671 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4410 ? arraysize(packet_cid_be) | 4672 ? arraysize(packet_cid_be) |
4411 : arraysize(packet)); | 4673 : arraysize(packet)); |
4412 } | 4674 } |
4413 | 4675 |
4414 TEST_P(QuicFramerTest, BuildPingPacket) { | 4676 TEST_P(QuicFramerTest, BuildPingPacket) { |
4415 QuicPacketHeader header; | 4677 QuicPacketHeader header; |
4416 header.public_header.connection_id = kConnectionId; | 4678 header.public_header.connection_id = kConnectionId; |
4417 header.public_header.reset_flag = false; | 4679 header.public_header.reset_flag = false; |
4418 header.public_header.version_flag = false; | 4680 header.public_header.version_flag = false; |
4419 header.packet_number = kPacketNumber; | 4681 header.packet_number = kPacketNumber; |
(...skipping 27 matching lines...) Expand all Loading... |
4447 // frame type (ping frame) | 4709 // frame type (ping frame) |
4448 0x07, | 4710 0x07, |
4449 }; | 4711 }; |
4450 // clang-format on | 4712 // clang-format on |
4451 | 4713 |
4452 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4714 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4453 ASSERT_TRUE(data != nullptr); | 4715 ASSERT_TRUE(data != nullptr); |
4454 | 4716 |
4455 test::CompareCharArraysWithHexError( | 4717 test::CompareCharArraysWithHexError( |
4456 "constructed packet", data->data(), data->length(), | 4718 "constructed packet", data->data(), data->length(), |
4457 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4719 AsChars( |
4458 ? packet_cid_be | 4720 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4459 : packet), | 4721 ? packet_cid_be |
4460 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4722 : packet), |
| 4723 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4461 ? arraysize(packet_cid_be) | 4724 ? arraysize(packet_cid_be) |
4462 : arraysize(packet)); | 4725 : arraysize(packet)); |
4463 } | 4726 } |
4464 | 4727 |
4465 // Test that the MTU discovery packet is serialized correctly as a PING packet. | 4728 // Test that the MTU discovery packet is serialized correctly as a PING packet. |
4466 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) { | 4729 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) { |
4467 QuicPacketHeader header; | 4730 QuicPacketHeader header; |
4468 header.public_header.connection_id = kConnectionId; | 4731 header.public_header.connection_id = kConnectionId; |
4469 header.public_header.reset_flag = false; | 4732 header.public_header.reset_flag = false; |
4470 header.public_header.version_flag = false; | 4733 header.public_header.version_flag = false; |
(...skipping 28 matching lines...) Expand all Loading... |
4499 // frame type (ping frame) | 4762 // frame type (ping frame) |
4500 0x07, | 4763 0x07, |
4501 }; | 4764 }; |
4502 // clang-format on | 4765 // clang-format on |
4503 | 4766 |
4504 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); | 4767 std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); |
4505 ASSERT_TRUE(data != nullptr); | 4768 ASSERT_TRUE(data != nullptr); |
4506 | 4769 |
4507 test::CompareCharArraysWithHexError( | 4770 test::CompareCharArraysWithHexError( |
4508 "constructed packet", data->data(), data->length(), | 4771 "constructed packet", data->data(), data->length(), |
4509 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4772 AsChars( |
4510 ? packet_cid_be | 4773 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4511 : packet), | 4774 ? packet_cid_be |
4512 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4775 : packet), |
| 4776 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4513 ? arraysize(packet_cid_be) | 4777 ? arraysize(packet_cid_be) |
4514 : arraysize(packet)); | 4778 : arraysize(packet)); |
4515 } | 4779 } |
4516 | 4780 |
4517 TEST_P(QuicFramerTest, BuildPublicResetPacketOld) { | 4781 TEST_P(QuicFramerTest, BuildPublicResetPacketOld) { |
4518 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = true; | 4782 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = true; |
4519 QuicPublicResetPacket reset_packet; | 4783 QuicPublicResetPacket reset_packet; |
4520 reset_packet.public_header.connection_id = kConnectionId; | 4784 reset_packet.public_header.connection_id = kConnectionId; |
4521 reset_packet.public_header.reset_flag = true; | 4785 reset_packet.public_header.reset_flag = true; |
4522 reset_packet.public_header.version_flag = false; | 4786 reset_packet.public_header.version_flag = false; |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4612 0x01, 0xEF, 0xCD, 0xAB, | 4876 0x01, 0xEF, 0xCD, 0xAB, |
4613 }; | 4877 }; |
4614 // clang-format on | 4878 // clang-format on |
4615 | 4879 |
4616 std::unique_ptr<QuicEncryptedPacket> data( | 4880 std::unique_ptr<QuicEncryptedPacket> data( |
4617 framer_.BuildPublicResetPacket(reset_packet)); | 4881 framer_.BuildPublicResetPacket(reset_packet)); |
4618 ASSERT_TRUE(data != nullptr); | 4882 ASSERT_TRUE(data != nullptr); |
4619 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { | 4883 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { |
4620 test::CompareCharArraysWithHexError( | 4884 test::CompareCharArraysWithHexError( |
4621 "constructed packet", data->data(), data->length(), | 4885 "constructed packet", data->data(), data->length(), |
4622 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4886 AsChars( |
4623 ? packet_no_rejected_packet_number_cid_be | 4887 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4624 : packet_no_rejected_packet_number), | 4888 ? packet_no_rejected_packet_number_cid_be |
4625 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4889 : packet_no_rejected_packet_number), |
| 4890 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4626 ? arraysize(packet_no_rejected_packet_number_cid_be) | 4891 ? arraysize(packet_no_rejected_packet_number_cid_be) |
4627 : arraysize(packet_no_rejected_packet_number)); | 4892 : arraysize(packet_no_rejected_packet_number)); |
4628 } else { | 4893 } else { |
4629 test::CompareCharArraysWithHexError( | 4894 test::CompareCharArraysWithHexError( |
4630 "constructed packet", data->data(), data->length(), | 4895 "constructed packet", data->data(), data->length(), |
4631 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4896 AsChars( |
4632 ? packet_cid_be | 4897 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4633 : packet), | 4898 ? packet_cid_be |
4634 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 4899 : packet), |
| 4900 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4635 ? arraysize(packet_cid_be) | 4901 ? arraysize(packet_cid_be) |
4636 : arraysize(packet)); | 4902 : arraysize(packet)); |
4637 } | 4903 } |
4638 } | 4904 } |
4639 | 4905 |
4640 TEST_P(QuicFramerTest, BuildPublicResetPacket) { | 4906 TEST_P(QuicFramerTest, BuildPublicResetPacket) { |
4641 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false; | 4907 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false; |
4642 QuicPublicResetPacket reset_packet; | 4908 QuicPublicResetPacket reset_packet; |
4643 reset_packet.public_header.connection_id = kConnectionId; | 4909 reset_packet.public_header.connection_id = kConnectionId; |
4644 reset_packet.public_header.reset_flag = true; | 4910 reset_packet.public_header.reset_flag = true; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4736 }; | 5002 }; |
4737 // clang-format on | 5003 // clang-format on |
4738 | 5004 |
4739 std::unique_ptr<QuicEncryptedPacket> data( | 5005 std::unique_ptr<QuicEncryptedPacket> data( |
4740 framer_.BuildPublicResetPacket(reset_packet)); | 5006 framer_.BuildPublicResetPacket(reset_packet)); |
4741 ASSERT_TRUE(data != nullptr); | 5007 ASSERT_TRUE(data != nullptr); |
4742 | 5008 |
4743 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { | 5009 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { |
4744 test::CompareCharArraysWithHexError( | 5010 test::CompareCharArraysWithHexError( |
4745 "constructed packet", data->data(), data->length(), | 5011 "constructed packet", data->data(), data->length(), |
4746 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5012 AsChars( |
4747 ? packet_no_rejected_packet_number_cid_be | 5013 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4748 : packet_no_rejected_packet_number), | 5014 ? packet_no_rejected_packet_number_cid_be |
4749 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5015 : packet_no_rejected_packet_number), |
| 5016 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4750 ? arraysize(packet_no_rejected_packet_number_cid_be) | 5017 ? arraysize(packet_no_rejected_packet_number_cid_be) |
4751 : arraysize(packet_no_rejected_packet_number)); | 5018 : arraysize(packet_no_rejected_packet_number)); |
4752 } else { | 5019 } else { |
4753 test::CompareCharArraysWithHexError( | 5020 test::CompareCharArraysWithHexError( |
4754 "constructed packet", data->data(), data->length(), | 5021 "constructed packet", data->data(), data->length(), |
4755 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5022 AsChars( |
4756 ? packet_cid_be | 5023 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4757 : packet), | 5024 ? packet_cid_be |
4758 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5025 : packet), |
| 5026 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4759 ? arraysize(packet_cid_be) | 5027 ? arraysize(packet_cid_be) |
4760 : arraysize(packet)); | 5028 : arraysize(packet)); |
4761 } | 5029 } |
4762 } | 5030 } |
4763 | 5031 |
4764 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) { | 5032 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) { |
4765 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false; | 5033 FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false; |
4766 QuicPublicResetPacket reset_packet; | 5034 QuicPublicResetPacket reset_packet; |
4767 reset_packet.public_header.connection_id = kConnectionId; | 5035 reset_packet.public_header.connection_id = kConnectionId; |
4768 reset_packet.public_header.reset_flag = true; | 5036 reset_packet.public_header.reset_flag = true; |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4894 }; | 5162 }; |
4895 // clang-format on | 5163 // clang-format on |
4896 | 5164 |
4897 std::unique_ptr<QuicEncryptedPacket> data( | 5165 std::unique_ptr<QuicEncryptedPacket> data( |
4898 framer_.BuildPublicResetPacket(reset_packet)); | 5166 framer_.BuildPublicResetPacket(reset_packet)); |
4899 ASSERT_TRUE(data != nullptr); | 5167 ASSERT_TRUE(data != nullptr); |
4900 | 5168 |
4901 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { | 5169 if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) { |
4902 test::CompareCharArraysWithHexError( | 5170 test::CompareCharArraysWithHexError( |
4903 "constructed packet", data->data(), data->length(), | 5171 "constructed packet", data->data(), data->length(), |
4904 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5172 AsChars( |
4905 ? packet_no_rejected_packet_number_cid_be | 5173 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4906 : packet_no_rejected_packet_number), | 5174 ? packet_no_rejected_packet_number_cid_be |
| 5175 : packet_no_rejected_packet_number), |
4907 | 5176 |
4908 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5177 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4909 ? arraysize(packet_no_rejected_packet_number_cid_be) | 5178 ? arraysize(packet_no_rejected_packet_number_cid_be) |
4910 : arraysize(packet_no_rejected_packet_number)); | 5179 : arraysize(packet_no_rejected_packet_number)); |
4911 } else { | 5180 } else { |
4912 test::CompareCharArraysWithHexError( | 5181 test::CompareCharArraysWithHexError( |
4913 "constructed packet", data->data(), data->length(), | 5182 "constructed packet", data->data(), data->length(), |
4914 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5183 AsChars( |
4915 ? packet_cid_be | 5184 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4916 : packet), | 5185 ? packet_cid_be |
| 5186 : packet), |
4917 | 5187 |
4918 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5188 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4919 ? arraysize(packet_cid_be) | 5189 ? arraysize(packet_cid_be) |
4920 : arraysize(packet)); | 5190 : arraysize(packet)); |
4921 } | 5191 } |
4922 } | 5192 } |
4923 | 5193 |
4924 TEST_P(QuicFramerTest, EncryptPacket) { | 5194 TEST_P(QuicFramerTest, EncryptPacket) { |
4925 QuicPacketNumber packet_number = kPacketNumber; | 5195 QuicPacketNumber packet_number = kPacketNumber; |
4926 // clang-format off | 5196 // clang-format off |
4927 unsigned char packet[] = { | 5197 unsigned char packet[] = { |
4928 // public flags (8 byte connection_id) | 5198 // public flags (8 byte connection_id) |
(...skipping 23 matching lines...) Expand all Loading... |
4952 | 5222 |
4953 // redundancy | 5223 // redundancy |
4954 'a', 'b', 'c', 'd', | 5224 'a', 'b', 'c', 'd', |
4955 'e', 'f', 'g', 'h', | 5225 'e', 'f', 'g', 'h', |
4956 'i', 'j', 'k', 'l', | 5226 'i', 'j', 'k', 'l', |
4957 'm', 'n', 'o', 'p', | 5227 'm', 'n', 'o', 'p', |
4958 }; | 5228 }; |
4959 // clang-format on | 5229 // clang-format on |
4960 | 5230 |
4961 std::unique_ptr<QuicPacket> raw(new QuicPacket( | 5231 std::unique_ptr<QuicPacket> raw(new QuicPacket( |
4962 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5232 AsChars( |
4963 ? packet_cid_be | 5233 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4964 : packet), | 5234 ? packet_cid_be |
4965 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5235 : packet), |
| 5236 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
4966 ? arraysize(packet_cid_be) | 5237 ? arraysize(packet_cid_be) |
4967 : arraysize(packet), | 5238 : arraysize(packet), |
4968 false, PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, | 5239 false, PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, |
4969 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER)); | 5240 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER)); |
4970 char buffer[kMaxPacketSize]; | 5241 char buffer[kMaxPacketSize]; |
4971 size_t encrypted_length = framer_.EncryptPayload( | 5242 size_t encrypted_length = framer_.EncryptPayload( |
4972 ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize); | 5243 ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize); |
4973 | 5244 |
4974 ASSERT_NE(0u, encrypted_length); | 5245 ASSERT_NE(0u, encrypted_length); |
4975 EXPECT_TRUE(CheckEncryption(packet_number, raw.get())); | 5246 EXPECT_TRUE(CheckEncryption(packet_number, raw.get())); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5010 | 5281 |
5011 // redundancy | 5282 // redundancy |
5012 'a', 'b', 'c', 'd', | 5283 'a', 'b', 'c', 'd', |
5013 'e', 'f', 'g', 'h', | 5284 'e', 'f', 'g', 'h', |
5014 'i', 'j', 'k', 'l', | 5285 'i', 'j', 'k', 'l', |
5015 'm', 'n', 'o', 'p', | 5286 'm', 'n', 'o', 'p', |
5016 }; | 5287 }; |
5017 // clang-format on | 5288 // clang-format on |
5018 | 5289 |
5019 std::unique_ptr<QuicPacket> raw(new QuicPacket( | 5290 std::unique_ptr<QuicPacket> raw(new QuicPacket( |
5020 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5291 AsChars( |
5021 ? packet_cid_be | 5292 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5022 : packet), | 5293 ? packet_cid_be |
5023 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5294 : packet), |
| 5295 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5024 ? arraysize(packet_cid_be) | 5296 ? arraysize(packet_cid_be) |
5025 : arraysize(packet), | 5297 : arraysize(packet), |
5026 false, PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, | 5298 false, PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, |
5027 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER)); | 5299 !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER)); |
5028 char buffer[kMaxPacketSize]; | 5300 char buffer[kMaxPacketSize]; |
5029 size_t encrypted_length = framer_.EncryptPayload( | 5301 size_t encrypted_length = framer_.EncryptPayload( |
5030 ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize); | 5302 ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize); |
5031 | 5303 |
5032 ASSERT_NE(0u, encrypted_length); | 5304 ASSERT_NE(0u, encrypted_length); |
5033 EXPECT_TRUE(CheckEncryption(packet_number, raw.get())); | 5305 EXPECT_TRUE(CheckEncryption(packet_number, raw.get())); |
(...skipping 186 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5220 EXPECT_CALL(visitor, OnPacket()); | 5492 EXPECT_CALL(visitor, OnPacket()); |
5221 EXPECT_CALL(visitor, OnPacketHeader(_)); | 5493 EXPECT_CALL(visitor, OnPacketHeader(_)); |
5222 EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false)); | 5494 EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false)); |
5223 EXPECT_CALL(visitor, OnAckFrame(_)).Times(0); | 5495 EXPECT_CALL(visitor, OnAckFrame(_)).Times(0); |
5224 EXPECT_CALL(visitor, OnPacketComplete()); | 5496 EXPECT_CALL(visitor, OnPacketComplete()); |
5225 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true)); | 5497 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true)); |
5226 EXPECT_CALL(visitor, OnUnauthenticatedHeader(_)).WillOnce(Return(true)); | 5498 EXPECT_CALL(visitor, OnUnauthenticatedHeader(_)).WillOnce(Return(true)); |
5227 EXPECT_CALL(visitor, OnDecryptedPacket(_)); | 5499 EXPECT_CALL(visitor, OnDecryptedPacket(_)); |
5228 | 5500 |
5229 QuicEncryptedPacket encrypted( | 5501 QuicEncryptedPacket encrypted( |
5230 AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5502 AsChars( |
5231 ? packet_cid_be | 5503 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5232 : packet), | 5504 ? packet_cid_be |
5233 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5505 : packet), |
| 5506 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5234 ? arraysize(packet_cid_be) | 5507 ? arraysize(packet_cid_be) |
5235 : arraysize(packet), | 5508 : arraysize(packet), |
5236 false); | 5509 false); |
5237 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); | 5510 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); |
5238 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); | 5511 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); |
5239 } | 5512 } |
5240 | 5513 |
5241 static char kTestString[] = "At least 20 characters."; | 5514 static char kTestString[] = "At least 20 characters."; |
5242 static QuicStreamId kTestQuicStreamId = 1; | 5515 static QuicStreamId kTestQuicStreamId = 1; |
5243 static bool ExpectedStreamFrame(const QuicStreamFrame& frame) { | 5516 static bool ExpectedStreamFrame(const QuicStreamFrame& frame) { |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5397 0xDC, 0xFE, 0x98, 0xBA, | 5670 0xDC, 0xFE, 0x98, 0xBA, |
5398 // data length | 5671 // data length |
5399 0x0c, 0x00, | 5672 0x0c, 0x00, |
5400 // data | 5673 // data |
5401 'h', 'e', 'l', 'l', | 5674 'h', 'e', 'l', 'l', |
5402 'o', ' ', 'w', 'o', | 5675 'o', ' ', 'w', 'o', |
5403 'r', 'l', 'd', '!', | 5676 'r', 'l', 'd', '!', |
5404 }; | 5677 }; |
5405 // clang-format on | 5678 // clang-format on |
5406 | 5679 |
5407 QuicFramerFuzzFunc(FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5680 QuicFramerFuzzFunc( |
5408 ? packet_cid_be | 5681 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5409 : packet, | 5682 ? packet_cid_be |
5410 FLAGS_quic_restart_flag_quic_big_endian_connection_id | 5683 : packet, |
5411 ? arraysize(packet_cid_be) | 5684 QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective()) |
5412 : arraysize(packet)); | 5685 ? arraysize(packet_cid_be) |
| 5686 : arraysize(packet)); |
5413 } | 5687 } |
5414 | 5688 |
5415 } // namespace test | 5689 } // namespace test |
5416 } // namespace net | 5690 } // namespace net |
OLD | NEW |