netwerk/test/unit/test_http3_fast_fallback.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 "use strict";
   6
   7 var { setTimeout } = ChromeUtils.importESModule(
   8   "resource://gre/modules/Timer.sys.mjs"
   9 );
  10
  11 let h2Port;
  12 let h3Port;
  13 let trrServer;
  14
  15 const { TestUtils } = ChromeUtils.importESModule(
  16   "resource://testing-common/TestUtils.sys.mjs"
  17 );
  18 const certOverrideService = Cc[
  19   "@mozilla.org/security/certoverride;1"
  20 ].getService(Ci.nsICertOverrideService);
  21
  22 add_setup(async function setup() {
  23   h2Port = Services.env.get("MOZHTTP2_PORT");
  24   Assert.notEqual(h2Port, null);
  25   Assert.notEqual(h2Port, "");
  26
  27   h3Port = Services.env.get("MOZHTTP3_PORT_NO_RESPONSE");
  28   Assert.notEqual(h3Port, null);
  29   Assert.notEqual(h3Port, "");
  30
  31   trr_test_setup();
  32
  33   if (mozinfo.socketprocess_networking) {
  34     Services.dns; // Needed to trigger socket process.
  35     await TestUtils.waitForCondition(() => Services.io.socketProcessLaunched);
  36   }
  37
  38   Services.prefs.setIntPref("network.trr.mode", 2); // TRR first
  39   Services.prefs.setBoolPref("network.http.http3.enable", true);
  40   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
  41   Services.prefs.setBoolPref(
  42     "network.dns.https_rr.check_record_with_cname",
  43     false
  44   );
  45
  46   registerCleanupFunction(async () => {
  47     trr_clear_prefs();
  48     Services.prefs.clearUserPref("network.dns.upgrade_with_https_rr");
  49     Services.prefs.clearUserPref("network.dns.use_https_rr_as_altsvc");
  50     Services.prefs.clearUserPref("network.dns.echconfig.enabled");
  51     Services.prefs.clearUserPref("network.dns.http3_echconfig.enabled");
  52     Services.prefs.clearUserPref(
  53       "network.dns.echconfig.fallback_to_origin_when_all_failed"
  54     );
  55     Services.prefs.clearUserPref("network.dns.httpssvc.reset_exclustion_list");
  56     Services.prefs.clearUserPref("network.http.http3.enable");
  57     Services.prefs.clearUserPref(
  58       "network.dns.httpssvc.http3_fast_fallback_timeout"
  59     );
  60     Services.prefs.clearUserPref(
  61       "network.http.http3.alt-svc-mapping-for-testing"
  62     );
  63     Services.prefs.clearUserPref("network.http.http3.backup_timer_delay");
  64     Services.prefs.clearUserPref("network.http.speculative-parallel-limit");
  65     Services.prefs.clearUserPref(
  66       "network.http.http3.parallel_fallback_conn_limit"
  67     );
  68     Services.prefs.clearUserPref(
  69       "network.dns.https_rr.check_record_with_cname"
  70     );
  71     if (trrServer) {
  72       await trrServer.stop();
  73     }
  74   });
  75 });
  76
  77 function makeChan(url) {
  78   let chan = NetUtil.newChannel({
  79     uri: url,
  80     loadUsingSystemPrincipal: true,
  81     contentPolicyType: Ci.nsIContentPolicy.TYPE_DOCUMENT,
  82   }).QueryInterface(Ci.nsIHttpChannel);
  83   chan.loadFlags = Ci.nsIChannel.LOAD_INITIAL_DOCUMENT_URI;
  84   return chan;
  85 }
  86
  87 function channelOpenPromise(chan, flags, delay) {
  88   // eslint-disable-next-line no-async-promise-executor
  89   return new Promise(async resolve => {
  90     function finish(req, buffer) {
  91       resolve([req, buffer]);
  92       certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(
  93         false
  94       );
  95     }
  96     certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(
  97       true
  98     );
  99     if (delay) {
 100       // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 101       await new Promise(r => setTimeout(r, delay));
 102     }
 103     chan.asyncOpen(new ChannelListener(finish, null, flags));
 104   });
 105 }
 106
 107 let CheckOnlyHttp2Listener = function () {};
 108
 109 CheckOnlyHttp2Listener.prototype = {
 110   onStartRequest: function testOnStartRequest() {},
 111
 112   onDataAvailable: function testOnDataAvailable(request, stream, off, cnt) {
 113     read_stream(stream, cnt);
 114   },
 115
 116   onStopRequest: function testOnStopRequest(request, status) {
 117     Assert.equal(status, Cr.NS_OK);
 118     let httpVersion = "";
 119     try {
 120       httpVersion = request.protocolVersion;
 121     } catch (e) {}
 122     Assert.equal(httpVersion, "h2");
 123
 124     let routed = "NA";
 125     try {
 126       routed = request.getRequestHeader("Alt-Used");
 127     } catch (e) {}
 128     dump("routed is " + routed + "\n");
 129     Assert.ok(routed === "0" || routed === "NA");
 130     this.finish();
 131   },
 132 };
 133
 134 async function fast_fallback_test() {
 135   let result = 1;
 136   // We need to loop here because we need to wait for AltSvc storage to
 137   // to be started.
 138   // We also do not have a way to verify that HTTP3 has been tried, because
 139   // the fallback is automatic, so try a couple of times.
 140   do {
 141     // We need to close HTTP2 connections, otherwise our connection pooling
 142     // will dispatch the request over already existing HTTP2 connection.
 143     Services.obs.notifyObservers(null, "net:prune-all-connections");
 144     let chan = makeChan(`https://foo.example.com:${h2Port}/`);
 145     let listener = new CheckOnlyHttp2Listener();
 146     await altsvcSetupPromise(chan, listener);
 147     result++;
 148   } while (result < 3);
 149 }
 150
 151 // Test the case when speculative connection is enabled. In this case, when the
 152 // backup connection is ready, the http transaction is still in pending
 153 // queue because the h3 connection is never ready to accept transactions.
 154 add_task(async function test_fast_fallback_with_speculative_connection() {
 155   Services.prefs.setBoolPref("network.http.http3.enable", true);
 156   Services.prefs.setCharPref("network.dns.localDomains", "foo.example.com");
 157   // Set AltSvc to point to not existing HTTP3 server on port 443
 158   Services.prefs.setCharPref(
 159     "network.http.http3.alt-svc-mapping-for-testing",
 160     "foo.example.com;h3=:" + h3Port
 161   );
 162   Services.prefs.setBoolPref("network.dns.disableIPv6", true);
 163   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
 164
 165   await fast_fallback_test();
 166 });
 167
 168 // Test the case when speculative connection is disabled. In this case, when the
 169 // back connection is ready, the http transaction is already activated,
 170 // but the socket is not ready to write.
 171 add_task(async function test_fast_fallback_without_speculative_connection() {
 172   // Make sure the h3 connection created by the previous test is cleared.
 173   Services.obs.notifyObservers(null, "net:cancel-all-connections");
 174   // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 175   await new Promise(resolve => setTimeout(resolve, 1000));
 176   // Clear the h3 excluded list, otherwise the Alt-Svc mapping will not be used.
 177   Services.obs.notifyObservers(null, "network:reset-http3-excluded-list");
 178   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 0);
 179
 180   await fast_fallback_test();
 181
 182   Services.prefs.clearUserPref(
 183     "network.http.http3.alt-svc-mapping-for-testing"
 184   );
 185 });
 186
 187 // Test when echConfig is disabled and we have https rr for http3. We use a
 188 // longer timeout in this test, so when fast fallback timer is triggered, the
 189 // http transaction is already activated.
 190 add_task(async function testFastfallback() {
 191   trrServer = new TRRServer();
 192   await trrServer.start();
 193   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 194   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 195   Services.prefs.setBoolPref("network.dns.echconfig.enabled", false);
 196
 197   Services.prefs.setIntPref("network.trr.mode", 3);
 198   Services.prefs.setCharPref(
 199     "network.trr.uri",
 200     `https://foo.example.com:${trrServer.port()}/dns-query`
 201   );
 202   Services.prefs.setBoolPref("network.http.http3.enable", true);
 203
 204   Services.prefs.setIntPref(
 205     "network.dns.httpssvc.http3_fast_fallback_timeout",
 206     1000
 207   );
 208
 209   await trrServer.registerDoHAnswers("test.fastfallback.com", "HTTPS", {
 210     answers: [
 211       {
 212         name: "test.fastfallback.com",
 213         ttl: 55,
 214         type: "HTTPS",
 215         flush: false,
 216         data: {
 217           priority: 1,
 218           name: "test.fastfallback1.com",
 219           values: [
 220             { key: "alpn", value: "h3" },
 221             { key: "no-default-alpn" },
 222             { key: "port", value: h3Port },
 223             { key: "echconfig", value: "456..." },
 224           ],
 225         },
 226       },
 227       {
 228         name: "test.fastfallback.com",
 229         ttl: 55,
 230         type: "HTTPS",
 231         flush: false,
 232         data: {
 233           priority: 2,
 234           name: "test.fastfallback2.com",
 235           values: [
 236             { key: "alpn", value: "h2" },
 237             { key: "port", value: h2Port },
 238             { key: "echconfig", value: "456..." },
 239           ],
 240         },
 241       },
 242     ],
 243   });
 244
 245   await trrServer.registerDoHAnswers("test.fastfallback1.com", "A", {
 246     answers: [
 247       {
 248         name: "test.fastfallback1.com",
 249         ttl: 55,
 250         type: "A",
 251         flush: false,
 252         data: "127.0.0.1",
 253       },
 254     ],
 255   });
 256
 257   await trrServer.registerDoHAnswers("test.fastfallback2.com", "A", {
 258     answers: [
 259       {
 260         name: "test.fastfallback2.com",
 261         ttl: 55,
 262         type: "A",
 263         flush: false,
 264         data: "127.0.0.1",
 265       },
 266     ],
 267   });
 268
 269   let chan = makeChan(`https://test.fastfallback.com/server-timing`);
 270   let [req] = await channelOpenPromise(chan);
 271   Assert.equal(req.protocolVersion, "h2");
 272   let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 273   Assert.equal(internal.remotePort, h2Port);
 274
 275   await trrServer.stop();
 276 });
 277
 278 // Like the previous test, but with a shorter timeout, so when fast fallback
 279 // timer is triggered, the http transaction is still in pending queue.
 280 add_task(async function testFastfallback1() {
 281   trrServer = new TRRServer();
 282   await trrServer.start();
 283   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 284   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 285   Services.prefs.setBoolPref("network.dns.echconfig.enabled", false);
 286
 287   Services.prefs.setIntPref("network.trr.mode", 3);
 288   Services.prefs.setCharPref(
 289     "network.trr.uri",
 290     `https://foo.example.com:${trrServer.port()}/dns-query`
 291   );
 292   Services.prefs.setBoolPref("network.http.http3.enable", true);
 293
 294   Services.prefs.setIntPref(
 295     "network.dns.httpssvc.http3_fast_fallback_timeout",
 296     10
 297   );
 298
 299   await trrServer.registerDoHAnswers("test.fastfallback.org", "HTTPS", {
 300     answers: [
 301       {
 302         name: "test.fastfallback.org",
 303         ttl: 55,
 304         type: "HTTPS",
 305         flush: false,
 306         data: {
 307           priority: 1,
 308           name: "test.fastfallback1.org",
 309           values: [
 310             { key: "alpn", value: "h3" },
 311             { key: "no-default-alpn" },
 312             { key: "port", value: h3Port },
 313             { key: "echconfig", value: "456..." },
 314           ],
 315         },
 316       },
 317       {
 318         name: "test.fastfallback.org",
 319         ttl: 55,
 320         type: "HTTPS",
 321         flush: false,
 322         data: {
 323           priority: 2,
 324           name: "test.fastfallback2.org",
 325           values: [
 326             { key: "alpn", value: "h2" },
 327             { key: "port", value: h2Port },
 328             { key: "echconfig", value: "456..." },
 329           ],
 330         },
 331       },
 332     ],
 333   });
 334
 335   await trrServer.registerDoHAnswers("test.fastfallback1.org", "A", {
 336     answers: [
 337       {
 338         name: "test.fastfallback1.org",
 339         ttl: 55,
 340         type: "A",
 341         flush: false,
 342         data: "127.0.0.1",
 343       },
 344     ],
 345   });
 346
 347   await trrServer.registerDoHAnswers("test.fastfallback2.org", "A", {
 348     answers: [
 349       {
 350         name: "test.fastfallback2.org",
 351         ttl: 55,
 352         type: "A",
 353         flush: false,
 354         data: "127.0.0.1",
 355       },
 356     ],
 357   });
 358
 359   let chan = makeChan(`https://test.fastfallback.org/server-timing`);
 360   let [req] = await channelOpenPromise(chan);
 361   Assert.equal(req.protocolVersion, "h2");
 362   let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 363   Assert.equal(internal.remotePort, h2Port);
 364
 365   await trrServer.stop();
 366 });
 367
 368 // Test when echConfig is enabled, we can sucessfully fallback to the last
 369 // record.
 370 add_task(async function testFastfallbackWithEchConfig() {
 371   trrServer = new TRRServer();
 372   await trrServer.start();
 373   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 374   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 375   Services.prefs.setBoolPref("network.dns.echconfig.enabled", true);
 376   Services.prefs.setBoolPref("network.dns.http3_echconfig.enabled", true);
 377
 378   Services.prefs.setIntPref("network.trr.mode", 3);
 379   Services.prefs.setCharPref(
 380     "network.trr.uri",
 381     `https://foo.example.com:${trrServer.port()}/dns-query`
 382   );
 383   Services.prefs.setBoolPref("network.http.http3.enable", true);
 384
 385   Services.prefs.setIntPref(
 386     "network.dns.httpssvc.http3_fast_fallback_timeout",
 387     50
 388   );
 389
 390   await trrServer.registerDoHAnswers("test.ech.org", "HTTPS", {
 391     answers: [
 392       {
 393         name: "test.ech.org",
 394         ttl: 55,
 395         type: "HTTPS",
 396         flush: false,
 397         data: {
 398           priority: 1,
 399           name: "test.ech1.org",
 400           values: [
 401             { key: "alpn", value: "h3" },
 402             { key: "port", value: h3Port },
 403             { key: "echconfig", value: "456..." },
 404           ],
 405         },
 406       },
 407       {
 408         name: "test.ech.org",
 409         ttl: 55,
 410         type: "HTTPS",
 411         flush: false,
 412         data: {
 413           priority: 2,
 414           name: "test.ech2.org",
 415           values: [
 416             { key: "alpn", value: "h2" },
 417             { key: "port", value: h2Port },
 418             { key: "echconfig", value: "456..." },
 419           ],
 420         },
 421       },
 422       {
 423         name: "test.ech.org",
 424         ttl: 55,
 425         type: "HTTPS",
 426         flush: false,
 427         data: {
 428           priority: 3,
 429           name: "test.ech3.org",
 430           values: [
 431             { key: "alpn", value: "h2" },
 432             { key: "port", value: h2Port },
 433             { key: "echconfig", value: "456..." },
 434           ],
 435         },
 436       },
 437     ],
 438   });
 439
 440   await trrServer.registerDoHAnswers("test.ech1.org", "A", {
 441     answers: [
 442       {
 443         name: "test.ech1.org",
 444         ttl: 55,
 445         type: "A",
 446         flush: false,
 447         data: "127.0.0.1",
 448       },
 449     ],
 450   });
 451
 452   await trrServer.registerDoHAnswers("test.ech3.org", "A", {
 453     answers: [
 454       {
 455         name: "test.ech3.org",
 456         ttl: 55,
 457         type: "A",
 458         flush: false,
 459         data: "127.0.0.1",
 460       },
 461     ],
 462   });
 463
 464   let chan = makeChan(`https://test.ech.org/server-timing`);
 465   let [req] = await channelOpenPromise(chan);
 466   Assert.equal(req.protocolVersion, "h2");
 467   let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 468   Assert.equal(internal.remotePort, h2Port);
 469
 470   await trrServer.stop();
 471 });
 472
 473 // Test when echConfig is enabled, the connection should fail when not all
 474 // records have echConfig.
 475 add_task(async function testFastfallbackWithpartialEchConfig() {
 476   trrServer = new TRRServer();
 477   await trrServer.start();
 478   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 479   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 480   Services.prefs.setBoolPref("network.dns.echconfig.enabled", true);
 481   Services.prefs.setBoolPref("network.dns.http3_echconfig.enabled", true);
 482
 483   Services.prefs.setIntPref("network.trr.mode", 3);
 484   Services.prefs.setCharPref(
 485     "network.trr.uri",
 486     `https://foo.example.com:${trrServer.port()}/dns-query`
 487   );
 488   Services.prefs.setBoolPref("network.http.http3.enable", true);
 489
 490   Services.prefs.setIntPref(
 491     "network.dns.httpssvc.http3_fast_fallback_timeout",
 492     50
 493   );
 494
 495   await trrServer.registerDoHAnswers("test.partial_ech.org", "HTTPS", {
 496     answers: [
 497       {
 498         name: "test.partial_ech.org",
 499         ttl: 55,
 500         type: "HTTPS",
 501         flush: false,
 502         data: {
 503           priority: 1,
 504           name: "test.partial_ech1.org",
 505           values: [
 506             { key: "alpn", value: "h3" },
 507             { key: "port", value: h3Port },
 508             { key: "echconfig", value: "456..." },
 509           ],
 510         },
 511       },
 512       {
 513         name: "test.partial_ech.org",
 514         ttl: 55,
 515         type: "HTTPS",
 516         flush: false,
 517         data: {
 518           priority: 2,
 519           name: "test.partial_ech2.org",
 520           values: [
 521             { key: "alpn", value: "h2" },
 522             { key: "port", value: h2Port },
 523           ],
 524         },
 525       },
 526     ],
 527   });
 528
 529   await trrServer.registerDoHAnswers("test.partial_ech1.org", "A", {
 530     answers: [
 531       {
 532         name: "test.partial_ech1.org",
 533         ttl: 55,
 534         type: "A",
 535         flush: false,
 536         data: "127.0.0.1",
 537       },
 538     ],
 539   });
 540
 541   await trrServer.registerDoHAnswers("test.partial_ech2.org", "A", {
 542     answers: [
 543       {
 544         name: "test.partial_ech2.org",
 545         ttl: 55,
 546         type: "A",
 547         flush: false,
 548         data: "127.0.0.1",
 549       },
 550     ],
 551   });
 552
 553   let chan = makeChan(`https://test.partial_ech.org/server-timing`);
 554   await channelOpenPromise(chan, CL_EXPECT_LATE_FAILURE | CL_ALLOW_UNKNOWN_CL);
 555
 556   await trrServer.stop();
 557 });
 558
 559 add_task(async function testFastfallbackWithoutEchConfig() {
 560   trrServer = new TRRServer();
 561   await trrServer.start();
 562   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 563   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 564
 565   Services.prefs.setIntPref("network.trr.mode", 3);
 566   Services.prefs.setCharPref(
 567     "network.trr.uri",
 568     `https://foo.example.com:${trrServer.port()}/dns-query`
 569   );
 570   Services.prefs.setBoolPref("network.http.http3.enable", true);
 571
 572   Services.prefs.setIntPref(
 573     "network.dns.httpssvc.http3_fast_fallback_timeout",
 574     50
 575   );
 576
 577   await trrServer.registerDoHAnswers("test.no_ech_h2.org", "HTTPS", {
 578     answers: [
 579       {
 580         name: "test.no_ech_h2.org",
 581         ttl: 55,
 582         type: "HTTPS",
 583         flush: false,
 584         data: {
 585           priority: 1,
 586           name: "test.no_ech_h3.org",
 587           values: [
 588             { key: "alpn", value: "h3" },
 589             { key: "port", value: h3Port },
 590           ],
 591         },
 592       },
 593     ],
 594   });
 595
 596   await trrServer.registerDoHAnswers("test.no_ech_h3.org", "A", {
 597     answers: [
 598       {
 599         name: "test.no_ech_h3.org",
 600         ttl: 55,
 601         type: "A",
 602         flush: false,
 603         data: "127.0.0.1",
 604       },
 605     ],
 606   });
 607
 608   await trrServer.registerDoHAnswers("test.no_ech_h2.org", "A", {
 609     answers: [
 610       {
 611         name: "test.no_ech_h2.org",
 612         ttl: 55,
 613         type: "A",
 614         flush: false,
 615         data: "127.0.0.1",
 616       },
 617     ],
 618   });
 619
 620   let chan = makeChan(`https://test.no_ech_h2.org:${h2Port}/server-timing`);
 621   let [req] = await channelOpenPromise(chan);
 622   Assert.equal(req.protocolVersion, "h2");
 623   let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 624   Assert.equal(internal.remotePort, h2Port);
 625
 626   await trrServer.stop();
 627 });
 628
 629 add_task(async function testH3FallbackWithMultipleTransactions() {
 630   trrServer = new TRRServer();
 631   await trrServer.start();
 632   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 633   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 634   Services.prefs.setBoolPref("network.dns.echconfig.enabled", false);
 635
 636   Services.prefs.setIntPref("network.trr.mode", 3);
 637   Services.prefs.setCharPref(
 638     "network.trr.uri",
 639     `https://foo.example.com:${trrServer.port()}/dns-query`
 640   );
 641   Services.prefs.setBoolPref("network.http.http3.enable", true);
 642
 643   // Disable fast fallback.
 644   Services.prefs.setIntPref(
 645     "network.http.http3.parallel_fallback_conn_limit",
 646     0
 647   );
 648   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 0);
 649
 650   await trrServer.registerDoHAnswers("test.multiple_trans.org", "HTTPS", {
 651     answers: [
 652       {
 653         name: "test.multiple_trans.org",
 654         ttl: 55,
 655         type: "HTTPS",
 656         flush: false,
 657         data: {
 658           priority: 1,
 659           name: "test.multiple_trans.org",
 660           values: [
 661             { key: "alpn", value: "h3" },
 662             { key: "port", value: h3Port },
 663           ],
 664         },
 665       },
 666     ],
 667   });
 668
 669   await trrServer.registerDoHAnswers("test.multiple_trans.org", "A", {
 670     answers: [
 671       {
 672         name: "test.multiple_trans.org",
 673         ttl: 55,
 674         type: "A",
 675         flush: false,
 676         data: "127.0.0.1",
 677       },
 678     ],
 679   });
 680
 681   let promises = [];
 682   for (let i = 0; i < 2; ++i) {
 683     let chan = makeChan(
 684       `https://test.multiple_trans.org:${h2Port}/server-timing`
 685     );
 686     promises.push(channelOpenPromise(chan));
 687   }
 688
 689   let res = await Promise.all(promises);
 690   res.forEach(function (e) {
 691     let [req] = e;
 692     Assert.equal(req.protocolVersion, "h2");
 693     let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 694     Assert.equal(internal.remotePort, h2Port);
 695   });
 696
 697   await trrServer.stop();
 698 });
 699
 700 add_task(async function testTwoFastFallbackTimers() {
 701   trrServer = new TRRServer();
 702   await trrServer.start();
 703   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 704   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 705   Services.prefs.setBoolPref("network.dns.echconfig.enabled", false);
 706
 707   Services.prefs.setIntPref("network.trr.mode", 3);
 708   Services.prefs.setCharPref(
 709     "network.trr.uri",
 710     `https://foo.example.com:${trrServer.port()}/dns-query`
 711   );
 712   Services.prefs.setBoolPref("network.http.http3.enable", true);
 713
 714   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
 715   Services.prefs.clearUserPref(
 716     "network.http.http3.parallel_fallback_conn_limit"
 717   );
 718
 719   Services.prefs.setCharPref(
 720     "network.http.http3.alt-svc-mapping-for-testing",
 721     "foo.fallback.org;h3=:" + h3Port
 722   );
 723
 724   Services.prefs.setIntPref(
 725     "network.dns.httpssvc.http3_fast_fallback_timeout",
 726     10
 727   );
 728   Services.prefs.setIntPref("network.http.http3.backup_timer_delay", 100);
 729
 730   await trrServer.registerDoHAnswers("foo.fallback.org", "HTTPS", {
 731     answers: [
 732       {
 733         name: "foo.fallback.org",
 734         ttl: 55,
 735         type: "HTTPS",
 736         flush: false,
 737         data: {
 738           priority: 1,
 739           name: "foo.fallback.org",
 740           values: [
 741             { key: "alpn", value: "h3" },
 742             { key: "port", value: h3Port },
 743           ],
 744         },
 745       },
 746     ],
 747   });
 748
 749   await trrServer.registerDoHAnswers("foo.fallback.org", "A", {
 750     answers: [
 751       {
 752         name: "foo.fallback.org",
 753         ttl: 55,
 754         type: "A",
 755         flush: false,
 756         data: "127.0.0.1",
 757       },
 758     ],
 759   });
 760
 761   // Test the case that http3 backup timer is triggered after
 762   // fast fallback timer or HTTPS RR.
 763   Services.prefs.setIntPref(
 764     "network.dns.httpssvc.http3_fast_fallback_timeout",
 765     10
 766   );
 767   Services.prefs.setIntPref("network.http.http3.backup_timer_delay", 100);
 768
 769   async function createChannelAndStartTest() {
 770     let chan = makeChan(`https://foo.fallback.org:${h2Port}/server-timing`);
 771     let [req] = await channelOpenPromise(chan);
 772     Assert.equal(req.protocolVersion, "h2");
 773     let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 774     Assert.equal(internal.remotePort, h2Port);
 775   }
 776
 777   await createChannelAndStartTest();
 778
 779   Services.obs.notifyObservers(null, "net:prune-all-connections");
 780   Services.obs.notifyObservers(null, "network:reset-http3-excluded-list");
 781   Services.dns.clearCache(true);
 782
 783   // Do the same test again, but with a different configuration.
 784   Services.prefs.setIntPref(
 785     "network.dns.httpssvc.http3_fast_fallback_timeout",
 786     100
 787   );
 788   Services.prefs.setIntPref("network.http.http3.backup_timer_delay", 10);
 789
 790   await createChannelAndStartTest();
 791
 792   await trrServer.stop();
 793 });
 794
 795 add_task(async function testH3FastFallbackWithMultipleTransactions() {
 796   trrServer = new TRRServer();
 797   await trrServer.start();
 798   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 799   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 800   Services.prefs.setBoolPref("network.dns.echconfig.enabled", false);
 801
 802   Services.prefs.setIntPref("network.trr.mode", 3);
 803   Services.prefs.setCharPref(
 804     "network.trr.uri",
 805     `https://foo.example.com:${trrServer.port()}/dns-query`
 806   );
 807   Services.prefs.setBoolPref("network.http.http3.enable", true);
 808
 809   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
 810   Services.prefs.clearUserPref(
 811     "network.http.http3.parallel_fallback_conn_limit"
 812   );
 813
 814   Services.prefs.setIntPref("network.http.http3.backup_timer_delay", 500);
 815
 816   Services.prefs.setCharPref(
 817     "network.http.http3.alt-svc-mapping-for-testing",
 818     "test.multiple_fallback_trans.org;h3=:" + h3Port
 819   );
 820
 821   await trrServer.registerDoHAnswers("test.multiple_fallback_trans.org", "A", {
 822     answers: [
 823       {
 824         name: "test.multiple_fallback_trans.org",
 825         ttl: 55,
 826         type: "A",
 827         flush: false,
 828         data: "127.0.0.1",
 829       },
 830     ],
 831   });
 832
 833   let promises = [];
 834   for (let i = 0; i < 3; ++i) {
 835     let chan = makeChan(
 836       `https://test.multiple_fallback_trans.org:${h2Port}/server-timing`
 837     );
 838     if (i == 0) {
 839       promises.push(channelOpenPromise(chan));
 840     } else {
 841       promises.push(channelOpenPromise(chan, null, 500));
 842     }
 843   }
 844
 845   let res = await Promise.all(promises);
 846   res.forEach(function (e) {
 847     let [req] = e;
 848     Assert.equal(req.protocolVersion, "h2");
 849     let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 850     Assert.equal(internal.remotePort, h2Port);
 851   });
 852
 853   await trrServer.stop();
 854 });
 855
 856 add_task(async function testFastfallbackToTheSameRecord() {
 857   trrServer = new TRRServer();
 858   await trrServer.start();
 859   Services.prefs.setBoolPref("network.dns.upgrade_with_https_rr", true);
 860   Services.prefs.setBoolPref("network.dns.use_https_rr_as_altsvc", true);
 861   Services.prefs.setBoolPref("network.dns.echconfig.enabled", true);
 862   Services.prefs.setBoolPref("network.dns.http3_echconfig.enabled", true);
 863
 864   Services.prefs.setIntPref("network.trr.mode", 3);
 865   Services.prefs.setCharPref(
 866     "network.trr.uri",
 867     `https://foo.example.com:${trrServer.port()}/dns-query`
 868   );
 869   Services.prefs.setBoolPref("network.http.http3.enable", true);
 870
 871   Services.prefs.setIntPref(
 872     "network.dns.httpssvc.http3_fast_fallback_timeout",
 873     1000
 874   );
 875
 876   await trrServer.registerDoHAnswers("test.ech.org", "HTTPS", {
 877     answers: [
 878       {
 879         name: "test.ech.org",
 880         ttl: 55,
 881         type: "HTTPS",
 882         flush: false,
 883         data: {
 884           priority: 1,
 885           name: "test.ech1.org",
 886           values: [
 887             { key: "alpn", value: ["h3", "h2"] },
 888             { key: "port", value: h2Port },
 889             { key: "echconfig", value: "456..." },
 890           ],
 891         },
 892       },
 893     ],
 894   });
 895
 896   await trrServer.registerDoHAnswers("test.ech1.org", "A", {
 897     answers: [
 898       {
 899         name: "test.ech1.org",
 900         ttl: 55,
 901         type: "A",
 902         flush: false,
 903         data: "127.0.0.1",
 904       },
 905     ],
 906   });
 907
 908   let chan = makeChan(`https://test.ech.org/server-timing`);
 909   let [req] = await channelOpenPromise(chan);
 910   Assert.equal(req.protocolVersion, "h2");
 911   let internal = req.QueryInterface(Ci.nsIHttpChannelInternal);
 912   Assert.equal(internal.remotePort, h2Port);
 913
 914   await trrServer.stop();
 915 });