Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: apple_silicon OR tsan && socketprocess_networking
- Manifest: netwerk/test/unit/xpcshell.toml
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et: */
/* 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
// This testcase exercises the Protocol Proxy Service
// These are the major sub tests:
// run_filter_test();
// run_filter_test2()
// run_filter_test3()
// run_pref_test();
// run_pac_test();
// run_pac_cancel_test();
// run_proxy_host_filters_test();
// run_myipaddress_test();
// run_failed_script_test();
// run_isresolvable_test();
"use strict";
var ios = Services.io;
var pps = Cc["@mozilla.org/network/protocol-proxy-service;1"].getService();
var prefs = Services.prefs;
var again = true;
/**
* Test nsIProtocolHandler that allows proxying, but doesn't allow HTTP
* proxying.
*/
function TestProtocolHandler() {}
TestProtocolHandler.prototype = {
QueryInterface: ChromeUtils.generateQI(["nsIProtocolHandler"]),
scheme: "moz-test",
defaultPort: -1,
protocolFlags:
Ci.nsIProtocolHandler.URI_NOAUTH |
Ci.nsIProtocolHandler.URI_NORELATIVE |
Ci.nsIProtocolHandler.ALLOWS_PROXY |
Ci.nsIProtocolHandler.URI_DANGEROUS_TO_LOAD,
newChannel() {
throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
},
allowPort() {
return true;
},
};
function TestProtocolHandlerFactory() {}
TestProtocolHandlerFactory.prototype = {
createInstance(iid) {
return new TestProtocolHandler().QueryInterface(iid);
},
};
function register_test_protocol_handler() {
var reg = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
reg.registerFactory(
Components.ID("{4ea7dd3a-8cae-499c-9f18-e1de773ca25b}"),
"TestProtocolHandler",
"@mozilla.org/network/protocol;1?name=moz-test",
new TestProtocolHandlerFactory()
);
}
function check_proxy(pi, type, host, port, flags, timeout, hasNext) {
Assert.notEqual(pi, null);
Assert.equal(pi.type, type);
Assert.equal(pi.host, host);
Assert.equal(pi.port, port);
if (flags != -1) {
Assert.equal(pi.flags, flags);
}
if (timeout != -1) {
Assert.equal(pi.failoverTimeout, timeout);
}
if (hasNext) {
Assert.notEqual(pi.failoverProxy, null);
} else {
Assert.equal(pi.failoverProxy, null);
}
}
function TestFilter(type, host, port, flags, timeout) {
this._type = type;
this._host = host;
this._port = port;
this._flags = flags;
this._timeout = timeout;
}
TestFilter.prototype = {
_type: "",
_host: "",
_port: -1,
_flags: 0,
_timeout: 0,
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyFilter"]),
applyFilter(uri, pi, cb) {
var pi_tail = pps.newProxyInfo(
this._type,
this._host,
this._port,
"",
"",
this._flags,
this._timeout,
null
);
if (pi) {
pi.failoverProxy = pi_tail;
} else {
pi = pi_tail;
}
cb.onProxyFilterResult(pi);
},
};
function BasicFilter() {}
BasicFilter.prototype = {
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyFilter"]),
applyFilter(uri, pi, cb) {
cb.onProxyFilterResult(
pps.newProxyInfo(
"http",
"localhost",
8080,
"",
"",
0,
10,
pps.newProxyInfo("direct", "", -1, "", "", 0, 0, null)
)
);
},
};
function BasicChannelFilter() {}
BasicChannelFilter.prototype = {
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyChannelFilter"]),
applyFilter(channel, pi, cb) {
cb.onProxyFilterResult(
pps.newProxyInfo(
"http",
channel.URI.host,
7777,
"",
"",
0,
10,
pps.newProxyInfo("direct", "", -1, "", "", 0, 0, null)
)
);
},
};
function resolveCallback() {}
resolveCallback.prototype = {
nextFunction: null,
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyCallback"]),
onProxyAvailable(req, channel, pi) {
this.nextFunction(pi);
},
};
function run_filter_test() {
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Verify initial state
var cb = new resolveCallback();
cb.nextFunction = filter_test0_1;
pps.asyncResolve(channel, 0, cb);
}
var filter01;
var filter02;
function filter_test0_1(pi) {
Assert.equal(pi, null);
// Push a filter and verify the results
filter01 = new BasicFilter();
filter02 = new BasicFilter();
pps.registerFilter(filter01, 10);
pps.registerFilter(filter02, 20);
var cb = new resolveCallback();
cb.nextFunction = filter_test0_2;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test0_2(pi) {
check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
pps.unregisterFilter(filter02);
var cb = new resolveCallback();
cb.nextFunction = filter_test0_3;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test0_3(pi) {
check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
// Remove filter and verify that we return to the initial state
pps.unregisterFilter(filter01);
var cb = new resolveCallback();
cb.nextFunction = filter_test0_4;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
var filter03;
function filter_test0_4(pi) {
Assert.equal(pi, null);
filter03 = new BasicChannelFilter();
pps.registerChannelFilter(filter03, 10);
var cb = new resolveCallback();
cb.nextFunction = filter_test0_5;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test0_5(pi) {
pps.unregisterChannelFilter(filter03);
check_proxy(pi, "http", "www.mozilla.org", 7777, 0, 10, true);
check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
run_filter_test_uri();
}
function run_filter_test_uri() {
var cb = new resolveCallback();
cb.nextFunction = filter_test_uri0_1;
pps.asyncResolve(uri, 0, cb);
}
function filter_test_uri0_1(pi) {
Assert.equal(pi, null);
// Push a filter and verify the results
filter01 = new BasicFilter();
filter02 = new BasicFilter();
pps.registerFilter(filter01, 10);
pps.registerFilter(filter02, 20);
var cb = new resolveCallback();
cb.nextFunction = filter_test_uri0_2;
pps.asyncResolve(uri, 0, cb);
}
function filter_test_uri0_2(pi) {
check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
pps.unregisterFilter(filter02);
var cb = new resolveCallback();
cb.nextFunction = filter_test_uri0_3;
pps.asyncResolve(uri, 0, cb);
}
function filter_test_uri0_3(pi) {
check_proxy(pi, "http", "localhost", 8080, 0, 10, true);
check_proxy(pi.failoverProxy, "direct", "", -1, 0, 0, false);
// Remove filter and verify that we return to the initial state
pps.unregisterFilter(filter01);
var cb = new resolveCallback();
cb.nextFunction = filter_test_uri0_4;
pps.asyncResolve(uri, 0, cb);
}
function filter_test_uri0_4(pi) {
Assert.equal(pi, null);
run_filter_test2();
}
var filter11;
var filter12;
function run_filter_test2() {
// Push a filter and verify the results
filter11 = new TestFilter("http", "foo", 8080, 0, 10);
filter12 = new TestFilter("http", "bar", 8090, 0, 10);
pps.registerFilter(filter11, 20);
pps.registerFilter(filter12, 10);
var cb = new resolveCallback();
cb.nextFunction = filter_test1_1;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test1_1(pi) {
check_proxy(pi, "http", "bar", 8090, 0, 10, true);
check_proxy(pi.failoverProxy, "http", "foo", 8080, 0, 10, false);
pps.unregisterFilter(filter12);
var cb = new resolveCallback();
cb.nextFunction = filter_test1_2;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test1_2(pi) {
check_proxy(pi, "http", "foo", 8080, 0, 10, false);
// Remove filter and verify that we return to the initial state
pps.unregisterFilter(filter11);
var cb = new resolveCallback();
cb.nextFunction = filter_test1_3;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function filter_test1_3(pi) {
Assert.equal(pi, null);
run_filter_test3();
}
var filter_3_1;
function run_filter_test3() {
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Push a filter and verify the results asynchronously
filter_3_1 = new TestFilter("http", "foo", 8080, 0, 10);
pps.registerFilter(filter_3_1, 20);
var cb = new resolveCallback();
cb.nextFunction = filter_test3_1;
pps.asyncResolve(channel, 0, cb);
}
function filter_test3_1(pi) {
check_proxy(pi, "http", "foo", 8080, 0, 10, false);
pps.unregisterFilter(filter_3_1);
run_pref_test();
}
function run_pref_test() {
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Verify 'direct' setting
prefs.setIntPref("network.proxy.type", 0);
var cb = new resolveCallback();
cb.nextFunction = pref_test1_1;
pps.asyncResolve(channel, 0, cb);
}
function pref_test1_1(pi) {
Assert.equal(pi, null);
// Verify 'manual' setting
prefs.setIntPref("network.proxy.type", 1);
var cb = new resolveCallback();
cb.nextFunction = pref_test1_2;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function pref_test1_2(pi) {
// nothing yet configured
Assert.equal(pi, null);
// try HTTP configuration
prefs.setCharPref("network.proxy.http", "foopy");
prefs.setIntPref("network.proxy.http_port", 8080);
var cb = new resolveCallback();
cb.nextFunction = pref_test1_3;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function pref_test1_3(pi) {
check_proxy(pi, "http", "foopy", 8080, 0, -1, false);
prefs.setCharPref("network.proxy.http", "");
prefs.setIntPref("network.proxy.http_port", 0);
// try SOCKS configuration
prefs.setCharPref("network.proxy.socks", "barbar");
prefs.setIntPref("network.proxy.socks_port", 1203);
var cb = new resolveCallback();
cb.nextFunction = pref_test1_4;
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
pps.asyncResolve(channel, 0, cb);
}
function pref_test1_4(pi) {
check_proxy(pi, "socks", "barbar", 1203, 0, -1, false);
run_pac_test();
}
function TestResolveCallback(type, nexttest) {
this.type = type;
this.nexttest = nexttest;
}
TestResolveCallback.prototype = {
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyCallback"]),
onProxyAvailable: function TestResolveCallback_onProxyAvailable(
req,
channel,
pi,
status
) {
dump("*** channelURI=" + channel.URI.spec + ", status=" + status + "\n");
if (this.type == null) {
Assert.equal(pi, null);
} else {
Assert.notEqual(req, null);
Assert.notEqual(channel, null);
Assert.equal(status, 0);
Assert.notEqual(pi, null);
check_proxy(pi, this.type, "foopy", 8080, 0, -1, true);
check_proxy(pi.failoverProxy, "direct", "", -1, -1, -1, false);
}
this.nexttest();
},
};
var originalTLSProxy;
function run_pac_test() {
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' return "PROXY foopy:8080; DIRECT";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
pps.asyncResolve(channel, 0, new TestResolveCallback("http", run_pac2_test));
}
function run_pac2_test() {
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' return "HTTPS foopy:8080; DIRECT";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
originalTLSProxy = prefs.getBoolPref("network.proxy.proxy_over_tls");
prefs.setCharPref("network.proxy.autoconfig_url", pac);
prefs.setBoolPref("network.proxy.proxy_over_tls", true);
pps.asyncResolve(channel, 0, new TestResolveCallback("https", run_pac3_test));
}
function run_pac3_test() {
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' return "HTTPS foopy:8080; DIRECT";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
prefs.setCharPref("network.proxy.autoconfig_url", pac);
prefs.setBoolPref("network.proxy.proxy_over_tls", false);
pps.asyncResolve(channel, 0, new TestResolveCallback(null, run_pac4_test));
}
function run_pac4_test() {
let wRange = [
["SUN", "MON", "SAT", "MON"], // for Sun
["SUN", "TUE", "SAT", "TUE"], // for Mon
["MON", "WED", "SAT", "WED"], // for Tue
["TUE", "THU", "SAT", "THU"], // for Wed
["WED", "FRI", "WED", "SUN"], // for Thu
["THU", "SAT", "THU", "SUN"], // for Fri
["FRI", "SAT", "FRI", "SUN"], // for Sat
];
let today = new Date().getDay();
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' if (weekdayRange("' +
wRange[today][0] +
'", "' +
wRange[today][1] +
'") &&' +
' weekdayRange("' +
wRange[today][2] +
'", "' +
wRange[today][3] +
'")) {' +
' return "PROXY foopy:8080; DIRECT";' +
" }" +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
pps.asyncResolve(
channel,
0,
new TestResolveCallback("http", run_utf8_pac_test)
);
}
function run_utf8_pac_test() {
var pac =
"data:text/plain;charset=UTF-8," +
"function FindProxyForURL(url, host) {" +
" /*" +
" U+00A9 COPYRIGHT SIGN: %C2%A9," +
" U+0B87 TAMIL LETTER I: %E0%AE%87," +
" U+10398 UGARITIC LETTER THANNA: %F0%90%8E%98 " +
" */" +
' var multiBytes = "%C2%A9 %E0%AE%87 %F0%90%8E%98"; ' +
" /* 6 UTF-16 units above if PAC script run as UTF-8; 11 units if run as Latin-1 */ " +
" return multiBytes.length === 6 " +
' ? "PROXY foopy:8080; DIRECT" ' +
' : "PROXY epicfail-utf8:12345; DIRECT";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
pps.asyncResolve(
channel,
0,
new TestResolveCallback("http", run_latin1_pac_test)
);
}
function run_latin1_pac_test() {
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
" /* A too-long encoding of U+0000, so not valid UTF-8 */ " +
' var multiBytes = "%C0%80"; ' +
" /* 2 UTF-16 units because interpreted as Latin-1 */ " +
" return multiBytes.length === 2 " +
' ? "PROXY foopy:8080; DIRECT" ' +
' : "PROXY epicfail-latin1:12345; DIRECT";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
pps.asyncResolve(
channel,
0,
new TestResolveCallback("http", finish_pac_test)
);
}
function finish_pac_test() {
prefs.setBoolPref("network.proxy.proxy_over_tls", originalTLSProxy);
run_pac_cancel_test();
}
function TestResolveCancelationCallback() {}
TestResolveCancelationCallback.prototype = {
QueryInterface: ChromeUtils.generateQI(["nsIProtocolProxyCallback"]),
onProxyAvailable: function TestResolveCancelationCallback_onProxyAvailable(
req,
channel,
pi,
status
) {
dump("*** channelURI=" + channel.URI.spec + ", status=" + status + "\n");
Assert.notEqual(req, null);
Assert.notEqual(channel, null);
Assert.equal(status, Cr.NS_ERROR_ABORT);
Assert.equal(pi, null);
prefs.setCharPref("network.proxy.autoconfig_url", "");
prefs.setIntPref("network.proxy.type", 0);
run_proxy_host_filters_test();
},
};
function run_pac_cancel_test() {
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
// Configure PAC
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' return "PROXY foopy:8080; DIRECT";' +
"}";
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var req = pps.asyncResolve(channel, 0, new TestResolveCancelationCallback());
req.cancel(Cr.NS_ERROR_ABORT);
}
var hostList;
var hostIDX;
var bShouldBeFiltered;
var hostNextFX;
function check_host_filters(hl, shouldBe, nextFX) {
hostList = hl;
hostIDX = 0;
bShouldBeFiltered = shouldBe;
hostNextFX = nextFX;
if (hostList.length > hostIDX) {
check_host_filter(hostIDX);
}
}
function check_host_filters_cb() {
hostIDX++;
if (hostList.length > hostIDX) {
check_host_filter(hostIDX);
} else {
hostNextFX();
}
}
function check_host_filter(i) {
dump(
"*** uri=" + hostList[i] + " bShouldBeFiltered=" + bShouldBeFiltered + "\n"
);
var channel = NetUtil.newChannel({
uri: hostList[i],
loadUsingSystemPrincipal: true,
});
var cb = new resolveCallback();
cb.nextFunction = host_filter_cb;
pps.asyncResolve(channel, 0, cb);
}
function host_filter_cb(proxy) {
if (bShouldBeFiltered) {
Assert.equal(proxy, null);
} else {
Assert.notEqual(proxy, null);
// Just to be sure, let's check that the proxy is correct
// - this should match the proxy setup in the calling function
check_proxy(proxy, "http", "foopy", 8080, 0, -1, false);
}
check_host_filters_cb();
}
// Verify that hists in the host filter list are not proxied
// refers to "network.proxy.no_proxies_on"
var uriStrUseProxyList;
var hostFilterList;
var uriStrFilterList;
function run_proxy_host_filters_test() {
// Get prefs object from DOM
// Setup a basic HTTP proxy configuration
// - pps.resolve() needs this to return proxy info for non-filtered hosts
prefs.setIntPref("network.proxy.type", 1);
prefs.setCharPref("network.proxy.http", "foopy");
prefs.setIntPref("network.proxy.http_port", 8080);
// Setup host filter list string for "no_proxies_on"
hostFilterList =
"www.mozilla.org, www.google.com, www.apple.com, " +
".domain, .domain2.org";
prefs.setCharPref("network.proxy.no_proxies_on", hostFilterList);
Assert.equal(
prefs.getCharPref("network.proxy.no_proxies_on"),
hostFilterList
);
// Check the hosts that should be filtered out
uriStrFilterList = [
];
check_host_filters(uriStrFilterList, true, host_filters_1);
}
function host_filters_1() {
// Check the hosts that should be proxied
uriStrUseProxyList = [
];
check_host_filters(uriStrUseProxyList, false, host_filters_2);
}
function host_filters_2() {
// Set no_proxies_on to include local hosts
prefs.setCharPref(
"network.proxy.no_proxies_on",
hostFilterList + ", <local>"
);
Assert.equal(
prefs.getCharPref("network.proxy.no_proxies_on"),
hostFilterList + ", <local>"
);
// Amend lists - move local domain to filtered list
uriStrFilterList.push(uriStrUseProxyList.pop());
check_host_filters(uriStrFilterList, true, host_filters_3);
}
function host_filters_3() {
check_host_filters(uriStrUseProxyList, false, host_filters_4);
}
function host_filters_4() {
// Cleanup
prefs.setCharPref("network.proxy.no_proxies_on", "");
Assert.equal(prefs.getCharPref("network.proxy.no_proxies_on"), "");
run_myipaddress_test();
}
function run_myipaddress_test() {
// This test makes sure myIpAddress() comes up with some valid
// IP address other than localhost. The DUT must be configured with
// an Internet route for this to work - though no Internet traffic
// should be created.
var pac =
"data:text/plain," +
"var pacUseMultihomedDNS = true;\n" +
"function FindProxyForURL(url, host) {" +
' return "PROXY " + myIpAddress() + ":1234";' +
"}";
// no traffic to this IP is ever sent, it is just a public IP that
// does not require DNS to determine a route.
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var cb = new resolveCallback();
cb.nextFunction = myipaddress_callback;
pps.asyncResolve(channel, 0, cb);
}
function myipaddress_callback(pi) {
Assert.notEqual(pi, null);
Assert.equal(pi.type, "http");
Assert.equal(pi.port, 1234);
// make sure we didn't return localhost
Assert.notEqual(pi.host, null);
Assert.notEqual(pi.host, "127.0.0.1");
Assert.notEqual(pi.host, "::1");
run_myipaddress_test_2();
}
function run_myipaddress_test_2() {
// test that myIPAddress() can be used outside of the scope of
var pac =
"data:text/plain," +
"var pacUseMultihomedDNS = true;\n" +
"var myaddr = myIpAddress(); " +
"function FindProxyForURL(url, host) {" +
' return "PROXY " + myaddr + ":5678";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var cb = new resolveCallback();
cb.nextFunction = myipaddress2_callback;
pps.asyncResolve(channel, 0, cb);
}
function myipaddress2_callback(pi) {
Assert.notEqual(pi, null);
Assert.equal(pi.type, "http");
Assert.equal(pi.port, 5678);
// make sure we didn't return localhost
Assert.notEqual(pi.host, null);
Assert.notEqual(pi.host, "127.0.0.1");
Assert.notEqual(pi.host, "::1");
run_failed_script_test();
}
function run_failed_script_test() {
// test to make sure we go direct with invalid PAC
// eslint-disable-next-line no-useless-concat
var pac = "data:text/plain," + "\nfor(;\n";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var cb = new resolveCallback();
cb.nextFunction = failed_script_callback;
pps.asyncResolve(channel, 0, cb);
}
var directFilter;
function failed_script_callback(pi) {
// we should go direct
Assert.equal(pi, null);
// test that we honor filters when configured to go direct
prefs.setIntPref("network.proxy.type", 0);
directFilter = new TestFilter("http", "127.0.0.1", 7246, 0, 0);
pps.registerFilter(directFilter, 10);
// test that on-modify-request contains the proxy info too
var obs = Cc["@mozilla.org/observer-service;1"].getService();
obs = obs.QueryInterface(Ci.nsIObserverService);
obs.addObserver(directFilterListener, "http-on-modify-request");
var ssm = Services.scriptSecurityManager;
let uri = TEST_URI;
var chan = NetUtil.newChannel({
uri,
loadingPrincipal: ssm.createContentPrincipal(Services.io.newURI(uri), {}),
securityFlags: Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT,
contentPolicyType: Ci.nsIContentPolicy.TYPE_DOCUMENT,
});
chan.asyncOpen(directFilterListener);
}
var directFilterListener = {
onModifyRequestCalled: false,
onStartRequest: function test_onStart() {},
onDataAvailable: function test_OnData() {},
onStopRequest: function test_onStop(request) {
// check on the PI from the channel itself
request.QueryInterface(Ci.nsIProxiedChannel);
check_proxy(request.proxyInfo, "http", "127.0.0.1", 7246, 0, 0, false);
pps.unregisterFilter(directFilter);
// check on the PI from on-modify-request
Assert.ok(this.onModifyRequestCalled);
var obs = Cc["@mozilla.org/observer-service;1"].getService();
obs = obs.QueryInterface(Ci.nsIObserverService);
obs.removeObserver(this, "http-on-modify-request");
run_isresolvable_test();
},
observe(subject, topic) {
if (
topic === "http-on-modify-request" &&
subject instanceof Ci.nsIHttpChannel &&
subject instanceof Ci.nsIProxiedChannel
) {
info("check proxy in observe uri=" + subject.URI.spec);
if (subject.URI.spec != TEST_URI) {
return;
}
check_proxy(subject.proxyInfo, "http", "127.0.0.1", 7246, 0, 0, false);
this.onModifyRequestCalled = true;
}
},
};
function run_isresolvable_test() {
// test a non resolvable host in the pac file
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' if (isResolvable("nonexistant.lan.onion"))' +
' return "DIRECT";' +
' return "PROXY 127.0.0.1:1234";' +
"}";
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var cb = new resolveCallback();
cb.nextFunction = isresolvable_callback;
pps.asyncResolve(channel, 0, cb);
}
function isresolvable_callback(pi) {
Assert.notEqual(pi, null);
Assert.equal(pi.type, "http");
Assert.equal(pi.port, 1234);
Assert.equal(pi.host, "127.0.0.1");
run_localhost_pac();
}
function run_localhost_pac() {
// test localhost in the pac file
var pac =
"data:text/plain," +
"function FindProxyForURL(url, host) {" +
' return "PROXY totallycrazy:1234";' +
"}";
// Use default filter list string for "no_proxies_on" ("localhost, 127.0.0.1")
prefs.clearUserPref("network.proxy.no_proxies_on");
var channel = NetUtil.newChannel({
loadUsingSystemPrincipal: true,
});
prefs.setIntPref("network.proxy.type", 2);
prefs.setCharPref("network.proxy.autoconfig_url", pac);
var cb = new resolveCallback();
cb.nextFunction = localhost_callback;
pps.asyncResolve(channel, 0, cb);
}
function localhost_callback(pi) {
Assert.equal(pi, null); // no proxy!
prefs.setIntPref("network.proxy.type", 0);
if (mozinfo.socketprocess_networking && again) {
info("run test again");
again = false;
cleanUp();
prefs.setBoolPref("network.proxy.parse_pac_on_socket_process", true);
run_filter_test();
} else {
cleanUp();
do_test_finished();
}
}
function cleanUp() {
prefs.clearUserPref("network.proxy.type");
prefs.clearUserPref("network.proxy.http");
prefs.clearUserPref("network.proxy.http_port");
prefs.clearUserPref("network.proxy.socks");
prefs.clearUserPref("network.proxy.socks_port");
prefs.clearUserPref("network.proxy.autoconfig_url");
prefs.clearUserPref("network.proxy.proxy_over_tls");
prefs.clearUserPref("network.proxy.no_proxies_on");
prefs.clearUserPref("network.proxy.parse_pac_on_socket_process");
}
function run_test() {
register_test_protocol_handler();
prefs.setBoolPref("network.proxy.parse_pac_on_socket_process", false);
// start of asynchronous test chain
run_filter_test();
do_test_pending();
}