dns_transaction_unittest.cc 172 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/dns/dns_transaction.h"
  5. #include <stdint.h>
  6. #include <limits>
  7. #include <memory>
  8. #include <utility>
  9. #include <vector>
  10. #include "base/base64url.h"
  11. #include "base/bind.h"
  12. #include "base/containers/circular_deque.h"
  13. #include "base/memory/raw_ptr.h"
  14. #include "base/numerics/safe_math.h"
  15. #include "base/rand_util.h"
  16. #include "base/run_loop.h"
  17. #include "base/strings/string_util.h"
  18. #include "base/strings/stringprintf.h"
  19. #include "base/sys_byteorder.h"
  20. #include "base/test/bind.h"
  21. #include "base/test/metrics/histogram_tester.h"
  22. #include "base/threading/thread_task_runner_handle.h"
  23. #include "base/time/time.h"
  24. #include "base/values.h"
  25. #include "net/base/idempotency.h"
  26. #include "net/base/ip_address.h"
  27. #include "net/base/port_util.h"
  28. #include "net/base/upload_bytes_element_reader.h"
  29. #include "net/base/url_util.h"
  30. #include "net/cookies/cookie_access_result.h"
  31. #include "net/cookies/cookie_util.h"
  32. #include "net/dns/dns_config.h"
  33. #include "net/dns/dns_query.h"
  34. #include "net/dns/dns_response.h"
  35. #include "net/dns/dns_server_iterator.h"
  36. #include "net/dns/dns_session.h"
  37. #include "net/dns/dns_test_util.h"
  38. #include "net/dns/dns_util.h"
  39. #include "net/dns/public/dns_over_https_config.h"
  40. #include "net/dns/public/dns_over_https_server_config.h"
  41. #include "net/dns/public/dns_protocol.h"
  42. #include "net/dns/public/secure_dns_policy.h"
  43. #include "net/dns/resolve_context.h"
  44. #include "net/http/http_util.h"
  45. #include "net/log/net_log.h"
  46. #include "net/log/net_log_capture_mode.h"
  47. #include "net/log/net_log_with_source.h"
  48. #include "net/proxy_resolution/proxy_config_service_fixed.h"
  49. #include "net/socket/socket_test_util.h"
  50. #include "net/test/gtest_util.h"
  51. #include "net/test/test_with_task_environment.h"
  52. #include "net/test/url_request/url_request_failed_job.h"
  53. #include "net/third_party/uri_template/uri_template.h"
  54. #include "net/url_request/url_request_context.h"
  55. #include "net/url_request/url_request_context_builder.h"
  56. #include "net/url_request/url_request_filter.h"
  57. #include "net/url_request/url_request_interceptor.h"
  58. #include "net/url_request/url_request_test_util.h"
  59. #include "testing/gmock/include/gmock/gmock.h"
  60. #include "testing/gtest/include/gtest/gtest.h"
  61. #include "third_party/abseil-cpp/absl/types/optional.h"
  62. using net::test::IsOk;
  63. namespace net {
  64. namespace {
  65. base::TimeDelta kFallbackPeriod = base::Seconds(1);
  66. const char kMockHostname[] = "mock.http";
  67. // Like `net::DNSDomainFromDot()` except allows converting more names than
  68. // accepted by that utility.
  69. std::string DomainFromDot(base::StringPiece dotted_name) {
  70. std::string dns_name;
  71. while (true) {
  72. size_t next_dot = dotted_name.find('.');
  73. if (next_dot == base::StringPiece::npos) {
  74. dns_name.append(1, base::checked_cast<base::StringPiece::value_type>(
  75. dotted_name.size()));
  76. dns_name.append(static_cast<std::string>(dotted_name));
  77. dns_name.append(1, 0);
  78. return dns_name;
  79. } else {
  80. dns_name.append(
  81. 1, base::checked_cast<base::StringPiece::value_type>(next_dot));
  82. dns_name.append(
  83. static_cast<std::string>(dotted_name.substr(0, next_dot)));
  84. dotted_name = dotted_name.substr(next_dot + 1);
  85. }
  86. }
  87. }
  88. enum class Transport { UDP, TCP, HTTPS };
  89. // A SocketDataProvider builder.
  90. class DnsSocketData {
  91. public:
  92. // The ctor takes parameters for the DnsQuery.
  93. DnsSocketData(uint16_t id,
  94. const char* dotted_name,
  95. uint16_t qtype,
  96. IoMode mode,
  97. Transport transport,
  98. const OptRecordRdata* opt_rdata = nullptr,
  99. DnsQuery::PaddingStrategy padding_strategy =
  100. DnsQuery::PaddingStrategy::NONE)
  101. : query_(std::make_unique<DnsQuery>(id,
  102. DomainFromDot(dotted_name),
  103. qtype,
  104. opt_rdata,
  105. padding_strategy)),
  106. transport_(transport) {
  107. if (Transport::TCP == transport_) {
  108. auto length = std::make_unique<uint16_t>();
  109. *length = base::HostToNet16(query_->io_buffer()->size());
  110. writes_.emplace_back(mode, reinterpret_cast<const char*>(length.get()),
  111. sizeof(uint16_t), num_reads_and_writes());
  112. lengths_.push_back(std::move(length));
  113. }
  114. writes_.emplace_back(mode, query_->io_buffer()->data(),
  115. query_->io_buffer()->size(), num_reads_and_writes());
  116. }
  117. DnsSocketData(const DnsSocketData&) = delete;
  118. DnsSocketData& operator=(const DnsSocketData&) = delete;
  119. ~DnsSocketData() = default;
  120. // All responses must be added before GetProvider.
  121. // Adds pre-built DnsResponse. |tcp_length| will be used in TCP mode only.
  122. void AddResponseWithLength(std::unique_ptr<DnsResponse> response,
  123. IoMode mode,
  124. uint16_t tcp_length) {
  125. CHECK(!provider_.get());
  126. if (Transport::TCP == transport_) {
  127. auto length = std::make_unique<uint16_t>();
  128. *length = base::HostToNet16(tcp_length);
  129. reads_.emplace_back(mode, reinterpret_cast<const char*>(length.get()),
  130. sizeof(uint16_t), num_reads_and_writes());
  131. lengths_.push_back(std::move(length));
  132. }
  133. reads_.emplace_back(mode, response->io_buffer()->data(),
  134. response->io_buffer_size(), num_reads_and_writes());
  135. responses_.push_back(std::move(response));
  136. }
  137. // Adds pre-built DnsResponse.
  138. void AddResponse(std::unique_ptr<DnsResponse> response, IoMode mode) {
  139. uint16_t tcp_length = response->io_buffer_size();
  140. AddResponseWithLength(std::move(response), mode, tcp_length);
  141. }
  142. // Adds pre-built response from |data| buffer.
  143. void AddResponseData(const uint8_t* data, size_t length, IoMode mode) {
  144. CHECK(!provider_.get());
  145. AddResponse(std::make_unique<DnsResponse>(
  146. reinterpret_cast<const char*>(data), length, 0),
  147. mode);
  148. }
  149. // Adds pre-built response from |data| buffer.
  150. void AddResponseData(const uint8_t* data,
  151. size_t length,
  152. int offset,
  153. IoMode mode) {
  154. CHECK(!provider_.get());
  155. AddResponse(
  156. std::make_unique<DnsResponse>(reinterpret_cast<const char*>(data),
  157. length - offset, offset),
  158. mode);
  159. }
  160. // Add no-answer (RCODE only) response matching the query.
  161. void AddRcode(int rcode, IoMode mode) {
  162. auto response = std::make_unique<DnsResponse>(
  163. query_->io_buffer()->data(), query_->io_buffer()->size(), 0);
  164. dns_protocol::Header* header =
  165. reinterpret_cast<dns_protocol::Header*>(response->io_buffer()->data());
  166. header->flags |= base::HostToNet16(dns_protocol::kFlagResponse | rcode);
  167. AddResponse(std::move(response), mode);
  168. }
  169. // Add error response.
  170. void AddReadError(int error, IoMode mode) {
  171. reads_.emplace_back(mode, error, num_reads_and_writes());
  172. }
  173. // Build, if needed, and return the SocketDataProvider. No new responses
  174. // should be added afterwards.
  175. SequencedSocketData* GetProvider() {
  176. if (provider_.get())
  177. return provider_.get();
  178. // Terminate the reads with ERR_IO_PENDING to prevent overrun and default to
  179. // timeout.
  180. if (transport_ != Transport::HTTPS) {
  181. reads_.emplace_back(SYNCHRONOUS, ERR_IO_PENDING,
  182. writes_.size() + reads_.size());
  183. }
  184. provider_ = std::make_unique<SequencedSocketData>(reads_, writes_);
  185. if (Transport::TCP == transport_ || Transport::HTTPS == transport_) {
  186. provider_->set_connect_data(MockConnect(reads_[0].mode, OK));
  187. }
  188. return provider_.get();
  189. }
  190. uint16_t query_id() const { return query_->id(); }
  191. IOBufferWithSize* query_buffer() { return query_->io_buffer(); }
  192. private:
  193. size_t num_reads_and_writes() const { return reads_.size() + writes_.size(); }
  194. std::unique_ptr<DnsQuery> query_;
  195. Transport transport_;
  196. std::vector<std::unique_ptr<uint16_t>> lengths_;
  197. std::vector<std::unique_ptr<DnsResponse>> responses_;
  198. std::vector<MockWrite> writes_;
  199. std::vector<MockRead> reads_;
  200. std::unique_ptr<SequencedSocketData> provider_;
  201. };
  202. class TestSocketFactory;
  203. // A variant of MockUDPClientSocket which always fails to Connect.
  204. class FailingUDPClientSocket : public MockUDPClientSocket {
  205. public:
  206. FailingUDPClientSocket(SocketDataProvider* data, net::NetLog* net_log)
  207. : MockUDPClientSocket(data, net_log) {}
  208. FailingUDPClientSocket(const FailingUDPClientSocket&) = delete;
  209. FailingUDPClientSocket& operator=(const FailingUDPClientSocket&) = delete;
  210. ~FailingUDPClientSocket() override = default;
  211. int Connect(const IPEndPoint& endpoint) override {
  212. return ERR_CONNECTION_REFUSED;
  213. }
  214. };
  215. // A variant of MockUDPClientSocket which notifies the factory OnConnect.
  216. class TestUDPClientSocket : public MockUDPClientSocket {
  217. public:
  218. TestUDPClientSocket(TestSocketFactory* factory,
  219. SocketDataProvider* data,
  220. net::NetLog* net_log)
  221. : MockUDPClientSocket(data, net_log), factory_(factory) {}
  222. TestUDPClientSocket(const TestUDPClientSocket&) = delete;
  223. TestUDPClientSocket& operator=(const TestUDPClientSocket&) = delete;
  224. ~TestUDPClientSocket() override = default;
  225. int Connect(const IPEndPoint& endpoint) override;
  226. private:
  227. raw_ptr<TestSocketFactory> factory_;
  228. };
  229. // Creates TestUDPClientSockets and keeps endpoints reported via OnConnect.
  230. class TestSocketFactory : public MockClientSocketFactory {
  231. public:
  232. TestSocketFactory() = default;
  233. ~TestSocketFactory() override = default;
  234. std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
  235. DatagramSocket::BindType bind_type,
  236. NetLog* net_log,
  237. const NetLogSource& source) override {
  238. if (fail_next_socket_) {
  239. fail_next_socket_ = false;
  240. return std::make_unique<FailingUDPClientSocket>(&empty_data_, net_log);
  241. }
  242. SocketDataProvider* data_provider = mock_data().GetNext();
  243. auto socket =
  244. std::make_unique<TestUDPClientSocket>(this, data_provider, net_log);
  245. // Even using DEFAULT_BIND, actual sockets have been measured to very rarely
  246. // repeat the same source port multiple times in a row. Need to mimic that
  247. // functionality here, so DnsUdpTracker doesn't misdiagnose repeated port
  248. // as low entropy.
  249. if (diverse_source_ports_)
  250. socket->set_source_port(next_source_port_++);
  251. return socket;
  252. }
  253. void OnConnect(const IPEndPoint& endpoint) {
  254. remote_endpoints_.emplace_back(endpoint);
  255. }
  256. struct RemoteNameserver {
  257. explicit RemoteNameserver(IPEndPoint insecure_nameserver)
  258. : insecure_nameserver(insecure_nameserver) {}
  259. explicit RemoteNameserver(DnsOverHttpsServerConfig secure_nameserver)
  260. : secure_nameserver(secure_nameserver) {}
  261. absl::optional<IPEndPoint> insecure_nameserver;
  262. absl::optional<DnsOverHttpsServerConfig> secure_nameserver;
  263. };
  264. std::vector<RemoteNameserver> remote_endpoints_;
  265. bool fail_next_socket_ = false;
  266. bool diverse_source_ports_ = true;
  267. private:
  268. StaticSocketDataProvider empty_data_;
  269. uint16_t next_source_port_ = 123;
  270. };
  271. int TestUDPClientSocket::Connect(const IPEndPoint& endpoint) {
  272. factory_->OnConnect(endpoint);
  273. return MockUDPClientSocket::Connect(endpoint);
  274. }
  275. // Helper class that holds a DnsTransaction and handles OnTransactionComplete.
  276. class TransactionHelper {
  277. public:
  278. // If |expected_answer_count| < 0 then it is the expected net error.
  279. explicit TransactionHelper(int expected_answer_count)
  280. : expected_answer_count_(expected_answer_count) {}
  281. // Mark that the transaction shall be destroyed immediately upon callback.
  282. void set_cancel_in_callback() { cancel_in_callback_ = true; }
  283. void StartTransaction(DnsTransactionFactory* factory,
  284. const char* hostname,
  285. uint16_t qtype,
  286. bool secure,
  287. ResolveContext* context) {
  288. std::unique_ptr<DnsTransaction> transaction = factory->CreateTransaction(
  289. hostname, qtype,
  290. NetLogWithSource::Make(net::NetLog::Get(), net::NetLogSourceType::NONE),
  291. secure, factory->GetSecureDnsModeForTest(), context,
  292. true /* fast_timeout */);
  293. transaction->SetRequestPriority(DEFAULT_PRIORITY);
  294. EXPECT_EQ(qtype, transaction->GetType());
  295. StartTransaction(std::move(transaction));
  296. }
  297. void StartTransaction(std::unique_ptr<DnsTransaction> transaction) {
  298. EXPECT_FALSE(transaction_);
  299. transaction_ = std::move(transaction);
  300. qtype_ = transaction_->GetType();
  301. transaction_->Start(base::BindOnce(
  302. &TransactionHelper::OnTransactionComplete, base::Unretained(this)));
  303. }
  304. void Cancel() {
  305. ASSERT_TRUE(transaction_.get() != nullptr);
  306. transaction_.reset(nullptr);
  307. }
  308. void OnTransactionComplete(int rv, const DnsResponse* response) {
  309. EXPECT_FALSE(completed_);
  310. completed_ = true;
  311. response_ = response;
  312. transaction_complete_run_loop_.Quit();
  313. if (cancel_in_callback_) {
  314. Cancel();
  315. return;
  316. }
  317. if (response)
  318. EXPECT_TRUE(response->IsValid());
  319. if (expected_answer_count_ >= 0) {
  320. ASSERT_THAT(rv, IsOk());
  321. ASSERT_TRUE(response != nullptr);
  322. EXPECT_EQ(static_cast<unsigned>(expected_answer_count_),
  323. response->answer_count());
  324. EXPECT_EQ(qtype_, response->GetSingleQType());
  325. DnsRecordParser parser = response->Parser();
  326. DnsResourceRecord record;
  327. for (int i = 0; i < expected_answer_count_; ++i) {
  328. EXPECT_TRUE(parser.ReadRecord(&record));
  329. }
  330. } else {
  331. EXPECT_EQ(expected_answer_count_, rv);
  332. }
  333. }
  334. bool has_completed() const { return completed_; }
  335. const DnsResponse* response() const { return response_; }
  336. // Runs until the completion callback is called. Transaction must have already
  337. // been started or this will never complete.
  338. void RunUntilComplete() {
  339. DCHECK(transaction_);
  340. DCHECK(!transaction_complete_run_loop_.running());
  341. transaction_complete_run_loop_.Run();
  342. DCHECK(has_completed());
  343. }
  344. private:
  345. uint16_t qtype_ = 0;
  346. std::unique_ptr<DnsTransaction> transaction_;
  347. raw_ptr<const DnsResponse> response_ = nullptr;
  348. int expected_answer_count_;
  349. bool cancel_in_callback_ = false;
  350. base::RunLoop transaction_complete_run_loop_;
  351. bool completed_ = false;
  352. };
  353. // Callback that allows a test to modify HttpResponseinfo
  354. // before the response is sent to the requester. This allows
  355. // response headers to be changed.
  356. using ResponseModifierCallback =
  357. base::RepeatingCallback<void(URLRequest* request, HttpResponseInfo* info)>;
  358. // Callback that allows the test to substitute its own implementation
  359. // of URLRequestJob to handle the request.
  360. using DohJobMakerCallback = base::RepeatingCallback<std::unique_ptr<
  361. URLRequestJob>(URLRequest* request, SocketDataProvider* data_provider)>;
  362. // Callback to notify that URLRequestJob::Start has been called.
  363. using UrlRequestStartedCallback = base::RepeatingCallback<void()>;
  364. // Subclass of URLRequestJob which takes a SocketDataProvider with data
  365. // representing both a DNS over HTTPS query and response.
  366. class URLRequestMockDohJob : public URLRequestJob, public AsyncSocket {
  367. public:
  368. URLRequestMockDohJob(
  369. URLRequest* request,
  370. SocketDataProvider* data_provider,
  371. ResponseModifierCallback response_modifier = ResponseModifierCallback(),
  372. UrlRequestStartedCallback on_start = UrlRequestStartedCallback())
  373. : URLRequestJob(request),
  374. data_provider_(data_provider),
  375. response_modifier_(response_modifier),
  376. on_start_(on_start) {
  377. data_provider_->Initialize(this);
  378. MatchQueryData(request, data_provider);
  379. }
  380. // Compare the query contained in either the POST body or the body
  381. // parameter of the GET query to the write data of the SocketDataProvider.
  382. static void MatchQueryData(URLRequest* request,
  383. SocketDataProvider* data_provider) {
  384. std::string decoded_query;
  385. if (request->method() == "GET") {
  386. std::string encoded_query;
  387. EXPECT_TRUE(GetValueForKeyInQuery(request->url(), "dns", &encoded_query));
  388. EXPECT_GT(encoded_query.size(), 0ul);
  389. EXPECT_TRUE(base::Base64UrlDecode(
  390. encoded_query, base::Base64UrlDecodePolicy::IGNORE_PADDING,
  391. &decoded_query));
  392. } else if (request->method() == "POST") {
  393. EXPECT_EQ(IDEMPOTENT, request->GetIdempotency());
  394. const UploadDataStream* stream = request->get_upload_for_testing();
  395. auto* readers = stream->GetElementReaders();
  396. EXPECT_TRUE(readers);
  397. EXPECT_FALSE(readers->empty());
  398. for (auto& reader : *readers) {
  399. const UploadBytesElementReader* byte_reader = reader->AsBytesReader();
  400. decoded_query +=
  401. std::string(byte_reader->bytes(), byte_reader->length());
  402. }
  403. }
  404. std::string query(decoded_query);
  405. MockWriteResult result(SYNCHRONOUS, 1);
  406. while (result.result > 0 && query.length() > 0) {
  407. result = data_provider->OnWrite(query);
  408. if (result.result > 0)
  409. query = query.substr(result.result);
  410. }
  411. }
  412. static std::string GetMockHttpsUrl(const std::string& path) {
  413. return "https://" + (kMockHostname + ("/" + path));
  414. }
  415. // URLRequestJob implementation:
  416. void Start() override {
  417. if (on_start_)
  418. on_start_.Run();
  419. // Start reading asynchronously so that all error reporting and data
  420. // callbacks happen as they would for network requests.
  421. base::ThreadTaskRunnerHandle::Get()->PostTask(
  422. FROM_HERE, base::BindOnce(&URLRequestMockDohJob::StartAsync,
  423. weak_factory_.GetWeakPtr()));
  424. }
  425. URLRequestMockDohJob(const URLRequestMockDohJob&) = delete;
  426. URLRequestMockDohJob& operator=(const URLRequestMockDohJob&) = delete;
  427. ~URLRequestMockDohJob() override {
  428. if (data_provider_)
  429. data_provider_->DetachSocket();
  430. }
  431. int ReadRawData(IOBuffer* buf, int buf_size) override {
  432. if (!data_provider_)
  433. return ERR_FAILED;
  434. if (leftover_data_len_ > 0) {
  435. int rv = DoBufferCopy(leftover_data_, leftover_data_len_, buf, buf_size);
  436. return rv;
  437. }
  438. if (data_provider_->AllReadDataConsumed())
  439. return 0;
  440. MockRead read = data_provider_->OnRead();
  441. if (read.result < ERR_IO_PENDING)
  442. return read.result;
  443. if (read.result == ERR_IO_PENDING) {
  444. pending_buf_ = buf;
  445. pending_buf_size_ = buf_size;
  446. return ERR_IO_PENDING;
  447. }
  448. return DoBufferCopy(read.data, read.data_len, buf, buf_size);
  449. }
  450. void GetResponseInfo(HttpResponseInfo* info) override {
  451. // Send back mock headers.
  452. std::string raw_headers;
  453. raw_headers.append(
  454. "HTTP/1.1 200 OK\n"
  455. "Content-type: application/dns-message\n");
  456. if (content_length_ > 0) {
  457. raw_headers.append(base::StringPrintf("Content-Length: %1d\n",
  458. static_cast<int>(content_length_)));
  459. }
  460. info->headers = base::MakeRefCounted<HttpResponseHeaders>(
  461. HttpUtil::AssembleRawHeaders(raw_headers));
  462. if (response_modifier_)
  463. response_modifier_.Run(request(), info);
  464. }
  465. // AsyncSocket implementation:
  466. void OnReadComplete(const MockRead& data) override {
  467. EXPECT_NE(data.result, ERR_IO_PENDING);
  468. if (data.result < 0)
  469. return ReadRawDataComplete(data.result);
  470. ReadRawDataComplete(DoBufferCopy(data.data, data.data_len, pending_buf_,
  471. pending_buf_size_));
  472. }
  473. void OnWriteComplete(int rv) override {}
  474. void OnConnectComplete(const MockConnect& data) override {}
  475. void OnDataProviderDestroyed() override { data_provider_ = nullptr; }
  476. private:
  477. void StartAsync() {
  478. if (!request_)
  479. return;
  480. if (content_length_)
  481. set_expected_content_size(content_length_);
  482. NotifyHeadersComplete();
  483. }
  484. int DoBufferCopy(const char* data,
  485. int data_len,
  486. IOBuffer* buf,
  487. int buf_size) {
  488. if (data_len > buf_size) {
  489. memcpy(buf->data(), data, buf_size);
  490. leftover_data_ = data + buf_size;
  491. leftover_data_len_ = data_len - buf_size;
  492. return buf_size;
  493. }
  494. memcpy(buf->data(), data, data_len);
  495. return data_len;
  496. }
  497. const int content_length_ = 0;
  498. const char* leftover_data_;
  499. int leftover_data_len_ = 0;
  500. raw_ptr<SocketDataProvider> data_provider_;
  501. const ResponseModifierCallback response_modifier_;
  502. const UrlRequestStartedCallback on_start_;
  503. raw_ptr<IOBuffer> pending_buf_;
  504. int pending_buf_size_;
  505. base::WeakPtrFactory<URLRequestMockDohJob> weak_factory_{this};
  506. };
  507. class DnsTransactionTestBase : public testing::Test {
  508. public:
  509. DnsTransactionTestBase() = default;
  510. ~DnsTransactionTestBase() override {
  511. // All queued transaction IDs should be used by a transaction calling
  512. // GetNextId().
  513. CHECK(transaction_ids_.empty());
  514. }
  515. // Generates |nameservers| for DnsConfig.
  516. void ConfigureNumServers(size_t num_servers) {
  517. CHECK_LE(num_servers, 255u);
  518. config_.nameservers.clear();
  519. for (size_t i = 0; i < num_servers; ++i) {
  520. config_.nameservers.emplace_back(IPAddress(192, 168, 1, i),
  521. dns_protocol::kDefaultPort);
  522. }
  523. }
  524. // Configures the DnsConfig DNS-over-HTTPS server(s), which either
  525. // accept GET or POST requests based on use_post. If a
  526. // ResponseModifierCallback is provided it will be called to construct the
  527. // HTTPResponse.
  528. void ConfigureDohServers(bool use_post,
  529. size_t num_doh_servers = 1,
  530. bool make_available = true) {
  531. GURL url(URLRequestMockDohJob::GetMockHttpsUrl("doh_test"));
  532. URLRequestFilter* filter = URLRequestFilter::GetInstance();
  533. filter->AddHostnameInterceptor(url.scheme(), url.host(),
  534. std::make_unique<DohJobInterceptor>(this));
  535. CHECK_LE(num_doh_servers, 255u);
  536. std::vector<string> templates;
  537. templates.reserve(num_doh_servers);
  538. for (size_t i = 0; i < num_doh_servers; ++i) {
  539. templates.push_back(URLRequestMockDohJob::GetMockHttpsUrl(
  540. base::StringPrintf("doh_test_%zu", i)) +
  541. (use_post ? "" : "{?dns}"));
  542. }
  543. config_.doh_config =
  544. *DnsOverHttpsConfig::FromTemplatesForTesting(std::move(templates));
  545. ConfigureFactory();
  546. if (make_available) {
  547. for (size_t server_index = 0; server_index < num_doh_servers;
  548. ++server_index) {
  549. resolve_context_->RecordServerSuccess(
  550. server_index, true /* is_doh_server */, session_.get());
  551. }
  552. }
  553. }
  554. // Called after fully configuring |config|.
  555. void ConfigureFactory() {
  556. session_ = base::MakeRefCounted<DnsSession>(
  557. config_,
  558. base::BindRepeating(&DnsTransactionTestBase::GetNextId,
  559. base::Unretained(this)),
  560. nullptr /* NetLog */);
  561. resolve_context_->InvalidateCachesAndPerSessionData(
  562. session_.get(), false /* network_change */);
  563. transaction_factory_ = DnsTransactionFactory::CreateFactory(session_.get());
  564. }
  565. void AddSocketData(std::unique_ptr<DnsSocketData> data,
  566. bool enqueue_transaction_id = true) {
  567. CHECK(socket_factory_.get());
  568. if (enqueue_transaction_id)
  569. transaction_ids_.push_back(data->query_id());
  570. socket_factory_->AddSocketDataProvider(data->GetProvider());
  571. socket_data_.push_back(std::move(data));
  572. }
  573. // Add expected query for |dotted_name| and |qtype| with |id| and response
  574. // taken verbatim from |data| of |data_length| bytes. The transaction id in
  575. // |data| should equal |id|, unless testing mismatched response.
  576. void AddQueryAndResponse(uint16_t id,
  577. const char* dotted_name,
  578. uint16_t qtype,
  579. const uint8_t* response_data,
  580. size_t response_length,
  581. IoMode mode,
  582. Transport transport,
  583. const OptRecordRdata* opt_rdata = nullptr,
  584. DnsQuery::PaddingStrategy padding_strategy =
  585. DnsQuery::PaddingStrategy::NONE,
  586. bool enqueue_transaction_id = true) {
  587. CHECK(socket_factory_.get());
  588. auto data = std::make_unique<DnsSocketData>(
  589. id, dotted_name, qtype, mode, transport, opt_rdata, padding_strategy);
  590. data->AddResponseData(response_data, response_length, mode);
  591. AddSocketData(std::move(data), enqueue_transaction_id);
  592. }
  593. void AddQueryAndErrorResponse(uint16_t id,
  594. const char* dotted_name,
  595. uint16_t qtype,
  596. int error,
  597. IoMode mode,
  598. Transport transport,
  599. const OptRecordRdata* opt_rdata = nullptr,
  600. DnsQuery::PaddingStrategy padding_strategy =
  601. DnsQuery::PaddingStrategy::NONE,
  602. bool enqueue_transaction_id = true) {
  603. CHECK(socket_factory_.get());
  604. auto data = std::make_unique<DnsSocketData>(
  605. id, dotted_name, qtype, mode, transport, opt_rdata, padding_strategy);
  606. data->AddReadError(error, mode);
  607. AddSocketData(std::move(data), enqueue_transaction_id);
  608. }
  609. void AddAsyncQueryAndResponse(uint16_t id,
  610. const char* dotted_name,
  611. uint16_t qtype,
  612. const uint8_t* data,
  613. size_t data_length,
  614. const OptRecordRdata* opt_rdata = nullptr) {
  615. AddQueryAndResponse(id, dotted_name, qtype, data, data_length, ASYNC,
  616. Transport::UDP, opt_rdata);
  617. }
  618. void AddSyncQueryAndResponse(uint16_t id,
  619. const char* dotted_name,
  620. uint16_t qtype,
  621. const uint8_t* data,
  622. size_t data_length,
  623. const OptRecordRdata* opt_rdata = nullptr) {
  624. AddQueryAndResponse(id, dotted_name, qtype, data, data_length, SYNCHRONOUS,
  625. Transport::UDP, opt_rdata);
  626. }
  627. // Add expected query of |dotted_name| and |qtype| and no response.
  628. void AddHangingQuery(
  629. const char* dotted_name,
  630. uint16_t qtype,
  631. DnsQuery::PaddingStrategy padding_strategy =
  632. DnsQuery::PaddingStrategy::NONE,
  633. uint16_t id = base::RandInt(0, std::numeric_limits<uint16_t>::max()),
  634. bool enqueue_transaction_id = true) {
  635. auto data = std::make_unique<DnsSocketData>(
  636. id, dotted_name, qtype, ASYNC, Transport::UDP, nullptr /* opt_rdata */,
  637. padding_strategy);
  638. AddSocketData(std::move(data), enqueue_transaction_id);
  639. }
  640. // Add expected query of |dotted_name| and |qtype| and matching response with
  641. // no answer and RCODE set to |rcode|. The id will be generated randomly.
  642. void AddQueryAndRcode(
  643. const char* dotted_name,
  644. uint16_t qtype,
  645. int rcode,
  646. IoMode mode,
  647. Transport trans,
  648. DnsQuery::PaddingStrategy padding_strategy =
  649. DnsQuery::PaddingStrategy::NONE,
  650. uint16_t id = base::RandInt(0, std::numeric_limits<uint16_t>::max()),
  651. bool enqueue_transaction_id = true) {
  652. CHECK_NE(dns_protocol::kRcodeNOERROR, rcode);
  653. auto data = std::make_unique<DnsSocketData>(id, dotted_name, qtype, mode,
  654. trans, nullptr /* opt_rdata */,
  655. padding_strategy);
  656. data->AddRcode(rcode, mode);
  657. AddSocketData(std::move(data), enqueue_transaction_id);
  658. }
  659. void AddAsyncQueryAndRcode(const char* dotted_name,
  660. uint16_t qtype,
  661. int rcode) {
  662. AddQueryAndRcode(dotted_name, qtype, rcode, ASYNC, Transport::UDP);
  663. }
  664. void AddSyncQueryAndRcode(const char* dotted_name,
  665. uint16_t qtype,
  666. int rcode) {
  667. AddQueryAndRcode(dotted_name, qtype, rcode, SYNCHRONOUS, Transport::UDP);
  668. }
  669. // Checks if the sockets were connected in the order matching the indices in
  670. // |servers|.
  671. void CheckServerOrder(const size_t* servers, size_t num_attempts) {
  672. ASSERT_EQ(num_attempts, socket_factory_->remote_endpoints_.size());
  673. auto num_insecure_nameservers = session_->config().nameservers.size();
  674. for (size_t i = 0; i < num_attempts; ++i) {
  675. if (servers[i] < num_insecure_nameservers) {
  676. // Check insecure server match.
  677. EXPECT_EQ(
  678. socket_factory_->remote_endpoints_[i].insecure_nameserver.value(),
  679. session_->config().nameservers[servers[i]]);
  680. } else {
  681. // Check secure server match.
  682. EXPECT_EQ(
  683. socket_factory_->remote_endpoints_[i].secure_nameserver.value(),
  684. session_->config()
  685. .doh_config.servers()[servers[i] - num_insecure_nameservers]);
  686. }
  687. }
  688. }
  689. std::unique_ptr<URLRequestJob> MaybeInterceptRequest(URLRequest* request) {
  690. // If the path indicates a redirect, skip checking the list of
  691. // configured servers, because it won't be there and we still want
  692. // to handle it.
  693. bool server_found = request->url().path() == "/redirect-destination";
  694. for (auto server : config_.doh_config.servers()) {
  695. if (server_found)
  696. break;
  697. std::string url_base =
  698. GetURLFromTemplateWithoutParameters(server.server_template());
  699. if (server.use_post() && request->method() == "POST") {
  700. if (url_base == request->url().spec()) {
  701. server_found = true;
  702. socket_factory_->remote_endpoints_.emplace_back(server);
  703. }
  704. } else if (!server.use_post() && request->method() == "GET") {
  705. std::string prefix = url_base + "?dns=";
  706. auto mispair = std::mismatch(prefix.begin(), prefix.end(),
  707. request->url().spec().begin());
  708. if (mispair.first == prefix.end()) {
  709. server_found = true;
  710. socket_factory_->remote_endpoints_.emplace_back(server);
  711. }
  712. }
  713. }
  714. EXPECT_TRUE(server_found);
  715. EXPECT_TRUE(
  716. request->isolation_info().network_isolation_key().IsTransient());
  717. // All DoH requests for the same ResolveContext should use the same
  718. // IsolationInfo, so network objects like sockets can be reused between
  719. // requests.
  720. if (!expect_multiple_isolation_infos_) {
  721. if (!isolation_info_) {
  722. isolation_info_ =
  723. std::make_unique<IsolationInfo>(request->isolation_info());
  724. } else {
  725. EXPECT_TRUE(
  726. isolation_info_->IsEqualForTesting(request->isolation_info()));
  727. }
  728. }
  729. EXPECT_FALSE(request->allow_credentials());
  730. EXPECT_EQ(SecureDnsPolicy::kBootstrap, request->secure_dns_policy());
  731. std::string accept;
  732. EXPECT_TRUE(request->extra_request_headers().GetHeader("Accept", &accept));
  733. EXPECT_EQ(accept, "application/dns-message");
  734. std::string language;
  735. EXPECT_TRUE(request->extra_request_headers().GetHeader("Accept-Language",
  736. &language));
  737. EXPECT_EQ(language, "*");
  738. std::string user_agent;
  739. EXPECT_TRUE(
  740. request->extra_request_headers().GetHeader("User-Agent", &user_agent));
  741. EXPECT_EQ(user_agent, "Chrome");
  742. SocketDataProvider* provider = socket_factory_->mock_data().GetNext();
  743. if (doh_job_maker_)
  744. return doh_job_maker_.Run(request, provider);
  745. return std::make_unique<URLRequestMockDohJob>(
  746. request, provider, response_modifier_, on_start_);
  747. }
  748. class DohJobInterceptor : public URLRequestInterceptor {
  749. public:
  750. explicit DohJobInterceptor(DnsTransactionTestBase* test) : test_(test) {}
  751. DohJobInterceptor(const DohJobInterceptor&) = delete;
  752. DohJobInterceptor& operator=(const DohJobInterceptor&) = delete;
  753. ~DohJobInterceptor() override = default;
  754. // URLRequestInterceptor implementation:
  755. std::unique_ptr<URLRequestJob> MaybeInterceptRequest(
  756. URLRequest* request) const override {
  757. return test_->MaybeInterceptRequest(request);
  758. }
  759. private:
  760. raw_ptr<DnsTransactionTestBase> test_;
  761. };
  762. void SetResponseModifierCallback(ResponseModifierCallback response_modifier) {
  763. response_modifier_ = response_modifier;
  764. }
  765. void SetDohJobMakerCallback(DohJobMakerCallback doh_job_maker) {
  766. doh_job_maker_ = doh_job_maker;
  767. }
  768. void SetUrlRequestStartedCallback(UrlRequestStartedCallback on_start) {
  769. on_start_ = on_start;
  770. }
  771. void SetUp() override {
  772. // By default set one server,
  773. ConfigureNumServers(1);
  774. // and no retransmissions,
  775. config_.attempts = 1;
  776. // and an arbitrary fallback period.
  777. config_.fallback_period = kFallbackPeriod;
  778. auto context_builder = CreateTestURLRequestContextBuilder();
  779. socket_factory_ = std::make_unique<TestSocketFactory>();
  780. context_builder->set_client_socket_factory_for_testing(
  781. socket_factory_.get());
  782. request_context_ = context_builder->Build();
  783. resolve_context_ = std::make_unique<ResolveContext>(
  784. request_context_.get(), false /* enable_caching */);
  785. ConfigureFactory();
  786. }
  787. void TearDown() override {
  788. // Check that all socket data was at least written to.
  789. for (size_t i = 0; i < socket_data_.size(); ++i) {
  790. EXPECT_TRUE(socket_data_[i]->GetProvider()->AllWriteDataConsumed()) << i;
  791. }
  792. URLRequestFilter* filter = URLRequestFilter::GetInstance();
  793. filter->ClearHandlers();
  794. }
  795. void set_expect_multiple_isolation_infos(
  796. bool expect_multiple_isolation_infos) {
  797. expect_multiple_isolation_infos_ = expect_multiple_isolation_infos;
  798. }
  799. protected:
  800. int GetNextId(int min, int max) {
  801. EXPECT_FALSE(transaction_ids_.empty());
  802. int id = transaction_ids_.front();
  803. transaction_ids_.pop_front();
  804. EXPECT_GE(id, min);
  805. EXPECT_LE(id, max);
  806. return id;
  807. }
  808. DnsConfig config_;
  809. std::vector<std::unique_ptr<DnsSocketData>> socket_data_;
  810. base::circular_deque<int> transaction_ids_;
  811. std::unique_ptr<TestSocketFactory> socket_factory_;
  812. std::unique_ptr<URLRequestContext> request_context_;
  813. std::unique_ptr<ResolveContext> resolve_context_;
  814. scoped_refptr<DnsSession> session_;
  815. std::unique_ptr<DnsTransactionFactory> transaction_factory_;
  816. ResponseModifierCallback response_modifier_;
  817. UrlRequestStartedCallback on_start_;
  818. DohJobMakerCallback doh_job_maker_;
  819. // Whether multiple IsolationInfos should be expected (due to there being
  820. // multiple RequestContexts in use).
  821. bool expect_multiple_isolation_infos_ = false;
  822. // IsolationInfo used by DoH requests. Populated on first DoH request, and
  823. // compared to IsolationInfo used by all subsequent requests, unless
  824. // |expect_multiple_isolation_infos_| is true.
  825. std::unique_ptr<IsolationInfo> isolation_info_;
  826. };
  827. class DnsTransactionTest : public DnsTransactionTestBase,
  828. public WithTaskEnvironment {
  829. public:
  830. DnsTransactionTest() = default;
  831. ~DnsTransactionTest() override = default;
  832. };
  833. class DnsTransactionTestWithMockTime : public DnsTransactionTestBase,
  834. public WithTaskEnvironment {
  835. protected:
  836. DnsTransactionTestWithMockTime()
  837. : WithTaskEnvironment(
  838. base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  839. ~DnsTransactionTestWithMockTime() override = default;
  840. };
  841. TEST_F(DnsTransactionTest, Lookup) {
  842. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  843. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  844. TransactionHelper helper0(kT0RecordCount);
  845. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  846. false /* secure */, resolve_context_.get());
  847. helper0.RunUntilComplete();
  848. }
  849. TEST_F(DnsTransactionTest, LookupWithEDNSOption) {
  850. OptRecordRdata expected_opt_rdata;
  851. transaction_factory_->AddEDNSOption(
  852. OptRecordRdata::UnknownOpt::CreateForTesting(123, "\xbe\xef"));
  853. expected_opt_rdata.AddOpt(
  854. OptRecordRdata::UnknownOpt::CreateForTesting(123, "\xbe\xef"));
  855. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  856. kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  857. &expected_opt_rdata);
  858. TransactionHelper helper0(kT0RecordCount);
  859. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  860. false /* secure */, resolve_context_.get());
  861. helper0.RunUntilComplete();
  862. }
  863. TEST_F(DnsTransactionTest, LookupWithMultipleEDNSOptions) {
  864. OptRecordRdata expected_opt_rdata;
  865. std::vector<std::pair<uint16_t, std::string>> params = {
  866. // Two options with the same code, to check that both are included.
  867. std::pair<uint16_t, std::string>(1, "\xde\xad"),
  868. std::pair<uint16_t, std::string>(1, "\xbe\xef"),
  869. // Try a different code and different length of data.
  870. std::pair<uint16_t, std::string>(2, "\xff")};
  871. for (auto& param : params) {
  872. transaction_factory_->AddEDNSOption(
  873. OptRecordRdata::UnknownOpt::CreateForTesting(param.first,
  874. param.second));
  875. expected_opt_rdata.AddOpt(OptRecordRdata::UnknownOpt::CreateForTesting(
  876. param.first, param.second));
  877. }
  878. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  879. kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  880. &expected_opt_rdata);
  881. TransactionHelper helper0(kT0RecordCount);
  882. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  883. false /* secure */, resolve_context_.get());
  884. helper0.RunUntilComplete();
  885. }
  886. // Concurrent lookup tests assume that DnsTransaction::Start immediately
  887. // consumes a socket from ClientSocketFactory.
  888. TEST_F(DnsTransactionTest, ConcurrentLookup) {
  889. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  890. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  891. AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
  892. kT1ResponseDatagram, std::size(kT1ResponseDatagram));
  893. TransactionHelper helper0(kT0RecordCount);
  894. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  895. false /* secure */, resolve_context_.get());
  896. TransactionHelper helper1(kT1RecordCount);
  897. helper1.StartTransaction(transaction_factory_.get(), kT1HostName, kT1Qtype,
  898. false /* secure */, resolve_context_.get());
  899. base::RunLoop().RunUntilIdle();
  900. EXPECT_TRUE(helper0.has_completed());
  901. EXPECT_TRUE(helper1.has_completed());
  902. }
  903. TEST_F(DnsTransactionTest, CancelLookup) {
  904. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  905. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  906. AddAsyncQueryAndResponse(1 /* id */, kT1HostName, kT1Qtype,
  907. kT1ResponseDatagram, std::size(kT1ResponseDatagram));
  908. TransactionHelper helper0(kT0RecordCount);
  909. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  910. false /* secure */, resolve_context_.get());
  911. TransactionHelper helper1(kT1RecordCount);
  912. helper1.StartTransaction(transaction_factory_.get(), kT1HostName, kT1Qtype,
  913. false /* secure */, resolve_context_.get());
  914. helper0.Cancel();
  915. base::RunLoop().RunUntilIdle();
  916. EXPECT_FALSE(helper0.has_completed());
  917. EXPECT_TRUE(helper1.has_completed());
  918. }
  919. TEST_F(DnsTransactionTest, DestroyFactory) {
  920. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  921. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  922. TransactionHelper helper0(kT0RecordCount);
  923. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  924. false /* secure */, resolve_context_.get());
  925. // Destroying the client does not affect running requests.
  926. transaction_factory_.reset(nullptr);
  927. helper0.RunUntilComplete();
  928. }
  929. TEST_F(DnsTransactionTest, CancelFromCallback) {
  930. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  931. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  932. TransactionHelper helper0(kT0RecordCount);
  933. helper0.set_cancel_in_callback();
  934. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  935. false /* secure */, resolve_context_.get());
  936. helper0.RunUntilComplete();
  937. }
  938. TEST_F(DnsTransactionTest, MismatchedResponseSync) {
  939. config_.attempts = 2;
  940. ConfigureFactory();
  941. // First attempt receives mismatched response synchronously.
  942. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  943. SYNCHRONOUS, Transport::UDP);
  944. data->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  945. SYNCHRONOUS);
  946. AddSocketData(std::move(data));
  947. // Second attempt receives valid response synchronously.
  948. auto data1 = std::make_unique<DnsSocketData>(
  949. 0 /* id */, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::UDP);
  950. data1->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  951. SYNCHRONOUS);
  952. AddSocketData(std::move(data1));
  953. TransactionHelper helper0(kT0RecordCount);
  954. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  955. false /* secure */, resolve_context_.get());
  956. helper0.RunUntilComplete();
  957. }
  958. TEST_F(DnsTransactionTest, MismatchedResponseAsync) {
  959. config_.attempts = 2;
  960. ConfigureFactory();
  961. // First attempt receives mismatched response asynchronously.
  962. auto data0 = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName,
  963. kT0Qtype, ASYNC, Transport::UDP);
  964. data0->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  965. ASYNC);
  966. AddSocketData(std::move(data0));
  967. // Second attempt receives valid response asynchronously.
  968. auto data1 = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName,
  969. kT0Qtype, ASYNC, Transport::UDP);
  970. data1->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  971. ASYNC);
  972. AddSocketData(std::move(data1));
  973. TransactionHelper helper0(kT0RecordCount);
  974. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  975. false /* secure */, resolve_context_.get());
  976. helper0.RunUntilComplete();
  977. }
  978. // Test that responses are not accepted when only the response ID mismatches.
  979. // Tests against incorrect transaction ID validation, which is anti-pattern #1
  980. // from the "NAME:WRECK" report:
  981. // https://www.forescout.com/company/resources/namewreck-breaking-and-fixing-dns-implementations/
  982. TEST_F(DnsTransactionTest, MismatchedResponseFail) {
  983. ConfigureFactory();
  984. // Attempt receives mismatched response and fails because only one attempt is
  985. // allowed.
  986. AddAsyncQueryAndResponse(1 /* id */, kT0HostName, kT0Qtype,
  987. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  988. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  989. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  990. false /* secure */, resolve_context_.get());
  991. helper0.RunUntilComplete();
  992. }
  993. TEST_F(DnsTransactionTest, MismatchedResponseNxdomain) {
  994. config_.attempts = 2;
  995. ConfigureFactory();
  996. // First attempt receives mismatched response followed by valid NXDOMAIN
  997. // response.
  998. // Second attempt receives valid NXDOMAIN response.
  999. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  1000. SYNCHRONOUS, Transport::UDP);
  1001. data->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  1002. SYNCHRONOUS);
  1003. data->AddRcode(dns_protocol::kRcodeNXDOMAIN, ASYNC);
  1004. AddSocketData(std::move(data));
  1005. AddSyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
  1006. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1007. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1008. false /* secure */, resolve_context_.get());
  1009. helper0.RunUntilComplete();
  1010. }
  1011. TEST_F(DnsTransactionTest, ServerFail) {
  1012. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
  1013. TransactionHelper helper0(ERR_DNS_SERVER_FAILED);
  1014. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1015. false /* secure */, resolve_context_.get());
  1016. helper0.RunUntilComplete();
  1017. ASSERT_NE(helper0.response(), nullptr);
  1018. EXPECT_EQ(helper0.response()->rcode(), dns_protocol::kRcodeSERVFAIL);
  1019. }
  1020. TEST_F(DnsTransactionTest, NoDomain) {
  1021. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
  1022. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1023. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1024. false /* secure */, resolve_context_.get());
  1025. helper0.RunUntilComplete();
  1026. }
  1027. TEST_F(DnsTransactionTestWithMockTime, Timeout_FastTimeout) {
  1028. config_.attempts = 3;
  1029. ConfigureFactory();
  1030. AddHangingQuery(kT0HostName, kT0Qtype);
  1031. AddHangingQuery(kT0HostName, kT0Qtype);
  1032. AddHangingQuery(kT0HostName, kT0Qtype);
  1033. TransactionHelper helper0(ERR_DNS_TIMED_OUT);
  1034. std::unique_ptr<DnsTransaction> transaction =
  1035. transaction_factory_->CreateTransaction(
  1036. kT0HostName, kT0Qtype, NetLogWithSource(), false /* secure */,
  1037. SecureDnsMode::kOff, resolve_context_.get(), true /* fast_timeout */);
  1038. helper0.StartTransaction(std::move(transaction));
  1039. // Finish when the third attempt expires its fallback period.
  1040. base::RunLoop().RunUntilIdle();
  1041. EXPECT_FALSE(helper0.has_completed());
  1042. FastForwardBy(
  1043. resolve_context_->NextClassicFallbackPeriod(0, 0, session_.get()));
  1044. EXPECT_FALSE(helper0.has_completed());
  1045. FastForwardBy(
  1046. resolve_context_->NextClassicFallbackPeriod(0, 1, session_.get()));
  1047. EXPECT_FALSE(helper0.has_completed());
  1048. FastForwardBy(
  1049. resolve_context_->NextClassicFallbackPeriod(0, 2, session_.get()));
  1050. EXPECT_TRUE(helper0.has_completed());
  1051. }
  1052. TEST_F(DnsTransactionTestWithMockTime, ServerFallbackAndRotate) {
  1053. // Test that we fallback on both server failure and fallback period
  1054. // expiration.
  1055. config_.attempts = 2;
  1056. // The next request should start from the next server.
  1057. config_.rotate = true;
  1058. ConfigureNumServers(3);
  1059. ConfigureFactory();
  1060. // Responses for first request.
  1061. AddHangingQuery(kT0HostName, kT0Qtype);
  1062. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
  1063. AddHangingQuery(kT0HostName, kT0Qtype);
  1064. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL);
  1065. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
  1066. // Responses for second request.
  1067. AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeSERVFAIL);
  1068. AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeSERVFAIL);
  1069. AddAsyncQueryAndRcode(kT1HostName, kT1Qtype, dns_protocol::kRcodeNXDOMAIN);
  1070. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1071. TransactionHelper helper1(ERR_NAME_NOT_RESOLVED);
  1072. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1073. false /* secure */, resolve_context_.get());
  1074. base::RunLoop().RunUntilIdle();
  1075. EXPECT_FALSE(helper0.has_completed());
  1076. FastForwardUntilNoTasksRemain();
  1077. EXPECT_TRUE(helper0.has_completed());
  1078. helper1.StartTransaction(transaction_factory_.get(), kT1HostName, kT1Qtype,
  1079. false /* secure */, resolve_context_.get());
  1080. helper1.RunUntilComplete();
  1081. size_t kOrder[] = {
  1082. // The first transaction.
  1083. 0,
  1084. 1,
  1085. 2,
  1086. 0,
  1087. 1,
  1088. // The second transaction starts from the next server, and 0 is skipped
  1089. // because it already has 2 consecutive failures.
  1090. 1,
  1091. 2,
  1092. 1,
  1093. };
  1094. CheckServerOrder(kOrder, std::size(kOrder));
  1095. }
  1096. TEST_F(DnsTransactionTest, SuffixSearchAboveNdots) {
  1097. config_.ndots = 2;
  1098. config_.search.push_back("a");
  1099. config_.search.push_back("b");
  1100. config_.search.push_back("c");
  1101. config_.rotate = true;
  1102. ConfigureNumServers(2);
  1103. ConfigureFactory();
  1104. AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
  1105. dns_protocol::kRcodeNXDOMAIN);
  1106. AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
  1107. dns_protocol::kRcodeNXDOMAIN);
  1108. AddAsyncQueryAndRcode("x.y.z.b", dns_protocol::kTypeA,
  1109. dns_protocol::kRcodeNXDOMAIN);
  1110. AddAsyncQueryAndRcode("x.y.z.c", dns_protocol::kTypeA,
  1111. dns_protocol::kRcodeNXDOMAIN);
  1112. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1113. helper0.StartTransaction(transaction_factory_.get(), "x.y.z",
  1114. dns_protocol::kTypeA, false /* secure */,
  1115. resolve_context_.get());
  1116. helper0.RunUntilComplete();
  1117. // Also check if suffix search causes server rotation.
  1118. size_t kOrder0[] = {0, 1, 0, 1};
  1119. CheckServerOrder(kOrder0, std::size(kOrder0));
  1120. }
  1121. TEST_F(DnsTransactionTest, SuffixSearchBelowNdots) {
  1122. config_.ndots = 2;
  1123. config_.search.push_back("a");
  1124. config_.search.push_back("b");
  1125. config_.search.push_back("c");
  1126. ConfigureFactory();
  1127. // Responses for first transaction.
  1128. AddAsyncQueryAndRcode("x.y.a", dns_protocol::kTypeA,
  1129. dns_protocol::kRcodeNXDOMAIN);
  1130. AddAsyncQueryAndRcode("x.y.b", dns_protocol::kTypeA,
  1131. dns_protocol::kRcodeNXDOMAIN);
  1132. AddAsyncQueryAndRcode("x.y.c", dns_protocol::kTypeA,
  1133. dns_protocol::kRcodeNXDOMAIN);
  1134. AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
  1135. dns_protocol::kRcodeNXDOMAIN);
  1136. // Responses for second transaction.
  1137. AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
  1138. dns_protocol::kRcodeNXDOMAIN);
  1139. AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
  1140. dns_protocol::kRcodeNXDOMAIN);
  1141. AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
  1142. dns_protocol::kRcodeNXDOMAIN);
  1143. // Responses for third transaction.
  1144. AddAsyncQueryAndRcode("x", dns_protocol::kTypeAAAA,
  1145. dns_protocol::kRcodeNXDOMAIN);
  1146. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1147. helper0.StartTransaction(transaction_factory_.get(), "x.y",
  1148. dns_protocol::kTypeA, false /* secure */,
  1149. resolve_context_.get());
  1150. helper0.RunUntilComplete();
  1151. // A single-label name.
  1152. TransactionHelper helper1(ERR_NAME_NOT_RESOLVED);
  1153. helper1.StartTransaction(transaction_factory_.get(), "x",
  1154. dns_protocol::kTypeA, false /* secure */,
  1155. resolve_context_.get());
  1156. helper1.RunUntilComplete();
  1157. // A fully-qualified name.
  1158. TransactionHelper helper2(ERR_NAME_NOT_RESOLVED);
  1159. helper2.StartTransaction(transaction_factory_.get(), "x.",
  1160. dns_protocol::kTypeAAAA, false /* secure */,
  1161. resolve_context_.get());
  1162. helper2.RunUntilComplete();
  1163. }
  1164. TEST_F(DnsTransactionTest, EmptySuffixSearch) {
  1165. // Responses for first transaction.
  1166. AddAsyncQueryAndRcode("x", dns_protocol::kTypeA,
  1167. dns_protocol::kRcodeNXDOMAIN);
  1168. // A fully-qualified name.
  1169. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1170. helper0.StartTransaction(transaction_factory_.get(), "x.",
  1171. dns_protocol::kTypeA, false /* secure */,
  1172. resolve_context_.get());
  1173. helper0.RunUntilComplete();
  1174. // A single label name is not even attempted.
  1175. TransactionHelper helper1(ERR_DNS_SEARCH_EMPTY);
  1176. helper1.StartTransaction(transaction_factory_.get(), "singlelabel",
  1177. dns_protocol::kTypeA, false /* secure */,
  1178. resolve_context_.get());
  1179. helper1.RunUntilComplete();
  1180. }
  1181. TEST_F(DnsTransactionTest, DontAppendToMultiLabelName) {
  1182. config_.search.push_back("a");
  1183. config_.search.push_back("b");
  1184. config_.search.push_back("c");
  1185. config_.append_to_multi_label_name = false;
  1186. ConfigureFactory();
  1187. // Responses for first transaction.
  1188. AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
  1189. dns_protocol::kRcodeNXDOMAIN);
  1190. // Responses for second transaction.
  1191. AddAsyncQueryAndRcode("x.y", dns_protocol::kTypeA,
  1192. dns_protocol::kRcodeNXDOMAIN);
  1193. // Responses for third transaction.
  1194. AddAsyncQueryAndRcode("x.a", dns_protocol::kTypeA,
  1195. dns_protocol::kRcodeNXDOMAIN);
  1196. AddAsyncQueryAndRcode("x.b", dns_protocol::kTypeA,
  1197. dns_protocol::kRcodeNXDOMAIN);
  1198. AddAsyncQueryAndRcode("x.c", dns_protocol::kTypeA,
  1199. dns_protocol::kRcodeNXDOMAIN);
  1200. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  1201. helper0.StartTransaction(transaction_factory_.get(), "x.y.z",
  1202. dns_protocol::kTypeA, false /* secure */,
  1203. resolve_context_.get());
  1204. helper0.RunUntilComplete();
  1205. TransactionHelper helper1(ERR_NAME_NOT_RESOLVED);
  1206. helper1.StartTransaction(transaction_factory_.get(), "x.y",
  1207. dns_protocol::kTypeA, false /* secure */,
  1208. resolve_context_.get());
  1209. helper1.RunUntilComplete();
  1210. TransactionHelper helper2(ERR_NAME_NOT_RESOLVED);
  1211. helper2.StartTransaction(transaction_factory_.get(), "x",
  1212. dns_protocol::kTypeA, false /* secure */,
  1213. resolve_context_.get());
  1214. helper2.RunUntilComplete();
  1215. }
  1216. const uint8_t kResponseNoData[] = {
  1217. 0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
  1218. // Question
  1219. 0x01, 'x', 0x01, 'y', 0x01, 'z', 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01,
  1220. // Authority section, SOA record, TTL 0x3E6
  1221. 0x01, 'z', 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE6,
  1222. // Minimal RDATA, 18 bytes
  1223. 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1224. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1225. };
  1226. TEST_F(DnsTransactionTest, SuffixSearchStop) {
  1227. config_.ndots = 2;
  1228. config_.search.push_back("a");
  1229. config_.search.push_back("b");
  1230. config_.search.push_back("c");
  1231. ConfigureFactory();
  1232. AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
  1233. dns_protocol::kRcodeNXDOMAIN);
  1234. AddAsyncQueryAndRcode("x.y.z.a", dns_protocol::kTypeA,
  1235. dns_protocol::kRcodeNXDOMAIN);
  1236. AddAsyncQueryAndResponse(0 /* id */, "x.y.z.b", dns_protocol::kTypeA,
  1237. kResponseNoData, std::size(kResponseNoData));
  1238. TransactionHelper helper0(0 /* answers */);
  1239. helper0.StartTransaction(transaction_factory_.get(), "x.y.z",
  1240. dns_protocol::kTypeA, false /* secure */,
  1241. resolve_context_.get());
  1242. helper0.RunUntilComplete();
  1243. }
  1244. TEST_F(DnsTransactionTest, SyncFirstQuery) {
  1245. config_.search.push_back("lab.ccs.neu.edu");
  1246. config_.search.push_back("ccs.neu.edu");
  1247. ConfigureFactory();
  1248. AddSyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  1249. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  1250. TransactionHelper helper0(kT0RecordCount);
  1251. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1252. false /* secure */, resolve_context_.get());
  1253. helper0.RunUntilComplete();
  1254. }
  1255. TEST_F(DnsTransactionTest, SyncFirstQueryWithSearch) {
  1256. config_.search.push_back("lab.ccs.neu.edu");
  1257. config_.search.push_back("ccs.neu.edu");
  1258. ConfigureFactory();
  1259. AddSyncQueryAndRcode("www.lab.ccs.neu.edu", kT2Qtype,
  1260. dns_protocol::kRcodeNXDOMAIN);
  1261. // "www.ccs.neu.edu"
  1262. AddAsyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
  1263. kT2ResponseDatagram, std::size(kT2ResponseDatagram));
  1264. TransactionHelper helper0(kT2RecordCount);
  1265. helper0.StartTransaction(transaction_factory_.get(), "www", kT2Qtype,
  1266. false /* secure */, resolve_context_.get());
  1267. helper0.RunUntilComplete();
  1268. }
  1269. TEST_F(DnsTransactionTest, SyncSearchQuery) {
  1270. config_.search.push_back("lab.ccs.neu.edu");
  1271. config_.search.push_back("ccs.neu.edu");
  1272. ConfigureFactory();
  1273. AddAsyncQueryAndRcode("www.lab.ccs.neu.edu", dns_protocol::kTypeA,
  1274. dns_protocol::kRcodeNXDOMAIN);
  1275. AddSyncQueryAndResponse(2 /* id */, kT2HostName, kT2Qtype,
  1276. kT2ResponseDatagram, std::size(kT2ResponseDatagram));
  1277. TransactionHelper helper0(kT2RecordCount);
  1278. helper0.StartTransaction(transaction_factory_.get(), "www", kT2Qtype,
  1279. false /* secure */, resolve_context_.get());
  1280. helper0.RunUntilComplete();
  1281. }
  1282. TEST_F(DnsTransactionTest, ConnectFailure) {
  1283. // Prep socket factory for a single socket with connection failure.
  1284. MockConnect connect_data;
  1285. connect_data.result = ERR_FAILED;
  1286. StaticSocketDataProvider data_provider;
  1287. data_provider.set_connect_data(connect_data);
  1288. socket_factory_->AddSocketDataProvider(&data_provider);
  1289. transaction_ids_.push_back(0); // Needed to make a DnsUDPAttempt.
  1290. TransactionHelper helper0(ERR_CONNECTION_REFUSED);
  1291. helper0.StartTransaction(transaction_factory_.get(), "www.chromium.org",
  1292. dns_protocol::kTypeA, false /* secure */,
  1293. resolve_context_.get());
  1294. helper0.RunUntilComplete();
  1295. EXPECT_FALSE(helper0.response());
  1296. EXPECT_FALSE(session_->udp_tracker()->low_entropy());
  1297. }
  1298. TEST_F(DnsTransactionTest, ConnectFailure_SocketLimitReached) {
  1299. // Prep socket factory for a single socket with connection failure.
  1300. MockConnect connect_data;
  1301. connect_data.result = ERR_INSUFFICIENT_RESOURCES;
  1302. StaticSocketDataProvider data_provider;
  1303. data_provider.set_connect_data(connect_data);
  1304. socket_factory_->AddSocketDataProvider(&data_provider);
  1305. transaction_ids_.push_back(0); // Needed to make a DnsUDPAttempt.
  1306. TransactionHelper helper0(ERR_CONNECTION_REFUSED);
  1307. helper0.StartTransaction(transaction_factory_.get(), "www.chromium.org",
  1308. dns_protocol::kTypeA, false /* secure */,
  1309. resolve_context_.get());
  1310. helper0.RunUntilComplete();
  1311. EXPECT_FALSE(helper0.response());
  1312. EXPECT_TRUE(session_->udp_tracker()->low_entropy());
  1313. }
  1314. TEST_F(DnsTransactionTest, ConnectFailureFollowedBySuccess) {
  1315. // Retry after server failure.
  1316. config_.attempts = 2;
  1317. ConfigureFactory();
  1318. // First server connection attempt fails.
  1319. transaction_ids_.push_back(0); // Needed to make a DnsUDPAttempt.
  1320. socket_factory_->fail_next_socket_ = true;
  1321. // Second DNS query succeeds.
  1322. AddAsyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  1323. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  1324. TransactionHelper helper0(kT0RecordCount);
  1325. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1326. false /* secure */, resolve_context_.get());
  1327. helper0.RunUntilComplete();
  1328. }
  1329. TEST_F(DnsTransactionTest, HttpsGetLookup) {
  1330. ConfigureDohServers(false /* use_post */);
  1331. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1332. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1333. Transport::HTTPS, nullptr /* opt_rdata */,
  1334. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1335. false /* enqueue_transaction_id */);
  1336. TransactionHelper helper0(kT0RecordCount);
  1337. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1338. true /* secure */, resolve_context_.get());
  1339. helper0.RunUntilComplete();
  1340. }
  1341. TEST_F(DnsTransactionTest, HttpsGetFailure) {
  1342. ConfigureDohServers(false /* use_post */);
  1343. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  1344. SYNCHRONOUS, Transport::HTTPS,
  1345. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  1346. false /* enqueue_transaction_id */);
  1347. TransactionHelper helper0(ERR_DNS_SERVER_FAILED);
  1348. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1349. true /* secure */, resolve_context_.get());
  1350. helper0.RunUntilComplete();
  1351. ASSERT_NE(helper0.response(), nullptr);
  1352. EXPECT_EQ(helper0.response()->rcode(), dns_protocol::kRcodeSERVFAIL);
  1353. }
  1354. TEST_F(DnsTransactionTest, HttpsGetMalformed) {
  1355. ConfigureDohServers(false /* use_post */);
  1356. // Use T1 response, which is malformed for a T0 request.
  1357. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT1ResponseDatagram,
  1358. std::size(kT1ResponseDatagram), SYNCHRONOUS,
  1359. Transport::HTTPS, nullptr /* opt_rdata */,
  1360. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1361. false /* enqueue_transaction_id */);
  1362. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  1363. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1364. true /* secure */, resolve_context_.get());
  1365. helper0.RunUntilComplete();
  1366. }
  1367. TEST_F(DnsTransactionTest, HttpsPostLookup) {
  1368. ConfigureDohServers(true /* use_post */);
  1369. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1370. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1371. Transport::HTTPS, nullptr /* opt_rdata */,
  1372. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1373. false /* enqueue_transaction_id */);
  1374. TransactionHelper helper0(kT0RecordCount);
  1375. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1376. true /* secure */, resolve_context_.get());
  1377. helper0.RunUntilComplete();
  1378. }
  1379. TEST_F(DnsTransactionTest, HttpsPostFailure) {
  1380. ConfigureDohServers(true /* use_post */);
  1381. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  1382. SYNCHRONOUS, Transport::HTTPS,
  1383. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  1384. false /* enqueue_transaction_id */);
  1385. TransactionHelper helper0(ERR_DNS_SERVER_FAILED);
  1386. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1387. true /* secure */, resolve_context_.get());
  1388. helper0.RunUntilComplete();
  1389. ASSERT_NE(helper0.response(), nullptr);
  1390. EXPECT_EQ(helper0.response()->rcode(), dns_protocol::kRcodeSERVFAIL);
  1391. }
  1392. TEST_F(DnsTransactionTest, HttpsPostMalformed) {
  1393. ConfigureDohServers(true /* use_post */);
  1394. // Use T1 response, which is malformed for a T0 request.
  1395. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT1ResponseDatagram,
  1396. std::size(kT1ResponseDatagram), SYNCHRONOUS,
  1397. Transport::HTTPS, nullptr /* opt_rdata */,
  1398. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1399. false /* enqueue_transaction_id */);
  1400. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  1401. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1402. true /* secure */, resolve_context_.get());
  1403. helper0.RunUntilComplete();
  1404. }
  1405. TEST_F(DnsTransactionTest, HttpsPostLookupAsync) {
  1406. ConfigureDohServers(true /* use_post */);
  1407. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1408. std::size(kT0ResponseDatagram), ASYNC, Transport::HTTPS,
  1409. nullptr /* opt_rdata */,
  1410. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1411. false /* enqueue_transaction_id */);
  1412. TransactionHelper helper0(kT0RecordCount);
  1413. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1414. true /* secure */, resolve_context_.get());
  1415. helper0.RunUntilComplete();
  1416. }
  1417. std::unique_ptr<URLRequestJob> DohJobMakerCallbackFailLookup(
  1418. URLRequest* request,
  1419. SocketDataProvider* data) {
  1420. URLRequestMockDohJob::MatchQueryData(request, data);
  1421. return std::make_unique<URLRequestFailedJob>(
  1422. request, URLRequestFailedJob::START, ERR_NAME_NOT_RESOLVED);
  1423. }
  1424. TEST_F(DnsTransactionTest, HttpsPostLookupFailDohServerLookup) {
  1425. ConfigureDohServers(true /* use_post */);
  1426. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1427. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1428. Transport::HTTPS, nullptr /* opt_rdata */,
  1429. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1430. false /* enqueue_transaction_id */);
  1431. TransactionHelper helper0(ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED);
  1432. SetDohJobMakerCallback(base::BindRepeating(DohJobMakerCallbackFailLookup));
  1433. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1434. true /* secure */, resolve_context_.get());
  1435. helper0.RunUntilComplete();
  1436. }
  1437. std::unique_ptr<URLRequestJob> DohJobMakerCallbackFailStart(
  1438. URLRequest* request,
  1439. SocketDataProvider* data) {
  1440. URLRequestMockDohJob::MatchQueryData(request, data);
  1441. return std::make_unique<URLRequestFailedJob>(
  1442. request, URLRequestFailedJob::START, ERR_FAILED);
  1443. }
  1444. TEST_F(DnsTransactionTest, HttpsPostLookupFailStart) {
  1445. ConfigureDohServers(true /* use_post */);
  1446. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1447. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1448. Transport::HTTPS, nullptr /* opt_rdata */,
  1449. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1450. false /* enqueue_transaction_id */);
  1451. TransactionHelper helper0(ERR_FAILED);
  1452. SetDohJobMakerCallback(base::BindRepeating(DohJobMakerCallbackFailStart));
  1453. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1454. true /* secure */, resolve_context_.get());
  1455. helper0.RunUntilComplete();
  1456. }
  1457. std::unique_ptr<URLRequestJob> DohJobMakerCallbackFailSync(
  1458. URLRequest* request,
  1459. SocketDataProvider* data) {
  1460. URLRequestMockDohJob::MatchQueryData(request, data);
  1461. return std::make_unique<URLRequestFailedJob>(
  1462. request, URLRequestFailedJob::READ_SYNC, ERR_FAILED);
  1463. }
  1464. TEST_F(DnsTransactionTest, HttpsPostLookupFailSync) {
  1465. ConfigureDohServers(true /* use_post */);
  1466. auto data = std::make_unique<DnsSocketData>(
  1467. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1468. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1469. data->AddResponseWithLength(std::make_unique<DnsResponse>(), SYNCHRONOUS, 0);
  1470. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1471. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  1472. SetDohJobMakerCallback(base::BindRepeating(DohJobMakerCallbackFailSync));
  1473. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1474. true /* secure */, resolve_context_.get());
  1475. helper0.RunUntilComplete();
  1476. }
  1477. std::unique_ptr<URLRequestJob> DohJobMakerCallbackFailAsync(
  1478. URLRequest* request,
  1479. SocketDataProvider* data) {
  1480. URLRequestMockDohJob::MatchQueryData(request, data);
  1481. return std::make_unique<URLRequestFailedJob>(
  1482. request, URLRequestFailedJob::READ_ASYNC, ERR_FAILED);
  1483. }
  1484. TEST_F(DnsTransactionTest, HttpsPostLookupFailAsync) {
  1485. ConfigureDohServers(true /* use_post */);
  1486. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1487. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1488. Transport::HTTPS, nullptr /* opt_rdata */,
  1489. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1490. false /* enqueue_transaction_id */);
  1491. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  1492. SetDohJobMakerCallback(base::BindRepeating(DohJobMakerCallbackFailAsync));
  1493. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1494. true /* secure */, resolve_context_.get());
  1495. helper0.RunUntilComplete();
  1496. }
  1497. TEST_F(DnsTransactionTest, HttpsPostLookup2Sync) {
  1498. ConfigureDohServers(true /* use_post */);
  1499. auto data = std::make_unique<DnsSocketData>(
  1500. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1501. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1502. data->AddResponseData(kT0ResponseDatagram, 20, SYNCHRONOUS);
  1503. data->AddResponseData(kT0ResponseDatagram + 20,
  1504. std::size(kT0ResponseDatagram) - 20, SYNCHRONOUS);
  1505. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1506. TransactionHelper helper0(kT0RecordCount);
  1507. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1508. true /* secure */, resolve_context_.get());
  1509. helper0.RunUntilComplete();
  1510. }
  1511. TEST_F(DnsTransactionTest, HttpsPostLookup2Async) {
  1512. ConfigureDohServers(true /* use_post */);
  1513. auto data = std::make_unique<DnsSocketData>(
  1514. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1515. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1516. data->AddResponseData(kT0ResponseDatagram, 20, ASYNC);
  1517. data->AddResponseData(kT0ResponseDatagram + 20,
  1518. std::size(kT0ResponseDatagram) - 20, ASYNC);
  1519. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1520. TransactionHelper helper0(kT0RecordCount);
  1521. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1522. true /* secure */, resolve_context_.get());
  1523. helper0.RunUntilComplete();
  1524. }
  1525. TEST_F(DnsTransactionTest, HttpsPostLookupAsyncWithAsyncZeroRead) {
  1526. ConfigureDohServers(true /* use_post */);
  1527. auto data = std::make_unique<DnsSocketData>(
  1528. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1529. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1530. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  1531. ASYNC);
  1532. data->AddResponseData(kT0ResponseDatagram, 0, ASYNC);
  1533. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1534. TransactionHelper helper0(kT0RecordCount);
  1535. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1536. true /* secure */, resolve_context_.get());
  1537. helper0.RunUntilComplete();
  1538. }
  1539. TEST_F(DnsTransactionTest, HttpsPostLookupSyncWithAsyncZeroRead) {
  1540. ConfigureDohServers(true /* use_post */);
  1541. auto data = std::make_unique<DnsSocketData>(
  1542. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1543. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1544. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  1545. SYNCHRONOUS);
  1546. data->AddResponseData(kT0ResponseDatagram, 0, ASYNC);
  1547. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1548. TransactionHelper helper0(kT0RecordCount);
  1549. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1550. true /* secure */, resolve_context_.get());
  1551. helper0.RunUntilComplete();
  1552. }
  1553. TEST_F(DnsTransactionTest, HttpsPostLookupAsyncThenSync) {
  1554. ConfigureDohServers(true /* use_post */);
  1555. auto data = std::make_unique<DnsSocketData>(
  1556. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1557. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1558. data->AddResponseData(kT0ResponseDatagram, 20, ASYNC);
  1559. data->AddResponseData(kT0ResponseDatagram + 20,
  1560. std::size(kT0ResponseDatagram) - 20, SYNCHRONOUS);
  1561. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1562. TransactionHelper helper0(kT0RecordCount);
  1563. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1564. true /* secure */, resolve_context_.get());
  1565. helper0.RunUntilComplete();
  1566. }
  1567. TEST_F(DnsTransactionTest, HttpsPostLookupAsyncThenSyncError) {
  1568. ConfigureDohServers(true /* use_post */);
  1569. auto data = std::make_unique<DnsSocketData>(
  1570. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1571. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1572. data->AddResponseData(kT0ResponseDatagram, 20, ASYNC);
  1573. data->AddReadError(ERR_FAILED, SYNCHRONOUS);
  1574. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1575. TransactionHelper helper0(ERR_FAILED);
  1576. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1577. true /* secure */, resolve_context_.get());
  1578. helper0.RunUntilComplete();
  1579. }
  1580. TEST_F(DnsTransactionTest, HttpsPostLookupAsyncThenAsyncError) {
  1581. ConfigureDohServers(true /* use_post */);
  1582. auto data = std::make_unique<DnsSocketData>(
  1583. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1584. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1585. data->AddResponseData(kT0ResponseDatagram, 20, ASYNC);
  1586. data->AddReadError(ERR_FAILED, ASYNC);
  1587. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1588. TransactionHelper helper0(ERR_FAILED);
  1589. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1590. true /* secure */, resolve_context_.get());
  1591. helper0.RunUntilComplete();
  1592. }
  1593. TEST_F(DnsTransactionTest, HttpsPostLookupSyncThenAsyncError) {
  1594. ConfigureDohServers(true /* use_post */);
  1595. auto data = std::make_unique<DnsSocketData>(
  1596. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1597. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1598. data->AddResponseData(kT0ResponseDatagram, 20, SYNCHRONOUS);
  1599. data->AddReadError(ERR_FAILED, ASYNC);
  1600. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1601. TransactionHelper helper0(ERR_FAILED);
  1602. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1603. true /* secure */, resolve_context_.get());
  1604. helper0.RunUntilComplete();
  1605. }
  1606. TEST_F(DnsTransactionTest, HttpsPostLookupSyncThenSyncError) {
  1607. ConfigureDohServers(true /* use_post */);
  1608. auto data = std::make_unique<DnsSocketData>(
  1609. 0, kT0HostName, kT0Qtype, SYNCHRONOUS, Transport::HTTPS,
  1610. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  1611. data->AddResponseData(kT0ResponseDatagram, 20, SYNCHRONOUS);
  1612. data->AddReadError(ERR_FAILED, SYNCHRONOUS);
  1613. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  1614. TransactionHelper helper0(ERR_FAILED);
  1615. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1616. true /* secure */, resolve_context_.get());
  1617. helper0.RunUntilComplete();
  1618. }
  1619. TEST_F(DnsTransactionTest, HttpsNotAvailable) {
  1620. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  1621. false /* make_available */);
  1622. ASSERT_FALSE(resolve_context_->GetDohServerAvailability(
  1623. 0u /* doh_server_index */, session_.get()));
  1624. TransactionHelper helper0(ERR_BLOCKED_BY_CLIENT);
  1625. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1626. true /* secure */, resolve_context_.get());
  1627. helper0.RunUntilComplete();
  1628. }
  1629. TEST_F(DnsTransactionTest, HttpsMarkHttpsBad) {
  1630. config_.attempts = 1;
  1631. ConfigureDohServers(true /* use_post */, 3);
  1632. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1633. SYNCHRONOUS, Transport::HTTPS,
  1634. nullptr /* opt_rdata */,
  1635. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1636. false /* enqueue_transaction_id */);
  1637. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1638. SYNCHRONOUS, Transport::HTTPS,
  1639. nullptr /* opt_rdata */,
  1640. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1641. false /* enqueue_transaction_id */);
  1642. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1643. std::size(kT0ResponseDatagram), ASYNC, Transport::HTTPS,
  1644. nullptr /* opt_rdata */,
  1645. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1646. false /* enqueue_transaction_id */);
  1647. AddQueryAndErrorResponse(0 /* id */, kT0HostName, kT0Qtype,
  1648. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  1649. Transport::HTTPS, nullptr /* opt_rdata */,
  1650. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1651. false /* enqueue_transaction_id */);
  1652. AddQueryAndErrorResponse(0 /* id */, kT0HostName, kT0Qtype,
  1653. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  1654. Transport::HTTPS, nullptr /* opt_rdata */,
  1655. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1656. false /* enqueue_transaction_id */);
  1657. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1658. std::size(kT0ResponseDatagram), ASYNC, Transport::HTTPS,
  1659. nullptr /* opt_rdata */,
  1660. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1661. false /* enqueue_transaction_id */);
  1662. TransactionHelper helper0(kT0RecordCount);
  1663. TransactionHelper helper1(kT0RecordCount);
  1664. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1665. true /* secure */, resolve_context_.get());
  1666. helper0.RunUntilComplete();
  1667. // UDP server 0 is our only UDP server, so it will be good. HTTPS
  1668. // servers 0 and 1 failed and will be marked bad. HTTPS server 2 succeeded
  1669. // so it will be good.
  1670. // The expected order of the HTTPS servers is therefore 2, 0, then 1.
  1671. {
  1672. std::unique_ptr<DnsServerIterator> classic_itr =
  1673. resolve_context_->GetClassicDnsIterator(session_->config(),
  1674. session_.get());
  1675. std::unique_ptr<DnsServerIterator> doh_itr =
  1676. resolve_context_->GetDohIterator(
  1677. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1678. EXPECT_TRUE(classic_itr->AttemptAvailable());
  1679. EXPECT_EQ(classic_itr->GetNextAttemptIndex(), 0u);
  1680. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1681. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 2u);
  1682. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1683. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1684. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1685. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 1u);
  1686. }
  1687. size_t kOrder0[] = {1, 2, 3};
  1688. CheckServerOrder(kOrder0, std::size(kOrder0));
  1689. helper1.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1690. true /* secure */, resolve_context_.get());
  1691. helper1.RunUntilComplete();
  1692. // UDP server 0 is still our only UDP server, so it will be good by
  1693. // definition. HTTPS server 2 started out as good, so it was tried first and
  1694. // failed. HTTPS server 0 then had the oldest failure so it would be the next
  1695. // good server and then it failed so it's marked bad. Next attempt was HTTPS
  1696. // server 1, which succeeded so it's good. The expected order of the HTTPS
  1697. // servers is therefore 1, 2, then 0.
  1698. {
  1699. std::unique_ptr<DnsServerIterator> classic_itr =
  1700. resolve_context_->GetClassicDnsIterator(session_->config(),
  1701. session_.get());
  1702. std::unique_ptr<DnsServerIterator> doh_itr =
  1703. resolve_context_->GetDohIterator(
  1704. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1705. EXPECT_EQ(classic_itr->GetNextAttemptIndex(), 0u);
  1706. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1707. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 1u);
  1708. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 2u);
  1709. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1710. }
  1711. size_t kOrder1[] = {
  1712. 1, 2, 3, /* transaction0 */
  1713. 3, 1, 2 /* transaction1 */
  1714. };
  1715. CheckServerOrder(kOrder1, std::size(kOrder1));
  1716. }
  1717. TEST_F(DnsTransactionTest, HttpsPostFailThenHTTPFallback) {
  1718. ConfigureDohServers(true /* use_post */, 2);
  1719. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL, ASYNC,
  1720. Transport::HTTPS,
  1721. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  1722. false /* enqueue_transaction_id */);
  1723. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1724. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1725. Transport::HTTPS, nullptr /* opt_rdata */,
  1726. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1727. false /* enqueue_transaction_id */);
  1728. TransactionHelper helper0(kT0RecordCount);
  1729. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1730. true /* secure */, resolve_context_.get());
  1731. helper0.RunUntilComplete();
  1732. size_t kOrder0[] = {1, 2};
  1733. CheckServerOrder(kOrder0, std::size(kOrder0));
  1734. }
  1735. TEST_F(DnsTransactionTest, HttpsPostFailTwice) {
  1736. config_.attempts = 3;
  1737. ConfigureDohServers(true /* use_post */, 2);
  1738. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1739. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1740. Transport::HTTPS, nullptr /* opt_rdata */,
  1741. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1742. false /* enqueue_transaction_id */);
  1743. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1744. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1745. Transport::HTTPS, nullptr /* opt_rdata */,
  1746. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1747. false /* enqueue_transaction_id */);
  1748. TransactionHelper helper0(ERR_FAILED);
  1749. SetDohJobMakerCallback(base::BindRepeating(DohJobMakerCallbackFailStart));
  1750. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1751. true /* secure */, resolve_context_.get());
  1752. helper0.RunUntilComplete();
  1753. size_t kOrder0[] = {1, 2};
  1754. CheckServerOrder(kOrder0, std::size(kOrder0));
  1755. }
  1756. TEST_F(DnsTransactionTest, HttpsNotAvailableThenHttpFallback) {
  1757. ConfigureDohServers(true /* use_post */, 2 /* num_doh_servers */,
  1758. false /* make_available */);
  1759. // Make just server 1 available.
  1760. resolve_context_->RecordServerSuccess(
  1761. 1u /* server_index */, true /* is_doh_server*/, session_.get());
  1762. {
  1763. std::unique_ptr<DnsServerIterator> doh_itr =
  1764. resolve_context_->GetDohIterator(
  1765. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1766. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1767. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 1u);
  1768. EXPECT_FALSE(doh_itr->AttemptAvailable());
  1769. }
  1770. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1771. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1772. Transport::HTTPS, nullptr /* opt_rdata */,
  1773. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1774. false /* enqueue_transaction_id */);
  1775. TransactionHelper helper0(kT0RecordCount);
  1776. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1777. true /* secure */, resolve_context_.get());
  1778. helper0.RunUntilComplete();
  1779. size_t kOrder0[] = {2};
  1780. CheckServerOrder(kOrder0, std::size(kOrder0));
  1781. {
  1782. std::unique_ptr<DnsServerIterator> doh_itr =
  1783. resolve_context_->GetDohIterator(
  1784. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1785. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1786. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 1u);
  1787. EXPECT_FALSE(doh_itr->AttemptAvailable());
  1788. }
  1789. }
  1790. // Fail first DoH server, then no fallbacks marked available in AUTOMATIC mode.
  1791. TEST_F(DnsTransactionTest, HttpsFailureThenNotAvailable_Automatic) {
  1792. config_.secure_dns_mode = SecureDnsMode::kAutomatic;
  1793. ConfigureDohServers(true /* use_post */, 3 /* num_doh_servers */,
  1794. false /* make_available */);
  1795. // Make just server 0 available.
  1796. resolve_context_->RecordServerSuccess(
  1797. 0u /* server_index */, true /* is_doh_server*/, session_.get());
  1798. {
  1799. std::unique_ptr<DnsServerIterator> doh_itr =
  1800. resolve_context_->GetDohIterator(
  1801. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1802. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1803. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1804. EXPECT_FALSE(doh_itr->AttemptAvailable());
  1805. }
  1806. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1807. SYNCHRONOUS, Transport::HTTPS,
  1808. nullptr /* opt_rdata */,
  1809. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1810. false /* enqueue_transaction_id */);
  1811. TransactionHelper helper0(ERR_CONNECTION_REFUSED);
  1812. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1813. true /* secure */, resolve_context_.get());
  1814. helper0.RunUntilComplete();
  1815. // Expect fallback not attempted because other servers not available in
  1816. // AUTOMATIC mode until they have recorded a success.
  1817. size_t kOrder0[] = {1};
  1818. CheckServerOrder(kOrder0, std::size(kOrder0));
  1819. {
  1820. std::unique_ptr<DnsServerIterator> doh_itr =
  1821. resolve_context_->GetDohIterator(
  1822. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1823. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1824. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1825. EXPECT_FALSE(doh_itr->AttemptAvailable());
  1826. }
  1827. }
  1828. // Test a secure transaction failure in SECURE mode when other DoH servers are
  1829. // only available for fallback because of
  1830. TEST_F(DnsTransactionTest, HttpsFailureThenNotAvailable_Secure) {
  1831. config_.secure_dns_mode = SecureDnsMode::kSecure;
  1832. ConfigureDohServers(true /* use_post */, 3 /* num_doh_servers */,
  1833. false /* make_available */);
  1834. // Make just server 0 available.
  1835. resolve_context_->RecordServerSuccess(
  1836. 0u /* server_index */, true /* is_doh_server*/, session_.get());
  1837. {
  1838. std::unique_ptr<DnsServerIterator> doh_itr =
  1839. resolve_context_->GetDohIterator(
  1840. session_->config(), SecureDnsMode::kSecure, session_.get());
  1841. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1842. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1843. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1844. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 1u);
  1845. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1846. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 2u);
  1847. }
  1848. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1849. SYNCHRONOUS, Transport::HTTPS,
  1850. nullptr /* opt_rdata */,
  1851. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1852. false /* enqueue_transaction_id */);
  1853. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1854. SYNCHRONOUS, Transport::HTTPS,
  1855. nullptr /* opt_rdata */,
  1856. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1857. false /* enqueue_transaction_id */);
  1858. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1859. SYNCHRONOUS, Transport::HTTPS,
  1860. nullptr /* opt_rdata */,
  1861. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1862. false /* enqueue_transaction_id */);
  1863. TransactionHelper helper0(ERR_CONNECTION_REFUSED);
  1864. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1865. true /* secure */, resolve_context_.get());
  1866. helper0.RunUntilComplete();
  1867. // Expect fallback to attempt all servers because SECURE mode does not require
  1868. // server availability.
  1869. size_t kOrder0[] = {1, 2, 3};
  1870. CheckServerOrder(kOrder0, std::size(kOrder0));
  1871. // Expect server 0 to be preferred due to least recent failure.
  1872. {
  1873. std::unique_ptr<DnsServerIterator> doh_itr =
  1874. resolve_context_->GetDohIterator(
  1875. session_->config(), SecureDnsMode::kSecure, session_.get());
  1876. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1877. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1878. }
  1879. }
  1880. TEST_F(DnsTransactionTest, MaxHttpsFailures_NonConsecutive) {
  1881. config_.attempts = 1;
  1882. ConfigureDohServers(false /* use_post */);
  1883. {
  1884. std::unique_ptr<DnsServerIterator> doh_itr =
  1885. resolve_context_->GetDohIterator(
  1886. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1887. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1888. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1889. }
  1890. for (size_t i = 0; i < ResolveContext::kAutomaticModeFailureLimit - 1; i++) {
  1891. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1892. SYNCHRONOUS, Transport::HTTPS,
  1893. nullptr /* opt_rdata */,
  1894. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1895. false /* enqueue_transaction_id */);
  1896. TransactionHelper failure(ERR_CONNECTION_REFUSED);
  1897. failure.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1898. true /* secure */, resolve_context_.get());
  1899. failure.RunUntilComplete();
  1900. std::unique_ptr<DnsServerIterator> doh_itr =
  1901. resolve_context_->GetDohIterator(
  1902. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1903. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1904. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1905. }
  1906. // A success should reset the failure counter for DoH.
  1907. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  1908. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  1909. Transport::HTTPS, nullptr /* opt_rdata */,
  1910. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1911. false /* enqueue_transaction_id */);
  1912. TransactionHelper success(kT0RecordCount);
  1913. success.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1914. true /* secure */, resolve_context_.get());
  1915. success.RunUntilComplete();
  1916. {
  1917. std::unique_ptr<DnsServerIterator> doh_itr =
  1918. resolve_context_->GetDohIterator(
  1919. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1920. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1921. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1922. }
  1923. // One more failure should not pass the threshold because failures were reset.
  1924. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1925. SYNCHRONOUS, Transport::HTTPS,
  1926. nullptr /* opt_rdata */,
  1927. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1928. false /* enqueue_transaction_id */);
  1929. TransactionHelper last_failure(ERR_CONNECTION_REFUSED);
  1930. last_failure.StartTransaction(transaction_factory_.get(), kT0HostName,
  1931. kT0Qtype, true /* secure */,
  1932. resolve_context_.get());
  1933. last_failure.RunUntilComplete();
  1934. {
  1935. std::unique_ptr<DnsServerIterator> doh_itr =
  1936. resolve_context_->GetDohIterator(
  1937. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1938. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1939. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1940. }
  1941. }
  1942. TEST_F(DnsTransactionTest, MaxHttpsFailures_Consecutive) {
  1943. config_.attempts = 1;
  1944. ConfigureDohServers(false /* use_post */);
  1945. {
  1946. std::unique_ptr<DnsServerIterator> doh_itr =
  1947. resolve_context_->GetDohIterator(
  1948. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1949. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1950. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1951. }
  1952. for (size_t i = 0; i < ResolveContext::kAutomaticModeFailureLimit - 1; i++) {
  1953. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1954. SYNCHRONOUS, Transport::HTTPS,
  1955. nullptr /* opt_rdata */,
  1956. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1957. false /* enqueue_transaction_id */);
  1958. TransactionHelper failure(ERR_CONNECTION_REFUSED);
  1959. failure.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  1960. true /* secure */, resolve_context_.get());
  1961. failure.RunUntilComplete();
  1962. std::unique_ptr<DnsServerIterator> doh_itr =
  1963. resolve_context_->GetDohIterator(
  1964. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1965. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1966. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1967. }
  1968. // One more failure should pass the threshold.
  1969. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  1970. SYNCHRONOUS, Transport::HTTPS,
  1971. nullptr /* opt_rdata */,
  1972. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  1973. false /* enqueue_transaction_id */);
  1974. TransactionHelper last_failure(ERR_CONNECTION_REFUSED);
  1975. last_failure.StartTransaction(transaction_factory_.get(), kT0HostName,
  1976. kT0Qtype, true /* secure */,
  1977. resolve_context_.get());
  1978. last_failure.RunUntilComplete();
  1979. {
  1980. std::unique_ptr<DnsServerIterator> doh_itr =
  1981. resolve_context_->GetDohIterator(
  1982. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1983. EXPECT_FALSE(doh_itr->AttemptAvailable());
  1984. }
  1985. }
  1986. // Test that a secure transaction started before a DoH server becomes
  1987. // unavailable can complete and make the server available again.
  1988. TEST_F(DnsTransactionTest, SuccessfulTransactionStartedBeforeUnavailable) {
  1989. ConfigureDohServers(false /* use_post */);
  1990. {
  1991. std::unique_ptr<DnsServerIterator> doh_itr =
  1992. resolve_context_->GetDohIterator(
  1993. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  1994. ASSERT_TRUE(doh_itr->AttemptAvailable());
  1995. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  1996. }
  1997. // Create a socket data to first return ERR_IO_PENDING. This will pause the
  1998. // response and not return the second response until
  1999. // SequencedSocketData::Resume() is called.
  2000. auto data = std::make_unique<DnsSocketData>(
  2001. 0, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  2002. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2003. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2004. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  2005. ASYNC);
  2006. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2007. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2008. TransactionHelper delayed_success(kT0RecordCount);
  2009. delayed_success.StartTransaction(transaction_factory_.get(), kT0HostName,
  2010. kT0Qtype, true /* secure */,
  2011. resolve_context_.get());
  2012. base::RunLoop().RunUntilIdle();
  2013. EXPECT_FALSE(delayed_success.has_completed());
  2014. // Trigger DoH server unavailability with a bunch of failures.
  2015. for (size_t i = 0; i < ResolveContext::kAutomaticModeFailureLimit; i++) {
  2016. AddQueryAndErrorResponse(0, kT0HostName, kT0Qtype, ERR_CONNECTION_REFUSED,
  2017. SYNCHRONOUS, Transport::HTTPS,
  2018. nullptr /* opt_rdata */,
  2019. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2020. false /* enqueue_transaction_id */);
  2021. TransactionHelper failure(ERR_CONNECTION_REFUSED);
  2022. failure.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2023. true /* secure */, resolve_context_.get());
  2024. failure.RunUntilComplete();
  2025. }
  2026. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  2027. 0u /* doh_server_index */, session_.get()));
  2028. // Resume first query.
  2029. ASSERT_FALSE(delayed_success.has_completed());
  2030. sequenced_socket_data->Resume();
  2031. delayed_success.RunUntilComplete();
  2032. // Expect DoH server is available again.
  2033. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  2034. 0u /* doh_server_index */, session_.get()));
  2035. }
  2036. void MakeResponseWithCookie(URLRequest* request, HttpResponseInfo* info) {
  2037. info->headers->AddHeader("Set-Cookie", "test-cookie=you-fail");
  2038. }
  2039. class CookieCallback {
  2040. public:
  2041. CookieCallback() : loop_to_quit_(std::make_unique<base::RunLoop>()) {}
  2042. void SetCookieCallback(CookieAccessResult result) {
  2043. result_ = result.status.IsInclude();
  2044. loop_to_quit_->Quit();
  2045. }
  2046. CookieCallback(const CookieCallback&) = delete;
  2047. CookieCallback& operator=(const CookieCallback&) = delete;
  2048. void GetCookieListCallback(
  2049. const net::CookieAccessResultList& list,
  2050. const net::CookieAccessResultList& excluded_cookies) {
  2051. list_ = cookie_util::StripAccessResults(list);
  2052. loop_to_quit_->Quit();
  2053. }
  2054. void Reset() { loop_to_quit_ = std::make_unique<base::RunLoop>(); }
  2055. void WaitUntilDone() { loop_to_quit_->Run(); }
  2056. size_t cookie_list_size() { return list_.size(); }
  2057. private:
  2058. net::CookieList list_;
  2059. bool result_ = false;
  2060. std::unique_ptr<base::RunLoop> loop_to_quit_;
  2061. };
  2062. TEST_F(DnsTransactionTest, HttpsPostTestNoCookies) {
  2063. ConfigureDohServers(true /* use_post */);
  2064. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2065. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2066. Transport::HTTPS, nullptr /* opt_rdata */,
  2067. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2068. false /* enqueue_transaction_id */);
  2069. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2070. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2071. Transport::HTTPS, nullptr /* opt_rdata */,
  2072. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2073. false /* enqueue_transaction_id */);
  2074. TransactionHelper helper0(kT0RecordCount);
  2075. TransactionHelper helper1(kT0RecordCount);
  2076. SetResponseModifierCallback(base::BindRepeating(MakeResponseWithCookie));
  2077. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2078. true /* secure */, resolve_context_.get());
  2079. helper0.RunUntilComplete();
  2080. CookieCallback callback;
  2081. request_context_->cookie_store()->GetCookieListWithOptionsAsync(
  2082. GURL(GetURLFromTemplateWithoutParameters(
  2083. config_.doh_config.servers()[0].server_template())),
  2084. CookieOptions::MakeAllInclusive(), CookiePartitionKeyCollection(),
  2085. base::BindOnce(&CookieCallback::GetCookieListCallback,
  2086. base::Unretained(&callback)));
  2087. callback.WaitUntilDone();
  2088. EXPECT_EQ(0u, callback.cookie_list_size());
  2089. callback.Reset();
  2090. GURL cookie_url(GetURLFromTemplateWithoutParameters(
  2091. config_.doh_config.servers()[0].server_template()));
  2092. auto cookie = CanonicalCookie::Create(
  2093. cookie_url, "test-cookie=you-still-fail", base::Time::Now(),
  2094. absl::nullopt /* server_time */,
  2095. absl::nullopt /* cookie_partition_key */);
  2096. request_context_->cookie_store()->SetCanonicalCookieAsync(
  2097. std::move(cookie), cookie_url, CookieOptions(),
  2098. base::BindOnce(&CookieCallback::SetCookieCallback,
  2099. base::Unretained(&callback)));
  2100. helper1.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2101. true /* secure */, resolve_context_.get());
  2102. helper1.RunUntilComplete();
  2103. }
  2104. void MakeResponseWithoutLength(URLRequest* request, HttpResponseInfo* info) {
  2105. info->headers->RemoveHeader("Content-Length");
  2106. }
  2107. TEST_F(DnsTransactionTest, HttpsPostNoContentLength) {
  2108. ConfigureDohServers(true /* use_post */);
  2109. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2110. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2111. Transport::HTTPS, nullptr /* opt_rdata */,
  2112. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2113. false /* enqueue_transaction_id */);
  2114. TransactionHelper helper0(kT0RecordCount);
  2115. SetResponseModifierCallback(base::BindRepeating(MakeResponseWithoutLength));
  2116. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2117. true /* secure */, resolve_context_.get());
  2118. helper0.RunUntilComplete();
  2119. }
  2120. void MakeResponseWithBadRequestResponse(URLRequest* request,
  2121. HttpResponseInfo* info) {
  2122. info->headers->ReplaceStatusLine("HTTP/1.1 400 Bad Request");
  2123. }
  2124. TEST_F(DnsTransactionTest, HttpsPostWithBadRequestResponse) {
  2125. ConfigureDohServers(true /* use_post */);
  2126. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2127. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2128. Transport::HTTPS, nullptr /* opt_rdata */,
  2129. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2130. false /* enqueue_transaction_id */);
  2131. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  2132. SetResponseModifierCallback(
  2133. base::BindRepeating(MakeResponseWithBadRequestResponse));
  2134. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2135. true /* secure */, resolve_context_.get());
  2136. helper0.RunUntilComplete();
  2137. }
  2138. void MakeResponseWrongType(URLRequest* request, HttpResponseInfo* info) {
  2139. info->headers->RemoveHeader("Content-Type");
  2140. info->headers->AddHeader("Content-Type", "text/html");
  2141. }
  2142. TEST_F(DnsTransactionTest, HttpsPostWithWrongType) {
  2143. ConfigureDohServers(true /* use_post */);
  2144. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2145. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2146. Transport::HTTPS, nullptr /* opt_rdata */,
  2147. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2148. false /* enqueue_transaction_id */);
  2149. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  2150. SetResponseModifierCallback(base::BindRepeating(MakeResponseWrongType));
  2151. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2152. true /* secure */, resolve_context_.get());
  2153. helper0.RunUntilComplete();
  2154. }
  2155. void MakeResponseRedirect(URLRequest* request, HttpResponseInfo* info) {
  2156. if (request->url_chain().size() < 2) {
  2157. info->headers->ReplaceStatusLine("HTTP/1.1 302 Found");
  2158. info->headers->AddHeader("Location",
  2159. "/redirect-destination?" + request->url().query());
  2160. }
  2161. }
  2162. TEST_F(DnsTransactionTest, HttpsGetRedirect) {
  2163. ConfigureDohServers(false /* use_post */);
  2164. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2165. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2166. Transport::HTTPS, nullptr /* opt_rdata */,
  2167. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2168. false /* enqueue_transaction_id */);
  2169. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2170. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2171. Transport::HTTPS, nullptr /* opt_rdata */,
  2172. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2173. false /* enqueue_transaction_id */);
  2174. TransactionHelper helper0(kT0RecordCount);
  2175. SetResponseModifierCallback(base::BindRepeating(MakeResponseRedirect));
  2176. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2177. true /* secure */, resolve_context_.get());
  2178. helper0.RunUntilComplete();
  2179. }
  2180. void MakeResponseNoType(URLRequest* request, HttpResponseInfo* info) {
  2181. info->headers->RemoveHeader("Content-Type");
  2182. }
  2183. TEST_F(DnsTransactionTest, HttpsPostWithNoType) {
  2184. ConfigureDohServers(true /* use_post */);
  2185. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2186. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2187. Transport::HTTPS, nullptr /* opt_rdata */,
  2188. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2189. false /* enqueue_transaction_id */);
  2190. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  2191. SetResponseModifierCallback(base::BindRepeating(MakeResponseNoType));
  2192. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2193. true /* secure */, resolve_context_.get());
  2194. helper0.RunUntilComplete();
  2195. }
  2196. TEST_F(DnsTransactionTest, CanLookupDohServerName) {
  2197. config_.search.push_back("http");
  2198. ConfigureDohServers(true /* use_post */);
  2199. AddQueryAndErrorResponse(0, kMockHostname, dns_protocol::kTypeA,
  2200. ERR_NAME_NOT_RESOLVED, SYNCHRONOUS, Transport::HTTPS,
  2201. nullptr /* opt_rdata */,
  2202. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2203. false /* enqueue_transaction_id */);
  2204. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  2205. helper0.StartTransaction(transaction_factory_.get(), "mock",
  2206. dns_protocol::kTypeA, true /* secure */,
  2207. resolve_context_.get());
  2208. helper0.RunUntilComplete();
  2209. }
  2210. class CountingObserver : public net::NetLog::ThreadSafeObserver {
  2211. public:
  2212. CountingObserver() = default;
  2213. ~CountingObserver() override {
  2214. if (net_log())
  2215. net_log()->RemoveObserver(this);
  2216. }
  2217. void OnAddEntry(const NetLogEntry& entry) override {
  2218. ++count_;
  2219. if (!entry.params.is_none() && entry.params.is_dict())
  2220. dict_count_++;
  2221. }
  2222. int count() const { return count_; }
  2223. int dict_count() const { return dict_count_; }
  2224. private:
  2225. int count_ = 0;
  2226. int dict_count_ = 0;
  2227. };
  2228. // Flaky on MSAN. https://crbug.com/1245953
  2229. #if defined(MEMORY_SANITIZER)
  2230. #define MAYBE_HttpsPostLookupWithLog \
  2231. DISABLED_HttpsPostLookupWithLog
  2232. #else
  2233. #define MAYBE_HttpsPostLookupWithLog \
  2234. HttpsPostLookupWithLog
  2235. #endif
  2236. TEST_F(DnsTransactionTest, MAYBE_HttpsPostLookupWithLog) {
  2237. ConfigureDohServers(true /* use_post */);
  2238. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2239. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2240. Transport::HTTPS, nullptr /* opt_rdata */,
  2241. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2242. false /* enqueue_transaction_id */);
  2243. TransactionHelper helper0(kT0RecordCount);
  2244. CountingObserver observer;
  2245. NetLog::Get()->AddObserver(&observer, NetLogCaptureMode::kEverything);
  2246. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2247. true /* secure */, resolve_context_.get());
  2248. helper0.RunUntilComplete();
  2249. base::RunLoop().RunUntilIdle();
  2250. EXPECT_EQ(observer.count(), 14);
  2251. EXPECT_EQ(observer.dict_count(), 6);
  2252. }
  2253. // Test for when a slow DoH response is delayed until after the initial fallback
  2254. // period (but succeeds before the full timeout period).
  2255. TEST_F(DnsTransactionTestWithMockTime, SlowHttpsResponse_SingleAttempt) {
  2256. config_.doh_attempts = 1;
  2257. ConfigureDohServers(false /* use_post */);
  2258. // Assume fallback period is less than timeout.
  2259. ASSERT_LT(resolve_context_->NextDohFallbackPeriod(0 /* doh_server_index */,
  2260. session_.get()),
  2261. resolve_context_->SecureTransactionTimeout(SecureDnsMode::kSecure,
  2262. session_.get()));
  2263. // Simulate a slow response by using an ERR_IO_PENDING read error to delay
  2264. // until SequencedSocketData::Resume() is called.
  2265. auto data = std::make_unique<DnsSocketData>(
  2266. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  2267. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2268. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2269. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  2270. ASYNC);
  2271. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2272. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2273. TransactionHelper helper(kT0RecordCount);
  2274. std::unique_ptr<DnsTransaction> transaction =
  2275. transaction_factory_->CreateTransaction(
  2276. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2277. SecureDnsMode::kSecure, resolve_context_.get(),
  2278. false /* fast_timeout */);
  2279. helper.StartTransaction(std::move(transaction));
  2280. base::RunLoop().RunUntilIdle();
  2281. ASSERT_FALSE(helper.has_completed());
  2282. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2283. 0 /* doh_server_index */, session_.get()));
  2284. EXPECT_FALSE(helper.has_completed());
  2285. sequenced_socket_data->Resume();
  2286. helper.RunUntilComplete();
  2287. }
  2288. // Test for when a slow DoH response is delayed until after the initial fallback
  2289. // period but fast timeout is enabled, resulting in timeout failure.
  2290. TEST_F(DnsTransactionTestWithMockTime,
  2291. SlowHttpsResponse_SingleAttempt_FastTimeout) {
  2292. config_.doh_attempts = 1;
  2293. ConfigureDohServers(false /* use_post */);
  2294. AddHangingQuery(kT0HostName, kT0Qtype,
  2295. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2296. false /* enqueue_transaction_id */);
  2297. TransactionHelper helper(ERR_DNS_TIMED_OUT);
  2298. std::unique_ptr<DnsTransaction> transaction =
  2299. transaction_factory_->CreateTransaction(
  2300. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2301. SecureDnsMode::kSecure, resolve_context_.get(),
  2302. true /* fast_timeout */);
  2303. helper.StartTransaction(std::move(transaction));
  2304. base::RunLoop().RunUntilIdle();
  2305. ASSERT_FALSE(helper.has_completed());
  2306. // Only one attempt configured and fast timeout enabled, so expect immediate
  2307. // failure after fallback period.
  2308. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2309. 0 /* doh_server_index */, session_.get()));
  2310. EXPECT_TRUE(helper.has_completed());
  2311. }
  2312. // Test for when a slow DoH response is delayed until after the initial fallback
  2313. // period but a retry is configured.
  2314. TEST_F(DnsTransactionTestWithMockTime, SlowHttpsResponse_TwoAttempts) {
  2315. config_.doh_attempts = 2;
  2316. ConfigureDohServers(false /* use_post */);
  2317. // Simulate a slow response by using an ERR_IO_PENDING read error to delay
  2318. // until SequencedSocketData::Resume() is called.
  2319. auto data = std::make_unique<DnsSocketData>(
  2320. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  2321. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2322. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2323. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  2324. ASYNC);
  2325. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2326. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2327. TransactionHelper helper(kT0RecordCount);
  2328. std::unique_ptr<DnsTransaction> transaction =
  2329. transaction_factory_->CreateTransaction(
  2330. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2331. SecureDnsMode::kSecure, resolve_context_.get(),
  2332. false /* fast_timeout */);
  2333. helper.StartTransaction(std::move(transaction));
  2334. base::RunLoop().RunUntilIdle();
  2335. ASSERT_FALSE(helper.has_completed());
  2336. ASSERT_TRUE(sequenced_socket_data->IsPaused());
  2337. // Another attempt configured, so transaction should not fail after initial
  2338. // fallback period. Setup the second attempt to never receive a response.
  2339. AddHangingQuery(kT0HostName, kT0Qtype,
  2340. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2341. false /* enqueue_transaction_id */);
  2342. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2343. 0 /* doh_server_index */, session_.get()));
  2344. EXPECT_FALSE(helper.has_completed());
  2345. // Expect first attempt to continue in parallel with retry, so expect the
  2346. // transaction to complete when the first query is allowed to resume.
  2347. sequenced_socket_data->Resume();
  2348. helper.RunUntilComplete();
  2349. }
  2350. // Test for when a slow DoH response is delayed until after the full timeout
  2351. // period.
  2352. TEST_F(DnsTransactionTestWithMockTime, HttpsTimeout) {
  2353. config_.doh_attempts = 1;
  2354. ConfigureDohServers(false /* use_post */);
  2355. // Assume fallback period is less than timeout.
  2356. ASSERT_LT(resolve_context_->NextDohFallbackPeriod(0 /* doh_server_index */,
  2357. session_.get()),
  2358. resolve_context_->SecureTransactionTimeout(SecureDnsMode::kSecure,
  2359. session_.get()));
  2360. AddHangingQuery(kT0HostName, kT0Qtype,
  2361. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2362. false /* enqueue_transaction_id */);
  2363. TransactionHelper helper(ERR_DNS_TIMED_OUT);
  2364. std::unique_ptr<DnsTransaction> transaction =
  2365. transaction_factory_->CreateTransaction(
  2366. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2367. SecureDnsMode::kSecure, resolve_context_.get(),
  2368. false /* fast_timeout */);
  2369. helper.StartTransaction(std::move(transaction));
  2370. base::RunLoop().RunUntilIdle();
  2371. ASSERT_FALSE(helper.has_completed());
  2372. // Stop a tiny bit short to ensure transaction doesn't finish early.
  2373. const base::TimeDelta kTimeHoldback = base::Milliseconds(5);
  2374. base::TimeDelta timeout = resolve_context_->SecureTransactionTimeout(
  2375. SecureDnsMode::kSecure, session_.get());
  2376. ASSERT_LT(kTimeHoldback, timeout);
  2377. FastForwardBy(timeout - kTimeHoldback);
  2378. EXPECT_FALSE(helper.has_completed());
  2379. FastForwardBy(kTimeHoldback);
  2380. EXPECT_TRUE(helper.has_completed());
  2381. }
  2382. // Test for when two slow DoH responses are delayed until after the full timeout
  2383. // period.
  2384. TEST_F(DnsTransactionTestWithMockTime, HttpsTimeout2) {
  2385. config_.doh_attempts = 2;
  2386. ConfigureDohServers(false /* use_post */);
  2387. // Assume fallback period is less than timeout.
  2388. ASSERT_LT(resolve_context_->NextDohFallbackPeriod(0 /* doh_server_index */,
  2389. session_.get()),
  2390. resolve_context_->SecureTransactionTimeout(SecureDnsMode::kSecure,
  2391. session_.get()));
  2392. AddHangingQuery(kT0HostName, kT0Qtype,
  2393. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2394. false /* enqueue_transaction_id */);
  2395. AddHangingQuery(kT0HostName, kT0Qtype,
  2396. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2397. false /* enqueue_transaction_id */);
  2398. TransactionHelper helper(ERR_DNS_TIMED_OUT);
  2399. std::unique_ptr<DnsTransaction> transaction =
  2400. transaction_factory_->CreateTransaction(
  2401. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2402. SecureDnsMode::kSecure, resolve_context_.get(),
  2403. false /* fast_timeout */);
  2404. helper.StartTransaction(std::move(transaction));
  2405. base::RunLoop().RunUntilIdle();
  2406. ASSERT_FALSE(helper.has_completed());
  2407. base::TimeDelta fallback_period = resolve_context_->NextDohFallbackPeriod(
  2408. 0 /* doh_server_index */, session_.get());
  2409. FastForwardBy(fallback_period);
  2410. EXPECT_FALSE(helper.has_completed());
  2411. // Timeout is from start of transaction, so need to keep track of the
  2412. // remainder after other fast forwards.
  2413. base::TimeDelta timeout = resolve_context_->SecureTransactionTimeout(
  2414. SecureDnsMode::kSecure, session_.get());
  2415. base::TimeDelta timeout_remainder = timeout - fallback_period;
  2416. // Fallback period for second attempt.
  2417. fallback_period = resolve_context_->NextDohFallbackPeriod(
  2418. 0 /* doh_server_index */, session_.get());
  2419. ASSERT_LT(fallback_period, timeout_remainder);
  2420. FastForwardBy(fallback_period);
  2421. EXPECT_FALSE(helper.has_completed());
  2422. timeout_remainder -= fallback_period;
  2423. // Stop a tiny bit short to ensure transaction doesn't finish early.
  2424. const base::TimeDelta kTimeHoldback = base::Milliseconds(5);
  2425. ASSERT_LT(kTimeHoldback, timeout_remainder);
  2426. FastForwardBy(timeout_remainder - kTimeHoldback);
  2427. EXPECT_FALSE(helper.has_completed());
  2428. FastForwardBy(kTimeHoldback);
  2429. EXPECT_TRUE(helper.has_completed());
  2430. }
  2431. // Test for when attempt fallback periods go beyond the full timeout period.
  2432. TEST_F(DnsTransactionTestWithMockTime, LongHttpsTimeouts) {
  2433. const int kNumAttempts = 20;
  2434. config_.doh_attempts = kNumAttempts;
  2435. ConfigureDohServers(false /* use_post */);
  2436. // Assume sum of fallback periods is greater than timeout.
  2437. ASSERT_GT(kNumAttempts * resolve_context_->NextDohFallbackPeriod(
  2438. 0 /* doh_server_index */, session_.get()),
  2439. resolve_context_->SecureTransactionTimeout(SecureDnsMode::kSecure,
  2440. session_.get()));
  2441. for (int i = 0; i < kNumAttempts; ++i) {
  2442. AddHangingQuery(kT0HostName, kT0Qtype,
  2443. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2444. false /* enqueue_transaction_id */);
  2445. }
  2446. TransactionHelper helper(ERR_DNS_TIMED_OUT);
  2447. std::unique_ptr<DnsTransaction> transaction =
  2448. transaction_factory_->CreateTransaction(
  2449. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2450. SecureDnsMode::kSecure, resolve_context_.get(),
  2451. false /* fast_timeout */);
  2452. helper.StartTransaction(std::move(transaction));
  2453. base::RunLoop().RunUntilIdle();
  2454. ASSERT_FALSE(helper.has_completed());
  2455. for (int i = 0; i < kNumAttempts - 1; ++i) {
  2456. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2457. 0 /* doh_server_index */, session_.get()));
  2458. EXPECT_FALSE(helper.has_completed());
  2459. }
  2460. // Expect transaction to time out immediately after the last fallback period.
  2461. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2462. 0 /* doh_server_index */, session_.get()));
  2463. EXPECT_TRUE(helper.has_completed());
  2464. }
  2465. // Test for when the last of multiple HTTPS attempts fails (SERVFAIL) before
  2466. // a previous attempt succeeds.
  2467. TEST_F(DnsTransactionTestWithMockTime, LastHttpsAttemptFails) {
  2468. config_.doh_attempts = 2;
  2469. ConfigureDohServers(false /* use_post */);
  2470. // Simulate a slow response by using an ERR_IO_PENDING read error to delay
  2471. // until SequencedSocketData::Resume() is called.
  2472. auto data = std::make_unique<DnsSocketData>(
  2473. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  2474. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2475. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2476. data->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  2477. ASYNC);
  2478. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2479. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2480. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2481. SYNCHRONOUS, Transport::HTTPS,
  2482. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2483. false /* enqueue_transaction_id */);
  2484. TransactionHelper helper(kT0RecordCount);
  2485. std::unique_ptr<DnsTransaction> transaction =
  2486. transaction_factory_->CreateTransaction(
  2487. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2488. SecureDnsMode::kSecure, resolve_context_.get(),
  2489. false /* fast_timeout */);
  2490. helper.StartTransaction(std::move(transaction));
  2491. // Wait for one timeout period to start (and fail) the second attempt.
  2492. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2493. 0 /* doh_server_index */, session_.get()));
  2494. EXPECT_FALSE(helper.has_completed());
  2495. // Complete the first attempt and expect immediate success.
  2496. sequenced_socket_data->Resume();
  2497. helper.RunUntilComplete();
  2498. }
  2499. // Test for when the last of multiple HTTPS attempts fails (SERVFAIL), and a
  2500. // previous attempt never completes.
  2501. TEST_F(DnsTransactionTestWithMockTime, LastHttpsAttemptFails_Timeout) {
  2502. config_.doh_attempts = 2;
  2503. ConfigureDohServers(false /* use_post */);
  2504. AddHangingQuery(kT0HostName, kT0Qtype,
  2505. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2506. false /* enqueue_transaction_id */);
  2507. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2508. SYNCHRONOUS, Transport::HTTPS,
  2509. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2510. false /* enqueue_transaction_id */);
  2511. TransactionHelper helper(ERR_DNS_TIMED_OUT);
  2512. std::unique_ptr<DnsTransaction> transaction =
  2513. transaction_factory_->CreateTransaction(
  2514. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2515. SecureDnsMode::kSecure, resolve_context_.get(),
  2516. false /* fast_timeout */);
  2517. helper.StartTransaction(std::move(transaction));
  2518. base::RunLoop().RunUntilIdle();
  2519. EXPECT_FALSE(helper.has_completed());
  2520. // Second attempt fails immediately after first fallback period, but because
  2521. // fast timeout is disabled, the transaction will attempt to wait for the
  2522. // first attempt.
  2523. base::TimeDelta fallback_period = resolve_context_->NextDohFallbackPeriod(
  2524. 0 /* doh_server_index */, session_.get());
  2525. FastForwardBy(fallback_period);
  2526. EXPECT_FALSE(helper.has_completed());
  2527. // Timeout is from start of transaction, so need to keep track of the
  2528. // remainder after other fast forwards.
  2529. base::TimeDelta timeout = resolve_context_->SecureTransactionTimeout(
  2530. SecureDnsMode::kSecure, session_.get());
  2531. base::TimeDelta timeout_remainder = timeout - fallback_period;
  2532. // Stop a tiny bit short to ensure transaction doesn't finish early.
  2533. const base::TimeDelta kTimeHoldback = base::Milliseconds(5);
  2534. ASSERT_LT(kTimeHoldback, timeout_remainder);
  2535. FastForwardBy(timeout_remainder - kTimeHoldback);
  2536. EXPECT_FALSE(helper.has_completed());
  2537. FastForwardBy(kTimeHoldback);
  2538. EXPECT_TRUE(helper.has_completed());
  2539. }
  2540. // Test for when the last of multiple HTTPS attempts fails (SERVFAIL) before
  2541. // a previous attempt can complete, but fast timeouts is enabled.
  2542. TEST_F(DnsTransactionTestWithMockTime, LastHttpsAttemptFails_FastTimeout) {
  2543. config_.doh_attempts = 2;
  2544. ConfigureDohServers(false /* use_post */);
  2545. AddHangingQuery(kT0HostName, kT0Qtype,
  2546. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2547. false /* enqueue_transaction_id */);
  2548. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2549. SYNCHRONOUS, Transport::HTTPS,
  2550. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2551. false /* enqueue_transaction_id */);
  2552. TransactionHelper helper(ERR_DNS_SERVER_FAILED);
  2553. std::unique_ptr<DnsTransaction> transaction =
  2554. transaction_factory_->CreateTransaction(
  2555. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2556. SecureDnsMode::kSecure, resolve_context_.get(),
  2557. true /* fast_timeout */);
  2558. helper.StartTransaction(std::move(transaction));
  2559. base::RunLoop().RunUntilIdle();
  2560. EXPECT_FALSE(helper.has_completed());
  2561. // With fast timeout enabled, expect the transaction to complete with failure
  2562. // immediately on failure of the last transaction.
  2563. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2564. 0 /* doh_server_index */, session_.get()));
  2565. EXPECT_TRUE(helper.has_completed());
  2566. }
  2567. // Test for when the last of multiple HTTPS attempts fails (SERVFAIL) before
  2568. // a previous attempt later fails as well.
  2569. TEST_F(DnsTransactionTestWithMockTime, LastHttpsAttemptFailsFirst) {
  2570. config_.doh_attempts = 2;
  2571. ConfigureDohServers(false /* use_post */);
  2572. // Simulate a slow response by using an ERR_IO_PENDING read error to delay
  2573. // until SequencedSocketData::Resume() is called.
  2574. auto data = std::make_unique<DnsSocketData>(
  2575. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  2576. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2577. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2578. data->AddRcode(dns_protocol::kRcodeSERVFAIL, ASYNC);
  2579. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2580. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2581. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2582. SYNCHRONOUS, Transport::HTTPS,
  2583. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2584. false /* enqueue_transaction_id */);
  2585. TransactionHelper helper(ERR_DNS_SERVER_FAILED);
  2586. std::unique_ptr<DnsTransaction> transaction =
  2587. transaction_factory_->CreateTransaction(
  2588. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2589. SecureDnsMode::kSecure, resolve_context_.get(),
  2590. false /* fast_timeout */);
  2591. helper.StartTransaction(std::move(transaction));
  2592. // Wait for one timeout period to start (and fail) the second attempt.
  2593. FastForwardBy(resolve_context_->NextDohFallbackPeriod(
  2594. 0 /* doh_server_index */, session_.get()));
  2595. EXPECT_FALSE(helper.has_completed());
  2596. // Complete the first attempt and expect immediate completion.
  2597. sequenced_socket_data->Resume();
  2598. helper.RunUntilComplete();
  2599. }
  2600. // Test for when multiple HTTPS attempts fail (SERVFAIL) in order, making the
  2601. // last started attempt also the last attempt to be pending.
  2602. TEST_F(DnsTransactionTestWithMockTime, LastHttpsAttemptFailsLast) {
  2603. config_.doh_attempts = 2;
  2604. ConfigureDohServers(false /* use_post */);
  2605. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2606. SYNCHRONOUS, Transport::HTTPS,
  2607. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2608. false /* enqueue_transaction_id */);
  2609. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL,
  2610. SYNCHRONOUS, Transport::HTTPS,
  2611. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128, 0 /* id */,
  2612. false /* enqueue_transaction_id */);
  2613. TransactionHelper helper(ERR_DNS_SERVER_FAILED);
  2614. std::unique_ptr<DnsTransaction> transaction =
  2615. transaction_factory_->CreateTransaction(
  2616. kT0HostName, kT0Qtype, NetLogWithSource(), true /* secure */,
  2617. SecureDnsMode::kSecure, resolve_context_.get(),
  2618. false /* fast_timeout */);
  2619. helper.StartTransaction(std::move(transaction));
  2620. // Expect both attempts will run quickly without waiting for fallbacks or
  2621. // transaction timeout.
  2622. helper.RunUntilComplete();
  2623. }
  2624. TEST_F(DnsTransactionTest, TcpLookup_UdpRetry) {
  2625. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2626. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2627. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2628. std::size(kT0ResponseDatagram), ASYNC, Transport::TCP);
  2629. TransactionHelper helper0(kT0RecordCount);
  2630. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2631. false /* secure */, resolve_context_.get());
  2632. helper0.RunUntilComplete();
  2633. }
  2634. TEST_F(DnsTransactionTest, TcpLookup_LowEntropy) {
  2635. socket_factory_->diverse_source_ports_ = false;
  2636. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  2637. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2638. std::size(kT0ResponseDatagram), ASYNC, Transport::UDP);
  2639. }
  2640. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2641. std::size(kT0ResponseDatagram), ASYNC, Transport::TCP);
  2642. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  2643. TransactionHelper udp_helper(kT0RecordCount);
  2644. udp_helper.StartTransaction(transaction_factory_.get(), kT0HostName,
  2645. kT0Qtype, false /* secure */,
  2646. resolve_context_.get());
  2647. udp_helper.RunUntilComplete();
  2648. }
  2649. ASSERT_TRUE(session_->udp_tracker()->low_entropy());
  2650. TransactionHelper helper0(kT0RecordCount);
  2651. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2652. false /* secure */, resolve_context_.get());
  2653. helper0.RunUntilComplete();
  2654. EXPECT_TRUE(session_->udp_tracker()->low_entropy());
  2655. }
  2656. TEST_F(DnsTransactionTest, TCPFailure) {
  2657. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2658. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2659. AddQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeSERVFAIL, ASYNC,
  2660. Transport::TCP);
  2661. TransactionHelper helper0(ERR_DNS_SERVER_FAILED);
  2662. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2663. false /* secure */, resolve_context_.get());
  2664. helper0.RunUntilComplete();
  2665. ASSERT_NE(helper0.response(), nullptr);
  2666. EXPECT_EQ(helper0.response()->rcode(), dns_protocol::kRcodeSERVFAIL);
  2667. }
  2668. TEST_F(DnsTransactionTest, TCPMalformed) {
  2669. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2670. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2671. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2672. ASYNC, Transport::TCP);
  2673. // Valid response but length too short.
  2674. // This must be truncated in the question section. The DnsResponse doesn't
  2675. // examine the answer section until asked to parse it, so truncating it in
  2676. // the answer section would result in the DnsTransaction itself succeeding.
  2677. data->AddResponseWithLength(
  2678. std::make_unique<DnsResponse>(
  2679. reinterpret_cast<const char*>(kT0ResponseDatagram),
  2680. std::size(kT0ResponseDatagram), 0),
  2681. ASYNC, static_cast<uint16_t>(kT0QuerySize - 1));
  2682. AddSocketData(std::move(data));
  2683. TransactionHelper helper0(ERR_DNS_MALFORMED_RESPONSE);
  2684. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2685. false /* secure */, resolve_context_.get());
  2686. helper0.RunUntilComplete();
  2687. }
  2688. TEST_F(DnsTransactionTestWithMockTime, TcpTimeout_UdpRetry) {
  2689. ConfigureFactory();
  2690. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2691. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2692. AddSocketData(std::make_unique<DnsSocketData>(
  2693. 1 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::TCP));
  2694. TransactionHelper helper0(ERR_DNS_TIMED_OUT);
  2695. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2696. false /* secure */, resolve_context_.get());
  2697. base::RunLoop().RunUntilIdle();
  2698. EXPECT_FALSE(helper0.has_completed());
  2699. FastForwardUntilNoTasksRemain();
  2700. EXPECT_TRUE(helper0.has_completed());
  2701. }
  2702. TEST_F(DnsTransactionTestWithMockTime, TcpTimeout_LowEntropy) {
  2703. ConfigureFactory();
  2704. socket_factory_->diverse_source_ports_ = false;
  2705. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  2706. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2707. std::size(kT0ResponseDatagram), ASYNC, Transport::UDP);
  2708. }
  2709. AddSocketData(std::make_unique<DnsSocketData>(
  2710. 1 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::TCP));
  2711. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  2712. TransactionHelper udp_helper(kT0RecordCount);
  2713. udp_helper.StartTransaction(transaction_factory_.get(), kT0HostName,
  2714. kT0Qtype, false /* secure */,
  2715. resolve_context_.get());
  2716. udp_helper.RunUntilComplete();
  2717. }
  2718. ASSERT_TRUE(session_->udp_tracker()->low_entropy());
  2719. TransactionHelper helper0(ERR_DNS_TIMED_OUT);
  2720. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2721. false /* secure */, resolve_context_.get());
  2722. base::RunLoop().RunUntilIdle();
  2723. EXPECT_FALSE(helper0.has_completed());
  2724. FastForwardUntilNoTasksRemain();
  2725. EXPECT_TRUE(helper0.has_completed());
  2726. }
  2727. TEST_F(DnsTransactionTest, TCPReadReturnsZeroAsync) {
  2728. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2729. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2730. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2731. ASYNC, Transport::TCP);
  2732. // Return all but the last byte of the response.
  2733. data->AddResponseWithLength(
  2734. std::make_unique<DnsResponse>(
  2735. reinterpret_cast<const char*>(kT0ResponseDatagram),
  2736. std::size(kT0ResponseDatagram) - 1, 0),
  2737. ASYNC, static_cast<uint16_t>(std::size(kT0ResponseDatagram)));
  2738. // Then return a 0-length read.
  2739. data->AddReadError(0, ASYNC);
  2740. AddSocketData(std::move(data));
  2741. TransactionHelper helper0(ERR_CONNECTION_CLOSED);
  2742. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2743. false /* secure */, resolve_context_.get());
  2744. helper0.RunUntilComplete();
  2745. }
  2746. TEST_F(DnsTransactionTest, TCPReadReturnsZeroSynchronous) {
  2747. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2748. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2749. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2750. ASYNC, Transport::TCP);
  2751. // Return all but the last byte of the response.
  2752. data->AddResponseWithLength(
  2753. std::make_unique<DnsResponse>(
  2754. reinterpret_cast<const char*>(kT0ResponseDatagram),
  2755. std::size(kT0ResponseDatagram) - 1, 0),
  2756. SYNCHRONOUS, static_cast<uint16_t>(std::size(kT0ResponseDatagram)));
  2757. // Then return a 0-length read.
  2758. data->AddReadError(0, SYNCHRONOUS);
  2759. AddSocketData(std::move(data));
  2760. TransactionHelper helper0(ERR_CONNECTION_CLOSED);
  2761. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2762. false /* secure */, resolve_context_.get());
  2763. helper0.RunUntilComplete();
  2764. }
  2765. TEST_F(DnsTransactionTest, TCPConnectionClosedAsync) {
  2766. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2767. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2768. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2769. ASYNC, Transport::TCP);
  2770. data->AddReadError(ERR_CONNECTION_CLOSED, ASYNC);
  2771. AddSocketData(std::move(data));
  2772. TransactionHelper helper0(ERR_CONNECTION_CLOSED);
  2773. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2774. false /* secure */, resolve_context_.get());
  2775. helper0.RunUntilComplete();
  2776. }
  2777. TEST_F(DnsTransactionTest, TCPConnectionClosedSynchronous) {
  2778. AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
  2779. dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
  2780. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2781. ASYNC, Transport::TCP);
  2782. data->AddReadError(ERR_CONNECTION_CLOSED, SYNCHRONOUS);
  2783. AddSocketData(std::move(data));
  2784. TransactionHelper helper0(ERR_CONNECTION_CLOSED);
  2785. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2786. false /* secure */, resolve_context_.get());
  2787. helper0.RunUntilComplete();
  2788. }
  2789. TEST_F(DnsTransactionTest, MismatchedThenNxdomainThenTCP) {
  2790. config_.attempts = 2;
  2791. ConfigureFactory();
  2792. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2793. SYNCHRONOUS, Transport::UDP);
  2794. // First attempt gets a mismatched response.
  2795. data->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  2796. SYNCHRONOUS);
  2797. // Second read from first attempt gets TCP required.
  2798. data->AddRcode(dns_protocol::kFlagTC, ASYNC);
  2799. AddSocketData(std::move(data));
  2800. // Second attempt gets NXDOMAIN, which happens before the TCP required.
  2801. AddSyncQueryAndRcode(kT0HostName, kT0Qtype, dns_protocol::kRcodeNXDOMAIN);
  2802. TransactionHelper helper0(ERR_NAME_NOT_RESOLVED);
  2803. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2804. false /* secure */, resolve_context_.get());
  2805. helper0.RunUntilComplete();
  2806. }
  2807. TEST_F(DnsTransactionTest, MismatchedThenOkThenTCP) {
  2808. config_.attempts = 2;
  2809. ConfigureFactory();
  2810. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2811. SYNCHRONOUS, Transport::UDP);
  2812. // First attempt gets a mismatched response.
  2813. data->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  2814. SYNCHRONOUS);
  2815. // Second read from first attempt gets TCP required.
  2816. data->AddRcode(dns_protocol::kFlagTC, ASYNC);
  2817. AddSocketData(std::move(data));
  2818. // Second attempt gets a valid response, which happens before the TCP
  2819. // required.
  2820. AddSyncQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype,
  2821. kT0ResponseDatagram, std::size(kT0ResponseDatagram));
  2822. TransactionHelper helper0(kT0RecordCount);
  2823. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2824. false /* secure */, resolve_context_.get());
  2825. helper0.RunUntilComplete();
  2826. }
  2827. TEST_F(DnsTransactionTest, MismatchedThenRefusedThenTCP) {
  2828. // Set up the expected sequence of events:
  2829. // 1) First attempt (UDP) gets a synchronous mismatched response. On such
  2830. // malformed responses, DnsTransaction triggers an immediate retry to read
  2831. // again from the socket within the same "attempt".
  2832. // 2) Second read (within the first attempt) starts. Test is configured to
  2833. // give an asynchronous TCP required response which will complete later.
  2834. // On asynchronous action after a malformed response, the attempt will
  2835. // immediately produce a retriable error result while the retry continues,
  2836. // thus forking the running attempts.
  2837. // 3) Error result triggers a second attempt (UDP) which test gives a
  2838. // synchronous ERR_CONNECTION_REFUSED, which is a retriable error, but
  2839. // DnsTransaction has exhausted max retries (2 attempts), so this result
  2840. // gets posted as the result of the transaction and other running attempts
  2841. // should be cancelled.
  2842. // 4) First attempt should be cancelled when the transaction result is posted,
  2843. // so first attempt's second read should never complete. If it did
  2844. // complete, it would complete with a TCP-required error, and
  2845. // DnsTransaction would start a TCP attempt and clear previous attempts. It
  2846. // would be very bad if that then cleared the attempt posted as the final
  2847. // result, as result handling does not expect that memory to go away.
  2848. config_.attempts = 2;
  2849. ConfigureFactory();
  2850. // Attempt 1.
  2851. auto data = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName, kT0Qtype,
  2852. SYNCHRONOUS, Transport::UDP);
  2853. data->AddResponseData(kT1ResponseDatagram, std::size(kT1ResponseDatagram),
  2854. SYNCHRONOUS);
  2855. data->AddRcode(dns_protocol::kFlagTC, ASYNC);
  2856. AddSocketData(std::move(data));
  2857. // Attempt 2.
  2858. AddQueryAndErrorResponse(0 /* id */, kT0HostName, kT0Qtype,
  2859. ERR_CONNECTION_REFUSED, SYNCHRONOUS, Transport::UDP);
  2860. TransactionHelper helper0(ERR_CONNECTION_REFUSED);
  2861. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2862. false /* secure */, resolve_context_.get());
  2863. helper0.RunUntilComplete();
  2864. }
  2865. TEST_F(DnsTransactionTest, InvalidQuery) {
  2866. ConfigureFactory();
  2867. TransactionHelper helper0(ERR_INVALID_ARGUMENT);
  2868. helper0.StartTransaction(transaction_factory_.get(), ".",
  2869. dns_protocol::kTypeA, false /* secure */,
  2870. resolve_context_.get());
  2871. helper0.RunUntilComplete();
  2872. TransactionHelper helper1(ERR_INVALID_ARGUMENT);
  2873. helper1.StartTransaction(transaction_factory_.get(), "foo,bar.com",
  2874. dns_protocol::kTypeA, false /* secure */,
  2875. resolve_context_.get());
  2876. helper1.RunUntilComplete();
  2877. }
  2878. TEST_F(DnsTransactionTest, CheckAsync) {
  2879. ConfigureDohServers(false /* use_post */);
  2880. AddQueryAndResponse(0, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  2881. std::size(kT0ResponseDatagram), SYNCHRONOUS,
  2882. Transport::HTTPS, nullptr /* opt_rdata */,
  2883. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2884. false /* enqueue_transaction_id */);
  2885. TransactionHelper helper0(kT0RecordCount);
  2886. bool started = false;
  2887. SetUrlRequestStartedCallback(
  2888. base::BindLambdaForTesting([&] { started = true; }));
  2889. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2890. true /* secure */, resolve_context_.get());
  2891. EXPECT_FALSE(started);
  2892. EXPECT_FALSE(helper0.has_completed());
  2893. helper0.RunUntilComplete();
  2894. EXPECT_TRUE(started);
  2895. }
  2896. TEST_F(DnsTransactionTest, EarlyCancel) {
  2897. ConfigureDohServers(false /* use_post */);
  2898. TransactionHelper helper0(0);
  2899. SetUrlRequestStartedCallback(base::BindRepeating([] { FAIL(); }));
  2900. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  2901. true /* secure */, resolve_context_.get());
  2902. EXPECT_FALSE(helper0.has_completed());
  2903. helper0.Cancel();
  2904. base::RunLoop().RunUntilIdle();
  2905. }
  2906. TEST_F(DnsTransactionTestWithMockTime, ProbeUntilSuccess) {
  2907. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  2908. false /* make_available */);
  2909. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  2910. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  2911. Transport::HTTPS, nullptr /* opt_rdata */,
  2912. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2913. false /* enqueue_transaction_id */);
  2914. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  2915. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  2916. Transport::HTTPS, nullptr /* opt_rdata */,
  2917. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2918. false /* enqueue_transaction_id */);
  2919. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  2920. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  2921. nullptr /* opt_rdata */,
  2922. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2923. false /* enqueue_transaction_id */);
  2924. std::unique_ptr<DnsProbeRunner> runner =
  2925. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  2926. runner->Start(false /* network_change */);
  2927. // The first probe happens without any delay.
  2928. RunUntilIdle();
  2929. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  2930. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  2931. EXPECT_FALSE(doh_itr->AttemptAvailable());
  2932. // Expect the server to still be unavailable after the second probe.
  2933. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  2934. EXPECT_FALSE(doh_itr->AttemptAvailable());
  2935. // Expect the server to be available after the successful third probe.
  2936. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  2937. ASSERT_TRUE(doh_itr->AttemptAvailable());
  2938. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  2939. }
  2940. // Test that if a probe attempt hangs, additional probes will still run on
  2941. // schedule
  2942. TEST_F(DnsTransactionTestWithMockTime, HungProbe) {
  2943. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  2944. false /* make_available */);
  2945. // Create a socket data to first return ERR_IO_PENDING. This will pause the
  2946. // probe and not return the error until SequencedSocketData::Resume() is
  2947. // called.
  2948. auto data = std::make_unique<DnsSocketData>(
  2949. 0 /* id */, kT4HostName, kT4Qtype, ASYNC, Transport::HTTPS,
  2950. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  2951. data->AddReadError(ERR_IO_PENDING, ASYNC);
  2952. data->AddReadError(ERR_CONNECTION_REFUSED, ASYNC);
  2953. data->AddResponseData(kT4ResponseDatagram, std::size(kT4ResponseDatagram),
  2954. ASYNC);
  2955. SequencedSocketData* sequenced_socket_data = data->GetProvider();
  2956. AddSocketData(std::move(data), false /* enqueue_transaction_id */);
  2957. // Add success for second probe.
  2958. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  2959. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  2960. nullptr /* opt_rdata */,
  2961. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2962. false /* enqueue_transaction_id */);
  2963. std::unique_ptr<DnsProbeRunner> runner =
  2964. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  2965. runner->Start(false /* network_change */);
  2966. // The first probe starts without any delay, but doesn't finish.
  2967. RunUntilIdle();
  2968. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  2969. 0u /* doh_server_index */, session_.get()));
  2970. // Second probe succeeds.
  2971. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  2972. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  2973. 0u /* doh_server_index */, session_.get()));
  2974. // Probe runner self-cancels on next cycle.
  2975. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  2976. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  2977. // Expect no effect when the hung probe wakes up and fails.
  2978. sequenced_socket_data->Resume();
  2979. RunUntilIdle();
  2980. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  2981. 0u /* doh_server_index */, session_.get()));
  2982. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  2983. }
  2984. TEST_F(DnsTransactionTestWithMockTime, ProbeMultipleServers) {
  2985. ConfigureDohServers(true /* use_post */, 2 /* num_doh_servers */,
  2986. false /* make_available */);
  2987. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  2988. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  2989. nullptr /* opt_rdata */,
  2990. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2991. false /* enqueue_transaction_id */);
  2992. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  2993. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  2994. Transport::HTTPS, nullptr /* opt_rdata */,
  2995. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  2996. false /* enqueue_transaction_id */);
  2997. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  2998. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  2999. nullptr /* opt_rdata */,
  3000. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3001. false /* enqueue_transaction_id */);
  3002. ASSERT_FALSE(resolve_context_->GetDohServerAvailability(
  3003. 0u /* doh_server_index */, session_.get()));
  3004. ASSERT_FALSE(resolve_context_->GetDohServerAvailability(
  3005. 1u /* doh_server_index */, session_.get()));
  3006. std::unique_ptr<DnsProbeRunner> runner =
  3007. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3008. runner->Start(true /* network_change */);
  3009. // The first probes happens without any delay and succeeds for only one server
  3010. RunUntilIdle();
  3011. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3012. 0u /* doh_server_index */, session_.get()));
  3013. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  3014. 1u /* doh_server_index */, session_.get()));
  3015. // On second round of probing, probes for first server should self-cancel and
  3016. // second server should become available.
  3017. FastForwardBy(
  3018. runner->GetDelayUntilNextProbeForTest(0u /* doh_server_index */));
  3019. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0u /* doh_server_index */),
  3020. base::TimeDelta());
  3021. FastForwardBy(
  3022. runner->GetDelayUntilNextProbeForTest(1u /* doh_server_index */));
  3023. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3024. 1u /* doh_server_index */, session_.get()));
  3025. // Expect server 2 probes to self-cancel on next cycle.
  3026. FastForwardBy(runner->GetDelayUntilNextProbeForTest(1u));
  3027. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(1u), base::TimeDelta());
  3028. }
  3029. TEST_F(DnsTransactionTestWithMockTime, MultipleProbeRunners) {
  3030. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3031. false /* make_available */);
  3032. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3033. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3034. nullptr /* opt_rdata */,
  3035. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3036. false /* enqueue_transaction_id */);
  3037. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3038. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3039. nullptr /* opt_rdata */,
  3040. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3041. false /* enqueue_transaction_id */);
  3042. std::unique_ptr<DnsProbeRunner> runner1 =
  3043. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3044. std::unique_ptr<DnsProbeRunner> runner2 =
  3045. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3046. runner1->Start(true /* network_change */);
  3047. runner2->Start(true /* network_change */);
  3048. // The first two probes (one for each runner) happen without any delay
  3049. // and mark the first server good.
  3050. RunUntilIdle();
  3051. {
  3052. std::unique_ptr<DnsServerIterator> doh_itr =
  3053. resolve_context_->GetDohIterator(
  3054. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3055. ASSERT_TRUE(doh_itr->AttemptAvailable());
  3056. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  3057. }
  3058. // Both probes expected to self-cancel on next scheduled run.
  3059. FastForwardBy(runner1->GetDelayUntilNextProbeForTest(0));
  3060. FastForwardBy(runner2->GetDelayUntilNextProbeForTest(0));
  3061. EXPECT_EQ(runner1->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3062. EXPECT_EQ(runner2->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3063. }
  3064. TEST_F(DnsTransactionTestWithMockTime, MultipleProbeRunners_SeparateContexts) {
  3065. // Each RequestContext uses its own transient IsolationInfo. Since there's
  3066. // typically only one RequestContext per URLRequestContext, there's no
  3067. // advantage in using the same IsolationInfo across RequestContexts.
  3068. set_expect_multiple_isolation_infos(true);
  3069. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3070. false /* make_available */);
  3071. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3072. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3073. nullptr /* opt_rdata */,
  3074. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3075. false /* enqueue_transaction_id */);
  3076. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3077. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3078. Transport::HTTPS, nullptr /* opt_rdata */,
  3079. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3080. false /* enqueue_transaction_id */);
  3081. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3082. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3083. nullptr /* opt_rdata */,
  3084. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3085. false /* enqueue_transaction_id */);
  3086. auto request_context2 = CreateTestURLRequestContextBuilder()->Build();
  3087. ResolveContext context2(request_context2.get(), false /* enable_caching */);
  3088. context2.InvalidateCachesAndPerSessionData(session_.get(),
  3089. false /* network_change */);
  3090. std::unique_ptr<DnsProbeRunner> runner1 =
  3091. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3092. std::unique_ptr<DnsProbeRunner> runner2 =
  3093. transaction_factory_->CreateDohProbeRunner(&context2);
  3094. runner1->Start(false /* network_change */);
  3095. runner2->Start(false /* network_change */);
  3096. // The first two probes (one for each runner) happen without any delay.
  3097. // Probe for first context succeeds and second fails.
  3098. RunUntilIdle();
  3099. {
  3100. std::unique_ptr<DnsServerIterator> doh_itr =
  3101. resolve_context_->GetDohIterator(
  3102. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3103. ASSERT_TRUE(doh_itr->AttemptAvailable());
  3104. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  3105. }
  3106. {
  3107. std::unique_ptr<DnsServerIterator> doh_itr2 = context2.GetDohIterator(
  3108. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3109. EXPECT_FALSE(doh_itr2->AttemptAvailable());
  3110. }
  3111. // First probe runner expected to be compete and self-cancel on next run.
  3112. FastForwardBy(runner1->GetDelayUntilNextProbeForTest(0));
  3113. EXPECT_EQ(runner1->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3114. // Expect second runner to succeed on its second probe.
  3115. FastForwardBy(runner2->GetDelayUntilNextProbeForTest(0));
  3116. {
  3117. std::unique_ptr<DnsServerIterator> doh_itr2 = context2.GetDohIterator(
  3118. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3119. ASSERT_TRUE(doh_itr2->AttemptAvailable());
  3120. EXPECT_EQ(doh_itr2->GetNextAttemptIndex(), 0u);
  3121. }
  3122. FastForwardBy(runner2->GetDelayUntilNextProbeForTest(0));
  3123. EXPECT_EQ(runner2->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3124. }
  3125. TEST_F(DnsTransactionTestWithMockTime, CancelDohProbeOnDestruction) {
  3126. ConfigureDohServers(/*use_post=*/true, /*num_doh_servers=*/1,
  3127. /*make_available=*/false);
  3128. AddQueryAndErrorResponse(/*id=*/0, kT4HostName, kT4Qtype,
  3129. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3130. Transport::HTTPS, /*opt_rdata=*/nullptr,
  3131. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3132. /*enqueue_transaction_id=*/false);
  3133. AddQueryAndErrorResponse(/*id=*/0, kT4HostName, kT4Qtype,
  3134. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3135. Transport::HTTPS, /*opt_rdata=*/nullptr,
  3136. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3137. /* enqueue_transaction_id=*/false);
  3138. std::unique_ptr<DnsProbeRunner> runner =
  3139. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3140. runner->Start(/*network_change=*/false);
  3141. // The first probe happens without any delay.
  3142. RunUntilIdle();
  3143. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  3144. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3145. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3146. // Expect the server to still be unavailable after the second probe.
  3147. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  3148. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3149. base::TimeDelta next_delay = runner->GetDelayUntilNextProbeForTest(0);
  3150. runner.reset();
  3151. // Server stays unavailable because probe canceled before (non-existent)
  3152. // success. No success result is added, so this FastForward will cause a
  3153. // failure if probes attempt to run.
  3154. FastForwardBy(next_delay);
  3155. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3156. }
  3157. TEST_F(DnsTransactionTestWithMockTime, CancelDohProbeOnContextDestruction) {
  3158. ConfigureDohServers(/*use_post=*/true, /*num_doh_servers=*/1,
  3159. /*make_available=*/false);
  3160. AddQueryAndErrorResponse(/*id=*/0, kT4HostName, kT4Qtype,
  3161. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3162. Transport::HTTPS, /*opt_rdata=*/nullptr,
  3163. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3164. /*enqueue_transaction_id=*/false);
  3165. AddQueryAndErrorResponse(/*id=*/0, kT4HostName, kT4Qtype,
  3166. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3167. Transport::HTTPS, /*opt_rdata=*/nullptr,
  3168. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3169. /* enqueue_transaction_id=*/false);
  3170. std::unique_ptr<DnsProbeRunner> runner =
  3171. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3172. runner->Start(/*network_change=*/false);
  3173. // The first probe happens without any delay.
  3174. RunUntilIdle();
  3175. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  3176. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3177. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3178. // Expect the server to still be unavailable after the second probe.
  3179. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  3180. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3181. base::TimeDelta next_delay = runner->GetDelayUntilNextProbeForTest(0);
  3182. resolve_context_.reset();
  3183. // The probe detects that the context no longer exists and stops running.
  3184. FastForwardBy(next_delay);
  3185. // There are no more probes to run.
  3186. EXPECT_EQ(base::TimeDelta(), runner->GetDelayUntilNextProbeForTest(0));
  3187. }
  3188. TEST_F(DnsTransactionTestWithMockTime, CancelOneOfMultipleProbeRunners) {
  3189. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3190. false /* make_available */);
  3191. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3192. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3193. Transport::HTTPS, nullptr /* opt_rdata */,
  3194. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3195. false /* enqueue_transaction_id */);
  3196. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3197. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3198. Transport::HTTPS, nullptr /* opt_rdata */,
  3199. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3200. false /* enqueue_transaction_id */);
  3201. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3202. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3203. nullptr /* opt_rdata */,
  3204. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3205. false /* enqueue_transaction_id */);
  3206. std::unique_ptr<DnsProbeRunner> runner1 =
  3207. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3208. std::unique_ptr<DnsProbeRunner> runner2 =
  3209. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3210. runner1->Start(true /* network_change */);
  3211. runner2->Start(true /* network_change */);
  3212. // The first two probes (one for each runner) happen without any delay.
  3213. RunUntilIdle();
  3214. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  3215. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3216. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3217. EXPECT_GT(runner1->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3218. EXPECT_GT(runner2->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3219. // Cancel only one probe runner.
  3220. runner1.reset();
  3221. // Expect the server to be available after the successful third probe.
  3222. FastForwardBy(runner2->GetDelayUntilNextProbeForTest(0));
  3223. ASSERT_TRUE(doh_itr->AttemptAvailable());
  3224. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  3225. FastForwardBy(runner2->GetDelayUntilNextProbeForTest(0));
  3226. EXPECT_EQ(runner2->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3227. }
  3228. TEST_F(DnsTransactionTestWithMockTime, CancelAllOfMultipleProbeRunners) {
  3229. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3230. false /* make_available */);
  3231. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3232. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3233. Transport::HTTPS, nullptr /* opt_rdata */,
  3234. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3235. false /* enqueue_transaction_id */);
  3236. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3237. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3238. Transport::HTTPS, nullptr /* opt_rdata */,
  3239. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3240. false /* enqueue_transaction_id */);
  3241. std::unique_ptr<DnsProbeRunner> runner1 =
  3242. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3243. std::unique_ptr<DnsProbeRunner> runner2 =
  3244. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3245. runner1->Start(false /* network_change */);
  3246. runner2->Start(false /* network_change */);
  3247. // The first two probes (one for each runner) happen without any delay.
  3248. RunUntilIdle();
  3249. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  3250. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3251. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3252. EXPECT_GT(runner1->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3253. EXPECT_GT(runner2->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3254. base::TimeDelta next_delay = runner1->GetDelayUntilNextProbeForTest(0);
  3255. runner1.reset();
  3256. runner2.reset();
  3257. // Server stays unavailable because probe canceled before (non-existent)
  3258. // success. No success result is added, so this FastForward will cause a
  3259. // failure if probes attempt to run.
  3260. FastForwardBy(next_delay);
  3261. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3262. }
  3263. TEST_F(DnsTransactionTestWithMockTime, CancelDohProbe_AfterSuccess) {
  3264. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3265. false /* make_available */);
  3266. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3267. std::size(kT4ResponseDatagram), SYNCHRONOUS,
  3268. Transport::HTTPS, nullptr /* opt_rdata */,
  3269. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3270. false /* enqueue_transaction_id */);
  3271. std::unique_ptr<DnsProbeRunner> runner =
  3272. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3273. runner->Start(true /* network_change */);
  3274. // The first probe happens without any delay, and immediately succeeds.
  3275. RunUntilIdle();
  3276. {
  3277. std::unique_ptr<DnsServerIterator> doh_itr =
  3278. resolve_context_->GetDohIterator(
  3279. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3280. ASSERT_TRUE(doh_itr->AttemptAvailable());
  3281. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  3282. }
  3283. runner.reset();
  3284. // No change expected after cancellation.
  3285. RunUntilIdle();
  3286. {
  3287. std::unique_ptr<DnsServerIterator> doh_itr =
  3288. resolve_context_->GetDohIterator(
  3289. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3290. ASSERT_TRUE(doh_itr->AttemptAvailable());
  3291. EXPECT_EQ(doh_itr->GetNextAttemptIndex(), 0u);
  3292. }
  3293. }
  3294. TEST_F(DnsTransactionTestWithMockTime, DestroyFactoryAfterStartingDohProbe) {
  3295. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3296. false /* make_available */);
  3297. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3298. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3299. Transport::HTTPS, nullptr /* opt_rdata */,
  3300. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3301. false /* enqueue_transaction_id */);
  3302. std::unique_ptr<DnsProbeRunner> runner =
  3303. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3304. runner->Start(false /* network_change */);
  3305. // The first probe happens without any delay.
  3306. RunUntilIdle();
  3307. std::unique_ptr<DnsServerIterator> doh_itr = resolve_context_->GetDohIterator(
  3308. session_->config(), SecureDnsMode::kAutomatic, session_.get());
  3309. EXPECT_FALSE(doh_itr->AttemptAvailable());
  3310. // Destroy factory and session.
  3311. transaction_factory_.reset();
  3312. ASSERT_TRUE(session_->HasOneRef());
  3313. session_.reset();
  3314. // Probe should not encounter issues and should stop running.
  3315. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  3316. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0), base::TimeDelta());
  3317. }
  3318. TEST_F(DnsTransactionTestWithMockTime, StartWhileRunning) {
  3319. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3320. false /* make_available */);
  3321. AddQueryAndErrorResponse(0 /* id */, kT4HostName, kT4Qtype,
  3322. ERR_CONNECTION_REFUSED, SYNCHRONOUS,
  3323. Transport::HTTPS, nullptr /* opt_rdata */,
  3324. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3325. false /* enqueue_transaction_id */);
  3326. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3327. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3328. nullptr /* opt_rdata */,
  3329. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3330. false /* enqueue_transaction_id */);
  3331. std::unique_ptr<DnsProbeRunner> runner =
  3332. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3333. runner->Start(false /* network_change */);
  3334. // The first probe happens without any delay.
  3335. RunUntilIdle();
  3336. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  3337. 0u /* doh_server_index */, session_.get()));
  3338. // Extra Start() call should have no effect because runner is already running.
  3339. runner->Start(true /* network_change */);
  3340. RunUntilIdle();
  3341. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  3342. 0u /* doh_server_index */, session_.get()));
  3343. // Expect the server to be available after the successful second probe.
  3344. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0));
  3345. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3346. 0u /* doh_server_index */, session_.get()));
  3347. }
  3348. TEST_F(DnsTransactionTestWithMockTime, RestartFinishedProbe) {
  3349. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3350. false /* make_available */);
  3351. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3352. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3353. nullptr /* opt_rdata */,
  3354. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3355. false /* enqueue_transaction_id */);
  3356. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3357. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3358. nullptr /* opt_rdata */,
  3359. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3360. false /* enqueue_transaction_id */);
  3361. std::unique_ptr<DnsProbeRunner> runner =
  3362. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3363. runner->Start(true /* network_change */);
  3364. // The first probe happens without any delay and succeeds.
  3365. RunUntilIdle();
  3366. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3367. 0u /* doh_server_index */, session_.get()));
  3368. // Expect runner to self-cancel on next cycle.
  3369. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0u));
  3370. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0u), base::TimeDelta());
  3371. // Mark server unavailabe and restart runner.
  3372. for (int i = 0; i < ResolveContext::kAutomaticModeFailureLimit; ++i) {
  3373. resolve_context_->RecordServerFailure(0u /* server_index */,
  3374. true /* is_doh_server */, ERR_FAILED,
  3375. session_.get());
  3376. }
  3377. ASSERT_FALSE(resolve_context_->GetDohServerAvailability(
  3378. 0u /* doh_server_index */, session_.get()));
  3379. runner->Start(false /* network_change */);
  3380. // Expect the server to be available again after a successful immediately-run
  3381. // probe.
  3382. RunUntilIdle();
  3383. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3384. 0u /* doh_server_index */, session_.get()));
  3385. // Expect self-cancel again.
  3386. FastForwardBy(runner->GetDelayUntilNextProbeForTest(0u));
  3387. EXPECT_EQ(runner->GetDelayUntilNextProbeForTest(0u), base::TimeDelta());
  3388. }
  3389. // Test that a probe runner keeps running on the same schedule if it completes
  3390. // but the server is marked unavailable again before the next scheduled probe.
  3391. TEST_F(DnsTransactionTestWithMockTime, FastProbeRestart) {
  3392. ConfigureDohServers(true /* use_post */, 1 /* num_doh_servers */,
  3393. false /* make_available */);
  3394. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3395. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3396. nullptr /* opt_rdata */,
  3397. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3398. false /* enqueue_transaction_id */);
  3399. AddQueryAndResponse(0 /* id */, kT4HostName, kT4Qtype, kT4ResponseDatagram,
  3400. std::size(kT4ResponseDatagram), ASYNC, Transport::HTTPS,
  3401. nullptr /* opt_rdata */,
  3402. DnsQuery::PaddingStrategy::BLOCK_LENGTH_128,
  3403. false /* enqueue_transaction_id */);
  3404. std::unique_ptr<DnsProbeRunner> runner =
  3405. transaction_factory_->CreateDohProbeRunner(resolve_context_.get());
  3406. runner->Start(true /* network_change */);
  3407. // The first probe happens without any delay and succeeds.
  3408. RunUntilIdle();
  3409. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3410. 0u /* doh_server_index */, session_.get()));
  3411. base::TimeDelta scheduled_delay = runner->GetDelayUntilNextProbeForTest(0);
  3412. EXPECT_GT(scheduled_delay, base::TimeDelta());
  3413. // Mark server unavailabe and restart runner. Note that restarting the runner
  3414. // is unnecessary, but a Start() call should always happen on a server
  3415. // becoming unavailable and might as well replecate real behavior for the
  3416. // test.
  3417. for (int i = 0; i < ResolveContext::kAutomaticModeFailureLimit; ++i) {
  3418. resolve_context_->RecordServerFailure(0u /* server_index */,
  3419. true /* is_doh_server */, ERR_FAILED,
  3420. session_.get());
  3421. }
  3422. ASSERT_FALSE(resolve_context_->GetDohServerAvailability(
  3423. 0u /* doh_server_index */, session_.get()));
  3424. runner->Start(false /* network_change */);
  3425. // Probe should not run until scheduled delay.
  3426. RunUntilIdle();
  3427. EXPECT_FALSE(resolve_context_->GetDohServerAvailability(
  3428. 0u /* doh_server_index */, session_.get()));
  3429. // Expect the probe to run again and succeed after scheduled delay.
  3430. FastForwardBy(scheduled_delay);
  3431. EXPECT_TRUE(resolve_context_->GetDohServerAvailability(
  3432. 0u /* doh_server_index */, session_.get()));
  3433. }
  3434. // Test that queries cannot be sent when they contain a too-long name.
  3435. // Tests against incorrect name length validation, which is anti-pattern #3 from
  3436. // the "NAME:WRECK" report:
  3437. // https://www.forescout.com/company/resources/namewreck-breaking-and-fixing-dns-implementations/
  3438. TEST_F(DnsTransactionTestWithMockTime, RejectsQueryingLongNames) {
  3439. std::string long_dotted_name;
  3440. while (long_dotted_name.size() <= dns_protocol::kMaxNameLength) {
  3441. long_dotted_name.append("naaaaaamelabel.");
  3442. }
  3443. long_dotted_name.append("test");
  3444. TransactionHelper helper0(ERR_INVALID_ARGUMENT);
  3445. helper0.StartTransaction(transaction_factory_.get(), long_dotted_name.c_str(),
  3446. dns_protocol::kTypeA, false /* secure */,
  3447. resolve_context_.get());
  3448. helper0.RunUntilComplete();
  3449. }
  3450. // Test that ERR_CONNECTION_REFUSED error after fallback of DnsTCPAttempt
  3451. // should not cause DCHECK failure (https://crbug.com/1334250).
  3452. TEST_F(DnsTransactionTestWithMockTime, TcpConnectionRefusedAfterFallback) {
  3453. ConfigureNumServers(2);
  3454. ConfigureFactory();
  3455. socket_factory_->diverse_source_ports_ = false;
  3456. // Data for UDP attempts to set `low_entropy` flag.
  3457. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  3458. AddQueryAndResponse(0 /* id */, kT0HostName, kT0Qtype, kT0ResponseDatagram,
  3459. std::size(kT0ResponseDatagram), ASYNC, Transport::UDP);
  3460. }
  3461. // Data for TCP attempt.
  3462. auto data1 = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName,
  3463. kT0Qtype, ASYNC, Transport::TCP);
  3464. data1->AddReadError(ERR_IO_PENDING, ASYNC);
  3465. data1->AddReadError(ERR_CONNECTION_REFUSED, ASYNC);
  3466. SequencedSocketData* sequenced_socket_data1 = data1->GetProvider();
  3467. AddSocketData(std::move(data1));
  3468. auto data2 = std::make_unique<DnsSocketData>(0 /* id */, kT0HostName,
  3469. kT0Qtype, ASYNC, Transport::TCP);
  3470. data2->AddReadError(ERR_IO_PENDING, ASYNC);
  3471. data2->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  3472. ASYNC);
  3473. SequencedSocketData* sequenced_socket_data2 = data2->GetProvider();
  3474. AddSocketData(std::move(data2));
  3475. // DNS transactions for UDP attempts to set `low_entropy` flag.
  3476. for (int i = 0; i <= DnsUdpTracker::kPortReuseThreshold; ++i) {
  3477. TransactionHelper udp_helper(kT0RecordCount);
  3478. udp_helper.StartTransaction(transaction_factory_.get(), kT0HostName,
  3479. kT0Qtype, false /* secure */,
  3480. resolve_context_.get());
  3481. udp_helper.RunUntilComplete();
  3482. }
  3483. ASSERT_TRUE(session_->udp_tracker()->low_entropy());
  3484. // DNS transactions for TCP attempt.
  3485. TransactionHelper helper0(kT0RecordCount);
  3486. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  3487. false /* secure */, resolve_context_.get());
  3488. base::RunLoop().RunUntilIdle();
  3489. EXPECT_FALSE(helper0.has_completed());
  3490. base::TimeDelta timeout = resolve_context_->NextClassicFallbackPeriod(
  3491. 0 /* classic_server_index */, 0 /* attempt */, session_.get());
  3492. FastForwardBy(timeout);
  3493. // Resume the first query.
  3494. sequenced_socket_data1->Resume();
  3495. base::RunLoop().RunUntilIdle();
  3496. EXPECT_FALSE(helper0.has_completed());
  3497. // Resume the second query.
  3498. sequenced_socket_data2->Resume();
  3499. base::RunLoop().RunUntilIdle();
  3500. EXPECT_TRUE(helper0.has_completed());
  3501. }
  3502. // Test that ERR_CONNECTION_REFUSED error after fallback of DnsHTTPAttempt
  3503. // should not cause DCHECK failure (https://crbug.com/1334250).
  3504. TEST_F(DnsTransactionTestWithMockTime, HttpsConnectionRefusedAfterFallback) {
  3505. ConfigureDohServers(false /* use_post */, 2 /* num_doh_servers */,
  3506. true /* make_available */);
  3507. auto data1 = std::make_unique<DnsSocketData>(
  3508. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  3509. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  3510. data1->AddReadError(ERR_IO_PENDING, ASYNC);
  3511. data1->AddReadError(ERR_CONNECTION_REFUSED, ASYNC);
  3512. SequencedSocketData* sequenced_socket_data1 = data1->GetProvider();
  3513. AddSocketData(std::move(data1), false /* enqueue_transaction_id */);
  3514. auto data2 = std::make_unique<DnsSocketData>(
  3515. 0 /* id */, kT0HostName, kT0Qtype, ASYNC, Transport::HTTPS,
  3516. nullptr /* opt_rdata */, DnsQuery::PaddingStrategy::BLOCK_LENGTH_128);
  3517. data2->AddReadError(ERR_IO_PENDING, ASYNC);
  3518. data2->AddResponseData(kT0ResponseDatagram, std::size(kT0ResponseDatagram),
  3519. ASYNC);
  3520. SequencedSocketData* sequenced_socket_data2 = data2->GetProvider();
  3521. AddSocketData(std::move(data2), false /* enqueue_transaction_id */);
  3522. TransactionHelper helper0(kT0RecordCount);
  3523. helper0.StartTransaction(transaction_factory_.get(), kT0HostName, kT0Qtype,
  3524. true /* secure */, resolve_context_.get());
  3525. base::RunLoop().RunUntilIdle();
  3526. EXPECT_FALSE(helper0.has_completed());
  3527. base::TimeDelta timeout = resolve_context_->NextDohFallbackPeriod(
  3528. 0 /* doh_server_index */, session_.get());
  3529. FastForwardBy(timeout);
  3530. // Resume the first query.
  3531. sequenced_socket_data1->Resume();
  3532. base::RunLoop().RunUntilIdle();
  3533. EXPECT_FALSE(helper0.has_completed());
  3534. // Resume the second query.
  3535. sequenced_socket_data2->Resume();
  3536. EXPECT_TRUE(helper0.has_completed());
  3537. }
  3538. } // namespace
  3539. } // namespace net