Add m-esr52 at 52.6.0

1 files changed, 1579 insertions, 0 deletions

diff --git a/netwerk/dns/nsHostResolver.cpp b/netwerk/dns/nsHostResolver.cpp
new file mode 100644
index 000000000..f2e26cadd
--- /dev/null
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -0,0 +1,1579 @@
+/* vim:set ts=4 sw=4 sts=4 et cin: */
+/* 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/. */
+
+#if defined(HAVE_RES_NINIT)
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>   
+#include <arpa/nameser.h>
+#include <resolv.h>
+#define RES_RETRY_ON_FAILURE
+#endif
+
+#include <stdlib.h>
+#include <ctime>
+#include "nsHostResolver.h"
+#include "nsError.h"
+#include "nsISupportsBase.h"
+#include "nsISupportsUtils.h"
+#include "nsAutoPtr.h"
+#include "nsPrintfCString.h"
+#include "prthread.h"
+#include "prerror.h"
+#include "prtime.h"
+#include "mozilla/Logging.h"
+#include "PLDHashTable.h"
+#include "plstr.h"
+#include "nsURLHelper.h"
+#include "nsThreadUtils.h"
+#include "GetAddrInfo.h"
+
+#include "mozilla/HashFunctions.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Preferences.h"
+
+using namespace mozilla;
+using namespace mozilla::net;
+
+// None of our implementations expose a TTL for negative responses, so we use a
+// constant always.
+static const unsigned int NEGATIVE_RECORD_LIFETIME = 60;
+
+//----------------------------------------------------------------------------
+
+// Use a persistent thread pool in order to avoid spinning up new threads all the time.
+// In particular, thread creation results in a res_init() call from libc which is 
+// quite expensive.
+//
+// The pool dynamically grows between 0 and MAX_RESOLVER_THREADS in size. New requests
+// go first to an idle thread. If that cannot be found and there are fewer than MAX_RESOLVER_THREADS
+// currently in the pool a new thread is created for high priority requests. If
+// the new request is at a lower priority a new thread will only be created if 
+// there are fewer than HighThreadThreshold currently outstanding. If a thread cannot be
+// created or an idle thread located for the request it is queued.
+//
+// When the pool is greater than HighThreadThreshold in size a thread will be destroyed after
+// ShortIdleTimeoutSeconds of idle time. Smaller pools use LongIdleTimeoutSeconds for a 
+// timeout period.
+
+#define HighThreadThreshold     MAX_RESOLVER_THREADS_FOR_ANY_PRIORITY
+#define LongIdleTimeoutSeconds  300           // for threads 1 -> HighThreadThreshold
+#define ShortIdleTimeoutSeconds 60            // for threads HighThreadThreshold+1 -> MAX_RESOLVER_THREADS
+
+static_assert(HighThreadThreshold <= MAX_RESOLVER_THREADS,
+              "High Thread Threshold should be less equal Maximum allowed thread");
+
+//----------------------------------------------------------------------------
+
+static LazyLogModule gHostResolverLog("nsHostResolver");
+#define LOG(args) MOZ_LOG(gHostResolverLog, mozilla::LogLevel::Debug, args)
+#define LOG_ENABLED() MOZ_LOG_TEST(gHostResolverLog, mozilla::LogLevel::Debug)
+
+#define LOG_HOST(host, interface) host,                                        \
+                 (interface && interface[0] != '\0') ? " on interface " : "",  \
+                 (interface && interface[0] != '\0') ? interface : ""
+
+//----------------------------------------------------------------------------
+
+static inline void
+MoveCList(PRCList &from, PRCList &to)
+{
+    if (!PR_CLIST_IS_EMPTY(&from)) {
+        to.next = from.next;
+        to.prev = from.prev;
+        to.next->prev = &to;
+        to.prev->next = &to;
+        PR_INIT_CLIST(&from);
+    }             
+}
+
+//----------------------------------------------------------------------------
+
+#if defined(RES_RETRY_ON_FAILURE)
+
+// this class represents the resolver state for a given thread.  if we
+// encounter a lookup failure, then we can invoke the Reset method on an
+// instance of this class to reset the resolver (in case /etc/resolv.conf
+// for example changed).  this is mainly an issue on GNU systems since glibc
+// only reads in /etc/resolv.conf once per thread.  it may be an issue on
+// other systems as well.
+
+class nsResState
+{
+public:
+    nsResState()
+        // initialize mLastReset to the time when this object
+        // is created.  this means that a reset will not occur
+        // if a thread is too young.  the alternative would be
+        // to initialize this to the beginning of time, so that
+        // the first failure would cause a reset, but since the
+        // thread would have just started up, it likely would
+        // already have current /etc/resolv.conf info.
+        : mLastReset(PR_IntervalNow())
+    {
+    }
+
+    bool Reset()
+    {
+        // reset no more than once per second
+        if (PR_IntervalToSeconds(PR_IntervalNow() - mLastReset) < 1)
+            return false;
+
+        LOG(("Calling 'res_ninit'.\n"));
+
+        mLastReset = PR_IntervalNow();
+        return (res_ninit(&_res) == 0);
+    }
+
+private:
+    PRIntervalTime mLastReset;
+};
+
+#endif // RES_RETRY_ON_FAILURE
+
+//----------------------------------------------------------------------------
+
+static inline bool
+IsHighPriority(uint16_t flags)
+{
+    return !(flags & (nsHostResolver::RES_PRIORITY_LOW | nsHostResolver::RES_PRIORITY_MEDIUM));
+}
+
+static inline bool
+IsMediumPriority(uint16_t flags)
+{
+    return flags & nsHostResolver::RES_PRIORITY_MEDIUM;
+}
+
+static inline bool
+IsLowPriority(uint16_t flags)
+{
+    return flags & nsHostResolver::RES_PRIORITY_LOW;
+}
+
+//----------------------------------------------------------------------------
+// this macro filters out any flags that are not used when constructing the
+// host key.  the significant flags are those that would affect the resulting
+// host record (i.e., the flags that are passed down to PR_GetAddrInfoByName).
+#define RES_KEY_FLAGS(_f) ((_f) & nsHostResolver::RES_CANON_NAME)
+
+nsHostRecord::nsHostRecord(const nsHostKey *key)
+    : addr_info_lock("nsHostRecord.addr_info_lock")
+    , addr_info_gencnt(0)
+    , addr_info(nullptr)
+    , addr(nullptr)
+    , negative(false)
+    , resolving(false)
+    , onQueue(false)
+    , usingAnyThread(false)
+    , mDoomed(false)
+#if TTL_AVAILABLE
+    , mGetTtl(false)
+#endif
+    , mBlacklistedCount(0)
+    , mResolveAgain(false)
+{
+    host = ((char *) this) + sizeof(nsHostRecord);
+    memcpy((char *) host, key->host, strlen(key->host) + 1);
+    flags = key->flags;
+    af = key->af;
+    netInterface = host + strlen(key->host) + 1;
+    memcpy((char *) netInterface, key->netInterface,
+           strlen(key->netInterface) + 1);
+    PR_INIT_CLIST(this);
+    PR_INIT_CLIST(&callbacks);
+}
+
+nsresult
+nsHostRecord::Create(const nsHostKey *key, nsHostRecord **result)
+{
+    size_t hostLen = strlen(key->host) + 1;
+    size_t netInterfaceLen = strlen(key->netInterface) + 1;
+    size_t size = hostLen + netInterfaceLen + sizeof(nsHostRecord);
+
+    // Use placement new to create the object with room for the hostname and
+    // network interface name allocated after it.
+    void *place = ::operator new(size);
+    *result = new(place) nsHostRecord(key);
+    NS_ADDREF(*result);
+
+    return NS_OK;
+}
+
+void
+nsHostRecord::SetExpiration(const mozilla::TimeStamp& now, unsigned int valid, unsigned int grace)
+{
+    mValidStart = now;
+    mGraceStart = now + TimeDuration::FromSeconds(valid);
+    mValidEnd = now + TimeDuration::FromSeconds(valid + grace);
+}
+
+void
+nsHostRecord::CopyExpirationTimesAndFlagsFrom(const nsHostRecord *aFromHostRecord)
+{
+    // This is used to copy information from a cache entry to a record. All
+    // information necessary for HasUsableRecord needs to be copied.
+    mValidStart = aFromHostRecord->mValidStart;
+    mValidEnd = aFromHostRecord->mValidEnd;
+    mGraceStart = aFromHostRecord->mGraceStart;
+    mDoomed = aFromHostRecord->mDoomed;
+}
+
+nsHostRecord::~nsHostRecord()
+{
+    Telemetry::Accumulate(Telemetry::DNS_BLACKLIST_COUNT, mBlacklistedCount);
+    delete addr_info;
+    delete addr;
+}
+
+bool
+nsHostRecord::Blacklisted(NetAddr *aQuery)
+{
+    // must call locked
+    LOG(("Checking blacklist for host [%s%s%s], host record [%p].\n",
+          LOG_HOST(host, netInterface), this));
+
+    // skip the string conversion for the common case of no blacklist
+    if (!mBlacklistedItems.Length()) {
+        return false;
+    }
+
+    char buf[kIPv6CStrBufSize];
+    if (!NetAddrToString(aQuery, buf, sizeof(buf))) {
+        return false;
+    }
+    nsDependentCString strQuery(buf);
+
+    for (uint32_t i = 0; i < mBlacklistedItems.Length(); i++) {
+        if (mBlacklistedItems.ElementAt(i).Equals(strQuery)) {
+            LOG(("Address [%s] is blacklisted for host [%s%s%s].\n", buf,
+                 LOG_HOST(host, netInterface)));
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void
+nsHostRecord::ReportUnusable(NetAddr *aAddress)
+{
+    // must call locked
+    LOG(("Adding address to blacklist for host [%s%s%s], host record [%p].\n",
+         LOG_HOST(host, netInterface), this));
+
+    ++mBlacklistedCount;
+
+    if (negative)
+        mDoomed = true;
+
+    char buf[kIPv6CStrBufSize];
+    if (NetAddrToString(aAddress, buf, sizeof(buf))) {
+        LOG(("Successfully adding address [%s] to blacklist for host "
+             "[%s%s%s].\n", buf, LOG_HOST(host, netInterface)));
+        mBlacklistedItems.AppendElement(nsCString(buf));
+    }
+}
+
+void
+nsHostRecord::ResetBlacklist()
+{
+    // must call locked
+    LOG(("Resetting blacklist for host [%s%s%s], host record [%p].\n",
+         LOG_HOST(host, netInterface), this));
+    mBlacklistedItems.Clear();
+}
+
+nsHostRecord::ExpirationStatus
+nsHostRecord::CheckExpiration(const mozilla::TimeStamp& now) const {
+    if (!mGraceStart.IsNull() && now >= mGraceStart
+            && !mValidEnd.IsNull() && now < mValidEnd) {
+        return nsHostRecord::EXP_GRACE;
+    } else if (!mValidEnd.IsNull() && now < mValidEnd) {
+        return nsHostRecord::EXP_VALID;
+    }
+
+    return nsHostRecord::EXP_EXPIRED;
+}
+
+
+bool
+nsHostRecord::HasUsableResult(const mozilla::TimeStamp& now, uint16_t queryFlags) const
+{
+    if (mDoomed) {
+        return false;
+    }
+
+    // don't use cached negative results for high priority queries.
+    if (negative && IsHighPriority(queryFlags)) {
+        return false;
+    }
+
+    if (CheckExpiration(now) == EXP_EXPIRED) {
+        return false;
+    }
+
+    return addr_info || addr || negative;
+}
+
+static size_t
+SizeOfResolveHostCallbackListExcludingHead(const PRCList *head,
+                                           MallocSizeOf mallocSizeOf)
+{
+    size_t n = 0;
+    PRCList *curr = head->next;
+    while (curr != head) {
+        nsResolveHostCallback *callback =
+            static_cast<nsResolveHostCallback*>(curr);
+        n += callback->SizeOfIncludingThis(mallocSizeOf);
+        curr = curr->next;
+    }
+    return n;
+}
+
+size_t
+nsHostRecord::SizeOfIncludingThis(MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+
+    // The |host| field (inherited from nsHostKey) actually points to extra
+    // memory that is allocated beyond the end of the nsHostRecord (see
+    // nsHostRecord::Create()).  So it will be included in the
+    // |mallocSizeOf(this)| call above.
+
+    n += SizeOfResolveHostCallbackListExcludingHead(&callbacks, mallocSizeOf);
+    n += addr_info ? addr_info->SizeOfIncludingThis(mallocSizeOf) : 0;
+    n += mallocSizeOf(addr);
+
+    n += mBlacklistedItems.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (size_t i = 0; i < mBlacklistedItems.Length(); i++) {
+        n += mBlacklistedItems[i].SizeOfExcludingThisIfUnshared(mallocSizeOf);
+    }
+    return n;
+}
+
+nsHostRecord::DnsPriority
+nsHostRecord::GetPriority(uint16_t aFlags)
+{
+    if (IsHighPriority(aFlags)){
+        return nsHostRecord::DNS_PRIORITY_HIGH;
+    } else if (IsMediumPriority(aFlags)) {
+        return nsHostRecord::DNS_PRIORITY_MEDIUM;
+    }
+
+    return nsHostRecord::DNS_PRIORITY_LOW;
+}
+
+// Returns true if the entry can be removed, or false if it should be left.
+// Sets mResolveAgain true for entries being resolved right now.
+bool
+nsHostRecord::RemoveOrRefresh()
+{
+    if (resolving) {
+        if (!onQueue) {
+            // The request has been passed to the OS resolver. The resultant DNS
+            // record should be considered stale and not trusted; set a flag to
+            // ensure it is called again.
+            mResolveAgain = true;
+        }
+        // if Onqueue is true, the host entry is already added to the cache
+        // but is still pending to get resolved: just leave it in hash.
+        return false;
+    }
+    // Already resolved; not in a pending state; remove from cache.
+    return true;
+}
+
+//----------------------------------------------------------------------------
+
+struct nsHostDBEnt : PLDHashEntryHdr
+{
+    nsHostRecord *rec;
+};
+
+static PLDHashNumber
+HostDB_HashKey(const void *key)
+{
+    const nsHostKey *hk = static_cast<const nsHostKey *>(key);
+    return AddToHash(HashString(hk->host), RES_KEY_FLAGS(hk->flags), hk->af,
+                     HashString(hk->netInterface));
+}
+
+static bool
+HostDB_MatchEntry(const PLDHashEntryHdr *entry,
+                  const void *key)
+{
+    const nsHostDBEnt *he = static_cast<const nsHostDBEnt *>(entry);
+    const nsHostKey *hk = static_cast<const nsHostKey *>(key); 
+
+    return !strcmp(he->rec->host ? he->rec->host : "",
+                   hk->host ? hk->host : "") &&
+            RES_KEY_FLAGS (he->rec->flags) == RES_KEY_FLAGS(hk->flags) &&
+            he->rec->af == hk->af &&
+            !strcmp(he->rec->netInterface, hk->netInterface);
+}
+
+static void
+HostDB_MoveEntry(PLDHashTable *table,
+                 const PLDHashEntryHdr *from,
+                 PLDHashEntryHdr *to)
+{
+    static_cast<nsHostDBEnt *>(to)->rec =
+            static_cast<const nsHostDBEnt *>(from)->rec;
+}
+
+static void
+HostDB_ClearEntry(PLDHashTable *table,
+                  PLDHashEntryHdr *entry)
+{
+    nsHostDBEnt *he = static_cast<nsHostDBEnt*>(entry);
+    MOZ_ASSERT(he, "nsHostDBEnt is null!");
+
+    nsHostRecord *hr = he->rec;
+    MOZ_ASSERT(hr, "nsHostDBEnt has null host record!");
+
+    LOG(("Clearing cache db entry for host [%s%s%s].\n",
+         LOG_HOST(hr->host, hr->netInterface)));
+#if defined(DEBUG)
+    {
+        MutexAutoLock lock(hr->addr_info_lock);
+        if (!hr->addr_info) {
+            LOG(("No address info for host [%s%s%s].\n",
+                 LOG_HOST(hr->host, hr->netInterface)));
+        } else {
+            if (!hr->mValidEnd.IsNull()) {
+                TimeDuration diff = hr->mValidEnd - TimeStamp::NowLoRes();
+                LOG(("Record for host [%s%s%s] expires in %f seconds.\n",
+                     LOG_HOST(hr->host, hr->netInterface),
+                     diff.ToSeconds()));
+            } else {
+                LOG(("Record for host [%s%s%s] not yet valid.\n",
+                     LOG_HOST(hr->host, hr->netInterface)));
+            }
+
+            NetAddrElement *addrElement = nullptr;
+            char buf[kIPv6CStrBufSize];
+            do {
+                if (!addrElement) {
+                    addrElement = hr->addr_info->mAddresses.getFirst();
+                } else {
+                    addrElement = addrElement->getNext();
+                }
+
+                if (addrElement) {
+                    NetAddrToString(&addrElement->mAddress, buf, sizeof(buf));
+                    LOG(("  [%s]\n", buf));
+                }
+            }
+            while (addrElement);
+        }
+    }
+#endif
+    NS_RELEASE(he->rec);
+}
+
+static void
+HostDB_InitEntry(PLDHashEntryHdr *entry,
+                 const void *key)
+{
+    nsHostDBEnt *he = static_cast<nsHostDBEnt *>(entry);
+    nsHostRecord::Create(static_cast<const nsHostKey *>(key), &he->rec);
+}
+
+static const PLDHashTableOps gHostDB_ops =
+{
+    HostDB_HashKey,
+    HostDB_MatchEntry,
+    HostDB_MoveEntry,
+    HostDB_ClearEntry,
+    HostDB_InitEntry,
+};
+
+//----------------------------------------------------------------------------
+
+#if TTL_AVAILABLE
+static const char kPrefGetTtl[] = "network.dns.get-ttl";
+static bool sGetTtlEnabled = false;
+
+static void DnsPrefChanged(const char* aPref, void* aClosure)
+{
+    MOZ_ASSERT(NS_IsMainThread(),
+               "Should be getting pref changed notification on main thread!");
+
+    if (strcmp(aPref, kPrefGetTtl) != 0) {
+        LOG(("DnsPrefChanged ignoring pref \"%s\"", aPref));
+        return;
+    }
+
+    auto self = static_cast<nsHostResolver*>(aClosure);
+    MOZ_ASSERT(self);
+
+    sGetTtlEnabled = Preferences::GetBool(kPrefGetTtl);
+}
+#endif
+
+nsHostResolver::nsHostResolver(uint32_t maxCacheEntries,
+                               uint32_t defaultCacheEntryLifetime,
+                               uint32_t defaultGracePeriod)
+    : mMaxCacheEntries(maxCacheEntries)
+    , mDefaultCacheLifetime(defaultCacheEntryLifetime)
+    , mDefaultGracePeriod(defaultGracePeriod)
+    , mLock("nsHostResolver.mLock")
+    , mIdleThreadCV(mLock, "nsHostResolver.mIdleThreadCV")
+    , mDB(&gHostDB_ops, sizeof(nsHostDBEnt), 0)
+    , mEvictionQSize(0)
+    , mShutdown(true)
+    , mNumIdleThreads(0)
+    , mThreadCount(0)
+    , mActiveAnyThreadCount(0)
+    , mPendingCount(0)
+{
+    mCreationTime = PR_Now();
+    PR_INIT_CLIST(&mHighQ);
+    PR_INIT_CLIST(&mMediumQ);
+    PR_INIT_CLIST(&mLowQ);
+    PR_INIT_CLIST(&mEvictionQ);
+
+    mLongIdleTimeout  = PR_SecondsToInterval(LongIdleTimeoutSeconds);
+    mShortIdleTimeout = PR_SecondsToInterval(ShortIdleTimeoutSeconds);
+}
+
+nsHostResolver::~nsHostResolver() = default;
+
+nsresult
+nsHostResolver::Init()
+{
+    if (NS_FAILED(GetAddrInfoInit())) {
+        return NS_ERROR_FAILURE;
+    }
+
+    mShutdown = false;
+
+#if TTL_AVAILABLE
+    // The preferences probably haven't been loaded from the disk yet, so we
+    // need to register a callback that will set up the experiment once they
+    // are. We also need to explicitly set a value for the props otherwise the
+    // callback won't be called.
+    {
+        DebugOnly<nsresult> rv = Preferences::RegisterCallbackAndCall(
+            &DnsPrefChanged, kPrefGetTtl, this);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                             "Could not register DNS TTL pref callback.");
+    }
+#endif
+
+#if defined(HAVE_RES_NINIT)
+    // We want to make sure the system is using the correct resolver settings,
+    // so we force it to reload those settings whenever we startup a subsequent
+    // nsHostResolver instance.  We assume that there is no reason to do this
+    // for the first nsHostResolver instance since that is usually created
+    // during application startup.
+    static int initCount = 0;
+    if (initCount++ > 0) {
+        LOG(("Calling 'res_ninit'.\n"));
+        res_ninit(&_res);
+    }
+#endif
+    return NS_OK;
+}
+
+void
+nsHostResolver::ClearPendingQueue(PRCList *aPendingQ)
+{
+    // loop through pending queue, erroring out pending lookups.
+    if (!PR_CLIST_IS_EMPTY(aPendingQ)) {
+        PRCList *node = aPendingQ->next;
+        while (node != aPendingQ) {
+            nsHostRecord *rec = static_cast<nsHostRecord *>(node);
+            node = node->next;
+            OnLookupComplete(rec, NS_ERROR_ABORT, nullptr);
+        }
+    }
+}
+
+//
+// FlushCache() is what we call when the network has changed. We must not
+// trust names that were resolved before this change. They may resolve
+// differently now.
+//
+// This function removes all existing resolved host entries from the hash.
+// Names that are in the pending queues can be left there. Entries in the
+// cache that have 'Resolve' set true but not 'onQueue' are being resolved
+// right now, so we need to mark them to get re-resolved on completion!
+
+void
+nsHostResolver::FlushCache()
+{
+    MutexAutoLock lock(mLock);
+    mEvictionQSize = 0;
+
+    // Clear the evictionQ and remove all its corresponding entries from
+    // the cache first
+    if (!PR_CLIST_IS_EMPTY(&mEvictionQ)) {
+        PRCList *node = mEvictionQ.next;
+        while (node != &mEvictionQ) {
+            nsHostRecord *rec = static_cast<nsHostRecord *>(node);
+            node = node->next;
+            PR_REMOVE_AND_INIT_LINK(rec);
+            mDB.Remove((nsHostKey *) rec);
+            NS_RELEASE(rec);
+        }
+    }
+
+    // Refresh the cache entries that are resolving RIGHT now, remove the rest.
+    for (auto iter = mDB.Iter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<nsHostDBEnt *>(iter.Get());
+        // Try to remove the record, or mark it for refresh.
+        if (entry->rec->RemoveOrRefresh()) {
+            PR_REMOVE_LINK(entry->rec);
+            iter.Remove();
+        }
+    }
+}
+
+void
+nsHostResolver::Shutdown()
+{
+    LOG(("Shutting down host resolver.\n"));
+
+#if TTL_AVAILABLE
+    {
+        DebugOnly<nsresult> rv = Preferences::UnregisterCallback(
+            &DnsPrefChanged, kPrefGetTtl, this);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                             "Could not unregister DNS TTL pref callback.");
+    }
+#endif
+
+    PRCList pendingQHigh, pendingQMed, pendingQLow, evictionQ;
+    PR_INIT_CLIST(&pendingQHigh);
+    PR_INIT_CLIST(&pendingQMed);
+    PR_INIT_CLIST(&pendingQLow);
+    PR_INIT_CLIST(&evictionQ);
+
+    {
+        MutexAutoLock lock(mLock);
+
+        mShutdown = true;
+
+        MoveCList(mHighQ, pendingQHigh);
+        MoveCList(mMediumQ, pendingQMed);
+        MoveCList(mLowQ, pendingQLow);
+        MoveCList(mEvictionQ, evictionQ);
+        mEvictionQSize = 0;
+        mPendingCount = 0;
+
+        if (mNumIdleThreads)
+            mIdleThreadCV.NotifyAll();
+
+        // empty host database
+        mDB.Clear();
+    }
+
+    ClearPendingQueue(&pendingQHigh);
+    ClearPendingQueue(&pendingQMed);
+    ClearPendingQueue(&pendingQLow);
+
+    if (!PR_CLIST_IS_EMPTY(&evictionQ)) {
+        PRCList *node = evictionQ.next;
+        while (node != &evictionQ) {
+            nsHostRecord *rec = static_cast<nsHostRecord *>(node);
+            node = node->next;
+            NS_RELEASE(rec);
+        }
+    }
+
+#ifdef NS_BUILD_REFCNT_LOGGING
+    
+    // Logically join the outstanding worker threads with a timeout.
+    // Use this approach instead of PR_JoinThread() because that does 
+    // not allow a timeout which may be necessary for a semi-responsive 
+    // shutdown if the thread is blocked on a very slow DNS resolution.
+    // mThreadCount is read outside of mLock, but the worst case 
+    // scenario for that race is one extra 25ms sleep.
+
+    PRIntervalTime delay = PR_MillisecondsToInterval(25);
+    PRIntervalTime stopTime = PR_IntervalNow() + PR_SecondsToInterval(20);
+    while (mThreadCount && PR_IntervalNow() < stopTime)
+        PR_Sleep(delay);
+#endif
+
+    {
+        mozilla::DebugOnly<nsresult> rv = GetAddrInfoShutdown();
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                             "Failed to shutdown GetAddrInfo");
+    }
+}
+
+void 
+nsHostResolver::MoveQueue(nsHostRecord *aRec, PRCList &aDestQ)
+{
+    NS_ASSERTION(aRec->onQueue, "Moving Host Record Not Currently Queued");
+    
+    PR_REMOVE_LINK(aRec);
+    PR_APPEND_LINK(aRec, &aDestQ);
+}
+
+nsresult
+nsHostResolver::ResolveHost(const char            *host,
+                            uint16_t               flags,
+                            uint16_t               af,
+                            const char            *netInterface,
+                            nsResolveHostCallback *callback)
+{
+    NS_ENSURE_TRUE(host && *host, NS_ERROR_UNEXPECTED);
+    NS_ENSURE_TRUE(netInterface, NS_ERROR_UNEXPECTED);
+
+    LOG(("Resolving host [%s%s%s]%s.\n", LOG_HOST(host, netInterface),
+         flags & RES_BYPASS_CACHE ? " - bypassing cache" : ""));
+
+    // ensure that we are working with a valid hostname before proceeding.  see
+    // bug 304904 for details.
+    if (!net_IsValidHostName(nsDependentCString(host)))
+        return NS_ERROR_UNKNOWN_HOST;
+
+    // if result is set inside the lock, then we need to issue the
+    // callback before returning.
+    RefPtr<nsHostRecord> result;
+    nsresult status = NS_OK, rv = NS_OK;
+    {
+        MutexAutoLock lock(mLock);
+
+        if (mShutdown)
+            rv = NS_ERROR_NOT_INITIALIZED;
+        else {
+            // Used to try to parse to an IP address literal.
+            PRNetAddr tempAddr;
+            // Unfortunately, PR_StringToNetAddr does not properly initialize
+            // the output buffer in the case of IPv6 input. See bug 223145.
+            memset(&tempAddr, 0, sizeof(PRNetAddr));
+            
+            // check to see if there is already an entry for this |host|
+            // in the hash table.  if so, then check to see if we can't
+            // just reuse the lookup result.  otherwise, if there are
+            // any pending callbacks, then add to pending callbacks queue,
+            // and return.  otherwise, add ourselves as first pending
+            // callback, and proceed to do the lookup.
+
+            nsHostKey key = { host, flags, af, netInterface };
+            auto he = static_cast<nsHostDBEnt*>(mDB.Add(&key, fallible));
+
+            // if the record is null, the hash table OOM'd.
+            if (!he) {
+                LOG(("  Out of memory: no cache entry for host [%s%s%s].\n",
+                     LOG_HOST(host, netInterface)));
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            // do we have a cached result that we can reuse?
+            else if (!(flags & RES_BYPASS_CACHE) &&
+                     he->rec->HasUsableResult(TimeStamp::NowLoRes(), flags)) {
+                LOG(("  Using cached record for host [%s%s%s].\n",
+                     LOG_HOST(host, netInterface)));
+                // put reference to host record on stack...
+                result = he->rec;
+                Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2, METHOD_HIT);
+
+                // For entries that are in the grace period
+                // or all cached negative entries, use the cache but start a new
+                // lookup in the background
+                ConditionallyRefreshRecord(he->rec, host);
+                
+                if (he->rec->negative) {
+                    LOG(("  Negative cache entry for host [%s%s%s].\n",
+                         LOG_HOST(host, netInterface)));
+                    Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                          METHOD_NEGATIVE_HIT);
+                    status = NS_ERROR_UNKNOWN_HOST;
+                }
+            }
+            // if the host name is an IP address literal and has been parsed,
+            // go ahead and use it.
+            else if (he->rec->addr) {
+                LOG(("  Using cached address for IP Literal [%s].\n", host));
+                Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                      METHOD_LITERAL);
+                result = he->rec;
+            }
+            // try parsing the host name as an IP address literal to short
+            // circuit full host resolution.  (this is necessary on some
+            // platforms like Win9x.  see bug 219376 for more details.)
+            else if (PR_StringToNetAddr(host, &tempAddr) == PR_SUCCESS) {
+                LOG(("  Host is IP Literal [%s].\n", host));
+                // ok, just copy the result into the host record, and be done
+                // with it! ;-)
+                he->rec->addr = new NetAddr();
+                PRNetAddrToNetAddr(&tempAddr, he->rec->addr);
+                // put reference to host record on stack...
+                Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                      METHOD_LITERAL);
+                result = he->rec;
+            }
+            else if (mPendingCount >= MAX_NON_PRIORITY_REQUESTS &&
+                     !IsHighPriority(flags) &&
+                     !he->rec->resolving) {
+                LOG(("  Lookup queue full: dropping %s priority request for "
+                     "host [%s%s%s].\n",
+                     IsMediumPriority(flags) ? "medium" : "low",
+                     LOG_HOST(host, netInterface)));
+                Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                      METHOD_OVERFLOW);
+                // This is a lower priority request and we are swamped, so refuse it.
+                rv = NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
+            }
+            else if (flags & RES_OFFLINE) {
+                LOG(("  Offline request for host [%s%s%s]; ignoring.\n",
+                     LOG_HOST(host, netInterface)));
+                rv = NS_ERROR_OFFLINE;
+            }
+
+            // If this is an IPV4 or IPV6 specific request, check if there is
+            // an AF_UNSPEC entry we can use. Otherwise, hit the resolver...
+            else if (!he->rec->resolving) {
+                if (!(flags & RES_BYPASS_CACHE) &&
+                    ((af == PR_AF_INET) || (af == PR_AF_INET6))) {
+                    // First, search for an entry with AF_UNSPEC
+                    const nsHostKey unspecKey = { host, flags, PR_AF_UNSPEC,
+                                                  netInterface };
+                    auto unspecHe =
+                        static_cast<nsHostDBEnt*>(mDB.Search(&unspecKey));
+                    NS_ASSERTION(!unspecHe ||
+                                 (unspecHe && unspecHe->rec),
+                                "Valid host entries should contain a record");
+                    TimeStamp now = TimeStamp::NowLoRes();
+                    if (unspecHe &&
+                        unspecHe->rec->HasUsableResult(now, flags)) {
+
+                        MOZ_ASSERT(unspecHe->rec->addr_info || unspecHe->rec->negative,
+                                   "Entry should be resolved or negative.");
+
+                        LOG(("  Trying AF_UNSPEC entry for host [%s%s%s] af: %s.\n",
+                             LOG_HOST(host, netInterface),
+                             (af == PR_AF_INET) ? "AF_INET" : "AF_INET6"));
+
+                        he->rec->addr_info = nullptr;
+                        if (unspecHe->rec->negative) {
+                            he->rec->negative = unspecHe->rec->negative;
+                            he->rec->CopyExpirationTimesAndFlagsFrom(unspecHe->rec);
+                        } else if (unspecHe->rec->addr_info) {
+                            // Search for any valid address in the AF_UNSPEC entry
+                            // in the cache (not blacklisted and from the right
+                            // family).
+                            NetAddrElement *addrIter =
+                                unspecHe->rec->addr_info->mAddresses.getFirst();
+                            while (addrIter) {
+                                if ((af == addrIter->mAddress.inet.family) &&
+                                     !unspecHe->rec->Blacklisted(&addrIter->mAddress)) {
+                                    if (!he->rec->addr_info) {
+                                        he->rec->addr_info = new AddrInfo(
+                                            unspecHe->rec->addr_info->mHostName,
+                                            unspecHe->rec->addr_info->mCanonicalName);
+                                        he->rec->CopyExpirationTimesAndFlagsFrom(unspecHe->rec);
+                                    }
+                                    he->rec->addr_info->AddAddress(
+                                        new NetAddrElement(*addrIter));
+                                }
+                                addrIter = addrIter->getNext();
+                            }
+                        }
+                        // Now check if we have a new record.
+                        if (he->rec->HasUsableResult(now, flags)) {
+                            result = he->rec;
+                            if (he->rec->negative) {
+                                status = NS_ERROR_UNKNOWN_HOST;
+                            }
+                            Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                                  METHOD_HIT);
+                            ConditionallyRefreshRecord(he->rec, host);
+                        }
+                        // For AF_INET6, a new lookup means another AF_UNSPEC
+                        // lookup. We have already iterated through the
+                        // AF_UNSPEC addresses, so we mark this record as
+                        // negative.
+                        else if (af == PR_AF_INET6) {
+                            LOG(("  No AF_INET6 in AF_UNSPEC entry: "
+                                 "host [%s%s%s] unknown host.",
+                                 LOG_HOST(host, netInterface)));
+                            result = he->rec;
+                            he->rec->negative = true;
+                            status = NS_ERROR_UNKNOWN_HOST;
+                            Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                                  METHOD_NEGATIVE_HIT);
+                        }
+                    }
+                }
+                // If no valid address was found in the cache or this is an
+                // AF_UNSPEC request, then start a new lookup.
+                if (!result) {
+                    LOG(("  No usable address in cache for host [%s%s%s].",
+                         LOG_HOST(host, netInterface)));
+
+                    // Add callback to the list of pending callbacks.
+                    PR_APPEND_LINK(callback, &he->rec->callbacks);
+                    he->rec->flags = flags;
+                    rv = IssueLookup(he->rec);
+                    Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                          METHOD_NETWORK_FIRST);
+                    if (NS_FAILED(rv)) {
+                        PR_REMOVE_AND_INIT_LINK(callback);
+                    }
+                    else {
+                        LOG(("  DNS lookup for host [%s%s%s] blocking "
+                             "pending 'getaddrinfo' query: callback [%p]",
+                             LOG_HOST(host, netInterface), callback));
+                    }
+                }
+            }
+            else {
+                LOG(("  Host [%s%s%s] is being resolved. Appending callback "
+                     "[%p].", LOG_HOST(host, netInterface), callback));
+
+                PR_APPEND_LINK(callback, &he->rec->callbacks);
+                if (he->rec->onQueue) {
+                    Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                                          METHOD_NETWORK_SHARED);
+
+                    // Consider the case where we are on a pending queue of
+                    // lower priority than the request is being made at.
+                    // In that case we should upgrade to the higher queue.
+
+                    if (IsHighPriority(flags) &&
+                        !IsHighPriority(he->rec->flags)) {
+                        // Move from (low|med) to high.
+                        MoveQueue(he->rec, mHighQ);
+                        he->rec->flags = flags;
+                        ConditionallyCreateThread(he->rec);
+                    } else if (IsMediumPriority(flags) &&
+                               IsLowPriority(he->rec->flags)) {
+                        // Move from low to med.
+                        MoveQueue(he->rec, mMediumQ);
+                        he->rec->flags = flags;
+                        mIdleThreadCV.Notify();
+                    }
+                }
+            }
+        }
+    }
+    if (result) {
+        callback->OnLookupComplete(this, result, status);
+    }
+
+    return rv;
+}
+
+void
+nsHostResolver::DetachCallback(const char            *host,
+                               uint16_t               flags,
+                               uint16_t               af,
+                               const char            *netInterface,
+                               nsResolveHostCallback *callback,
+                               nsresult               status)
+{
+    RefPtr<nsHostRecord> rec;
+    {
+        MutexAutoLock lock(mLock);
+
+        nsHostKey key = { host, flags, af, netInterface };
+        auto he = static_cast<nsHostDBEnt*>(mDB.Search(&key));
+        if (he) {
+            // walk list looking for |callback|... we cannot assume
+            // that it will be there!
+            PRCList *node = he->rec->callbacks.next;
+            while (node != &he->rec->callbacks) {
+                if (static_cast<nsResolveHostCallback *>(node) == callback) {
+                    PR_REMOVE_LINK(callback);
+                    rec = he->rec;
+                    break;
+                }
+                node = node->next;
+            }
+        }
+    }
+
+    // complete callback with the given status code; this would only be done if
+    // the record was in the process of being resolved.
+    if (rec)
+        callback->OnLookupComplete(this, rec, status);
+}
+
+nsresult
+nsHostResolver::ConditionallyCreateThread(nsHostRecord *rec)
+{
+    if (mNumIdleThreads) {
+        // wake up idle thread to process this lookup
+        mIdleThreadCV.Notify();
+    }
+    else if ((mThreadCount < HighThreadThreshold) ||
+             (IsHighPriority(rec->flags) && mThreadCount < MAX_RESOLVER_THREADS)) {
+        // dispatch new worker thread
+        NS_ADDREF_THIS(); // owning reference passed to thread
+
+        mThreadCount++;
+        PRThread *thr = PR_CreateThread(PR_SYSTEM_THREAD,
+                                        ThreadFunc,
+                                        this,
+                                        PR_PRIORITY_NORMAL,
+                                        PR_GLOBAL_THREAD,
+                                        PR_UNJOINABLE_THREAD,
+                                        0);
+        if (!thr) {
+            mThreadCount--;
+            NS_RELEASE_THIS();
+            return NS_ERROR_OUT_OF_MEMORY;
+        }
+    }
+    else {
+        LOG(("  Unable to find a thread for looking up host [%s%s%s].\n",
+             LOG_HOST(rec->host, rec->netInterface)));
+    }
+    return NS_OK;
+}
+
+nsresult
+nsHostResolver::IssueLookup(nsHostRecord *rec)
+{
+    nsresult rv = NS_OK;
+    NS_ASSERTION(!rec->resolving, "record is already being resolved");
+
+    // Add rec to one of the pending queues, possibly removing it from mEvictionQ.
+    // If rec is on mEvictionQ, then we can just move the owning
+    // reference over to the new active queue.
+    if (rec->next == rec)
+        NS_ADDREF(rec);
+    else {
+        PR_REMOVE_LINK(rec);
+        mEvictionQSize--;
+    }
+    
+    switch (nsHostRecord::GetPriority(rec->flags)) {
+        case nsHostRecord::DNS_PRIORITY_HIGH:
+            PR_APPEND_LINK(rec, &mHighQ);
+            break;
+
+        case nsHostRecord::DNS_PRIORITY_MEDIUM:
+            PR_APPEND_LINK(rec, &mMediumQ);
+            break;
+
+        case nsHostRecord::DNS_PRIORITY_LOW:
+            PR_APPEND_LINK(rec, &mLowQ);
+            break;
+    }
+    mPendingCount++;
+    
+    rec->resolving = true;
+    rec->onQueue = true;
+
+    rv = ConditionallyCreateThread(rec);
+    
+    LOG (("  DNS thread counters: total=%d any-live=%d idle=%d pending=%d\n",
+          static_cast<uint32_t>(mThreadCount),
+          static_cast<uint32_t>(mActiveAnyThreadCount),
+          static_cast<uint32_t>(mNumIdleThreads),
+          static_cast<uint32_t>(mPendingCount)));
+
+    return rv;
+}
+
+nsresult
+nsHostResolver::ConditionallyRefreshRecord(nsHostRecord *rec, const char *host)
+{
+    if ((rec->CheckExpiration(TimeStamp::NowLoRes()) != nsHostRecord::EXP_VALID
+            || rec->negative) && !rec->resolving) {
+        LOG(("  Using %s cache entry for host [%s] but starting async renewal.",
+            rec->negative ? "negative" :"positive", host));
+        IssueLookup(rec);
+
+        if (!rec->negative) {
+            // negative entries are constantly being refreshed, only
+            // track positive grace period induced renewals
+            Telemetry::Accumulate(Telemetry::DNS_LOOKUP_METHOD2,
+                METHOD_RENEWAL);
+        }
+    }
+    return NS_OK;
+}
+
+void
+nsHostResolver::DeQueue(PRCList &aQ, nsHostRecord **aResult)
+{
+    *aResult = static_cast<nsHostRecord *>(aQ.next);
+    PR_REMOVE_AND_INIT_LINK(*aResult);
+    mPendingCount--;
+    (*aResult)->onQueue = false;
+}
+
+bool
+nsHostResolver::GetHostToLookup(nsHostRecord **result)
+{
+    bool timedOut = false;
+    PRIntervalTime epoch, now, timeout;
+
+    MutexAutoLock lock(mLock);
+
+    timeout = (mNumIdleThreads >= HighThreadThreshold) ? mShortIdleTimeout : mLongIdleTimeout;
+    epoch = PR_IntervalNow();
+
+    while (!mShutdown) {
+        // remove next record from Q; hand over owning reference. Check high, then med, then low
+        
+#if TTL_AVAILABLE
+        #define SET_GET_TTL(var, val) \
+            (var)->mGetTtl = sGetTtlEnabled && (val)
+#else
+        #define SET_GET_TTL(var, val)
+#endif
+
+        if (!PR_CLIST_IS_EMPTY(&mHighQ)) {
+            DeQueue (mHighQ, result);
+            SET_GET_TTL(*result, false);
+            return true;
+        }
+
+        if (mActiveAnyThreadCount < HighThreadThreshold) {
+            if (!PR_CLIST_IS_EMPTY(&mMediumQ)) {
+                DeQueue (mMediumQ, result);
+                mActiveAnyThreadCount++;
+                (*result)->usingAnyThread = true;
+                SET_GET_TTL(*result, true);
+                return true;
+            }
+            
+            if (!PR_CLIST_IS_EMPTY(&mLowQ)) {
+                DeQueue (mLowQ, result);
+                mActiveAnyThreadCount++;
+                (*result)->usingAnyThread = true;
+                SET_GET_TTL(*result, true);
+                return true;
+            }
+        }
+        
+        // Determining timeout is racy, so allow one cycle through checking the queues
+        // before exiting.
+        if (timedOut)
+            break;
+
+        // wait for one or more of the following to occur:
+        //  (1) the pending queue has a host record to process
+        //  (2) the shutdown flag has been set
+        //  (3) the thread has been idle for too long
+        
+        mNumIdleThreads++;
+        mIdleThreadCV.Wait(timeout);
+        mNumIdleThreads--;
+        
+        now = PR_IntervalNow();
+        
+        if ((PRIntervalTime)(now - epoch) >= timeout)
+            timedOut = true;
+        else {
+            // It is possible that PR_WaitCondVar() was interrupted and returned early,
+            // in which case we will loop back and re-enter it. In that case we want to
+            // do so with the new timeout reduced to reflect time already spent waiting.
+            timeout -= (PRIntervalTime)(now - epoch);
+            epoch = now;
+        }
+    }
+    
+    // tell thread to exit...
+    return false;
+}
+
+void
+nsHostResolver::PrepareRecordExpiration(nsHostRecord* rec) const
+{
+    MOZ_ASSERT(((bool)rec->addr_info) != rec->negative);
+    if (!rec->addr_info) {
+        rec->SetExpiration(TimeStamp::NowLoRes(),
+                           NEGATIVE_RECORD_LIFETIME, 0);
+        LOG(("Caching host [%s%s%s] negative record for %u seconds.\n",
+             LOG_HOST(rec->host, rec->netInterface),
+             NEGATIVE_RECORD_LIFETIME));
+        return;
+    }
+
+    unsigned int lifetime = mDefaultCacheLifetime;
+    unsigned int grace = mDefaultGracePeriod;
+#if TTL_AVAILABLE
+    unsigned int ttl = mDefaultCacheLifetime;
+    if (sGetTtlEnabled) {
+        MutexAutoLock lock(rec->addr_info_lock);
+        if (rec->addr_info && rec->addr_info->ttl != AddrInfo::NO_TTL_DATA) {
+            ttl = rec->addr_info->ttl;
+        }
+        lifetime = ttl;
+        grace = 0;
+    }
+#endif
+
+    rec->SetExpiration(TimeStamp::NowLoRes(), lifetime, grace);
+    LOG(("Caching host [%s%s%s] record for %u seconds (grace %d).",
+         LOG_HOST(rec->host, rec->netInterface), lifetime, grace));
+}
+
+static bool
+different_rrset(AddrInfo *rrset1, AddrInfo *rrset2)
+{
+    if (!rrset1 || !rrset2) {
+        return true;
+    }
+
+    LOG(("different_rrset %s\n", rrset1->mHostName));
+    nsTArray<NetAddr> orderedSet1;
+    nsTArray<NetAddr> orderedSet2;
+
+    for (NetAddrElement *element = rrset1->mAddresses.getFirst();
+         element; element = element->getNext()) {
+        if (LOG_ENABLED()) {
+            char buf[128];
+            NetAddrToString(&element->mAddress, buf, 128);
+            LOG(("different_rrset add to set 1 %s\n", buf));
+        }
+        orderedSet1.InsertElementAt(orderedSet1.Length(), element->mAddress);
+    }
+
+    for (NetAddrElement *element = rrset2->mAddresses.getFirst();
+         element; element = element->getNext()) {
+        if (LOG_ENABLED()) {
+            char buf[128];
+            NetAddrToString(&element->mAddress, buf, 128);
+            LOG(("different_rrset add to set 2 %s\n", buf));
+        }
+        orderedSet2.InsertElementAt(orderedSet2.Length(), element->mAddress);
+    }
+
+    if (orderedSet1.Length() != orderedSet2.Length()) {
+        LOG(("different_rrset true due to length change\n"));
+        return true;
+    }
+    orderedSet1.Sort();
+    orderedSet2.Sort();
+
+    for (uint32_t i = 0; i < orderedSet1.Length(); ++i) {
+        if (!(orderedSet1[i] == orderedSet2[i])) {
+            LOG(("different_rrset true due to content change\n"));
+            return true;
+        }
+    }
+    LOG(("different_rrset false\n"));
+    return false;
+}
+
+//
+// OnLookupComplete() checks if the resolving should be redone and if so it
+// returns LOOKUP_RESOLVEAGAIN, but only if 'status' is not NS_ERROR_ABORT.
+// takes ownership of AddrInfo parameter
+nsHostResolver::LookupStatus
+nsHostResolver::OnLookupComplete(nsHostRecord* rec, nsresult status, AddrInfo* newRRSet)
+{
+    // get the list of pending callbacks for this lookup, and notify
+    // them that the lookup is complete.
+    PRCList cbs;
+    PR_INIT_CLIST(&cbs);
+    {
+        MutexAutoLock lock(mLock);
+
+        if (rec->mResolveAgain && (status != NS_ERROR_ABORT)) {
+            LOG(("nsHostResolver record %p resolve again due to flushcache\n", rec));
+            rec->mResolveAgain = false;
+            delete newRRSet;
+            return LOOKUP_RESOLVEAGAIN;
+        }
+
+        // grab list of callbacks to notify
+        MoveCList(rec->callbacks, cbs);
+
+        // update record fields.  We might have a rec->addr_info already if a
+        // previous lookup result expired and we're reresolving it..
+        AddrInfo  *old_addr_info;
+        {
+            MutexAutoLock lock(rec->addr_info_lock);
+            if (different_rrset(rec->addr_info, newRRSet)) {
+                LOG(("nsHostResolver record %p new gencnt\n", rec));
+                old_addr_info = rec->addr_info;
+                rec->addr_info = newRRSet;
+                rec->addr_info_gencnt++;
+            } else {
+                if (rec->addr_info && newRRSet) {
+                    rec->addr_info->ttl = newRRSet->ttl;
+                }
+                old_addr_info = newRRSet;
+            }
+        }
+        delete old_addr_info;
+
+        rec->negative = !rec->addr_info;
+        PrepareRecordExpiration(rec);
+        rec->resolving = false;
+        
+        if (rec->usingAnyThread) {
+            mActiveAnyThreadCount--;
+            rec->usingAnyThread = false;
+        }
+
+        if (!mShutdown) {
+            // add to mEvictionQ
+            PR_APPEND_LINK(rec, &mEvictionQ);
+            NS_ADDREF(rec);
+            if (mEvictionQSize < mMaxCacheEntries)
+                mEvictionQSize++;
+            else {
+                // remove first element on mEvictionQ
+                nsHostRecord *head =
+                    static_cast<nsHostRecord *>(PR_LIST_HEAD(&mEvictionQ));
+                PR_REMOVE_AND_INIT_LINK(head);
+                mDB.Remove((nsHostKey *) head);
+
+                if (!head->negative) {
+                    // record the age of the entry upon eviction.
+                    TimeDuration age = TimeStamp::NowLoRes() - head->mValidStart;
+                    Telemetry::Accumulate(Telemetry::DNS_CLEANUP_AGE,
+                                          static_cast<uint32_t>(age.ToSeconds() / 60));
+                }
+
+                // release reference to rec owned by mEvictionQ
+                NS_RELEASE(head);
+            }
+#if TTL_AVAILABLE
+            if (!rec->mGetTtl && !rec->resolving && sGetTtlEnabled) {
+                LOG(("Issuing second async lookup for TTL for host [%s%s%s].",
+                     LOG_HOST(rec->host, rec->netInterface)));
+                rec->flags =
+                  (rec->flags & ~RES_PRIORITY_MEDIUM) | RES_PRIORITY_LOW;
+                DebugOnly<nsresult> rv = IssueLookup(rec);
+                NS_WARNING_ASSERTION(
+                    NS_SUCCEEDED(rv),
+                    "Could not issue second async lookup for TTL.");
+            }
+#endif
+        }
+    }
+
+    if (!PR_CLIST_IS_EMPTY(&cbs)) {
+        PRCList *node = cbs.next;
+        while (node != &cbs) {
+            nsResolveHostCallback *callback =
+                    static_cast<nsResolveHostCallback *>(node);
+            node = node->next;
+            callback->OnLookupComplete(this, rec, status);
+            // NOTE: callback must not be dereferenced after this point!!
+        }
+    }
+
+    NS_RELEASE(rec);
+
+    return LOOKUP_OK;
+}
+
+void
+nsHostResolver::CancelAsyncRequest(const char            *host,
+                                   uint16_t               flags,
+                                   uint16_t               af,
+                                   const char            *netInterface,
+                                   nsIDNSListener        *aListener,
+                                   nsresult               status)
+
+{
+    MutexAutoLock lock(mLock);
+
+    // Lookup the host record associated with host, flags & address family
+    nsHostKey key = { host, flags, af, netInterface };
+    auto he = static_cast<nsHostDBEnt*>(mDB.Search(&key));
+    if (he) {
+        nsHostRecord* recPtr = nullptr;
+        PRCList *node = he->rec->callbacks.next;
+        // Remove the first nsDNSAsyncRequest callback which matches the
+        // supplied listener object
+        while (node != &he->rec->callbacks) {
+            nsResolveHostCallback *callback
+                = static_cast<nsResolveHostCallback *>(node);
+            if (callback && (callback->EqualsAsyncListener(aListener))) {
+                // Remove from the list of callbacks
+                PR_REMOVE_LINK(callback);
+                recPtr = he->rec;
+                callback->OnLookupComplete(this, recPtr, status);
+                break;
+            }
+            node = node->next;
+        }
+
+        // If there are no more callbacks, remove the hash table entry
+        if (recPtr && PR_CLIST_IS_EMPTY(&recPtr->callbacks)) {
+            mDB.Remove((nsHostKey *)recPtr);
+            // If record is on a Queue, remove it and then deref it
+            if (recPtr->next != recPtr) {
+                PR_REMOVE_LINK(recPtr);
+                NS_RELEASE(recPtr);
+            }
+        }
+    }
+}
+
+size_t
+nsHostResolver::SizeOfIncludingThis(MallocSizeOf mallocSizeOf) const
+{
+    MutexAutoLock lock(mLock);
+
+    size_t n = mallocSizeOf(this);
+
+    n += mDB.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (auto iter = mDB.ConstIter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<nsHostDBEnt*>(iter.Get());
+        n += entry->rec->SizeOfIncludingThis(mallocSizeOf);
+    }
+
+    // The following fields aren't measured.
+    // - mHighQ, mMediumQ, mLowQ, mEvictionQ, because they just point to
+    //   nsHostRecords that also pointed to by entries |mDB|, and measured when
+    //   |mDB| is measured.
+
+    return n;
+}
+
+void
+nsHostResolver::ThreadFunc(void *arg)
+{
+    LOG(("DNS lookup thread - starting execution.\n"));
+
+    static nsThreadPoolNaming naming;
+    naming.SetThreadPoolName(NS_LITERAL_CSTRING("DNS Resolver"));
+
+#if defined(RES_RETRY_ON_FAILURE)
+    nsResState rs;
+#endif
+    nsHostResolver *resolver = (nsHostResolver *)arg;
+    nsHostRecord *rec  = nullptr;
+    AddrInfo *ai = nullptr;
+
+    while (rec || resolver->GetHostToLookup(&rec)) {
+        LOG(("DNS lookup thread - Calling getaddrinfo for host [%s%s%s].\n",
+             LOG_HOST(rec->host, rec->netInterface)));
+
+        TimeStamp startTime = TimeStamp::Now();
+#if TTL_AVAILABLE
+        bool getTtl = rec->mGetTtl;
+#else
+        bool getTtl = false;
+#endif
+
+        nsresult status = GetAddrInfo(rec->host, rec->af, rec->flags, rec->netInterface,
+                                      &ai, getTtl);
+#if defined(RES_RETRY_ON_FAILURE)
+        if (NS_FAILED(status) && rs.Reset()) {
+            status = GetAddrInfo(rec->host, rec->af, rec->flags, rec->netInterface, &ai,
+                                 getTtl);
+        }
+#endif
+
+        {   // obtain lock to check shutdown and manage inter-module telemetry
+            MutexAutoLock lock(resolver->mLock);
+
+            if (!resolver->mShutdown) {
+                TimeDuration elapsed = TimeStamp::Now() - startTime;
+                uint32_t millis = static_cast<uint32_t>(elapsed.ToMilliseconds());
+
+                if (NS_SUCCEEDED(status)) {
+                    Telemetry::ID histogramID;
+                    if (!rec->addr_info_gencnt) {
+                        // Time for initial lookup.
+                        histogramID = Telemetry::DNS_LOOKUP_TIME;
+                    } else if (!getTtl) {
+                        // Time for renewal; categorized by expiration strategy.
+                        histogramID = Telemetry::DNS_RENEWAL_TIME;
+                    } else {
+                        // Time to get TTL; categorized by expiration strategy.
+                        histogramID = Telemetry::DNS_RENEWAL_TIME_FOR_TTL;
+                    }
+                    Telemetry::Accumulate(histogramID, millis);
+                } else {
+                    Telemetry::Accumulate(Telemetry::DNS_FAILED_LOOKUP_TIME, millis);
+                }
+            }
+        }
+
+        // OnLookupComplete may release "rec", long before we lose it.
+        LOG(("DNS lookup thread - lookup completed for host [%s%s%s]: %s.\n",
+             LOG_HOST(rec->host, rec->netInterface),
+             ai ? "success" : "failure: unknown host"));
+
+        if (LOOKUP_RESOLVEAGAIN == resolver->OnLookupComplete(rec, status, ai)) {
+            // leave 'rec' assigned and loop to make a renewed host resolve
+            LOG(("DNS lookup thread - Re-resolving host [%s%s%s].\n",
+                 LOG_HOST(rec->host, rec->netInterface)));
+        } else {
+            rec = nullptr;
+        }
+    }
+    resolver->mThreadCount--;
+    NS_RELEASE(resolver);
+    LOG(("DNS lookup thread - queue empty, thread finished.\n"));
+}
+
+nsresult
+nsHostResolver::Create(uint32_t maxCacheEntries,
+                       uint32_t defaultCacheEntryLifetime,
+                       uint32_t defaultGracePeriod,
+                       nsHostResolver **result)
+{
+    auto *res = new nsHostResolver(maxCacheEntries, defaultCacheEntryLifetime,
+                                             defaultGracePeriod);
+    NS_ADDREF(res);
+
+    nsresult rv = res->Init();
+    if (NS_FAILED(rv))
+        NS_RELEASE(res);
+
+    *result = res;
+    return rv;
+}
+
+void
+nsHostResolver::GetDNSCacheEntries(nsTArray<DNSCacheEntries> *args)
+{
+    for (auto iter = mDB.Iter(); !iter.Done(); iter.Next()) {
+        // We don't pay attention to address literals, only resolved domains.
+        // Also require a host.
+        auto entry = static_cast<nsHostDBEnt*>(iter.Get());
+        nsHostRecord* rec = entry->rec;
+        MOZ_ASSERT(rec, "rec should never be null here!");
+        if (!rec || !rec->addr_info || !rec->host) {
+            continue;
+        }
+
+        DNSCacheEntries info;
+        info.hostname = rec->host;
+        info.family = rec->af;
+        info.netInterface = rec->netInterface;
+        info.expiration =
+            (int64_t)(rec->mValidEnd - TimeStamp::NowLoRes()).ToSeconds();
+        if (info.expiration <= 0) {
+            // We only need valid DNS cache entries
+            continue;
+        }
+
+        {
+            MutexAutoLock lock(rec->addr_info_lock);
+
+            NetAddr *addr = nullptr;
+            NetAddrElement *addrElement = rec->addr_info->mAddresses.getFirst();
+            if (addrElement) {
+                addr = &addrElement->mAddress;
+            }
+            while (addr) {
+                char buf[kIPv6CStrBufSize];
+                if (NetAddrToString(addr, buf, sizeof(buf))) {
+                    info.hostaddr.AppendElement(buf);
+                }
+                addr = nullptr;
+                addrElement = addrElement->getNext();
+                if (addrElement) {
+                    addr = &addrElement->mAddress;
+                }
+            }
+        }
+
+        args->AppendElement(info);
+    }
+}