The Tor Browser: comparison netwerk/dns/nsHostResolver.h

--1:000000000000
+:862cecd46db7
+/* 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/. */
+#ifndef nsHostResolver_h__
+#define nsHostResolver_h__
+#include "nscore.h"
+#include "prclist.h"
+#include "prnetdb.h"
+#include "pldhash.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
+#include "nsISupportsImpl.h"
+#include "nsIDNSListener.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "mozilla/net/DNS.h"
+#include "mozilla/net/DashboardTypes.h"
+#include "mozilla/TimeStamp.h"
+class nsHostResolver;
+class nsHostRecord;
+class nsResolveHostCallback;
+#define MAX_RESOLVER_THREADS_FOR_ANY_PRIORITY  3
+#define MAX_RESOLVER_THREADS_FOR_HIGH_PRIORITY 5
+#define MAX_NON_PRIORITY_REQUESTS 150
+#define MAX_RESOLVER_THREADS (MAX_RESOLVER_THREADS_FOR_ANY_PRIORITY + \
+MAX_RESOLVER_THREADS_FOR_HIGH_PRIORITY)
+struct nsHostKey
+{
+const char *host;
+uint16_t    flags;
+uint16_t    af;
+};
+/**
+* nsHostRecord - ref counted object type stored in host resolver cache.
+*/
+class nsHostRecord : public PRCList, public nsHostKey
+{
+typedef mozilla::Mutex Mutex;
+public:
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHostRecord)
+/* instantiates a new host record */
+static nsresult Create(const nsHostKey *key, nsHostRecord **record);
+/* a fully resolved host record has either a non-null |addr_info| or |addr|
+* field.  if |addr_info| is null, it implies that the |host| is an IP
+* address literal.  in which case, |addr| contains the parsed address.
+* otherwise, if |addr_info| is non-null, then it contains one or many
+* IP addresses corresponding to the given host name.  if both |addr_info|
+* and |addr| are null, then the given host has not yet been fully resolved.
+* |af| is the address family of the record we are querying for.
+*/
+/* the lock protects |addr_info| and |addr_info_gencnt| because they
+* are mutable and accessed by the resolver worker thread and the
+* nsDNSService2 class.  |addr| doesn't change after it has been
+* assigned a value.  only the resolver worker thread modifies
+* nsHostRecord (and only in nsHostResolver::OnLookupComplete);
+* the other threads just read it.  therefore the resolver worker
+* thread doesn't need to lock when reading |addr_info|.
+*/
+Mutex        addr_info_lock;
+int          addr_info_gencnt; /* generation count of |addr_info| */
+mozilla::net::AddrInfo *addr_info;
+mozilla::net::NetAddr  *addr;
+bool         negative;   /* True if this record is a cache of a failed lookup.
+Negative cache entries are valid just like any other
+(though never for more than 60 seconds), but a use
+of that negative entry forces an asynchronous refresh. */
+mozilla::TimeStamp expiration;
+bool HasUsableResult(uint16_t queryFlags) const;
+// hold addr_info_lock when calling the blacklist functions
+bool   Blacklisted(mozilla::net::NetAddr *query);
+void   ResetBlacklist();
+void   ReportUnusable(mozilla::net::NetAddr *addr);
+size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+private:
+friend class nsHostResolver;
+PRCList callbacks; /* list of callbacks */
+bool    resolving; /* true if this record is being resolved, which means
+* that it is either on the pending queue or owned by
+* one of the worker threads. */
+bool    onQueue;  /* true if pending and on the queue (not yet given to getaddrinfo())*/
+bool    usingAnyThread; /* true if off queue and contributing to mActiveAnyThreadCount */
+bool    mDoomed; /* explicitly expired */
+// a list of addresses associated with this record that have been reported
+// as unusable. the list is kept as a set of strings to make it independent
+// of gencnt.
+nsTArray<nsCString> mBlacklistedItems;
+nsHostRecord(const nsHostKey *key);           /* use Create() instead */
+~nsHostRecord();
+};
+/**
+* ResolveHost callback object.  It's PRCList members are used by
+* the nsHostResolver and should not be used by anything else.
+*/
+class NS_NO_VTABLE nsResolveHostCallback : public PRCList
+{
+public:
+/**
+* OnLookupComplete
+*
+* this function is called to complete a host lookup initiated by
+* nsHostResolver::ResolveHost.  it may be invoked recursively from
+* ResolveHost or on an unspecified background thread.
+*
+* NOTE: it is the responsibility of the implementor of this method
+* to handle the callback in a thread safe manner.
+*
+* @param resolver
+*        nsHostResolver object associated with this result
+* @param record
+*        the host record containing the results of the lookup
+* @param status
+*        if successful, |record| contains non-null results
+*/
+virtual void OnLookupComplete(nsHostResolver *resolver,
+nsHostRecord   *record,
+nsresult        status) = 0;
+/**
+* EqualsAsyncListener
+*
+* Determines if the listener argument matches the listener member var.
+* For subclasses not implementing a member listener, should return false.
+* For subclasses having a member listener, the function should check if
+* they are the same.  Used for cases where a pointer to an object
+* implementing nsResolveHostCallback is unknown, but a pointer to
+* the original listener is known.
+*
+* @param aListener
+*        nsIDNSListener object associated with the original request
+*/
+virtual bool EqualsAsyncListener(nsIDNSListener *aListener) = 0;
+virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const = 0;
+};
+/**
+* nsHostResolver - an asynchronous host name resolver.
+*/
+class nsHostResolver
+{
+typedef mozilla::CondVar CondVar;
+typedef mozilla::Mutex Mutex;
+public:
+/**
+* host resolver instances are reference counted.
+*/
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsHostResolver)
+/**
+* creates an addref'd instance of a nsHostResolver object.
+*/
+static nsresult Create(uint32_t         maxCacheEntries,  // zero disables cache
+uint32_t         maxCacheLifetime, // seconds
+uint32_t         lifetimeGracePeriod, // seconds
+nsHostResolver **resolver);
+/**
+* puts the resolver in the shutdown state, which will cause any pending
+* callbacks to be detached.  any future calls to ResolveHost will fail.
+*/
+void Shutdown();
+/**
+* resolve the given hostname asynchronously.  the caller can synthesize
+* a synchronous host lookup using a lock and a cvar.  as noted above
+* the callback will occur re-entrantly from an unspecified thread.  the
+* host lookup cannot be canceled (cancelation can be layered above this
+* by having the callback implementation return without doing anything).
+*/
+nsresult ResolveHost(const char            *hostname,
+uint16_t               flags,
+uint16_t               af,
+nsResolveHostCallback *callback);
+/**
+* removes the specified callback from the nsHostRecord for the given
+* hostname, flags, and address family.  these parameters should correspond
+* to the parameters passed to ResolveHost.  this function executes the
+* callback if the callback is still pending with the given status.
+*/
+void DetachCallback(const char            *hostname,
+uint16_t               flags,
+uint16_t               af,
+nsResolveHostCallback *callback,
+nsresult               status);
+/**
+* Cancels an async request associated with the hostname, flags,
+* address family and listener.  Cancels first callback found which matches
+* these criteria.  These parameters should correspond to the parameters
+* passed to ResolveHost.  If this is the last callback associated with the
+* host record, it is removed from any request queues it might be on.
+*/
+void CancelAsyncRequest(const char            *host,
+uint16_t               flags,
+uint16_t               af,
+nsIDNSListener        *aListener,
+nsresult               status);
+/**
+* values for the flags parameter passed to ResolveHost and DetachCallback
+* that may be bitwise OR'd together.
+*
+* NOTE: in this implementation, these flags correspond exactly in value
+*       to the flags defined on nsIDNSService.
+*/
+enum {
+RES_BYPASS_CACHE = 1 << 0,
+RES_CANON_NAME   = 1 << 1,
+RES_PRIORITY_MEDIUM   = 1 << 2,
+RES_PRIORITY_LOW  = 1 << 3,
+RES_SPECULATE     = 1 << 4,
+//RES_DISABLE_IPV6 = 1 << 5, // Not used
+RES_OFFLINE       = 1 << 6
+};
+size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+private:
+nsHostResolver(uint32_t maxCacheEntries = 50, uint32_t maxCacheLifetime = 60,
+uint32_t lifetimeGracePeriod = 0);
+~nsHostResolver();
+nsresult Init();
+nsresult IssueLookup(nsHostRecord *);
+bool     GetHostToLookup(nsHostRecord **m);
+void     OnLookupComplete(nsHostRecord *, nsresult, mozilla::net::AddrInfo *);
+void     DeQueue(PRCList &aQ, nsHostRecord **aResult);
+void     ClearPendingQueue(PRCList *aPendingQueue);
+nsresult ConditionallyCreateThread(nsHostRecord *rec);
+/**
+* Starts a new lookup in the background for entries that are in the grace
+* period with a failed connect or all cached entries are negative.
+*/
+nsresult ConditionallyRefreshRecord(nsHostRecord *rec, const char *host);
+static void  MoveQueue(nsHostRecord *aRec, PRCList &aDestQ);
+static void ThreadFunc(void *);
+enum {
+METHOD_HIT = 1,
+METHOD_RENEWAL = 2,
+METHOD_NEGATIVE_HIT = 3,
+METHOD_LITERAL = 4,
+METHOD_OVERFLOW = 5,
+METHOD_NETWORK_FIRST = 6,
+METHOD_NETWORK_SHARED = 7
+};
+uint32_t      mMaxCacheEntries;
+mozilla::TimeDuration mMaxCacheLifetime; // granularity seconds
+mozilla::TimeDuration mGracePeriod; // granularity seconds
+mutable Mutex mLock;    // mutable so SizeOfIncludingThis can be const
+CondVar       mIdleThreadCV;
+uint32_t      mNumIdleThreads;
+uint32_t      mThreadCount;
+uint32_t      mActiveAnyThreadCount;
+PLDHashTable  mDB;
+PRCList       mHighQ;
+PRCList       mMediumQ;
+PRCList       mLowQ;
+PRCList       mEvictionQ;
+uint32_t      mEvictionQSize;
+uint32_t      mPendingCount;
+PRTime        mCreationTime;
+bool          mShutdown;
+PRIntervalTime mLongIdleTimeout;
+PRIntervalTime mShortIdleTimeout;
+public:
+/*
+* Called by the networking dashboard via the DnsService2
+*/
+void GetDNSCacheEntries(nsTArray<mozilla::net::DNSCacheEntries> *);
+};
+#endif // nsHostResolver_h__

The Tor Browser / file comparison

comparison: netwerk/dns/nsHostResolver.h

netwerk/dns/nsHostResolver.h