quic_test_packet_maker.cc 58 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/quic/quic_test_packet_maker.h"
  5. #include <list>
  6. #include <utility>
  7. #include "base/strings/strcat.h"
  8. #include "base/strings/string_number_conversions.h"
  9. #include "net/quic/mock_crypto_client_stream.h"
  10. #include "net/quic/quic_chromium_client_session.h"
  11. #include "net/quic/quic_http_utils.h"
  12. #include "net/third_party/quiche/src/quiche/quic/core/crypto/null_encrypter.h"
  13. #include "net/third_party/quiche/src/quiche/quic/core/http/http_constants.h"
  14. #include "net/third_party/quiche/src/quiche/quic/core/quic_framer.h"
  15. #include "net/third_party/quiche/src/quiche/quic/core/quic_stream.h"
  16. #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
  17. #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
  18. #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
  19. namespace net::test {
  20. namespace {
  21. quic::QuicFrames CloneFrames(const quic::QuicFrames& frames) {
  22. quic::QuicFrames new_frames = frames;
  23. for (auto& frame : new_frames) {
  24. switch (frame.type) {
  25. // Frames smaller than a pointer are inlined, so don't need to be cloned.
  26. case quic::PADDING_FRAME:
  27. case quic::MTU_DISCOVERY_FRAME:
  28. case quic::PING_FRAME:
  29. case quic::MAX_STREAMS_FRAME:
  30. case quic::STOP_WAITING_FRAME:
  31. case quic::STREAMS_BLOCKED_FRAME:
  32. case quic::STREAM_FRAME:
  33. case quic::HANDSHAKE_DONE_FRAME:
  34. case quic::BLOCKED_FRAME:
  35. case quic::WINDOW_UPDATE_FRAME:
  36. case quic::STOP_SENDING_FRAME:
  37. case quic::PATH_CHALLENGE_FRAME:
  38. case quic::PATH_RESPONSE_FRAME:
  39. break;
  40. case quic::ACK_FRAME:
  41. frame.ack_frame = new quic::QuicAckFrame(*frame.ack_frame);
  42. break;
  43. case quic::RST_STREAM_FRAME:
  44. frame.rst_stream_frame =
  45. new quic::QuicRstStreamFrame(*frame.rst_stream_frame);
  46. break;
  47. case quic::CONNECTION_CLOSE_FRAME:
  48. frame.connection_close_frame =
  49. new quic::QuicConnectionCloseFrame(*frame.connection_close_frame);
  50. break;
  51. case quic::GOAWAY_FRAME:
  52. frame.goaway_frame = new quic::QuicGoAwayFrame(*frame.goaway_frame);
  53. break;
  54. case quic::NEW_CONNECTION_ID_FRAME:
  55. frame.new_connection_id_frame =
  56. new quic::QuicNewConnectionIdFrame(*frame.new_connection_id_frame);
  57. break;
  58. case quic::RETIRE_CONNECTION_ID_FRAME:
  59. frame.retire_connection_id_frame =
  60. new quic::QuicRetireConnectionIdFrame(
  61. *frame.retire_connection_id_frame);
  62. break;
  63. case quic::MESSAGE_FRAME:
  64. DCHECK(false) << "Message frame not supported";
  65. // frame.message_frame = new
  66. // quic::QuicMessageFrame(*frame.message_frame);
  67. break;
  68. case quic::CRYPTO_FRAME:
  69. frame.crypto_frame = new quic::QuicCryptoFrame(*frame.crypto_frame);
  70. break;
  71. case quic::NEW_TOKEN_FRAME:
  72. frame.new_token_frame =
  73. new quic::QuicNewTokenFrame(*frame.new_token_frame);
  74. break;
  75. case quic::ACK_FREQUENCY_FRAME:
  76. frame.ack_frequency_frame =
  77. new quic::QuicAckFrequencyFrame(*frame.ack_frequency_frame);
  78. break;
  79. case quic::NUM_FRAME_TYPES:
  80. DCHECK(false) << "Cannot clone frame type: " << frame.type;
  81. }
  82. }
  83. return new_frames;
  84. }
  85. } // namespace
  86. QuicTestPacketMaker::QuicTestPacketMaker(
  87. quic::ParsedQuicVersion version,
  88. quic::QuicConnectionId connection_id,
  89. const quic::QuicClock* clock,
  90. const std::string& host,
  91. quic::Perspective perspective,
  92. bool client_headers_include_h2_stream_dependency)
  93. : version_(version),
  94. connection_id_(connection_id),
  95. clock_(clock),
  96. host_(host),
  97. spdy_request_framer_(spdy::SpdyFramer::ENABLE_COMPRESSION),
  98. spdy_response_framer_(spdy::SpdyFramer::ENABLE_COMPRESSION),
  99. qpack_encoder_(&decoder_stream_error_delegate_),
  100. perspective_(perspective),
  101. client_headers_include_h2_stream_dependency_(
  102. client_headers_include_h2_stream_dependency) {
  103. DCHECK(!(perspective_ == quic::Perspective::IS_SERVER &&
  104. client_headers_include_h2_stream_dependency_));
  105. qpack_encoder_.set_qpack_stream_sender_delegate(
  106. &encoder_stream_sender_delegate_);
  107. }
  108. QuicTestPacketMaker::~QuicTestPacketMaker() {
  109. for (auto& kv : saved_frames_) {
  110. quic::DeleteFrames(&(kv.second));
  111. }
  112. }
  113. void QuicTestPacketMaker::set_hostname(const std::string& host) {
  114. host_.assign(host);
  115. }
  116. std::unique_ptr<quic::QuicReceivedPacket>
  117. QuicTestPacketMaker::MakeConnectivityProbingPacket(uint64_t num,
  118. bool include_version) {
  119. InitializeHeader(num, include_version);
  120. if (!version_.HasIetfQuicFrames()) {
  121. AddQuicPingFrame();
  122. } else if (perspective_ == quic::Perspective::IS_CLIENT) {
  123. AddQuicPathChallengeFrame();
  124. } else {
  125. AddQuicPathResponseFrame();
  126. }
  127. AddQuicPaddingFrame();
  128. return BuildPacket();
  129. }
  130. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
  131. uint64_t num,
  132. bool include_version) {
  133. InitializeHeader(num, include_version);
  134. AddQuicPingFrame();
  135. return BuildPacket();
  136. }
  137. std::unique_ptr<quic::QuicReceivedPacket>
  138. QuicTestPacketMaker::MakeRetireConnectionIdPacket(uint64_t num,
  139. bool include_version,
  140. uint64_t sequence_number) {
  141. InitializeHeader(num, include_version);
  142. AddQuicRetireConnectionIdFrame(sequence_number);
  143. return BuildPacket();
  144. }
  145. std::unique_ptr<quic::QuicReceivedPacket>
  146. QuicTestPacketMaker::MakeNewConnectionIdPacket(
  147. uint64_t num,
  148. bool include_version,
  149. const quic::QuicConnectionId& cid,
  150. uint64_t sequence_number,
  151. uint64_t retire_prior_to) {
  152. InitializeHeader(num, include_version);
  153. AddQuicNewConnectionIdFrame(
  154. cid, sequence_number, retire_prior_to,
  155. quic::QuicUtils::GenerateStatelessResetToken(cid));
  156. return BuildPacket();
  157. }
  158. std::unique_ptr<quic::QuicReceivedPacket>
  159. QuicTestPacketMaker::MakeAckAndNewConnectionIdPacket(
  160. uint64_t num,
  161. bool include_version,
  162. uint64_t largest_received,
  163. uint64_t smallest_received,
  164. const quic::QuicConnectionId& cid,
  165. uint64_t sequence_number,
  166. uint64_t retire_prior_to) {
  167. InitializeHeader(num, include_version);
  168. AddQuicAckFrame(largest_received, smallest_received);
  169. AddQuicNewConnectionIdFrame(
  170. cid, sequence_number, retire_prior_to,
  171. quic::QuicUtils::GenerateStatelessResetToken(cid));
  172. return BuildPacket();
  173. }
  174. std::unique_ptr<quic::QuicReceivedPacket>
  175. QuicTestPacketMaker::MakeDummyCHLOPacket(uint64_t packet_num) {
  176. SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
  177. InitializeHeader(packet_num, /*include_version=*/true);
  178. quic::CryptoHandshakeMessage message =
  179. MockCryptoClientStream::GetDummyCHLOMessage();
  180. const quic::QuicData& data = message.GetSerialized();
  181. if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
  182. AddQuicStreamFrameWithOffset(
  183. quic::QuicUtils::GetCryptoStreamId(version_.transport_version),
  184. /*fin=*/false, /*offset=*/0, data.AsStringPiece());
  185. } else {
  186. AddQuicCryptoFrame(quic::ENCRYPTION_INITIAL, 0, data.length());
  187. data_producer_ = std::make_unique<quic::test::SimpleDataProducer>();
  188. data_producer_->SaveCryptoData(quic::ENCRYPTION_INITIAL, 0,
  189. data.AsStringPiece());
  190. }
  191. AddQuicPaddingFrame();
  192. return BuildPacket();
  193. }
  194. std::unique_ptr<quic::QuicReceivedPacket>
  195. QuicTestPacketMaker::MakeAckAndPingPacket(uint64_t num,
  196. bool include_version,
  197. uint64_t largest_received,
  198. uint64_t smallest_received) {
  199. InitializeHeader(num, include_version);
  200. AddQuicAckFrame(largest_received, smallest_received);
  201. AddQuicPingFrame();
  202. return BuildPacket();
  203. }
  204. std::unique_ptr<quic::QuicReceivedPacket>
  205. QuicTestPacketMaker::MakeAckAndRetireConnectionIdPacket(
  206. uint64_t num,
  207. bool include_version,
  208. uint64_t largest_received,
  209. uint64_t smallest_received,
  210. uint64_t sequence_number) {
  211. InitializeHeader(num, include_version);
  212. AddQuicAckFrame(largest_received, smallest_received);
  213. AddQuicRetireConnectionIdFrame(sequence_number);
  214. return BuildPacket();
  215. }
  216. std::unique_ptr<quic::QuicReceivedPacket>
  217. QuicTestPacketMaker::MakeRetransmissionAndRetireConnectionIdPacket(
  218. uint64_t num,
  219. bool include_version,
  220. const std::vector<uint64_t>& original_packet_numbers,
  221. uint64_t sequence_number) {
  222. InitializeHeader(num, include_version);
  223. for (auto it : original_packet_numbers) {
  224. for (auto frame : saved_frames_[quic::QuicPacketNumber(it)]) {
  225. frames_.push_back(frame);
  226. }
  227. }
  228. AddQuicRetireConnectionIdFrame(sequence_number);
  229. return BuildPacket();
  230. }
  231. std::unique_ptr<quic::QuicReceivedPacket>
  232. QuicTestPacketMaker::MakeStreamsBlockedPacket(
  233. uint64_t num,
  234. bool include_version,
  235. quic::QuicStreamCount stream_count,
  236. bool unidirectional) {
  237. InitializeHeader(num, include_version);
  238. AddQuicStreamsBlockedFrame(1, stream_count, unidirectional);
  239. return BuildPacket();
  240. }
  241. std::unique_ptr<quic::QuicReceivedPacket>
  242. QuicTestPacketMaker::MakeMaxStreamsPacket(uint64_t num,
  243. bool include_version,
  244. quic::QuicStreamCount stream_count,
  245. bool unidirectional) {
  246. InitializeHeader(num, include_version);
  247. AddQuicMaxStreamsFrame(1, stream_count, unidirectional);
  248. return BuildPacket();
  249. }
  250. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
  251. uint64_t num,
  252. bool include_version,
  253. quic::QuicStreamId stream_id,
  254. quic::QuicRstStreamErrorCode error_code) {
  255. return MakeRstPacket(num, include_version, stream_id, error_code,
  256. /*include_stop_sending_if_v99=*/true);
  257. }
  258. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
  259. uint64_t num,
  260. bool include_version,
  261. quic::QuicStreamId stream_id,
  262. quic::QuicRstStreamErrorCode error_code,
  263. bool include_stop_sending_if_v99) {
  264. InitializeHeader(num, include_version);
  265. if (include_stop_sending_if_v99 && version_.HasIetfQuicFrames()) {
  266. AddQuicStopSendingFrame(stream_id, error_code);
  267. }
  268. if (!version_.HasIetfQuicFrames() ||
  269. quic::QuicUtils::IsBidirectionalStreamId(stream_id, version_)) {
  270. AddQuicRstStreamFrame(stream_id, error_code);
  271. }
  272. return BuildPacket();
  273. }
  274. std::unique_ptr<quic::QuicReceivedPacket>
  275. QuicTestPacketMaker::MakeRstAndDataPacket(
  276. uint64_t num,
  277. bool include_version,
  278. quic::QuicStreamId rst_stream_id,
  279. quic::QuicRstStreamErrorCode rst_error_code,
  280. quic::QuicStreamId data_stream_id,
  281. absl::string_view data) {
  282. InitializeHeader(num, include_version);
  283. if (version_.HasIetfQuicFrames()) {
  284. AddQuicStopSendingFrame(rst_stream_id, rst_error_code);
  285. }
  286. AddQuicRstStreamFrame(rst_stream_id, rst_error_code);
  287. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  288. return BuildPacket();
  289. }
  290. std::unique_ptr<quic::QuicReceivedPacket>
  291. QuicTestPacketMaker::MakeRetransmissionRstAndDataPacket(
  292. const std::vector<uint64_t>& original_packet_numbers,
  293. uint64_t num,
  294. bool include_version,
  295. quic::QuicStreamId rst_stream_id,
  296. quic::QuicRstStreamErrorCode rst_error_code,
  297. quic::QuicStreamId data_stream_id,
  298. absl::string_view data) {
  299. DCHECK(save_packet_frames_);
  300. InitializeHeader(num, include_version);
  301. for (auto it : original_packet_numbers) {
  302. for (auto frame : saved_frames_[quic::QuicPacketNumber(it)]) {
  303. frames_.push_back(frame);
  304. }
  305. }
  306. if (version_.HasIetfQuicFrames()) {
  307. AddQuicStopSendingFrame(rst_stream_id, rst_error_code);
  308. }
  309. AddQuicRstStreamFrame(rst_stream_id, rst_error_code);
  310. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  311. return BuildPacket();
  312. }
  313. std::unique_ptr<quic::QuicReceivedPacket>
  314. QuicTestPacketMaker::MakeDataAndRstPacket(
  315. uint64_t num,
  316. bool include_version,
  317. quic::QuicStreamId data_stream_id,
  318. absl::string_view data,
  319. quic::QuicStreamId rst_stream_id,
  320. quic::QuicRstStreamErrorCode rst_error_code) {
  321. InitializeHeader(num, include_version);
  322. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  323. if (version_.HasIetfQuicFrames()) {
  324. AddQuicStopSendingFrame(rst_stream_id, rst_error_code);
  325. }
  326. AddQuicRstStreamFrame(rst_stream_id, rst_error_code);
  327. return BuildPacket();
  328. }
  329. std::unique_ptr<quic::QuicReceivedPacket>
  330. QuicTestPacketMaker::MakeDataRstAndAckPacket(
  331. uint64_t num,
  332. bool include_version,
  333. quic::QuicStreamId data_stream_id,
  334. absl::string_view data,
  335. quic::QuicStreamId rst_stream_id,
  336. quic::QuicRstStreamErrorCode rst_error_code,
  337. uint64_t largest_received,
  338. uint64_t smallest_received) {
  339. InitializeHeader(num, include_version);
  340. AddQuicAckFrame(largest_received, smallest_received);
  341. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  342. if (version_.HasIetfQuicFrames()) {
  343. AddQuicStopSendingFrame(rst_stream_id, rst_error_code);
  344. }
  345. AddQuicRstStreamFrame(rst_stream_id, rst_error_code);
  346. return BuildPacket();
  347. }
  348. std::unique_ptr<quic::QuicReceivedPacket>
  349. QuicTestPacketMaker::MakeAckAndRstPacket(
  350. uint64_t num,
  351. bool include_version,
  352. quic::QuicStreamId stream_id,
  353. quic::QuicRstStreamErrorCode error_code,
  354. uint64_t largest_received,
  355. uint64_t smallest_received) {
  356. return MakeAckAndRstPacket(num, include_version, stream_id, error_code,
  357. largest_received, smallest_received,
  358. /*include_stop_sending_if_v99=*/true);
  359. }
  360. std::unique_ptr<quic::QuicReceivedPacket>
  361. QuicTestPacketMaker::MakeAckAndRstPacket(
  362. uint64_t num,
  363. bool include_version,
  364. quic::QuicStreamId stream_id,
  365. quic::QuicRstStreamErrorCode error_code,
  366. uint64_t largest_received,
  367. uint64_t smallest_received,
  368. bool include_stop_sending_if_v99) {
  369. InitializeHeader(num, include_version);
  370. AddQuicAckFrame(largest_received, smallest_received);
  371. if (version_.HasIetfQuicFrames() && include_stop_sending_if_v99) {
  372. AddQuicStopSendingFrame(stream_id, error_code);
  373. }
  374. if (!version_.HasIetfQuicFrames() ||
  375. quic::QuicUtils::IsBidirectionalStreamId(stream_id, version_)) {
  376. AddQuicRstStreamFrame(stream_id, error_code);
  377. }
  378. return BuildPacket();
  379. }
  380. std::unique_ptr<quic::QuicReceivedPacket>
  381. QuicTestPacketMaker::MakeRstAckAndConnectionClosePacket(
  382. uint64_t num,
  383. bool include_version,
  384. quic::QuicStreamId stream_id,
  385. quic::QuicRstStreamErrorCode error_code,
  386. uint64_t largest_received,
  387. uint64_t smallest_received,
  388. quic::QuicErrorCode quic_error,
  389. const std::string& quic_error_details) {
  390. InitializeHeader(num, include_version);
  391. AddQuicAckFrame(largest_received, smallest_received);
  392. if (version_.HasIetfQuicFrames()) {
  393. AddQuicStopSendingFrame(stream_id, error_code);
  394. }
  395. AddQuicRstStreamFrame(stream_id, error_code);
  396. AddQuicConnectionCloseFrame(quic_error, quic_error_details);
  397. return BuildPacket();
  398. }
  399. std::unique_ptr<quic::QuicReceivedPacket>
  400. QuicTestPacketMaker::MakeRstAckAndDataPacket(
  401. uint64_t num,
  402. bool include_version,
  403. quic::QuicStreamId stream_id,
  404. quic::QuicRstStreamErrorCode error_code,
  405. uint64_t largest_received,
  406. uint64_t smallest_received,
  407. quic::QuicStreamId data_id,
  408. bool fin,
  409. absl::string_view data) {
  410. InitializeHeader(num, include_version);
  411. AddQuicRstStreamFrame(stream_id, error_code);
  412. AddQuicAckFrame(largest_received, smallest_received);
  413. AddQuicStreamFrame(data_id, fin, data);
  414. return BuildPacket();
  415. }
  416. std::unique_ptr<quic::QuicReceivedPacket>
  417. QuicTestPacketMaker::MakeAckDataAndRst(uint64_t num,
  418. bool include_version,
  419. quic::QuicStreamId stream_id,
  420. quic::QuicRstStreamErrorCode error_code,
  421. uint64_t largest_received,
  422. uint64_t smallest_received,
  423. quic::QuicStreamId data_id,
  424. bool fin,
  425. absl::string_view data) {
  426. InitializeHeader(num, include_version);
  427. AddQuicAckFrame(largest_received, smallest_received);
  428. AddQuicStreamFrame(data_id, fin, data);
  429. AddQuicStopSendingFrame(stream_id, error_code);
  430. AddQuicRstStreamFrame(stream_id, error_code);
  431. return BuildPacket();
  432. }
  433. std::unique_ptr<quic::QuicReceivedPacket>
  434. QuicTestPacketMaker::MakeAckRstAndDataPacket(
  435. uint64_t num,
  436. bool include_version,
  437. quic::QuicStreamId stream_id,
  438. quic::QuicRstStreamErrorCode error_code,
  439. uint64_t largest_received,
  440. uint64_t smallest_received,
  441. quic::QuicStreamId data_id,
  442. bool fin,
  443. absl::string_view data) {
  444. InitializeHeader(num, include_version);
  445. AddQuicAckFrame(largest_received, smallest_received);
  446. AddQuicRstStreamFrame(stream_id, error_code);
  447. AddQuicStreamFrame(data_id, fin, data);
  448. return BuildPacket();
  449. }
  450. std::unique_ptr<quic::QuicReceivedPacket>
  451. QuicTestPacketMaker::MakeAckAndRetransmissionPacket(
  452. uint64_t packet_number,
  453. uint64_t first_received,
  454. uint64_t largest_received,
  455. uint64_t smallest_received,
  456. const std::vector<uint64_t>& original_packet_numbers) {
  457. DCHECK(save_packet_frames_);
  458. InitializeHeader(packet_number, /*include_version=*/false);
  459. AddQuicAckFrame(first_received, largest_received, smallest_received);
  460. for (auto it : original_packet_numbers) {
  461. for (auto frame : saved_frames_[quic::QuicPacketNumber(it)]) {
  462. frames_.push_back(frame);
  463. }
  464. }
  465. return BuildPacket();
  466. }
  467. std::unique_ptr<quic::QuicReceivedPacket>
  468. QuicTestPacketMaker::MakeCombinedRetransmissionPacket(
  469. const std::vector<uint64_t>& original_packet_numbers,
  470. uint64_t new_packet_number,
  471. bool should_include_version) {
  472. DCHECK(save_packet_frames_);
  473. InitializeHeader(new_packet_number, should_include_version);
  474. for (auto it : original_packet_numbers) {
  475. for (auto& frame : CloneFrames(saved_frames_[quic::QuicPacketNumber(it)])) {
  476. if (frame.type != quic::PADDING_FRAME) {
  477. frames_.push_back(frame);
  478. }
  479. }
  480. }
  481. return BuildPacket();
  482. }
  483. std::unique_ptr<quic::QuicReceivedPacket>
  484. QuicTestPacketMaker::MakeRstAndConnectionClosePacket(
  485. uint64_t num,
  486. bool include_version,
  487. quic::QuicStreamId stream_id,
  488. quic::QuicRstStreamErrorCode error_code,
  489. quic::QuicErrorCode quic_error,
  490. const std::string& quic_error_details) {
  491. InitializeHeader(num, include_version);
  492. if (version_.HasIetfQuicFrames()) {
  493. AddQuicStopSendingFrame(stream_id, error_code);
  494. }
  495. AddQuicRstStreamFrame(stream_id, error_code);
  496. AddQuicConnectionCloseFrame(quic_error, quic_error_details);
  497. return BuildPacket();
  498. }
  499. std::unique_ptr<quic::QuicReceivedPacket>
  500. QuicTestPacketMaker::MakeDataRstAndConnectionClosePacket(
  501. uint64_t num,
  502. bool include_version,
  503. quic::QuicStreamId data_stream_id,
  504. absl::string_view data,
  505. quic::QuicStreamId rst_stream_id,
  506. quic::QuicRstStreamErrorCode error_code,
  507. quic::QuicErrorCode quic_error,
  508. const std::string& quic_error_details) {
  509. InitializeHeader(num, include_version);
  510. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  511. if (version_.HasIetfQuicFrames()) {
  512. AddQuicStopSendingFrame(rst_stream_id, error_code);
  513. }
  514. AddQuicRstStreamFrame(rst_stream_id, error_code);
  515. AddQuicConnectionCloseFrame(quic_error, quic_error_details);
  516. return BuildPacket();
  517. }
  518. std::unique_ptr<quic::QuicReceivedPacket>
  519. QuicTestPacketMaker::MakeDataRstAckAndConnectionClosePacket(
  520. uint64_t num,
  521. bool include_version,
  522. quic::QuicStreamId data_stream_id,
  523. absl::string_view data,
  524. quic::QuicStreamId rst_stream_id,
  525. quic::QuicRstStreamErrorCode error_code,
  526. uint64_t largest_received,
  527. uint64_t smallest_received,
  528. quic::QuicErrorCode quic_error,
  529. const std::string& quic_error_details) {
  530. InitializeHeader(num, include_version);
  531. AddQuicAckFrame(largest_received, smallest_received);
  532. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  533. if (version_.HasIetfQuicFrames()) {
  534. AddQuicStopSendingFrame(rst_stream_id, error_code);
  535. }
  536. AddQuicRstStreamFrame(rst_stream_id, error_code);
  537. AddQuicConnectionCloseFrame(quic_error, quic_error_details);
  538. return BuildPacket();
  539. }
  540. std::unique_ptr<quic::QuicReceivedPacket>
  541. QuicTestPacketMaker::MakeDataRstAckAndConnectionClosePacket(
  542. uint64_t num,
  543. bool include_version,
  544. quic::QuicStreamId data_stream_id,
  545. absl::string_view data,
  546. quic::QuicStreamId rst_stream_id,
  547. quic::QuicRstStreamErrorCode error_code,
  548. uint64_t largest_received,
  549. uint64_t smallest_received,
  550. quic::QuicErrorCode quic_error,
  551. const std::string& quic_error_details,
  552. uint64_t frame_type) {
  553. InitializeHeader(num, include_version);
  554. AddQuicStreamFrame(data_stream_id, /* fin = */ false, data);
  555. if (version_.HasIetfQuicFrames()) {
  556. AddQuicStopSendingFrame(rst_stream_id, error_code);
  557. }
  558. AddQuicRstStreamFrame(rst_stream_id, error_code);
  559. AddQuicAckFrame(largest_received, smallest_received);
  560. AddQuicConnectionCloseFrame(quic_error, quic_error_details, frame_type);
  561. return BuildPacket();
  562. }
  563. std::unique_ptr<quic::QuicReceivedPacket>
  564. QuicTestPacketMaker::MakeStopSendingPacket(
  565. uint64_t num,
  566. bool include_version,
  567. quic::QuicStreamId stream_id,
  568. quic::QuicRstStreamErrorCode error_code) {
  569. DCHECK(version_.HasIetfQuicFrames());
  570. InitializeHeader(num, include_version);
  571. AddQuicStopSendingFrame(stream_id, error_code);
  572. return BuildPacket();
  573. }
  574. std::unique_ptr<quic::QuicReceivedPacket>
  575. QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
  576. uint64_t num,
  577. bool include_version,
  578. uint64_t largest_received,
  579. uint64_t smallest_received,
  580. quic::QuicErrorCode quic_error,
  581. const std::string& quic_error_details,
  582. uint64_t frame_type) {
  583. InitializeHeader(num, include_version);
  584. AddQuicAckFrame(largest_received, smallest_received);
  585. AddQuicConnectionCloseFrame(quic_error, quic_error_details, frame_type);
  586. return BuildPacket();
  587. }
  588. std::unique_ptr<quic::QuicReceivedPacket>
  589. QuicTestPacketMaker::MakeConnectionClosePacket(
  590. uint64_t num,
  591. bool include_version,
  592. quic::QuicErrorCode quic_error,
  593. const std::string& quic_error_details) {
  594. InitializeHeader(num, include_version);
  595. AddQuicConnectionCloseFrame(quic_error, quic_error_details);
  596. return BuildPacket();
  597. }
  598. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
  599. uint64_t num,
  600. quic::QuicErrorCode error_code,
  601. std::string reason_phrase) {
  602. InitializeHeader(num, /*include_version=*/false);
  603. AddQuicGoAwayFrame(error_code, reason_phrase);
  604. return BuildPacket();
  605. }
  606. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
  607. uint64_t packet_number,
  608. uint64_t largest_received,
  609. uint64_t smallest_received) {
  610. return MakeAckPacket(packet_number, 1, largest_received, smallest_received);
  611. }
  612. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
  613. uint64_t packet_number,
  614. uint64_t first_received,
  615. uint64_t largest_received,
  616. uint64_t smallest_received) {
  617. InitializeHeader(packet_number, /*include_version=*/false);
  618. AddQuicAckFrame(first_received, largest_received, smallest_received);
  619. return BuildPacket();
  620. }
  621. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
  622. uint64_t packet_number,
  623. quic::QuicStreamId stream_id,
  624. bool should_include_version,
  625. bool fin,
  626. absl::string_view data) {
  627. InitializeHeader(packet_number, should_include_version);
  628. AddQuicStreamFrame(stream_id, fin, data);
  629. return BuildPacket();
  630. }
  631. std::unique_ptr<quic::QuicReceivedPacket>
  632. QuicTestPacketMaker::MakeAckAndDataPacket(uint64_t packet_number,
  633. bool include_version,
  634. quic::QuicStreamId stream_id,
  635. uint64_t largest_received,
  636. uint64_t smallest_received,
  637. bool fin,
  638. absl::string_view data) {
  639. InitializeHeader(packet_number, include_version);
  640. AddQuicAckFrame(largest_received, smallest_received);
  641. AddQuicStreamFrame(stream_id, fin, data);
  642. return BuildPacket();
  643. }
  644. std::unique_ptr<quic::QuicReceivedPacket>
  645. QuicTestPacketMaker::MakeAckRetransmissionAndDataPacket(
  646. uint64_t packet_number,
  647. bool include_version,
  648. const std::vector<uint64_t>& original_packet_numbers,
  649. quic::QuicStreamId stream_id,
  650. uint64_t largest_received,
  651. uint64_t smallest_received,
  652. bool fin,
  653. absl::string_view data) {
  654. InitializeHeader(packet_number, include_version);
  655. AddQuicAckFrame(largest_received, smallest_received);
  656. for (auto it : original_packet_numbers) {
  657. for (auto frame : saved_frames_[quic::QuicPacketNumber(it)]) {
  658. frames_.push_back(frame);
  659. }
  660. }
  661. AddQuicStreamFrame(stream_id, fin, data);
  662. return BuildPacket();
  663. }
  664. std::unique_ptr<quic::QuicReceivedPacket>
  665. QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
  666. uint64_t packet_number,
  667. quic::QuicStreamId stream_id,
  668. bool should_include_version,
  669. bool fin,
  670. spdy::SpdyPriority priority,
  671. spdy::Http2HeaderBlock headers,
  672. quic::QuicStreamId parent_stream_id,
  673. size_t* spdy_headers_frame_length,
  674. const std::vector<std::string>& data_writes) {
  675. InitializeHeader(packet_number, should_include_version);
  676. if (quic::VersionUsesHttp3(version_.transport_version)) {
  677. MaybeAddHttp3SettingsFrames();
  678. if (priority != quic::QuicStream::kDefaultUrgency) {
  679. std::string priority_data =
  680. GenerateHttp3PriorityData(priority, stream_id);
  681. AddQuicStreamFrame(2, false, priority_data);
  682. }
  683. std::string data = QpackEncodeHeaders(stream_id, std::move(headers),
  684. spdy_headers_frame_length);
  685. for (const auto& data_write : data_writes) {
  686. data += data_write;
  687. }
  688. AddQuicStreamFrame(stream_id, fin, data);
  689. return BuildPacket();
  690. }
  691. spdy::SpdySerializedFrame spdy_frame =
  692. MakeSpdyHeadersFrame(stream_id, fin && data_writes.empty(), priority,
  693. std::move(headers), parent_stream_id);
  694. if (spdy_headers_frame_length) {
  695. *spdy_headers_frame_length = spdy_frame.size();
  696. }
  697. AddQuicStreamFrame(GetHeadersStreamId(), false,
  698. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  699. for (size_t i = 0; i < data_writes.size(); ++i) {
  700. bool is_fin = fin && (i == data_writes.size() - 1);
  701. AddQuicStreamFrame(stream_id, is_fin, absl::string_view(data_writes[i]));
  702. }
  703. return BuildPacket();
  704. }
  705. std::unique_ptr<quic::QuicReceivedPacket>
  706. QuicTestPacketMaker::MakeRequestHeadersPacket(
  707. uint64_t packet_number,
  708. quic::QuicStreamId stream_id,
  709. bool should_include_version,
  710. bool fin,
  711. spdy::SpdyPriority priority,
  712. spdy::Http2HeaderBlock headers,
  713. quic::QuicStreamId parent_stream_id,
  714. size_t* spdy_headers_frame_length) {
  715. InitializeHeader(packet_number, should_include_version);
  716. if (quic::VersionUsesHttp3(version_.transport_version)) {
  717. MaybeAddHttp3SettingsFrames();
  718. if (priority != quic::QuicStream::kDefaultUrgency) {
  719. std::string priority_data =
  720. GenerateHttp3PriorityData(priority, stream_id);
  721. AddQuicStreamFrame(2, false, priority_data);
  722. }
  723. std::string data = QpackEncodeHeaders(stream_id, std::move(headers),
  724. spdy_headers_frame_length);
  725. AddQuicStreamFrame(stream_id, fin, data);
  726. return BuildPacket();
  727. }
  728. spdy::SpdySerializedFrame spdy_frame = MakeSpdyHeadersFrame(
  729. stream_id, fin, priority, std::move(headers), parent_stream_id);
  730. if (spdy_headers_frame_length)
  731. *spdy_headers_frame_length = spdy_frame.size();
  732. AddQuicStreamFrame(GetHeadersStreamId(), false,
  733. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  734. return BuildPacket();
  735. }
  736. std::unique_ptr<quic::QuicReceivedPacket>
  737. QuicTestPacketMaker::MakeRetransmissionAndRequestHeadersPacket(
  738. const std::vector<uint64_t>& original_packet_numbers,
  739. uint64_t packet_number,
  740. quic::QuicStreamId stream_id,
  741. bool should_include_version,
  742. bool fin,
  743. spdy::SpdyPriority priority,
  744. spdy::Http2HeaderBlock headers,
  745. quic::QuicStreamId parent_stream_id,
  746. size_t* spdy_headers_frame_length) {
  747. DCHECK(save_packet_frames_);
  748. InitializeHeader(packet_number, should_include_version);
  749. for (auto it : original_packet_numbers) {
  750. for (auto frame : saved_frames_[quic::QuicPacketNumber(it)]) {
  751. frames_.push_back(frame);
  752. }
  753. }
  754. if (quic::VersionUsesHttp3(version_.transport_version)) {
  755. MaybeAddHttp3SettingsFrames();
  756. if (priority != quic::QuicStream::kDefaultUrgency) {
  757. std::string priority_data =
  758. GenerateHttp3PriorityData(priority, stream_id);
  759. AddQuicStreamFrame(2, false, priority_data);
  760. }
  761. std::string data = QpackEncodeHeaders(stream_id, std::move(headers),
  762. spdy_headers_frame_length);
  763. AddQuicStreamFrame(stream_id, fin, data);
  764. return BuildPacket();
  765. }
  766. spdy::SpdySerializedFrame spdy_frame = MakeSpdyHeadersFrame(
  767. stream_id, fin, priority, std::move(headers), parent_stream_id);
  768. if (spdy_headers_frame_length)
  769. *spdy_headers_frame_length = spdy_frame.size();
  770. AddQuicStreamFrame(GetHeadersStreamId(), false,
  771. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  772. return BuildPacket();
  773. }
  774. std::unique_ptr<quic::QuicReceivedPacket>
  775. QuicTestPacketMaker::MakeRequestHeadersAndRstPacket(
  776. uint64_t packet_number,
  777. quic::QuicStreamId stream_id,
  778. bool should_include_version,
  779. bool fin,
  780. spdy::SpdyPriority priority,
  781. spdy::Http2HeaderBlock headers,
  782. quic::QuicStreamId parent_stream_id,
  783. size_t* spdy_headers_frame_length,
  784. quic::QuicRstStreamErrorCode error_code) {
  785. InitializeHeader(packet_number, should_include_version);
  786. if (quic::VersionUsesHttp3(version_.transport_version)) {
  787. MaybeAddHttp3SettingsFrames();
  788. if (priority != quic::QuicStream::kDefaultUrgency) {
  789. std::string priority_data =
  790. GenerateHttp3PriorityData(priority, stream_id);
  791. AddQuicStreamFrame(2, false, priority_data);
  792. }
  793. std::string data = QpackEncodeHeaders(stream_id, std::move(headers),
  794. spdy_headers_frame_length);
  795. AddQuicStreamFrame(stream_id, fin, data);
  796. AddQuicStopSendingFrame(stream_id, error_code);
  797. AddQuicRstStreamFrame(stream_id, error_code);
  798. return BuildPacket();
  799. }
  800. spdy::SpdySerializedFrame spdy_frame = MakeSpdyHeadersFrame(
  801. stream_id, fin, priority, std::move(headers), parent_stream_id);
  802. if (spdy_headers_frame_length) {
  803. *spdy_headers_frame_length = spdy_frame.size();
  804. }
  805. AddQuicStreamFrame(GetHeadersStreamId(), false,
  806. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  807. if (version_.HasIetfQuicFrames()) {
  808. AddQuicStopSendingFrame(stream_id, error_code);
  809. }
  810. AddQuicRstStreamFrame(stream_id, error_code);
  811. return BuildPacket();
  812. }
  813. std::unique_ptr<quic::QuicReceivedPacket>
  814. QuicTestPacketMaker::MakePushPromisePacket(
  815. uint64_t packet_number,
  816. quic::QuicStreamId stream_id,
  817. quic::QuicStreamId promised_stream_id,
  818. bool should_include_version,
  819. bool fin,
  820. spdy::Http2HeaderBlock headers,
  821. size_t* spdy_headers_frame_length) {
  822. InitializeHeader(packet_number, should_include_version);
  823. DCHECK(!quic::VersionUsesHttp3(version_.transport_version));
  824. spdy::SpdySerializedFrame spdy_frame;
  825. spdy::SpdyPushPromiseIR promise_frame(stream_id, promised_stream_id,
  826. std::move(headers));
  827. promise_frame.set_fin(fin);
  828. spdy_frame = spdy_request_framer_.SerializeFrame(promise_frame);
  829. if (spdy_headers_frame_length) {
  830. *spdy_headers_frame_length = spdy_frame.size();
  831. }
  832. AddQuicStreamFrame(GetHeadersStreamId(), false,
  833. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  834. return BuildPacket();
  835. }
  836. std::unique_ptr<quic::QuicReceivedPacket>
  837. QuicTestPacketMaker::MakeResponseHeadersPacket(
  838. uint64_t packet_number,
  839. quic::QuicStreamId stream_id,
  840. bool should_include_version,
  841. bool fin,
  842. spdy::Http2HeaderBlock headers,
  843. size_t* spdy_headers_frame_length) {
  844. InitializeHeader(packet_number, should_include_version);
  845. if (quic::VersionUsesHttp3(version_.transport_version)) {
  846. std::string data = QpackEncodeHeaders(stream_id, std::move(headers),
  847. spdy_headers_frame_length);
  848. AddQuicStreamFrame(stream_id, fin, data);
  849. return BuildPacket();
  850. }
  851. spdy::SpdySerializedFrame spdy_frame;
  852. spdy::SpdyHeadersIR headers_frame(stream_id, std::move(headers));
  853. headers_frame.set_fin(fin);
  854. spdy_frame = spdy_response_framer_.SerializeFrame(headers_frame);
  855. if (spdy_headers_frame_length) {
  856. *spdy_headers_frame_length = spdy_frame.size();
  857. }
  858. AddQuicStreamFrame(GetHeadersStreamId(), false,
  859. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  860. return BuildPacket();
  861. }
  862. std::unique_ptr<quic::QuicReceivedPacket>
  863. QuicTestPacketMaker::MakeInitialSettingsPacket(uint64_t packet_number) {
  864. InitializeHeader(packet_number, /*should_include_version*/ true);
  865. if (!quic::VersionUsesHttp3(version_.transport_version)) {
  866. spdy::SpdySettingsIR settings_frame;
  867. settings_frame.AddSetting(spdy::SETTINGS_MAX_HEADER_LIST_SIZE,
  868. kQuicMaxHeaderListSize);
  869. settings_frame.AddSetting(quic::SETTINGS_QPACK_BLOCKED_STREAMS,
  870. quic::kDefaultMaximumBlockedStreams);
  871. spdy::SpdySerializedFrame spdy_frame(
  872. spdy_request_framer_.SerializeFrame(settings_frame));
  873. AddQuicStreamFrame(GetHeadersStreamId(), false,
  874. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  875. return BuildPacket();
  876. }
  877. MaybeAddHttp3SettingsFrames();
  878. return BuildPacket();
  879. }
  880. std::unique_ptr<quic::QuicReceivedPacket>
  881. QuicTestPacketMaker::MakePriorityPacket(uint64_t packet_number,
  882. bool should_include_version,
  883. quic::QuicStreamId id,
  884. quic::QuicStreamId parent_stream_id,
  885. spdy::SpdyPriority priority) {
  886. InitializeHeader(packet_number, should_include_version);
  887. if (!client_headers_include_h2_stream_dependency_) {
  888. parent_stream_id = 0;
  889. }
  890. int weight = spdy::Spdy3PriorityToHttp2Weight(priority);
  891. bool exclusive = client_headers_include_h2_stream_dependency_;
  892. if (!VersionUsesHttp3(version_.transport_version)) {
  893. spdy::SpdyPriorityIR priority_frame(id, parent_stream_id, weight,
  894. exclusive);
  895. spdy::SpdySerializedFrame spdy_frame(
  896. spdy_request_framer_.SerializeFrame(priority_frame));
  897. AddQuicStreamFrame(GetHeadersStreamId(), false,
  898. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  899. return BuildPacket();
  900. }
  901. if (priority != quic::QuicStream::kDefaultUrgency) {
  902. std::string priority_data = GenerateHttp3PriorityData(priority, id);
  903. AddQuicStreamFrame(2, false, priority_data);
  904. }
  905. return BuildPacket();
  906. }
  907. std::unique_ptr<quic::QuicReceivedPacket>
  908. QuicTestPacketMaker::MakeAckAndPriorityPacket(
  909. uint64_t packet_number,
  910. bool should_include_version,
  911. uint64_t largest_received,
  912. uint64_t smallest_received,
  913. quic::QuicStreamId id,
  914. quic::QuicStreamId parent_stream_id,
  915. spdy::SpdyPriority priority) {
  916. InitializeHeader(packet_number, should_include_version);
  917. AddQuicAckFrame(largest_received, smallest_received);
  918. if (!client_headers_include_h2_stream_dependency_) {
  919. parent_stream_id = 0;
  920. }
  921. int weight = spdy::Spdy3PriorityToHttp2Weight(priority);
  922. bool exclusive = client_headers_include_h2_stream_dependency_;
  923. if (!VersionUsesHttp3(version_.transport_version)) {
  924. spdy::SpdyPriorityIR priority_frame(id, parent_stream_id, weight,
  925. exclusive);
  926. spdy::SpdySerializedFrame spdy_frame(
  927. spdy_request_framer_.SerializeFrame(priority_frame));
  928. AddQuicStreamFrame(GetHeadersStreamId(), false,
  929. absl::string_view(spdy_frame.data(), spdy_frame.size()));
  930. return BuildPacket();
  931. }
  932. if (priority != quic::QuicStream::kDefaultUrgency) {
  933. std::string priority_data = GenerateHttp3PriorityData(priority, id);
  934. AddQuicStreamFrame(2, false, priority_data);
  935. }
  936. return BuildPacket();
  937. }
  938. std::unique_ptr<quic::QuicReceivedPacket>
  939. QuicTestPacketMaker::MakeAckAndPriorityUpdatePacket(
  940. uint64_t packet_number,
  941. bool should_include_version,
  942. uint64_t largest_received,
  943. uint64_t smallest_received,
  944. quic::QuicStreamId id,
  945. spdy::SpdyPriority priority) {
  946. InitializeHeader(packet_number, should_include_version);
  947. AddQuicAckFrame(largest_received, smallest_received);
  948. std::string priority_data = GenerateHttp3PriorityData(priority, id);
  949. AddQuicStreamFrame(2, false, priority_data);
  950. return BuildPacket();
  951. }
  952. std::unique_ptr<quic::QuicReceivedPacket>
  953. QuicTestPacketMaker::MakeMultiplePriorityFramesPacket(
  954. uint64_t packet_number,
  955. bool should_include_version,
  956. const std::vector<Http2StreamDependency>& priority_frames) {
  957. InitializeHeader(packet_number, should_include_version);
  958. const bool exclusive = client_headers_include_h2_stream_dependency_;
  959. std::string coalesced_data;
  960. for (const Http2StreamDependency& info : priority_frames) {
  961. spdy::SpdyPriorityIR priority_frame(
  962. info.stream_id, info.parent_stream_id,
  963. spdy::Spdy3PriorityToHttp2Weight(info.spdy_priority), exclusive);
  964. auto spdy_frame = spdy_request_framer_.SerializeFrame(priority_frame);
  965. coalesced_data += std::string(spdy_frame.data(), spdy_frame.size());
  966. }
  967. AddQuicStreamFrame(quic::VersionUsesHttp3(version_.transport_version)
  968. ? GetFirstBidirectionalStreamId()
  969. : GetHeadersStreamId(),
  970. false, coalesced_data);
  971. return BuildPacket();
  972. }
  973. std::unique_ptr<quic::QuicReceivedPacket>
  974. QuicTestPacketMaker::MakeAckAndMultiplePriorityFramesPacket(
  975. uint64_t packet_number,
  976. bool should_include_version,
  977. uint64_t largest_received,
  978. uint64_t smallest_received,
  979. const std::vector<Http2StreamDependency>& priority_frames) {
  980. InitializeHeader(packet_number, should_include_version);
  981. AddQuicAckFrame(largest_received, smallest_received);
  982. const bool exclusive = client_headers_include_h2_stream_dependency_;
  983. std::string coalesced_data;
  984. for (const Http2StreamDependency& info : priority_frames) {
  985. spdy::SpdyPriorityIR priority_frame(
  986. info.stream_id, info.parent_stream_id,
  987. spdy::Spdy3PriorityToHttp2Weight(info.spdy_priority), exclusive);
  988. auto spdy_frame = spdy_request_framer_.SerializeFrame(priority_frame);
  989. coalesced_data += std::string(spdy_frame.data(), spdy_frame.size());
  990. }
  991. AddQuicStreamFrame(quic::VersionUsesHttp3(version_.transport_version)
  992. ? GetFirstBidirectionalStreamId()
  993. : GetHeadersStreamId(),
  994. false, coalesced_data);
  995. return BuildPacket();
  996. }
  997. std::unique_ptr<quic::QuicReceivedPacket>
  998. QuicTestPacketMaker::MakeRetransmissionPacket(uint64_t original_packet_number,
  999. uint64_t new_packet_number,
  1000. bool should_include_version) {
  1001. DCHECK(save_packet_frames_);
  1002. InitializeHeader(new_packet_number, should_include_version);
  1003. return BuildPacketImpl(
  1004. saved_frames_[quic::QuicPacketNumber(original_packet_number)], nullptr);
  1005. }
  1006. std::unique_ptr<quic::QuicEncryptedPacket>
  1007. QuicTestPacketMaker::MakeStatelessResetPacket() {
  1008. auto connection_id = quic::test::TestConnectionId();
  1009. return quic::QuicFramer::BuildIetfStatelessResetPacket(
  1010. connection_id, quic::QuicFramer::GetMinStatelessResetPacketLength() + 1,
  1011. quic::QuicUtils::GenerateStatelessResetToken(connection_id));
  1012. }
  1013. void QuicTestPacketMaker::RemoveSavedStreamFrames(
  1014. quic::QuicStreamId stream_id) {
  1015. for (auto& kv : saved_frames_) {
  1016. auto* it = kv.second.begin();
  1017. while (it != kv.second.end()) {
  1018. if (it->type == quic::STREAM_FRAME &&
  1019. it->stream_frame.stream_id == stream_id) {
  1020. it = kv.second.erase(it);
  1021. } else {
  1022. ++it;
  1023. }
  1024. }
  1025. }
  1026. }
  1027. void QuicTestPacketMaker::SetEncryptionLevel(quic::EncryptionLevel level) {
  1028. encryption_level_ = level;
  1029. switch (level) {
  1030. case quic::ENCRYPTION_INITIAL:
  1031. long_header_type_ = quic::INITIAL;
  1032. break;
  1033. case quic::ENCRYPTION_ZERO_RTT:
  1034. long_header_type_ = quic::ZERO_RTT_PROTECTED;
  1035. break;
  1036. case quic::ENCRYPTION_FORWARD_SECURE:
  1037. long_header_type_ = quic::INVALID_PACKET_TYPE;
  1038. break;
  1039. default:
  1040. LOG(DFATAL) << quic::EncryptionLevelToString(level);
  1041. long_header_type_ = quic::INVALID_PACKET_TYPE;
  1042. }
  1043. }
  1044. spdy::Http2HeaderBlock QuicTestPacketMaker::GetRequestHeaders(
  1045. const std::string& method,
  1046. const std::string& scheme,
  1047. const std::string& path) const {
  1048. spdy::Http2HeaderBlock headers;
  1049. headers[":method"] = method;
  1050. headers[":authority"] = host_;
  1051. headers[":scheme"] = scheme;
  1052. headers[":path"] = path;
  1053. return headers;
  1054. }
  1055. spdy::Http2HeaderBlock QuicTestPacketMaker::ConnectRequestHeaders(
  1056. const std::string& host_port) const {
  1057. spdy::Http2HeaderBlock headers;
  1058. headers[":method"] = "CONNECT";
  1059. headers[":authority"] = host_port;
  1060. return headers;
  1061. }
  1062. spdy::Http2HeaderBlock QuicTestPacketMaker::GetResponseHeaders(
  1063. const std::string& status) const {
  1064. spdy::Http2HeaderBlock headers;
  1065. headers[":status"] = status;
  1066. headers["content-type"] = "text/plain";
  1067. return headers;
  1068. }
  1069. spdy::Http2HeaderBlock QuicTestPacketMaker::GetResponseHeaders(
  1070. const std::string& status,
  1071. const std::string& alt_svc) const {
  1072. spdy::Http2HeaderBlock headers;
  1073. headers[":status"] = status;
  1074. headers["alt-svc"] = alt_svc;
  1075. headers["content-type"] = "text/plain";
  1076. return headers;
  1077. }
  1078. void QuicTestPacketMaker::Reset() {
  1079. stream_offsets_.clear();
  1080. }
  1081. std::string QuicTestPacketMaker::QpackEncodeHeaders(
  1082. quic::QuicStreamId stream_id,
  1083. spdy::Http2HeaderBlock headers,
  1084. size_t* encoded_data_length) {
  1085. DCHECK(quic::VersionUsesHttp3(version_.transport_version));
  1086. std::string data;
  1087. std::string encoded_headers =
  1088. qpack_encoder_.EncodeHeaderList(stream_id, headers, nullptr);
  1089. // Generate HEADERS frame header.
  1090. const std::string headers_frame_header =
  1091. quic::HttpEncoder::SerializeHeadersFrameHeader(encoded_headers.size());
  1092. // Possible add a PUSH stream type.
  1093. if (!quic::QuicUtils::IsBidirectionalStreamId(stream_id, version_) &&
  1094. stream_offsets_[stream_id] == 0) {
  1095. // Push stream type header
  1096. data += "\x01";
  1097. }
  1098. // Add the HEADERS frame header.
  1099. data += headers_frame_header;
  1100. // Add the HEADERS frame payload.
  1101. data += encoded_headers;
  1102. // Compute the total data length.
  1103. if (encoded_data_length) {
  1104. *encoded_data_length = data.length();
  1105. }
  1106. return data;
  1107. }
  1108. void QuicTestPacketMaker::InitializeHeader(uint64_t packet_number,
  1109. bool should_include_version) {
  1110. header_.destination_connection_id = DestinationConnectionId();
  1111. header_.destination_connection_id_included = HasDestinationConnectionId();
  1112. header_.source_connection_id = SourceConnectionId();
  1113. header_.source_connection_id_included = HasSourceConnectionId();
  1114. header_.reset_flag = false;
  1115. header_.version_flag = ShouldIncludeVersion(should_include_version);
  1116. if (quic::VersionHasIetfInvariantHeader(version_.transport_version)) {
  1117. header_.form = header_.version_flag ? quic::IETF_QUIC_LONG_HEADER_PACKET
  1118. : quic::IETF_QUIC_SHORT_HEADER_PACKET;
  1119. }
  1120. header_.long_packet_type = long_header_type_;
  1121. header_.packet_number_length = GetPacketNumberLength();
  1122. header_.packet_number = quic::QuicPacketNumber(packet_number);
  1123. if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
  1124. header_.version_flag) {
  1125. if (long_header_type_ == quic::INITIAL) {
  1126. header_.retry_token_length_length =
  1127. quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
  1128. }
  1129. header_.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
  1130. }
  1131. }
  1132. void QuicTestPacketMaker::AddQuicPaddingFrame() {
  1133. quic::QuicPaddingFrame padding_frame;
  1134. frames_.push_back(quic::QuicFrame(padding_frame));
  1135. DVLOG(1) << "Adding frame: " << frames_.back();
  1136. }
  1137. void QuicTestPacketMaker::AddQuicPingFrame() {
  1138. quic::QuicPingFrame ping_frame;
  1139. frames_.push_back(quic::QuicFrame(ping_frame));
  1140. DVLOG(1) << "Adding frame: " << frames_.back();
  1141. }
  1142. void QuicTestPacketMaker::AddQuicRetireConnectionIdFrame(
  1143. uint64_t sequence_number) {
  1144. auto* retire_cid_frame = new quic::QuicRetireConnectionIdFrame();
  1145. retire_cid_frame->sequence_number = sequence_number;
  1146. frames_.push_back(quic::QuicFrame(retire_cid_frame));
  1147. DVLOG(1) << "Adding frame: " << frames_.back();
  1148. }
  1149. void QuicTestPacketMaker::AddQuicNewConnectionIdFrame(
  1150. const quic::QuicConnectionId& cid,
  1151. uint64_t sequence_number,
  1152. uint64_t retire_prior_to,
  1153. quic::StatelessResetToken reset_token) {
  1154. auto* new_cid_frame = new quic::QuicNewConnectionIdFrame();
  1155. new_cid_frame->connection_id = cid;
  1156. new_cid_frame->sequence_number = sequence_number;
  1157. new_cid_frame->retire_prior_to = retire_prior_to;
  1158. new_cid_frame->stateless_reset_token = reset_token;
  1159. frames_.push_back(quic::QuicFrame(new_cid_frame));
  1160. DVLOG(1) << "Adding frame: " << frames_.back();
  1161. }
  1162. void QuicTestPacketMaker::AddQuicMaxStreamsFrame(
  1163. quic::QuicControlFrameId control_frame_id,
  1164. quic::QuicStreamCount stream_count,
  1165. bool unidirectional) {
  1166. quic::QuicMaxStreamsFrame max_streams_frame(control_frame_id, stream_count,
  1167. unidirectional);
  1168. frames_.push_back(quic::QuicFrame(max_streams_frame));
  1169. DVLOG(1) << "Adding frame: " << frames_.back();
  1170. }
  1171. void QuicTestPacketMaker::AddQuicStreamsBlockedFrame(
  1172. quic::QuicControlFrameId control_frame_id,
  1173. quic::QuicStreamCount stream_count,
  1174. bool unidirectional) {
  1175. quic::QuicStreamsBlockedFrame streams_blocked_frame(
  1176. control_frame_id, stream_count, unidirectional);
  1177. frames_.push_back(quic::QuicFrame(streams_blocked_frame));
  1178. DVLOG(1) << "Adding frame: " << frames_.back();
  1179. }
  1180. void QuicTestPacketMaker::AddQuicStreamFrame(quic::QuicStreamId stream_id,
  1181. bool fin,
  1182. absl::string_view data) {
  1183. AddQuicStreamFrameWithOffset(stream_id, fin, stream_offsets_[stream_id],
  1184. data);
  1185. stream_offsets_[stream_id] += data.length();
  1186. }
  1187. void QuicTestPacketMaker::AddQuicStreamFrameWithOffset(
  1188. quic::QuicStreamId stream_id,
  1189. bool fin,
  1190. quic::QuicStreamOffset offset,
  1191. absl::string_view data) {
  1192. // Save the stream data so that callers can use temporary objects for data.
  1193. saved_stream_data_.push_back(std::make_unique<std::string>(data));
  1194. absl::string_view saved_data = *saved_stream_data_.back();
  1195. quic::QuicStreamFrame stream_frame(stream_id, fin, offset, saved_data);
  1196. frames_.push_back(quic::QuicFrame(stream_frame));
  1197. DVLOG(1) << "Adding frame: " << frames_.back();
  1198. }
  1199. void QuicTestPacketMaker::AddQuicAckFrame(uint64_t largest_received,
  1200. uint64_t smallest_received) {
  1201. AddQuicAckFrame(1, largest_received, smallest_received);
  1202. }
  1203. void QuicTestPacketMaker::AddQuicAckFrame(uint64_t first_received,
  1204. uint64_t largest_received,
  1205. uint64_t smallest_received) {
  1206. auto* ack_frame = new quic::QuicAckFrame;
  1207. ack_frame->largest_acked = quic::QuicPacketNumber(largest_received);
  1208. ack_frame->ack_delay_time = quic::QuicTime::Delta::Zero();
  1209. for (uint64_t i = smallest_received; i <= largest_received; ++i) {
  1210. ack_frame->received_packet_times.push_back(
  1211. std::make_pair(quic::QuicPacketNumber(i), clock_->Now()));
  1212. }
  1213. if (largest_received > 0) {
  1214. DCHECK_GE(largest_received, first_received);
  1215. ack_frame->packets.AddRange(quic::QuicPacketNumber(first_received),
  1216. quic::QuicPacketNumber(largest_received + 1));
  1217. }
  1218. frames_.push_back(quic::QuicFrame(ack_frame));
  1219. DVLOG(1) << "Adding frame: " << frames_.back();
  1220. }
  1221. void QuicTestPacketMaker::AddQuicRstStreamFrame(
  1222. quic::QuicStreamId stream_id,
  1223. quic::QuicRstStreamErrorCode error_code) {
  1224. auto* rst_stream_frame = new quic::QuicRstStreamFrame(
  1225. 1, stream_id, error_code, stream_offsets_[stream_id]);
  1226. frames_.push_back(quic::QuicFrame(rst_stream_frame));
  1227. DVLOG(1) << "Adding frame: " << frames_.back();
  1228. }
  1229. void QuicTestPacketMaker::AddQuicConnectionCloseFrame(
  1230. quic::QuicErrorCode quic_error,
  1231. const std::string& quic_error_details) {
  1232. AddQuicConnectionCloseFrame(quic_error, quic_error_details, 0);
  1233. }
  1234. void QuicTestPacketMaker::AddQuicConnectionCloseFrame(
  1235. quic::QuicErrorCode quic_error,
  1236. const std::string& quic_error_details,
  1237. uint64_t frame_type) {
  1238. auto* close_frame = new quic::QuicConnectionCloseFrame(
  1239. version_.transport_version, quic_error, quic::NO_IETF_QUIC_ERROR,
  1240. quic_error_details, frame_type);
  1241. frames_.push_back(quic::QuicFrame(close_frame));
  1242. DVLOG(1) << "Adding frame: " << frames_.back();
  1243. }
  1244. void QuicTestPacketMaker::AddQuicGoAwayFrame(quic::QuicErrorCode error_code,
  1245. std::string reason_phrase) {
  1246. auto* goaway_frame = new quic::QuicGoAwayFrame();
  1247. goaway_frame->error_code = error_code;
  1248. goaway_frame->last_good_stream_id = 0;
  1249. goaway_frame->reason_phrase = reason_phrase;
  1250. frames_.push_back(quic::QuicFrame(goaway_frame));
  1251. DVLOG(1) << "Adding frame: " << frames_.back();
  1252. }
  1253. void QuicTestPacketMaker::AddQuicPathResponseFrame() {
  1254. quic::test::MockRandom rand(0);
  1255. quic::QuicPathFrameBuffer payload;
  1256. rand.RandBytes(payload.data(), payload.size());
  1257. auto path_response_frame = quic::QuicPathResponseFrame(0, payload);
  1258. frames_.push_back(quic::QuicFrame(path_response_frame));
  1259. DVLOG(1) << "Adding frame: " << frames_.back();
  1260. }
  1261. void QuicTestPacketMaker::AddQuicPathChallengeFrame() {
  1262. quic::test::MockRandom rand(0);
  1263. quic::QuicPathFrameBuffer payload;
  1264. rand.RandBytes(payload.data(), payload.size());
  1265. auto path_challenge_frame = quic::QuicPathChallengeFrame(0, payload);
  1266. frames_.push_back(quic::QuicFrame(path_challenge_frame));
  1267. DVLOG(1) << "Adding frame: " << frames_.back();
  1268. }
  1269. void QuicTestPacketMaker::AddQuicStopSendingFrame(
  1270. quic::QuicStreamId stream_id,
  1271. quic::QuicRstStreamErrorCode error_code) {
  1272. auto stop_sending_frame =
  1273. quic::QuicStopSendingFrame(1, stream_id, error_code);
  1274. frames_.push_back(quic::QuicFrame(stop_sending_frame));
  1275. DVLOG(1) << "Adding frame: " << frames_.back();
  1276. }
  1277. void QuicTestPacketMaker::AddQuicCryptoFrame(
  1278. quic::EncryptionLevel level,
  1279. quic::QuicStreamOffset offset,
  1280. quic::QuicPacketLength data_length) {
  1281. auto* crypto_frame = new quic::QuicCryptoFrame(level, offset, data_length);
  1282. frames_.push_back(quic::QuicFrame(crypto_frame));
  1283. DVLOG(1) << "Adding frame: " << frames_.back();
  1284. }
  1285. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::BuildPacket() {
  1286. auto packet = BuildPacketImpl(frames_, data_producer_.get());
  1287. DeleteFrames(&frames_);
  1288. data_producer_.reset();
  1289. return packet;
  1290. }
  1291. std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::BuildPacketImpl(
  1292. const quic::QuicFrames& frames,
  1293. quic::QuicStreamFrameDataProducer* data_producer) {
  1294. quic::QuicFramer framer(quic::test::SupportedVersions(version_),
  1295. clock_->Now(), perspective_,
  1296. quic::kQuicDefaultConnectionIdLength);
  1297. if (encryption_level_ == quic::ENCRYPTION_INITIAL) {
  1298. framer.SetInitialObfuscators(perspective_ == quic::Perspective::IS_CLIENT
  1299. ? header_.destination_connection_id
  1300. : header_.source_connection_id);
  1301. } else {
  1302. framer.SetEncrypter(encryption_level_,
  1303. std::make_unique<quic::NullEncrypter>(perspective_));
  1304. }
  1305. if (data_producer != nullptr) {
  1306. framer.set_data_producer(data_producer);
  1307. }
  1308. quic::QuicFrames frames_copy = CloneFrames(frames);
  1309. size_t max_plaintext_size =
  1310. framer.GetMaxPlaintextSize(quic::kDefaultMaxPacketSize);
  1311. if (version_.HasHeaderProtection()) {
  1312. size_t packet_size =
  1313. quic::GetPacketHeaderSize(version_.transport_version, header_);
  1314. size_t frames_size = 0;
  1315. for (size_t i = 0; i < frames.size(); ++i) {
  1316. bool first_frame = i == 0;
  1317. bool last_frame = i == frames.size() - 1;
  1318. const size_t frame_size = framer.GetSerializedFrameLength(
  1319. frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
  1320. header_.packet_number_length);
  1321. packet_size += frame_size;
  1322. frames_size += frame_size;
  1323. }
  1324. const size_t min_plaintext_packet_size =
  1325. quic::QuicPacketCreator::MinPlaintextPacketSize(version_);
  1326. if (frames_size < min_plaintext_packet_size) {
  1327. const size_t expansion_on_new_frame =
  1328. frames.empty()
  1329. ? 0
  1330. : quic::QuicPacketCreator::ExpansionOnNewFrameWithLastFrame(
  1331. frames.back(), version_.transport_version);
  1332. const size_t padding_length =
  1333. std::max(1 + expansion_on_new_frame,
  1334. min_plaintext_packet_size - frames_size) -
  1335. expansion_on_new_frame;
  1336. CHECK_LE(padding_length + packet_size + expansion_on_new_frame,
  1337. max_plaintext_size);
  1338. frames_copy.push_back(
  1339. quic::QuicFrame(quic::QuicPaddingFrame(padding_length)));
  1340. }
  1341. }
  1342. std::unique_ptr<quic::QuicPacket> packet(quic::test::BuildUnsizedDataPacket(
  1343. &framer, header_, frames_copy, max_plaintext_size));
  1344. char buffer[quic::kMaxOutgoingPacketSize];
  1345. size_t encrypted_size =
  1346. framer.EncryptPayload(encryption_level_, header_.packet_number, *packet,
  1347. buffer, quic::kMaxOutgoingPacketSize);
  1348. EXPECT_NE(0u, encrypted_size);
  1349. quic::QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(),
  1350. false);
  1351. if (save_packet_frames_) {
  1352. saved_frames_[header_.packet_number] = frames_copy;
  1353. } else {
  1354. saved_stream_data_.clear();
  1355. DeleteFrames(&frames_copy);
  1356. }
  1357. return encrypted.Clone();
  1358. }
  1359. spdy::SpdySerializedFrame QuicTestPacketMaker::MakeSpdyHeadersFrame(
  1360. quic::QuicStreamId stream_id,
  1361. bool fin,
  1362. spdy::SpdyPriority priority,
  1363. spdy::Http2HeaderBlock headers,
  1364. quic::QuicStreamId parent_stream_id) {
  1365. spdy::SpdyHeadersIR headers_frame(stream_id, std::move(headers));
  1366. headers_frame.set_fin(fin);
  1367. headers_frame.set_weight(spdy::Spdy3PriorityToHttp2Weight(priority));
  1368. headers_frame.set_has_priority(true);
  1369. if (client_headers_include_h2_stream_dependency_) {
  1370. headers_frame.set_parent_stream_id(parent_stream_id);
  1371. headers_frame.set_exclusive(true);
  1372. } else {
  1373. headers_frame.set_parent_stream_id(0);
  1374. headers_frame.set_exclusive(false);
  1375. }
  1376. return spdy_request_framer_.SerializeFrame(headers_frame);
  1377. }
  1378. bool QuicTestPacketMaker::ShouldIncludeVersion(bool include_version) const {
  1379. if (version_.HasIetfInvariantHeader()) {
  1380. return encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE;
  1381. }
  1382. return include_version;
  1383. }
  1384. quic::QuicPacketNumberLength QuicTestPacketMaker::GetPacketNumberLength()
  1385. const {
  1386. if (version_.HasIetfInvariantHeader() &&
  1387. encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE &&
  1388. !version_.SendsVariableLengthPacketNumberInLongHeader()) {
  1389. return quic::PACKET_4BYTE_PACKET_NUMBER;
  1390. }
  1391. return quic::PACKET_1BYTE_PACKET_NUMBER;
  1392. }
  1393. quic::QuicConnectionId QuicTestPacketMaker::DestinationConnectionId() const {
  1394. if (perspective_ == quic::Perspective::IS_SERVER) {
  1395. return quic::EmptyQuicConnectionId();
  1396. }
  1397. return connection_id_;
  1398. }
  1399. quic::QuicConnectionId QuicTestPacketMaker::SourceConnectionId() const {
  1400. if (perspective_ == quic::Perspective::IS_CLIENT) {
  1401. return quic::EmptyQuicConnectionId();
  1402. }
  1403. return connection_id_;
  1404. }
  1405. quic::QuicConnectionIdIncluded QuicTestPacketMaker::HasDestinationConnectionId()
  1406. const {
  1407. if (!version_.SupportsClientConnectionIds() &&
  1408. perspective_ == quic::Perspective::IS_SERVER) {
  1409. return quic::CONNECTION_ID_ABSENT;
  1410. }
  1411. return quic::CONNECTION_ID_PRESENT;
  1412. }
  1413. quic::QuicConnectionIdIncluded QuicTestPacketMaker::HasSourceConnectionId()
  1414. const {
  1415. if (version_.SupportsClientConnectionIds() ||
  1416. (perspective_ == quic::Perspective::IS_SERVER &&
  1417. encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE)) {
  1418. return quic::CONNECTION_ID_PRESENT;
  1419. }
  1420. return quic::CONNECTION_ID_ABSENT;
  1421. }
  1422. quic::QuicStreamId QuicTestPacketMaker::GetFirstBidirectionalStreamId() const {
  1423. return quic::QuicUtils::GetFirstBidirectionalStreamId(
  1424. version_.transport_version, perspective_);
  1425. }
  1426. quic::QuicStreamId QuicTestPacketMaker::GetHeadersStreamId() const {
  1427. return quic::QuicUtils::GetHeadersStreamId(version_.transport_version);
  1428. }
  1429. std::string QuicTestPacketMaker::GenerateHttp3SettingsData() {
  1430. quic::SettingsFrame settings;
  1431. settings.values[quic::SETTINGS_MAX_FIELD_SECTION_SIZE] =
  1432. kQuicMaxHeaderListSize;
  1433. settings.values[quic::SETTINGS_QPACK_MAX_TABLE_CAPACITY] =
  1434. quic::kDefaultQpackMaxDynamicTableCapacity;
  1435. settings.values[quic::SETTINGS_QPACK_BLOCKED_STREAMS] =
  1436. quic::kDefaultMaximumBlockedStreams;
  1437. // Greased setting.
  1438. settings.values[0x40] = 20;
  1439. return quic::HttpEncoder::SerializeSettingsFrame(settings);
  1440. }
  1441. std::string QuicTestPacketMaker::GenerateHttp3PriorityData(
  1442. spdy::SpdyPriority priority,
  1443. quic::QuicStreamId stream_id) {
  1444. quic::PriorityUpdateFrame priority_update;
  1445. priority_update.prioritized_element_type = quic::REQUEST_STREAM;
  1446. priority_update.prioritized_element_id = stream_id;
  1447. priority_update.priority_field_value =
  1448. base::StrCat({"u=", base::NumberToString(priority)});
  1449. return quic::HttpEncoder::SerializePriorityUpdateFrame(priority_update);
  1450. }
  1451. std::string QuicTestPacketMaker::GenerateHttp3GreaseData() {
  1452. return quic::HttpEncoder::SerializeGreasingFrame();
  1453. }
  1454. void QuicTestPacketMaker::MaybeAddHttp3SettingsFrames() {
  1455. DCHECK(quic::VersionUsesHttp3(version_.transport_version));
  1456. quic::QuicStreamId stream_id =
  1457. quic::QuicUtils::GetFirstUnidirectionalStreamId(
  1458. version_.transport_version, perspective_);
  1459. if (stream_offsets_[stream_id] != 0)
  1460. return;
  1461. // A stream frame containing stream type will be written on the control
  1462. // stream first.
  1463. std::string type(1, 0x00);
  1464. std::string settings_data = GenerateHttp3SettingsData();
  1465. std::string grease_data = GenerateHttp3GreaseData();
  1466. // The type and the SETTINGS frame may be sent in multiple QUIC STREAM
  1467. // frames.
  1468. std::string data = type + settings_data + grease_data;
  1469. AddQuicStreamFrame(stream_id, false, data);
  1470. }
  1471. } // namespace net::test