1 // Copyright 2013 The Chromium Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 // 5 // Provides a simple interface for QUIC tests to create a variety of packets. 6 7 #ifndef NET_QUIC_QUIC_TEST_PACKET_MAKER_H_ 8 #define NET_QUIC_QUIC_TEST_PACKET_MAKER_H_ 9 10 #include <stddef.h> 11 #include <sys/types.h> 12 13 #include <memory> 14 #include <string> 15 #include <vector> 16 17 #include "base/memory/raw_ptr.h" 18 #include "net/base/request_priority.h" 19 #include "net/third_party/quiche/src/quiche/quic/core/http/http_encoder.h" 20 #include "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder.h" 21 #include "net/third_party/quiche/src/quiche/quic/core/quic_clock.h" 22 #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h" 23 #include "net/third_party/quiche/src/quiche/quic/core/quic_stream_frame_data_producer.h" 24 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h" 25 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h" 26 #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h" 27 #include "net/third_party/quiche/src/quiche/quic/test_tools/simple_data_producer.h" 28 29 namespace net::test { 30 31 class QuicTestPacketMaker { 32 public: 33 // |client_priority_uses_incremental| affects the output of any method that 34 // includes HTTP3 priority data. The protocol default is to omit the 35 // incremental flag in the priority data but HTTP streams may enable it 36 // if the feature kPriorityIncremental is enabled. 37 QuicTestPacketMaker(quic::ParsedQuicVersion version, 38 quic::QuicConnectionId connection_id, 39 const quic::QuicClock* clock, 40 const std::string& host, 41 quic::Perspective perspective, 42 bool client_priority_uses_incremental = false); 43 44 QuicTestPacketMaker(const QuicTestPacketMaker&) = delete; 45 QuicTestPacketMaker& operator=(const QuicTestPacketMaker&) = delete; 46 47 ~QuicTestPacketMaker(); 48 49 void set_hostname(const std::string& host); 50 set_connection_id(const quic::QuicConnectionId & connection_id)51 void set_connection_id(const quic::QuicConnectionId& connection_id) { 52 connection_id_ = connection_id; 53 } 54 55 std::unique_ptr<quic::QuicReceivedPacket> MakeConnectivityProbingPacket( 56 uint64_t num, 57 bool include_version); 58 59 std::unique_ptr<quic::QuicReceivedPacket> MakePingPacket( 60 uint64_t num, 61 bool include_version); 62 63 std::unique_ptr<quic::QuicReceivedPacket> MakeRetireConnectionIdPacket( 64 uint64_t num, 65 bool include_version, 66 uint64_t sequence_number); 67 68 std::unique_ptr<quic::QuicReceivedPacket> MakeNewConnectionIdPacket( 69 uint64_t num, 70 bool include_version, 71 const quic::QuicConnectionId& cid, 72 uint64_t sequence_number, 73 uint64_t retire_prior_to); 74 75 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndNewConnectionIdPacket( 76 uint64_t num, 77 bool include_version, 78 uint64_t largest_received, 79 uint64_t smallest_received, 80 const quic::QuicConnectionId& cid, 81 uint64_t sequence_number, 82 uint64_t retire_prior_to); 83 84 std::unique_ptr<quic::QuicReceivedPacket> MakeDummyCHLOPacket( 85 uint64_t packet_num); 86 87 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndPingPacket( 88 uint64_t num, 89 bool include_version, 90 uint64_t largest_received, 91 uint64_t smallest_received); 92 93 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndRetireConnectionIdPacket( 94 uint64_t num, 95 bool include_version, 96 uint64_t largest_received, 97 uint64_t smallest_received, 98 uint64_t sequence_number); 99 100 std::unique_ptr<quic::QuicReceivedPacket> 101 MakeRetransmissionAndRetireConnectionIdPacket( 102 uint64_t num, 103 bool include_version, 104 const std::vector<uint64_t>& original_packet_numbers, 105 uint64_t sequence_number); 106 107 std::unique_ptr<quic::QuicReceivedPacket> MakeStreamsBlockedPacket( 108 uint64_t num, 109 bool include_version, 110 quic::QuicStreamCount stream_count, 111 bool unidirectional); 112 113 std::unique_ptr<quic::QuicReceivedPacket> MakeMaxStreamsPacket( 114 uint64_t num, 115 bool include_version, 116 quic::QuicStreamCount stream_count, 117 bool unidirectional); 118 119 std::unique_ptr<quic::QuicReceivedPacket> MakeRstPacket( 120 uint64_t num, 121 bool include_version, 122 quic::QuicStreamId stream_id, 123 quic::QuicRstStreamErrorCode error_code); 124 125 std::unique_ptr<quic::QuicReceivedPacket> MakeRstPacket( 126 uint64_t num, 127 bool include_version, 128 quic::QuicStreamId stream_id, 129 quic::QuicRstStreamErrorCode error_code, 130 bool include_stop_sending_if_v99); 131 132 std::unique_ptr<quic::QuicReceivedPacket> MakeRstAndDataPacket( 133 uint64_t num, 134 bool include_version, 135 quic::QuicStreamId rst_stream_id, 136 quic::QuicRstStreamErrorCode rst_error_code, 137 quic::QuicStreamId data_stream_id, 138 absl::string_view data); 139 140 std::unique_ptr<quic::QuicReceivedPacket> MakeRetransmissionRstAndDataPacket( 141 const std::vector<uint64_t>& original_packet_numbers, 142 uint64_t num, 143 bool include_version, 144 quic::QuicStreamId rst_stream_id, 145 quic::QuicRstStreamErrorCode rst_error_code, 146 quic::QuicStreamId data_stream_id, 147 absl::string_view data, 148 uint64_t retransmit_frame_count = 0); 149 150 std::unique_ptr<quic::QuicReceivedPacket> MakeDataAndRstPacket( 151 uint64_t num, 152 bool include_version, 153 quic::QuicStreamId data_stream_id, 154 absl::string_view data, 155 quic::QuicStreamId rst_stream_id, 156 quic::QuicRstStreamErrorCode rst_error_code); 157 158 std::unique_ptr<quic::QuicReceivedPacket> MakeDataRstAndAckPacket( 159 uint64_t num, 160 bool include_version, 161 quic::QuicStreamId data_stream_id, 162 absl::string_view data, 163 quic::QuicStreamId rst_stream_id, 164 quic::QuicRstStreamErrorCode rst_error_code, 165 uint64_t largest_received, 166 uint64_t smallest_received); 167 168 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndRstPacket( 169 uint64_t num, 170 bool include_version, 171 quic::QuicStreamId stream_id, 172 quic::QuicRstStreamErrorCode error_code, 173 uint64_t largest_received, 174 uint64_t smallest_received); 175 176 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndRstPacket( 177 uint64_t num, 178 bool include_version, 179 quic::QuicStreamId stream_id, 180 quic::QuicRstStreamErrorCode error_code, 181 uint64_t largest_received, 182 uint64_t smallest_received, 183 bool include_stop_sending_if_v99); 184 185 std::unique_ptr<quic::QuicReceivedPacket> MakeRstAckAndConnectionClosePacket( 186 uint64_t num, 187 bool include_version, 188 quic::QuicStreamId stream_id, 189 quic::QuicRstStreamErrorCode error_code, 190 uint64_t largest_received, 191 uint64_t smallest_received, 192 quic::QuicErrorCode quic_error, 193 const std::string& quic_error_details); 194 195 std::unique_ptr<quic::QuicReceivedPacket> MakeRstAckAndDataPacket( 196 uint64_t num, 197 bool include_version, 198 quic::QuicStreamId stream_id, 199 quic::QuicRstStreamErrorCode error_code, 200 uint64_t largest_received, 201 uint64_t smallest_received, 202 quic::QuicStreamId data_id, 203 bool fin, 204 absl::string_view data); 205 206 std::unique_ptr<quic::QuicReceivedPacket> MakeAckDataAndRst( 207 uint64_t num, 208 bool include_version, 209 quic::QuicStreamId stream_id, 210 quic::QuicRstStreamErrorCode error_code, 211 uint64_t largest_received, 212 uint64_t smallest_received, 213 quic::QuicStreamId data_id, 214 bool fin, 215 absl::string_view data); 216 217 std::unique_ptr<quic::QuicReceivedPacket> MakeAckRstAndDataPacket( 218 uint64_t num, 219 bool include_version, 220 quic::QuicStreamId stream_id, 221 quic::QuicRstStreamErrorCode error_code, 222 uint64_t largest_received, 223 uint64_t smallest_received, 224 quic::QuicStreamId data_id, 225 bool fin, 226 absl::string_view data); 227 228 std::unique_ptr<quic::QuicReceivedPacket> MakeRstAndConnectionClosePacket( 229 uint64_t num, 230 bool include_version, 231 quic::QuicStreamId stream_id, 232 quic::QuicRstStreamErrorCode error_code, 233 quic::QuicErrorCode quic_error, 234 const std::string& quic_error_details); 235 236 std::unique_ptr<quic::QuicReceivedPacket> MakeDataRstAndConnectionClosePacket( 237 uint64_t num, 238 bool include_version, 239 quic::QuicStreamId data_stream_id, 240 absl::string_view data, 241 quic::QuicStreamId rst_stream_id, 242 quic::QuicRstStreamErrorCode error_code, 243 quic::QuicErrorCode quic_error, 244 const std::string& quic_error_details); 245 246 std::unique_ptr<quic::QuicReceivedPacket> 247 MakeDataRstAckAndConnectionClosePacket( 248 uint64_t num, 249 bool include_version, 250 quic::QuicStreamId data_stream_id, 251 absl::string_view data, 252 quic::QuicStreamId rst_stream_id, 253 quic::QuicRstStreamErrorCode error_code, 254 uint64_t largest_received, 255 uint64_t smallest_received, 256 quic::QuicErrorCode quic_error, 257 const std::string& quic_error_details); 258 259 std::unique_ptr<quic::QuicReceivedPacket> 260 MakeDataRstAckAndConnectionClosePacket( 261 uint64_t num, 262 bool include_version, 263 quic::QuicStreamId data_stream_id, 264 absl::string_view data, 265 quic::QuicStreamId rst_stream_id, 266 quic::QuicRstStreamErrorCode error_code, 267 uint64_t largest_received, 268 uint64_t smallest_received, 269 quic::QuicErrorCode quic_error, 270 const std::string& quic_error_details, 271 uint64_t frame_type); 272 273 std::unique_ptr<quic::QuicReceivedPacket> MakeStopSendingPacket( 274 uint64_t num, 275 bool include_version, 276 quic::QuicStreamId stream_id, 277 quic::QuicRstStreamErrorCode error_code); 278 279 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndConnectionClosePacket( 280 uint64_t num, 281 bool include_version, 282 uint64_t largest_received, 283 uint64_t smallest_received, 284 quic::QuicErrorCode quic_error, 285 const std::string& quic_error_details, 286 uint64_t frame_type); 287 288 std::unique_ptr<quic::QuicReceivedPacket> MakeConnectionClosePacket( 289 uint64_t num, 290 bool include_version, 291 quic::QuicErrorCode quic_error, 292 const std::string& quic_error_details); 293 294 std::unique_ptr<quic::QuicReceivedPacket> MakeGoAwayPacket( 295 uint64_t num, 296 quic::QuicErrorCode error_code, 297 std::string reason_phrase); 298 299 std::unique_ptr<quic::QuicReceivedPacket> MakeAckPacket( 300 uint64_t packet_number, 301 uint64_t largest_received, 302 uint64_t smallest_received); 303 304 std::unique_ptr<quic::QuicReceivedPacket> MakeAckPacket( 305 uint64_t packet_number, 306 uint64_t first_received, 307 uint64_t largest_received, 308 uint64_t smallest_received); 309 310 std::unique_ptr<quic::QuicReceivedPacket> MakeDataPacket( 311 uint64_t packet_number, 312 quic::QuicStreamId stream_id, 313 bool should_include_version, 314 bool fin, 315 absl::string_view data); 316 317 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndDataPacket( 318 uint64_t packet_number, 319 bool include_version, 320 quic::QuicStreamId stream_id, 321 uint64_t largest_received, 322 uint64_t smallest_received, 323 bool fin, 324 absl::string_view data); 325 326 std::unique_ptr<quic::QuicReceivedPacket> MakeAckRetransmissionAndDataPacket( 327 uint64_t packet_number, 328 bool include_version, 329 const std::vector<uint64_t>& original_packet_numbers, 330 quic::QuicStreamId stream_id, 331 uint64_t largest_received, 332 uint64_t smallest_received, 333 bool fin, 334 absl::string_view data); 335 336 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndRetransmissionPacket( 337 uint64_t packet_number, 338 uint64_t first_received, 339 uint64_t largest_received, 340 uint64_t smallest_received, 341 const std::vector<uint64_t>& original_packet_numbers); 342 343 std::unique_ptr<quic::QuicReceivedPacket> 344 MakeRequestHeadersAndMultipleDataFramesPacket( 345 uint64_t packet_number, 346 quic::QuicStreamId stream_id, 347 bool should_include_version, 348 bool fin, 349 spdy::SpdyPriority spdy_priority, 350 spdy::Http2HeaderBlock headers, 351 size_t* spdy_headers_frame_length, 352 const std::vector<std::string>& data_writes); 353 354 // If |spdy_headers_frame_length| is non-null, it will be set to the size of 355 // the SPDY headers frame created for this packet. 356 std::unique_ptr<quic::QuicReceivedPacket> MakeRequestHeadersPacket( 357 uint64_t packet_number, 358 quic::QuicStreamId stream_id, 359 bool should_include_version, 360 bool fin, 361 spdy::SpdyPriority spdy_priority, 362 spdy::Http2HeaderBlock headers, 363 size_t* spdy_headers_frame_length, 364 bool should_include_priority_frame = true); 365 366 std::unique_ptr<quic::QuicReceivedPacket> 367 MakeRetransmissionAndRequestHeadersPacket( 368 const std::vector<uint64_t>& original_packet_numbers, 369 uint64_t packet_number, 370 quic::QuicStreamId stream_id, 371 bool should_include_version, 372 bool fin, 373 spdy::SpdyPriority spdy_priority, 374 spdy::Http2HeaderBlock headers, 375 size_t* spdy_headers_frame_length); 376 377 std::unique_ptr<quic::QuicReceivedPacket> MakeRequestHeadersAndRstPacket( 378 uint64_t packet_number, 379 quic::QuicStreamId stream_id, 380 bool should_include_version, 381 bool fin, 382 spdy::SpdyPriority spdy_priority, 383 spdy::Http2HeaderBlock headers, 384 size_t* spdy_headers_frame_length, 385 quic::QuicRstStreamErrorCode error_code); 386 387 // If |spdy_headers_frame_length| is non-null, it will be set to the size of 388 // the SPDY headers frame created for this packet. 389 std::unique_ptr<quic::QuicReceivedPacket> MakeResponseHeadersPacket( 390 uint64_t packet_number, 391 quic::QuicStreamId stream_id, 392 bool should_include_version, 393 bool fin, 394 spdy::Http2HeaderBlock headers, 395 size_t* spdy_headers_frame_length); 396 397 // Creates a packet containing the initial SETTINGS frame, and saves the 398 // headers stream offset into |offset|. 399 std::unique_ptr<quic::QuicReceivedPacket> MakeInitialSettingsPacket( 400 uint64_t packet_number); 401 402 std::unique_ptr<quic::QuicReceivedPacket> MakePriorityPacket( 403 uint64_t packet_number, 404 bool should_include_version, 405 quic::QuicStreamId id, 406 spdy::SpdyPriority spdy_priority); 407 408 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndPriorityPacket( 409 uint64_t packet_number, 410 bool should_include_version, 411 uint64_t largest_received, 412 uint64_t smallest_received, 413 quic::QuicStreamId id, 414 spdy::SpdyPriority spdy_priority); 415 416 std::unique_ptr<quic::QuicReceivedPacket> MakeRetransmissionPacket( 417 uint64_t original_packet_number, 418 uint64_t new_packet_number, 419 bool should_include_version); 420 421 std::unique_ptr<quic::QuicReceivedPacket> MakeCombinedRetransmissionPacket( 422 const std::vector<uint64_t>& original_packet_numbers, 423 uint64_t new_packet_number, 424 bool should_include_version); 425 426 std::unique_ptr<quic::QuicReceivedPacket> MakeAckAndPriorityUpdatePacket( 427 uint64_t packet_number, 428 bool should_include_version, 429 uint64_t largest_received, 430 uint64_t smallest_received, 431 quic::QuicStreamId id, 432 spdy::SpdyPriority spdy_priority); 433 434 std::unique_ptr<quic::QuicEncryptedPacket> MakeStatelessResetPacket(); 435 436 // Removes all stream frames associated with |stream_id|. 437 void RemoveSavedStreamFrames(quic::QuicStreamId stream_id); 438 439 void SetEncryptionLevel(quic::EncryptionLevel level); 440 441 spdy::Http2HeaderBlock GetRequestHeaders(const std::string& method, 442 const std::string& scheme, 443 const std::string& path) const; 444 445 spdy::Http2HeaderBlock ConnectRequestHeaders( 446 const std::string& host_port) const; 447 448 spdy::Http2HeaderBlock GetResponseHeaders(const std::string& status) const; 449 450 spdy::Http2HeaderBlock GetResponseHeaders(const std::string& status, 451 const std::string& alt_svc) const; 452 453 void Reset(); 454 stream_offset(quic::QuicStreamId stream_id)455 quic::QuicStreamOffset stream_offset(quic::QuicStreamId stream_id) { 456 return stream_offsets_[stream_id]; 457 } 458 set_save_packet_frames(bool save_packet_frames)459 void set_save_packet_frames(bool save_packet_frames) { 460 save_packet_frames_ = save_packet_frames; 461 } 462 463 std::string QpackEncodeHeaders(quic::QuicStreamId stream_id, 464 spdy::Http2HeaderBlock headers, 465 size_t* encoded_data_length); 466 467 private: 468 // Initialize header of next packet to build. 469 void InitializeHeader(uint64_t packet_number, bool should_include_version); 470 471 // Add frames to current packet. 472 void AddQuicPaddingFrame(); 473 void AddQuicPingFrame(); 474 void AddQuicRetireConnectionIdFrame(uint64_t sequence_number); 475 void AddQuicNewConnectionIdFrame(const quic::QuicConnectionId& cid, 476 uint64_t sequence_number, 477 uint64_t retire_prior_to, 478 quic::StatelessResetToken reset_token); 479 void AddQuicMaxStreamsFrame(quic::QuicControlFrameId control_frame_id, 480 quic::QuicStreamCount stream_count, 481 bool unidirectional); 482 void AddQuicStreamsBlockedFrame(quic::QuicControlFrameId control_frame_id, 483 quic::QuicStreamCount stream_count, 484 bool unidirectional); 485 // Use and increase stream's current offset. 486 void AddQuicStreamFrame(quic::QuicStreamId stream_id, 487 bool fin, 488 absl::string_view data); 489 // Use |offset| and do not change stream's current offset. 490 void AddQuicStreamFrameWithOffset(quic::QuicStreamId stream_id, 491 bool fin, 492 quic::QuicStreamOffset offset, 493 absl::string_view data); 494 void AddQuicAckFrame(uint64_t largest_received, uint64_t smallest_received); 495 void AddQuicAckFrame(uint64_t first_received, 496 uint64_t largest_received, 497 uint64_t smallest_received); 498 void AddQuicRstStreamFrame(quic::QuicStreamId stream_id, 499 quic::QuicRstStreamErrorCode error_code); 500 void AddQuicConnectionCloseFrame(quic::QuicErrorCode quic_error, 501 const std::string& quic_error_details); 502 void AddQuicConnectionCloseFrame(quic::QuicErrorCode quic_error, 503 const std::string& quic_error_details, 504 uint64_t frame_type); 505 void AddQuicGoAwayFrame(quic::QuicErrorCode error_code, 506 std::string reason_phrase); 507 void AddQuicPathResponseFrame(); 508 void AddQuicPathChallengeFrame(); 509 void AddQuicStopSendingFrame(quic::QuicStreamId stream_id, 510 quic::QuicRstStreamErrorCode error_code); 511 void AddQuicCryptoFrame(quic::EncryptionLevel level, 512 quic::QuicStreamOffset offset, 513 quic::QuicPacketLength data_length); 514 515 // Build packet using |header_|, |frames_|, and |data_producer_|, 516 // and clear |frames_| and |data_producer_| afterwards. 517 std::unique_ptr<quic::QuicReceivedPacket> BuildPacket(); 518 519 // Build packet using |header_|, |frames|, and |data_producer|. 520 std::unique_ptr<quic::QuicReceivedPacket> BuildPacketImpl( 521 const quic::QuicFrames& frames, 522 quic::QuicStreamFrameDataProducer* data_producer); 523 524 bool ShouldIncludeVersion(bool include_version) const; 525 526 quic::QuicPacketNumberLength GetPacketNumberLength() const; 527 528 quic::QuicConnectionId DestinationConnectionId() const; 529 quic::QuicConnectionId SourceConnectionId() const; 530 531 quic::QuicConnectionIdIncluded HasDestinationConnectionId() const; 532 quic::QuicConnectionIdIncluded HasSourceConnectionId() const; 533 534 quic::QuicStreamId GetFirstBidirectionalStreamId() const; 535 quic::QuicStreamId GetHeadersStreamId() const; 536 537 std::string GenerateHttp3SettingsData(); 538 std::string GenerateHttp3PriorityData(spdy::SpdyPriority spdy_priority, 539 quic::QuicStreamId stream_id); 540 std::string GenerateHttp3GreaseData(); 541 542 void MaybeAddHttp3SettingsFrames(); 543 bool MaybeCoalesceStreamFrame(const quic::QuicFrame& frame); 544 545 // Parameters used throughout the lifetime of the class. 546 quic::ParsedQuicVersion version_; 547 quic::QuicConnectionId connection_id_; 548 raw_ptr<const quic::QuicClock> clock_; // Not owned. 549 std::string host_; 550 quic::NoopDecoderStreamErrorDelegate decoder_stream_error_delegate_; 551 quic::test::NoopQpackStreamSenderDelegate encoder_stream_sender_delegate_; 552 quic::QpackEncoder qpack_encoder_; 553 quic::test::MockRandom random_generator_; 554 std::map<quic::QuicStreamId, quic::QuicStreamOffset> stream_offsets_; 555 quic::Perspective perspective_; 556 quic::EncryptionLevel encryption_level_ = quic::ENCRYPTION_FORWARD_SECURE; 557 quic::QuicLongHeaderType long_header_type_ = quic::INVALID_PACKET_TYPE; 558 559 // The value of incremental flag in generated priority headers. 560 bool client_priority_uses_incremental_; 561 562 // Save a copy of stream frame data that QuicStreamFrame objects can refer to. 563 std::vector<std::unique_ptr<std::string>> saved_stream_data_; 564 // If |save_packet_frames_| is true, save generated packets in 565 // |saved_frames_|, allowing retransmission packets to be built. 566 bool save_packet_frames_ = false; 567 std::map<quic::QuicPacketNumber, quic::QuicFrames> saved_frames_; 568 569 // State necessary for building the current packet. 570 quic::QuicPacketHeader header_; 571 quic::QuicFrames frames_; 572 std::unique_ptr<quic::test::SimpleDataProducer> data_producer_; 573 }; 574 575 } // namespace net::test 576 577 #endif // NET_QUIC_QUIC_TEST_PACKET_MAKER_H_ 578