tor-browser

test_http3_proxy_ipv6_fallback.js (5771B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

var { setTimeout } = ChromeUtils.importESModule(
 "resource://gre/modules/Timer.sys.mjs"
);

const { Http3ProxyFilter, NodeHTTP2Server, NodeHTTP2ProxyServer } =
 ChromeUtils.importESModule("resource://testing-common/NodeServer.sys.mjs");

let pps = Cc["@mozilla.org/network/protocol-proxy-service;1"].getService();
let trrServer;
let proxyFilter;
let proxyPort;
let proxyHost;
let serverPort;

add_setup(async function setup() {
 trr_test_setup();

 if (mozinfo.socketprocess_networking) {
   Cc["@mozilla.org/network/protocol;1?name=http"].getService(
     Ci.nsIHttpProtocolHandler
   );
   Services.dns; // Needed to trigger socket process.
   // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
   await new Promise(resolve => setTimeout(resolve, 1000));
 }

 Services.prefs.setBoolPref("network.http.http3.enable", true);
 Services.prefs.setBoolPref(
   "network.http.http3.block_loopback_ipv6_addr",
   true
 );
 Services.prefs.setBoolPref(
   "network.http.http3.retry_different_ip_family",
   false
 );
 Services.prefs.setBoolPref("network.proxy.allow_hijacking_localhost", true);
 Services.prefs.setBoolPref("network.dns.get-ttl", false);

 let proxy = new NodeHTTP2ProxyServer();
 await proxy.startWithoutProxyFilter();
 proxyPort = proxy.port();
 proxyHost = "alt2.example.com";

 trrServer = new TRRServer();
 await trrServer.start();

 Services.prefs.setIntPref("network.trr.mode", 3);
 Services.prefs.setCharPref(
   "network.trr.uri",
   `https://foo.example.com:${trrServer.port()}/dns-query`
 );

 await trrServer.registerDoHAnswers(proxyHost, "AAAA", {
   answers: [
     {
       name: proxyHost,
       ttl: 55,
       type: "AAAA",
       flush: false,
       data: "::1",
     },
   ],
 });
 await trrServer.registerDoHAnswers(proxyHost, "A", {
   answers: [
     {
       name: proxyHost,
       ttl: 55,
       type: "A",
       flush: false,
       data: "127.0.0.1",
     },
   ],
 });

 await new TRRDNSListener(proxyHost, "::1");

 let server = new NodeHTTP2Server();
 await server.start();
 serverPort = server.port();
 info(`server port:${server.port()}`);

 // Register multiple endpoints
 await server.registerPathHandler("/concurrent1", (req, resp) => {
   resp.writeHead(200);
   resp.end("response1");
 });
 await server.registerPathHandler("/concurrent2", (req, resp) => {
   resp.writeHead(200);
   resp.end("response2");
 });
 await server.registerPathHandler("/concurrent3", (req, resp) => {
   resp.writeHead(200);
   resp.end("response3");
 });

 proxyFilter = new Http3ProxyFilter(
   proxyHost,
   proxyPort,
   0,
   "/.well-known/masque/udp/{target_host}/{target_port}/",
   ""
 );

 registerCleanupFunction(async () => {
   trr_clear_prefs();
   Services.prefs.clearUserPref(
     "network.http.http3.retry_different_ip_family"
   );
   Services.prefs.clearUserPref("network.http.speculative-parallel-limit");
   Services.prefs.clearUserPref("network.http.http3.block_loopback_ipv6_addr");
   Services.prefs.clearUserPref("network.dns.get-ttl");
   Services.prefs.clearUserPref("network.proxy.allow_hijacking_localhost");
   if (trrServer) {
     await trrServer.stop();
   }
   await proxy.stop();
   await server.stop();
 });
});

function makeChan(url) {
 let chan = NetUtil.newChannel({
   uri: url,
   loadUsingSystemPrincipal: true,
   contentPolicyType: Ci.nsIContentPolicy.TYPE_DOCUMENT,
 }).QueryInterface(Ci.nsIHttpChannel);
 chan.loadFlags = Ci.nsIChannel.LOAD_INITIAL_DOCUMENT_URI;
 return chan;
}

function channelOpenPromise(chan, flags) {
 // eslint-disable-next-line no-async-promise-executor
 return new Promise(async resolve => {
   function finish(req, buffer) {
     resolve([req, buffer]);
   }
   chan.asyncOpen(new ChannelListener(finish, null, flags));
 });
}

// Test if we fallback to HTTP/2 proxy when IPv6 is blocked.
add_task(async function test_fallback_with_speculative_connection() {
 Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
 pps.registerFilter(proxyFilter, 10);

 const promises = [];
 for (let i = 1; i <= 3; i++) {
   let chan = makeChan(
     `https://alt1.example.com:${serverPort}/concurrent${i}`
   );
   promises.push(channelOpenPromise(chan, CL_IGNORE_CL | CL_ALLOW_UNKNOWN_CL));
 }

 const results = await Promise.all(promises);

 // Verify all requests succeeded with correct responses
 for (let i = 0; i < 3; i++) {
   const [req, buf] = results[i];
   Assert.equal(req.status, Cr.NS_OK);
   Assert.equal(buf, `response${i + 1}`);
 }

 pps.unregisterFilter(proxyFilter);
});

add_task(async function test_fallback_without_speculative_connection() {
 Services.prefs.setIntPref("network.http.speculative-parallel-limit", 0);

 Services.obs.notifyObservers(null, "net:cancel-all-connections");
 // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 await new Promise(resolve => setTimeout(resolve, 1000));

 pps.registerFilter(proxyFilter, 10);

 const promises = [];
 for (let i = 1; i <= 3; i++) {
   let chan = makeChan(
     `https://alt1.example.com:${serverPort}/concurrent${i}`
   );
   promises.push(channelOpenPromise(chan, CL_IGNORE_CL | CL_ALLOW_UNKNOWN_CL));
 }

 const results = await Promise.all(promises);

 // Verify all requests succeeded with correct responses
 for (let i = 0; i < 3; i++) {
   const [req, buf] = results[i];
   Assert.equal(req.status, Cr.NS_OK);
   Assert.equal(buf, `response${i + 1}`);
 }

 pps.unregisterFilter(proxyFilter);
});