The Tor Browser: netwerk/dns/nsHostResolver.h@a63d609f5ebe (annotated)

netwerk/dns/nsHostResolver.h@a63d609f5ebe (annotated)

netwerk/dns/nsHostResolver.h

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 /* 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 / annotate

netwerk/dns/nsHostResolver.h@a63d609f5ebe (annotated)

netwerk/dns/nsHostResolver.h