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