netwerk/dns/TRRService.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef TRRService_h_
   7 #define TRRService_h_
   8
   9 #include "mozilla/DataMutex.h"
  10 #include "nsHostResolver.h"
  11 #include "nsIObserver.h"
  12 #include "nsITimer.h"
  13 #include "nsWeakReference.h"
  14 #include "TRRServiceBase.h"
  15 #include "nsICaptivePortalService.h"
  16 #include "nsTHashSet.h"
  17 #include "TRR.h"
  18
  19 class nsDNSService;
  20 class nsIPrefBranch;
  21 class nsINetworkLinkService;
  22 class nsIObserverService;
  23
  24 namespace mozilla {
  25 namespace net {
  26
  27 class TRRServiceChild;
  28 class TRRServiceParent;
  29
  30 class TRRService : public TRRServiceBase,
  31                    public nsIObserver,
  32                    public nsSupportsWeakReference,
  33                    public AHostResolver,
  34                    public SingleWriterLockOwner {
  35  public:
  36   NS_DECL_ISUPPORTS_INHERITED
  37   NS_DECL_NSIOBSERVER
  38   NS_DECL_NSIPROXYCONFIGCHANGEDCALLBACK
  39
  40   TRRService();
  41   static TRRService* Get();
  42
  43   bool OnWritingThread() const override { return NS_IsMainThread(); }
  44
  45   nsresult Init();
  46   nsresult Start();
  47   bool Enabled(nsIRequest::TRRMode aRequestMode = nsIRequest::TRR_DEFAULT_MODE);
  48   bool IsConfirmed() { return mConfirmation.State() == CONFIRM_OK; }
  49   uint32_t ConfirmationState() { return mConfirmation.State(); }
  50
  51   bool DisableIPv6() { return mDisableIPv6; }
  52   void GetURI(nsACString& result) override;
  53   nsresult GetCredentials(nsCString& result);
  54   uint32_t GetRequestTimeout();
  55   void RetryTRRConfirm();
  56
  57   LookupStatus CompleteLookup(nsHostRecord*, nsresult, mozilla::net::AddrInfo*,
  58                               bool pb, const nsACString& aOriginSuffix,
  59                               TRRSkippedReason aReason,
  60                               TRR* aTrrRequest) override;
  61   LookupStatus CompleteLookupByType(nsHostRecord*, nsresult,
  62                                     mozilla::net::TypeRecordResultType&,
  63                                     uint32_t, bool pb) override;
  64   void AddToBlocklist(const nsACString& host, const nsACString& originSuffix,
  65                       bool privateBrowsing, bool aParentsToo);
  66   bool IsTemporarilyBlocked(const nsACString& aHost,
  67                             const nsACString& aOriginSuffix,
  68                             bool aPrivateBrowsing, bool aParentsToo);
  69   bool IsExcludedFromTRR(const nsACString& aHost);
  70
  71   bool MaybeBootstrap(const nsACString& possible, nsACString& result);
  72   void RecordTRRStatus(TRR* aTrrRequest);
  73   bool ParentalControlEnabled() const { return mParentalControlEnabled; }
  74
  75   nsresult DispatchTRRRequest(TRR* aTrrRequest);
  76   already_AddRefed<nsIThread> TRRThread();
  77   bool IsOnTRRThread();
  78
  79   bool IsUsingAutoDetectedURL() { return mURISetByDetection; }
  80
  81   void SetHeuristicDetectionResult(TRRSkippedReason aValue) {
  82     mHeuristicDetectionValue = aValue;
  83   }
  84   TRRSkippedReason GetHeuristicDetectionResult() {
  85     return mHeuristicDetectionValue;
  86   }
  87
  88   nsresult LastConfirmationStatus() {
  89     return mConfirmation.LastConfirmationStatus();
  90   }
  91   TRRSkippedReason LastConfirmationSkipReason() {
  92     return mConfirmation.LastConfirmationSkipReason();
  93   }
  94
  95   // Returns a reference to a static string identifying the current DoH server
  96   // If the DoH server is not one of the built-in ones it will return "(other)"
  97   static const nsCString& ProviderKey();
  98   static void SetProviderDomain(const nsACString& aTRRDomain);
  99   // Only called when TRR mode changed.
 100   static void SetCurrentTRRMode(nsIDNSService::ResolverMode aMode);
 101
 102   void InitTRRConnectionInfo() override;
 103
 104   void DontUseTRRThread() { mDontUseTRRThread = true; }
 105
 106  private:
 107   virtual ~TRRService();
 108
 109   friend class TRRServiceChild;
 110   friend class TRRServiceParent;
 111   static void AddObserver(nsIObserver* aObserver,
 112                           nsIObserverService* aObserverService = nullptr);
 113   static bool CheckCaptivePortalIsPassed();
 114   static bool GetParentalControlEnabledInternal();
 115   static bool CheckPlatformDNSStatus(nsINetworkLinkService* aLinkService);
 116
 117   nsresult ReadPrefs(const char* name);
 118   void GetPrefBranch(nsIPrefBranch** result);
 119   friend class ::nsDNSService;
 120   void SetDetectedTrrURI(const nsACString& aURI);
 121
 122   bool IsDomainBlocked(const nsACString& aHost, const nsACString& aOriginSuffix,
 123                        bool aPrivateBrowsing);
 124   bool IsExcludedFromTRR_unlocked(const nsACString& aHost);
 125
 126   void RebuildSuffixList(nsTArray<nsCString>&& aSuffixList);
 127
 128   nsresult DispatchTRRRequestInternal(TRR* aTrrRequest, bool aWithLock);
 129   already_AddRefed<nsIThread> TRRThread_locked();
 130   already_AddRefed<nsIThread> MainThreadOrTRRThread(bool aWithLock = true);
 131
 132   // This method will process the URI and try to set mPrivateURI to that value.
 133   // Will return true if performed the change (if the value was different)
 134   // or false if mPrivateURI already had that value.
 135   bool MaybeSetPrivateURI(const nsACString& aURI) override;
 136   void ClearEntireCache();
 137
 138   virtual void ReadEtcHostsFile() override;
 139   void AddEtcHosts(const nsTArray<nsCString>&);
 140
 141   bool mInitialized{false};
 142   MutexSingleWriter mLock;
 143
 144   nsCString mPrivateCred;  // main thread only
 145   nsCString mConfirmationNS MOZ_GUARDED_BY(mLock){"example.com"_ns};
 146   nsCString mBootstrapAddr MOZ_GUARDED_BY(mLock);
 147
 148   Atomic<bool, Relaxed> mCaptiveIsPassed{
 149       false};  // set when captive portal check is passed
 150   Atomic<bool, Relaxed> mDisableIPv6;  // don't even try
 151   Atomic<bool, Relaxed> mShutdown{false};
 152   Atomic<bool, Relaxed> mDontUseTRRThread{false};
 153
 154   // TRR Blocklist storage
 155   // mTRRBLStorage is only modified on the main thread, but we query whether it
 156   // is initialized or not off the main thread as well. Therefore we need to
 157   // lock while creating it and while accessing it off the main thread.
 158   DataMutex<nsTHashMap<nsCStringHashKey, int32_t>> mTRRBLStorage{
 159       "DataMutex::TRRBlocklist"};
 160
 161   // A set of domains that we should not use TRR for.
 162   nsTHashSet<nsCString> mExcludedDomains MOZ_GUARDED_BY(mLock);
 163   nsTHashSet<nsCString> mDNSSuffixDomains MOZ_GUARDED_BY(mLock);
 164   nsTHashSet<nsCString> mEtcHostsDomains MOZ_GUARDED_BY(mLock);
 165
 166   // The result of the TRR heuristic detection
 167   TRRSkippedReason mHeuristicDetectionValue = nsITRRSkipReason::TRR_UNSET;
 168
 169   enum class ConfirmationEvent {
 170     Init,
 171     PrefChange,
 172     ConfirmationRetry,
 173     FailedLookups,
 174     RetryTRR,
 175     URIChange,
 176     CaptivePortalConnectivity,
 177     NetworkUp,
 178     ConfirmOK,
 179     ConfirmFail,
 180   };
 181
 182   //                            (FailedLookups/RetryTRR/URIChange/NetworkUp)
 183   //                                    +---------------------------+
 184   // +-----------+                      |                           |
 185   // |   (Init)  |               +------v---------+               +-+--+
 186   // |           | TRR turned on |                | (ConfirmOK)   |    |
 187   // |    OFF    +--------------->     TRY-OK     +---------------> OK |
 188   // |           |  (PrefChange) |                |               |    |
 189   // +-----^-----+               +^-^----+--------+               +-^--+
 190   //       |    (PrefChange/CP)   | |    |                          |
 191   //   TRR +   +------------------+ |    |                          |
 192   //   off |   |               +----+    |(ConfirmFail)             |(ConfirmOK)
 193   // (Pref)|   |               |         |                          |
 194   // +---------+-+             |         |                          |
 195   // |           |    (CPConn) | +-------v--------+               +-+---------+
 196   // | ANY-STATE |  (NetworkUp)| |                |  timer        |           |
 197   // |           |  (URIChange)+-+      FAIL      +--------------->  TRY-FAIL |
 198   // +-----+-----+               |                | (Confirmation |           |
 199   //       |                     +------^---------+  Retry)       +------+----+
 200   //       | (PrefChange)               |                                |
 201   //       | TRR_ONLY mode or           +--------------------------------+
 202   //       | confirmationNS = skip                (ConfirmFail)
 203   // +-----v-----+
 204   // |           |
 205   // |  DISABLED |
 206   // |           |
 207   // +-----------+
 208   //
 209   enum ConfirmationState {
 210     CONFIRM_OFF = 0,
 211     CONFIRM_TRYING_OK = 1,
 212     CONFIRM_OK = 2,
 213     CONFIRM_FAILED = 3,
 214     CONFIRM_TRYING_FAILED = 4,
 215     CONFIRM_DISABLED = 5,
 216   };
 217
 218   class ConfirmationContext final : public nsITimerCallback, public nsINamed {
 219     NS_DECL_ISUPPORTS_INHERITED
 220     NS_DECL_NSITIMERCALLBACK
 221     NS_DECL_NSINAMED
 222
 223    private:
 224     static const size_t RESULTS_SIZE = 32;
 225
 226     RefPtr<TRR> mTask;
 227     nsCOMPtr<nsITimer> mTimer;
 228     uint32_t mRetryInterval = 125;  // milliseconds until retry
 229     // The number of TRR requests that failed in a row.
 230     Atomic<uint32_t, Relaxed> mTRRFailures{0};
 231
 232     // This buffer holds consecutive TRR failures reported by calling
 233     // RecordTRRStatus(). It is only meant for reporting event telemetry.
 234     char mFailureReasons[RESULTS_SIZE] = {0};
 235
 236     // The number of confirmation retries.
 237     uint32_t mAttemptCount = 0;
 238
 239     // The results of past confirmation attempts.
 240     // This is circular buffer ending at mAttemptCount.
 241     char mResults[RESULTS_SIZE] = {0};
 242
 243     // Time when first confirmation started. Needed so we can
 244     // record the time from start to confirmed.
 245     TimeStamp mFirstRequestTime;
 246     // The network ID at the start of the last confirmation attempt
 247     nsCString mNetworkId;
 248     // Captive portal status at the time of recording.
 249     int32_t mCaptivePortalStatus = nsICaptivePortalService::UNKNOWN;
 250
 251     // The reason the confirmation context changed.
 252     nsCString mContextChangeReason;
 253
 254     // What triggered the confirmation
 255     nsCString mTrigger;
 256
 257     // String representation of consecutive failed lookups that triggered
 258     // confirmation.
 259     nsCString mFailedLookups;
 260
 261     Atomic<TRRSkippedReason, Relaxed> mLastConfirmationSkipReason{
 262         nsITRRSkipReason::TRR_UNSET};
 263     Atomic<nsresult, Relaxed> mLastConfirmationStatus{NS_OK};
 264
 265     void SetState(enum ConfirmationState aNewState);
 266
 267    public:
 268     // Called when a confirmation completes successfully or when the
 269     // confirmation context changes.
 270     void RecordEvent(const char* aReason, const MutexSingleWriterAutoLock&);
 271
 272     // Called when a confirmation request is completed. The status is recorded
 273     // in the results.
 274     void RequestCompleted(nsresult aLookupStatus, nsresult aChannelStatus);
 275
 276     enum ConfirmationState State() { return mState; }
 277
 278     void CompleteConfirmation(nsresult aStatus, TRR* aTrrRequest);
 279
 280     void RecordTRRStatus(TRR* aTrrRequest);
 281
 282     // Returns true when handling the event caused a new confirmation task to be
 283     // dispatched.
 284     bool HandleEvent(ConfirmationEvent aEvent);
 285     bool HandleEvent(ConfirmationEvent aEvent,
 286                      const MutexSingleWriterAutoLock&);
 287
 288     void SetCaptivePortalStatus(int32_t aStatus) {
 289       mCaptivePortalStatus = aStatus;
 290     }
 291
 292     TRRSkippedReason LastConfirmationSkipReason() {
 293       return mLastConfirmationSkipReason;
 294     }
 295     nsresult LastConfirmationStatus() { return mLastConfirmationStatus; }
 296
 297     uintptr_t TaskAddr() { return uintptr_t(mTask.get()); }
 298
 299    private:
 300     // Since the ConfirmationContext is embedded in the TRRService object
 301     // we can easily get a pointer to the TRRService. ConfirmationContext
 302     // delegates AddRef/Release calls to the owning object since they are
 303     // guaranteed to have the same lifetime.
 304     TRRService* OwningObject() {
 305       return reinterpret_cast<TRRService*>(
 306           reinterpret_cast<uint8_t*>(this) -
 307           offsetof(TRRService, mConfirmation) -
 308           offsetof(ConfirmationWrapper, mConfirmation));
 309     }
 310
 311     Atomic<enum ConfirmationState, Relaxed> mState{CONFIRM_OFF};
 312
 313     // TRRService needs to be a friend class because it needs to access the
 314     // destructor.
 315     friend class TRRService;
 316     ~ConfirmationContext() = default;
 317   };
 318
 319   // Because TRRService needs to be a friend class to ConfirmationContext that
 320   // means it can access member variables. In order to properly separate logic
 321   // and prevent direct access to its member variables we embed it in a wrapper
 322   // class.
 323   class ConfirmationWrapper {
 324    public:
 325     // Called when a confirmation completes successfully or when the
 326     // confirmation context changes.
 327     void RecordEvent(const char* aReason,
 328                      const MutexSingleWriterAutoLock& aLock) {
 329       mConfirmation.RecordEvent(aReason, aLock);
 330     }
 331
 332     // Called when a confirmation request is completed. The status is recorded
 333     // in the results.
 334     void RequestCompleted(nsresult aLookupStatus, nsresult aChannelStatus) {
 335       mConfirmation.RequestCompleted(aLookupStatus, aChannelStatus);
 336     }
 337
 338     enum ConfirmationState State() { return mConfirmation.State(); }
 339
 340     void CompleteConfirmation(nsresult aStatus, TRR* aTrrRequest) {
 341       mConfirmation.CompleteConfirmation(aStatus, aTrrRequest);
 342     }
 343
 344     void RecordTRRStatus(TRR* aTrrRequest) {
 345       mConfirmation.RecordTRRStatus(aTrrRequest);
 346     }
 347
 348     bool HandleEvent(ConfirmationEvent aEvent) {
 349       return mConfirmation.HandleEvent(aEvent);
 350     }
 351
 352     bool HandleEvent(ConfirmationEvent aEvent,
 353                      const MutexSingleWriterAutoLock& lock) {
 354       return mConfirmation.HandleEvent(aEvent, lock);
 355     }
 356
 357     void SetCaptivePortalStatus(int32_t aStatus) {
 358       mConfirmation.SetCaptivePortalStatus(aStatus);
 359     }
 360
 361     TRRSkippedReason LastConfirmationSkipReason() {
 362       return mConfirmation.LastConfirmationSkipReason();
 363     }
 364     nsresult LastConfirmationStatus() {
 365       return mConfirmation.LastConfirmationStatus();
 366     }
 367
 368    private:
 369     friend TRRService* ConfirmationContext::OwningObject();
 370     ConfirmationContext mConfirmation;
 371   };
 372
 373   ConfirmationWrapper mConfirmation;
 374
 375   bool mParentalControlEnabled{false};
 376   // This is used to track whether a confirmation was triggered by a URI change,
 377   // so we don't trigger another one just because other prefs have changed.
 378   bool mConfirmationTriggered{false};
 379   nsCOMPtr<nsINetworkLinkService> mLinkService;
 380 };
 381
 382 }  // namespace net
 383 }  // namespace mozilla
 384
 385 #endif  // TRRService_h_