--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -45,17 +45,16 @@ using namespace mozilla;
using namespace mozilla::net;
static const char kPrefDnsCacheEntries[] = "network.dnsCacheEntries";
static const char kPrefDnsCacheExpiration[] = "network.dnsCacheExpiration";
static const char kPrefDnsCacheGrace[] = "network.dnsCacheExpirationGracePeriod";
static const char kPrefIPv4OnlyDomains[] = "network.dns.ipv4OnlyDomains";
static const char kPrefDisableIPv6[] = "network.dns.disableIPv6";
static const char kPrefDisablePrefetch[] = "network.dns.disablePrefetch";
-static const char kPrefBlockDotOnion[] = "network.dns.blockDotOnion";
static const char kPrefDnsLocalDomains[] = "network.dns.localDomains";
static const char kPrefDnsOfflineLocalhost[] = "network.dns.offline-localhost";
static const char kPrefDnsNotifyResolution[] = "network.dns.notifyResolution";
//-----------------------------------------------------------------------------
class nsDNSRecord : public nsIDNSRecord
{
@@ -539,17 +538,16 @@ nsDNSService::Init()
NS_ENSURE_TRUE(!mResolver, NS_ERROR_ALREADY_INITIALIZED);
// prefs
uint32_t maxCacheEntries = 400;
uint32_t defaultCacheLifetime = 120; // seconds
uint32_t defaultGracePeriod = 60; // seconds
bool disableIPv6 = false;
bool offlineLocalhost = true;
bool disablePrefetch = false;
- bool blockDotOnion = true;
int proxyType = nsIProtocolProxyService::PROXYCONFIG_DIRECT;
bool notifyResolution = false;
nsAdoptingCString ipv4OnlyDomains;
nsAdoptingCString localDomains;
// read prefs
nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
@@ -563,17 +561,16 @@ nsDNSService::Init()
defaultGracePeriod = val;
// ASSUMPTION: pref branch does not modify out params on failure
prefs->GetBoolPref(kPrefDisableIPv6, &disableIPv6);
prefs->GetCharPref(kPrefIPv4OnlyDomains, getter_Copies(ipv4OnlyDomains));
prefs->GetCharPref(kPrefDnsLocalDomains, getter_Copies(localDomains));
prefs->GetBoolPref(kPrefDnsOfflineLocalhost, &offlineLocalhost);
prefs->GetBoolPref(kPrefDisablePrefetch, &disablePrefetch);
- prefs->GetBoolPref(kPrefBlockDotOnion, &blockDotOnion);
// If a manual proxy is in use, disable prefetch implicitly
prefs->GetIntPref("network.proxy.type", &proxyType);
prefs->GetBoolPref(kPrefDnsNotifyResolution, ¬ifyResolution);
}
if (mFirstTime) {
mFirstTime = false;
@@ -583,17 +580,16 @@ nsDNSService::Init()
prefs->AddObserver(kPrefDnsCacheEntries, this, false);
prefs->AddObserver(kPrefDnsCacheExpiration, this, false);
prefs->AddObserver(kPrefDnsCacheGrace, this, false);
prefs->AddObserver(kPrefIPv4OnlyDomains, this, false);
prefs->AddObserver(kPrefDnsLocalDomains, this, false);
prefs->AddObserver(kPrefDisableIPv6, this, false);
prefs->AddObserver(kPrefDnsOfflineLocalhost, this, false);
prefs->AddObserver(kPrefDisablePrefetch, this, false);
- prefs->AddObserver(kPrefBlockDotOnion, this, false);
prefs->AddObserver(kPrefDnsNotifyResolution, this, false);
// Monitor these to see if there is a change in proxy configuration
// If a manual proxy is in use, disable prefetch implicitly
prefs->AddObserver("network.proxy.type", this, false);
}
nsCOMPtr<nsIObserverService> observerService =
@@ -617,17 +613,16 @@ nsDNSService::Init()
if (NS_SUCCEEDED(rv)) {
// now, set all of our member variables while holding the lock
MutexAutoLock lock(mLock);
mResolver = res;
mIDN = idn;
mIPv4OnlyDomains = ipv4OnlyDomains; // exchanges buffer ownership
mOfflineLocalhost = offlineLocalhost;
mDisableIPv6 = disableIPv6;
- mBlockDotOnion = blockDotOnion;
// Disable prefetching either by explicit preference or if a manual proxy is configured
mDisablePrefetch = disablePrefetch || (proxyType == nsIProtocolProxyService::PROXYCONFIG_MANUAL);
mLocalDomains.Clear();
if (localDomains) {
nsCCharSeparatedTokenizer tokenizer(localDomains, ',',
nsCCharSeparatedTokenizer::SEPARATOR_OPTIONAL);
@@ -698,42 +693,32 @@ nsDNSService::GetPrefetchEnabled(bool *o
NS_IMETHODIMP
nsDNSService::SetPrefetchEnabled(bool inVal)
{
MutexAutoLock lock(mLock);
mDisablePrefetch = !inVal;
return NS_OK;
}
-nsresult
-nsDNSService::PreprocessHostname(bool aLocalDomain,
- const nsACString &aInput,
- nsIIDNService *aIDN,
- nsACString &aACE)
+static inline bool PreprocessHostname(bool aLocalDomain,
+ const nsACString &aInput,
+ nsIIDNService *aIDN,
+ nsACString &aACE)
{
- // Enforce RFC 7686
- if (mBlockDotOnion &&
- StringEndsWith(aInput, NS_LITERAL_CSTRING(".onion"))) {
- return NS_ERROR_UNKNOWN_HOST;
- }
-
if (aLocalDomain) {
aACE.AssignLiteral("localhost");
- return NS_OK;
+ return true;
}
if (!aIDN || IsASCII(aInput)) {
aACE = aInput;
- return NS_OK;
+ return true;
}
- if (!(IsUTF8(aInput) && NS_SUCCEEDED(aIDN->ConvertUTF8toACE(aInput, aACE)))) {
- return NS_ERROR_FAILURE;
- }
- return NS_OK;
+ return IsUTF8(aInput) && NS_SUCCEEDED(aIDN->ConvertUTF8toACE(aInput, aACE));
}
NS_IMETHODIMP
nsDNSService::AsyncResolve(const nsACString &aHostname,
uint32_t flags,
nsIDNSListener *listener,
nsIEventTarget *target_,
nsICancelable **result)
@@ -770,20 +755,18 @@ nsDNSService::AsyncResolveExtended(const
if (mNotifyResolution) {
NS_DispatchToMainThread(new NotifyDNSResolution(aHostname));
}
if (!res)
return NS_ERROR_OFFLINE;
nsCString hostname;
- nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
- if (NS_FAILED(rv)) {
- return rv;
- }
+ if (!PreprocessHostname(localDomain, aHostname, idn, hostname))
+ return NS_ERROR_FAILURE;
if (mOffline &&
(!mOfflineLocalhost || !hostname.LowerCaseEqualsASCII("localhost"))) {
flags |= RESOLVE_OFFLINE;
}
// make sure JS callers get notification on the main thread
nsCOMPtr<nsIXPConnectWrappedJS> wrappedListener = do_QueryInterface(listener);
@@ -803,18 +786,19 @@ nsDNSService::AsyncResolveExtended(const
new nsDNSAsyncRequest(res, hostname, listener, flags, af,
aNetworkInterface);
if (!req)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(*result = req);
// addref for resolver; will be released when OnLookupComplete is called.
NS_ADDREF(req);
- rv = res->ResolveHost(req->mHost.get(), flags, af,
- req->mNetworkInterface.get(), req);
+ nsresult rv = res->ResolveHost(req->mHost.get(), flags, af,
+ req->mNetworkInterface.get(),
+ req);
if (NS_FAILED(rv)) {
NS_RELEASE(req);
NS_RELEASE(*result);
}
return rv;
}
NS_IMETHODIMP
@@ -848,20 +832,18 @@ nsDNSService::CancelAsyncResolveExtended
res = mResolver;
idn = mIDN;
localDomain = mLocalDomains.GetEntry(aHostname);
}
if (!res)
return NS_ERROR_OFFLINE;
nsCString hostname;
- nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
- if (NS_FAILED(rv)) {
- return rv;
- }
+ if (!PreprocessHostname(localDomain, aHostname, idn, hostname))
+ return NS_ERROR_FAILURE;
uint16_t af = GetAFForLookup(hostname, aFlags);
res->CancelAsyncRequest(hostname.get(), aFlags, af,
nsPromiseFlatCString(aNetworkInterface).get(), aListener,
aReason);
return NS_OK;
}
@@ -885,20 +867,18 @@ nsDNSService::Resolve(const nsACString &
if (mNotifyResolution) {
NS_DispatchToMainThread(new NotifyDNSResolution(aHostname));
}
NS_ENSURE_TRUE(res, NS_ERROR_OFFLINE);
nsCString hostname;
- nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
- if (NS_FAILED(rv)) {
- return rv;
- }
+ if (!PreprocessHostname(localDomain, aHostname, idn, hostname))
+ return NS_ERROR_FAILURE;
if (mOffline &&
(!mOfflineLocalhost || !hostname.LowerCaseEqualsASCII("localhost"))) {
flags |= RESOLVE_OFFLINE;
}
//
// sync resolve: since the host resolver only works asynchronously, we need
@@ -912,17 +892,17 @@ nsDNSService::Resolve(const nsACString &
if (!mon)
return NS_ERROR_OUT_OF_MEMORY;
PR_EnterMonitor(mon);
nsDNSSyncRequest syncReq(mon);
uint16_t af = GetAFForLookup(hostname, flags);
- rv = res->ResolveHost(hostname.get(), flags, af, "", &syncReq);
+ nsresult rv = res->ResolveHost(hostname.get(), flags, af, "", &syncReq);
if (NS_SUCCEEDED(rv)) {
// wait for result
while (!syncReq.mDone)
PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
if (NS_FAILED(syncReq.mStatus))
rv = syncReq.mStatus;
else {
--- a/netwerk/test/unit/test_dns_service.js
+++ b/netwerk/test/unit/test_dns_service.js
@@ -1,83 +1,26 @@
var dns = Cc["@mozilla.org/network/dns-service;1"].getService(Ci.nsIDNSService);
-var threadManager = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
-var mainThread = threadManager.currentThread;
-var onionPref;
-var localdomainPref;
-var prefs = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
-
-var listener1 = {
+var listener = {
onLookupComplete: function(inRequest, inRecord, inStatus) {
var answer = inRecord.getNextAddrAsString();
do_check_true(answer == "127.0.0.1" || answer == "::1");
- do_test_2();
- },
- QueryInterface: function(aIID) {
- if (aIID.equals(Ci.nsIDNSListener) ||
- aIID.equals(Ci.nsISupports)) {
- return this;
- }
- throw Cr.NS_ERROR_NO_INTERFACE;
- }
-};
-var listener2 = {
- onLookupComplete: function(inRequest, inRecord, inStatus) {
- do_check_false(Components.isSuccessCode(inStatus));
- do_test_3();
+ do_test_finished();
},
QueryInterface: function(aIID) {
if (aIID.equals(Ci.nsIDNSListener) ||
aIID.equals(Ci.nsISupports)) {
return this;
}
throw Cr.NS_ERROR_NO_INTERFACE;
}
};
-var listener3 = {
- onLookupComplete: function(inRequest, inRecord, inStatus) {
- var answer = inRecord.getNextAddrAsString();
- do_check_true(answer == "127.0.0.1" || answer == "::1");
- all_done();
- },
- QueryInterface: function(aIID) {
- if (aIID.equals(Ci.nsIDNSListener) ||
- aIID.equals(Ci.nsISupports)) {
- return this;
- }
- throw Cr.NS_ERROR_NO_INTERFACE;
- }
-};
-
-function do_test_3() {
- prefs.setBoolPref("network.dns.blockDotOnion", false);
- dns.asyncResolve("private.onion", 0, listener3, mainThread);
-}
+function run_test() {
+ var threadManager = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
+ var mainThread = threadManager.currentThread;
+ dns.asyncResolve("localhost", 0, listener, mainThread);
-function do_test_2() {
- prefs.setBoolPref("network.dns.blockDotOnion", true);
- try {
- dns.asyncResolve("private.onion", 0, listener2, mainThread);
- } catch (e) {
- // it is ok for this negative test to fail fast
- do_check_true(true);
- do_test_3();
- }
-}
-
-function all_done() {
- // reset locally modified prefs
- prefs.setCharPref("network.dns.localDomains", localdomainPref);
- prefs.setBoolPref("network.dns.blockDotOnion", onionPref);
- do_test_finished();
-}
-
-function run_test() {
- onionPref = prefs.getBoolPref("network.dns.blockDotOnion");
- localdomainPref = prefs.getCharPref("network.dns.localDomains");
- prefs.setCharPref("network.dns.localDomains", "private.onion");
- dns.asyncResolve("localhost", 0, listener1, mainThread);
do_test_pending();
}