docshell/base/nsDocShellLoadState.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef nsDocShellLoadState_h__
   8 #define nsDocShellLoadState_h__
   9
  10 #include "mozilla/dom/BrowsingContext.h"
  11 #include "mozilla/dom/SessionHistoryEntry.h"
  12
  13 // Helper Classes
  14 #include "mozilla/Maybe.h"
  15 #include "nsCOMPtr.h"
  16 #include "nsString.h"
  17 #include "nsDocShellLoadTypes.h"
  18 #include "nsTArrayForwardDeclare.h"
  19
  20 class nsIContentSecurityPolicy;
  21 class nsIInputStream;
  22 class nsISHEntry;
  23 class nsIURI;
  24 class nsIDocShell;
  25 class nsIChannel;
  26 class nsIReferrerInfo;
  27 namespace mozilla {
  28 class OriginAttributes;
  29 template <typename, class>
  30 class UniquePtr;
  31 namespace dom {
  32 class DocShellLoadStateInit;
  33 }  // namespace dom
  34 }  // namespace mozilla
  35
  36 /**
  37  * nsDocShellLoadState contains setup information used in a nsIDocShell::loadURI
  38  * call.
  39  */
  40 class nsDocShellLoadState final {
  41   using BrowsingContext = mozilla::dom::BrowsingContext;
  42   template <typename T>
  43   using MaybeDiscarded = mozilla::dom::MaybeDiscarded<T>;
  44
  45  public:
  46   NS_INLINE_DECL_REFCOUNTING(nsDocShellLoadState);
  47
  48   explicit nsDocShellLoadState(nsIURI* aURI);
  49   explicit nsDocShellLoadState(
  50       const mozilla::dom::DocShellLoadStateInit& aLoadState,
  51       mozilla::ipc::IProtocol* aActor, bool* aReadSuccess);
  52   explicit nsDocShellLoadState(const nsDocShellLoadState& aOther);
  53   nsDocShellLoadState(nsIURI* aURI, uint64_t aLoadIdentifier);
  54
  55   static nsresult CreateFromPendingChannel(nsIChannel* aPendingChannel,
  56                                            uint64_t aLoadIdentifier,
  57                                            uint64_t aRegistarId,
  58                                            nsDocShellLoadState** aResult);
  59
  60   static nsresult CreateFromLoadURIOptions(
  61       BrowsingContext* aBrowsingContext, const nsAString& aURI,
  62       const mozilla::dom::LoadURIOptions& aLoadURIOptions,
  63       nsDocShellLoadState** aResult);
  64   static nsresult CreateFromLoadURIOptions(
  65       BrowsingContext* aBrowsingContext, nsIURI* aURI,
  66       const mozilla::dom::LoadURIOptions& aLoadURIOptions,
  67       nsDocShellLoadState** aResult);
  68
  69   // Getters and Setters
  70
  71   nsIReferrerInfo* GetReferrerInfo() const;
  72
  73   void SetReferrerInfo(nsIReferrerInfo* aReferrerInfo);
  74
  75   nsIURI* URI() const;
  76
  77   void SetURI(nsIURI* aURI);
  78
  79   nsIURI* OriginalURI() const;
  80
  81   void SetOriginalURI(nsIURI* aOriginalURI);
  82
  83   nsIURI* ResultPrincipalURI() const;
  84
  85   void SetResultPrincipalURI(nsIURI* aResultPrincipalURI);
  86
  87   bool ResultPrincipalURIIsSome() const;
  88
  89   void SetResultPrincipalURIIsSome(bool aIsSome);
  90
  91   bool KeepResultPrincipalURIIfSet() const;
  92
  93   void SetKeepResultPrincipalURIIfSet(bool aKeep);
  94
  95   nsIPrincipal* PrincipalToInherit() const;
  96
  97   void SetPrincipalToInherit(nsIPrincipal* aPrincipalToInherit);
  98
  99   nsIPrincipal* PartitionedPrincipalToInherit() const;
 100
 101   void SetPartitionedPrincipalToInherit(
 102       nsIPrincipal* aPartitionedPrincipalToInherit);
 103
 104   bool LoadReplace() const;
 105
 106   void SetLoadReplace(bool aLoadReplace);
 107
 108   nsIPrincipal* TriggeringPrincipal() const;
 109
 110   void SetTriggeringPrincipal(nsIPrincipal* aTriggeringPrincipal);
 111
 112   uint32_t TriggeringSandboxFlags() const;
 113
 114   void SetTriggeringSandboxFlags(uint32_t aTriggeringSandboxFlags);
 115
 116   nsIContentSecurityPolicy* Csp() const;
 117
 118   void SetCsp(nsIContentSecurityPolicy* aCsp);
 119
 120   bool InheritPrincipal() const;
 121
 122   void SetInheritPrincipal(bool aInheritPrincipal);
 123
 124   bool PrincipalIsExplicit() const;
 125
 126   void SetPrincipalIsExplicit(bool aPrincipalIsExplicit);
 127
 128   // If true, "beforeunload" event listeners were notified by the creater of the
 129   // LoadState and given the chance to abort the navigation, and should not be
 130   // notified again.
 131   bool NotifiedBeforeUnloadListeners() const;
 132
 133   void SetNotifiedBeforeUnloadListeners(bool aNotifiedBeforeUnloadListeners);
 134
 135   bool ForceAllowDataURI() const;
 136
 137   void SetForceAllowDataURI(bool aForceAllowDataURI);
 138
 139   bool IsExemptFromHTTPSOnlyMode() const;
 140
 141   void SetIsExemptFromHTTPSOnlyMode(bool aIsExemptFromHTTPSOnlyMode);
 142
 143   bool OriginalFrameSrc() const;
 144
 145   void SetOriginalFrameSrc(bool aOriginalFrameSrc);
 146
 147   bool IsFormSubmission() const;
 148
 149   void SetIsFormSubmission(bool aIsFormSubmission);
 150
 151   uint32_t LoadType() const;
 152
 153   void SetLoadType(uint32_t aLoadType);
 154
 155   nsISHEntry* SHEntry() const;
 156
 157   void SetSHEntry(nsISHEntry* aSHEntry);
 158
 159   const mozilla::dom::LoadingSessionHistoryInfo* GetLoadingSessionHistoryInfo()
 160       const;
 161
 162   // Copies aLoadingInfo and stores the copy in this nsDocShellLoadState.
 163   void SetLoadingSessionHistoryInfo(
 164       const mozilla::dom::LoadingSessionHistoryInfo& aLoadingInfo);
 165
 166   // Stores aLoadingInfo in this nsDocShellLoadState.
 167   void SetLoadingSessionHistoryInfo(
 168       mozilla::UniquePtr<mozilla::dom::LoadingSessionHistoryInfo> aLoadingInfo);
 169
 170   bool LoadIsFromSessionHistory() const;
 171
 172   const nsString& Target() const;
 173
 174   void SetTarget(const nsAString& aTarget);
 175
 176   nsIInputStream* PostDataStream() const;
 177
 178   void SetPostDataStream(nsIInputStream* aStream);
 179
 180   nsIInputStream* HeadersStream() const;
 181
 182   void SetHeadersStream(nsIInputStream* aHeadersStream);
 183
 184   bool IsSrcdocLoad() const;
 185
 186   const nsString& SrcdocData() const;
 187
 188   void SetSrcdocData(const nsAString& aSrcdocData);
 189
 190   const MaybeDiscarded<BrowsingContext>& SourceBrowsingContext() const {
 191     return mSourceBrowsingContext;
 192   }
 193
 194   void SetSourceBrowsingContext(BrowsingContext*);
 195
 196   void SetAllowFocusMove(bool aAllow) { mAllowFocusMove = aAllow; }
 197
 198   bool AllowFocusMove() const { return mAllowFocusMove; }
 199
 200   const MaybeDiscarded<BrowsingContext>& TargetBrowsingContext() const {
 201     return mTargetBrowsingContext;
 202   }
 203
 204   void SetTargetBrowsingContext(BrowsingContext* aTargetBrowsingContext);
 205
 206   nsIURI* BaseURI() const;
 207
 208   void SetBaseURI(nsIURI* aBaseURI);
 209
 210   // Helper function allowing convenient work with mozilla::Maybe in C++, hiding
 211   // resultPrincipalURI and resultPrincipalURIIsSome attributes from the
 212   // consumer.
 213   void GetMaybeResultPrincipalURI(
 214       mozilla::Maybe<nsCOMPtr<nsIURI>>& aRPURI) const;
 215
 216   void SetMaybeResultPrincipalURI(
 217       mozilla::Maybe<nsCOMPtr<nsIURI>> const& aRPURI);
 218
 219   uint32_t LoadFlags() const;
 220
 221   void SetLoadFlags(uint32_t aFlags);
 222
 223   void SetLoadFlag(uint32_t aFlag);
 224
 225   void UnsetLoadFlag(uint32_t aFlag);
 226
 227   bool HasLoadFlags(uint32_t aFlag);
 228
 229   uint32_t InternalLoadFlags() const;
 230
 231   void SetInternalLoadFlags(uint32_t aFlags);
 232
 233   void SetInternalLoadFlag(uint32_t aFlag);
 234
 235   void UnsetInternalLoadFlag(uint32_t aFlag);
 236
 237   bool HasInternalLoadFlags(uint32_t aFlag);
 238
 239   bool FirstParty() const;
 240
 241   void SetFirstParty(bool aFirstParty);
 242
 243   bool HasValidUserGestureActivation() const;
 244
 245   void SetHasValidUserGestureActivation(bool HasValidUserGestureActivation);
 246
 247   const nsCString& TypeHint() const;
 248
 249   void SetTypeHint(const nsCString& aTypeHint);
 250
 251   const nsString& FileName() const;
 252
 253   void SetFileName(const nsAString& aFileName);
 254
 255   nsIURI* GetUnstrippedURI() const;
 256
 257   void SetUnstrippedURI(nsIURI* aUnstrippedURI);
 258
 259   // Give the type of DocShell we're loading into (chrome/content/etc) and
 260   // origin attributes for the URI we're loading, figure out if we should
 261   // inherit our principal from the document the load was requested from, or
 262   // else if the principal should be set up later in the process (after loads).
 263   // See comments in function for more info on principal selection algorithm
 264   nsresult SetupInheritingPrincipal(
 265       mozilla::dom::BrowsingContext::Type aType,
 266       const mozilla::OriginAttributes& aOriginAttributes);
 267
 268   // If no triggering principal exists at the moment, create one using referrer
 269   // information and origin attributes.
 270   nsresult SetupTriggeringPrincipal(
 271       const mozilla::OriginAttributes& aOriginAttributes);
 272
 273   void SetIsFromProcessingFrameAttributes() {
 274     mIsFromProcessingFrameAttributes = true;
 275   }
 276   bool GetIsFromProcessingFrameAttributes() const {
 277     return mIsFromProcessingFrameAttributes;
 278   }
 279
 280   nsIChannel* GetPendingRedirectedChannel() {
 281     return mPendingRedirectedChannel;
 282   }
 283
 284   uint64_t GetPendingRedirectChannelRegistrarId() const {
 285     return mChannelRegistrarId;
 286   }
 287
 288   void SetOriginalURIString(const nsCString& aOriginalURI) {
 289     mOriginalURIString.emplace(aOriginalURI);
 290   }
 291   const mozilla::Maybe<nsCString>& GetOriginalURIString() const {
 292     return mOriginalURIString;
 293   }
 294
 295   void SetCancelContentJSEpoch(int32_t aCancelEpoch) {
 296     mCancelContentJSEpoch.emplace(aCancelEpoch);
 297   }
 298   const mozilla::Maybe<int32_t>& GetCancelContentJSEpoch() const {
 299     return mCancelContentJSEpoch;
 300   }
 301
 302   uint64_t GetLoadIdentifier() const { return mLoadIdentifier; }
 303
 304   void SetChannelInitialized(bool aInitilized) {
 305     mChannelInitialized = aInitilized;
 306   }
 307
 308   bool GetChannelInitialized() const { return mChannelInitialized; }
 309
 310   void SetIsMetaRefresh(bool aMetaRefresh) { mIsMetaRefresh = aMetaRefresh; }
 311
 312   bool IsMetaRefresh() const { return mIsMetaRefresh; }
 313
 314   const mozilla::Maybe<nsCString>& GetRemoteTypeOverride() const {
 315     return mRemoteTypeOverride;
 316   }
 317
 318   void SetRemoteTypeOverride(const nsCString& aRemoteTypeOverride) {
 319     mRemoteTypeOverride = mozilla::Some(aRemoteTypeOverride);
 320   }
 321
 322   // Determine the remote type of the process which should be considered
 323   // responsible for this load for the purposes of security checks.
 324   //
 325   // This will generally be the process which created the nsDocShellLoadState
 326   // originally, however non-errorpage history loads are always considered to be
 327   // triggered by the parent process, as we can validate them against the
 328   // history entry.
 329   const nsCString& GetEffectiveTriggeringRemoteType() const;
 330
 331   void SetTriggeringRemoteType(const nsACString& aTriggeringRemoteType);
 332
 333   // Diagnostic assert if this is a system-principal triggered load, and it is
 334   // trivial to determine that the effective triggering remote type would not be
 335   // allowed to perform this load.
 336   //
 337   // This is called early during the load to crash as close to the cause as
 338   // possible. See bug 1838686 for details.
 339 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 340   void AssertProcessCouldTriggerLoadIfSystem();
 341 #else
 342   void AssertProcessCouldTriggerLoadIfSystem() {}
 343 #endif
 344
 345   // When loading a document through nsDocShell::LoadURI(), a special set of
 346   // flags needs to be set based on other values in nsDocShellLoadState. This
 347   // function calculates those flags, before the LoadState is passed to
 348   // nsDocShell::InternalLoad.
 349   void CalculateLoadURIFlags();
 350
 351   // Compute the load flags to be used by creating channel.  aUriModified and
 352   // aIsXFOError are expected to be Nothing when called from Parent process.
 353   nsLoadFlags CalculateChannelLoadFlags(
 354       mozilla::dom::BrowsingContext* aBrowsingContext,
 355       mozilla::Maybe<bool> aUriModified, mozilla::Maybe<bool> aIsXFOError);
 356
 357   mozilla::dom::DocShellLoadStateInit Serialize(
 358       mozilla::ipc::IProtocol* aActor);
 359
 360   void SetLoadIsFromSessionHistory(int32_t aOffset, bool aLoadingCurrentEntry);
 361   void ClearLoadIsFromSessionHistory();
 362
 363   void MaybeStripTrackerQueryStrings(mozilla::dom::BrowsingContext* aContext);
 364
 365  protected:
 366   // Destructor can't be defaulted or inlined, as header doesn't have all type
 367   // includes it needs to do so.
 368   ~nsDocShellLoadState();
 369
 370   // Given the original `nsDocShellLoadState` which was sent to a content
 371   // process, validate that they corespond to the same load.
 372   // Returns a static (telemetry-safe) string naming what did not match, or
 373   // nullptr if it succeeds.
 374   const char* ValidateWithOriginalState(nsDocShellLoadState* aOriginalState);
 375
 376   static nsresult CreateFromLoadURIOptions(
 377       BrowsingContext* aBrowsingContext, nsIURI* aURI,
 378       const mozilla::dom::LoadURIOptions& aLoadURIOptions,
 379       uint32_t aLoadFlagsOverride, nsIInputStream* aPostDataOverride,
 380       nsDocShellLoadState** aResult);
 381
 382   // This is the referrer for the load.
 383   nsCOMPtr<nsIReferrerInfo> mReferrerInfo;
 384
 385   // The URI we are navigating to. Will not be null once set.
 386   nsCOMPtr<nsIURI> mURI;
 387
 388   // The URI to set as the originalURI on the channel that does the load. If
 389   // null, aURI will be set as the originalURI.
 390   nsCOMPtr<nsIURI> mOriginalURI;
 391
 392   // The URI to be set to loadInfo.resultPrincipalURI
 393   // - When Nothing, there will be no change
 394   // - When Some, the principal URI will overwrite even
 395   //   with a null value.
 396   //
 397   // Valid only if mResultPrincipalURIIsSome is true (has the same meaning as
 398   // isSome() on mozilla::Maybe.)
 399   nsCOMPtr<nsIURI> mResultPrincipalURI;
 400   bool mResultPrincipalURIIsSome;
 401
 402   // The principal of the load, that is, the entity responsible for causing the
 403   // load to occur. In most cases the referrer and the triggeringPrincipal's URI
 404   // will be identical.
 405   //
 406   // Please note that this is the principal that is used for security checks. If
 407   // the argument aURI is provided by the web, then please do not pass a
 408   // SystemPrincipal as the triggeringPrincipal.
 409   nsCOMPtr<nsIPrincipal> mTriggeringPrincipal;
 410
 411   // The SandboxFlags of the load, that are, the SandboxFlags of the entity
 412   // responsible for causing the load to occur. Most likely this are the
 413   // SandboxFlags of the document that started the load.
 414   uint32_t mTriggeringSandboxFlags;
 415
 416   // The CSP of the load, that is, the CSP of the entity responsible for causing
 417   // the load to occur. Most likely this is the CSP of the document that started
 418   // the load. In case the entity starting the load did not use a CSP, then mCsp
 419   // can be null. Please note that this is also the CSP that will be applied to
 420   // the load in case the load encounters a server side redirect.
 421   nsCOMPtr<nsIContentSecurityPolicy> mCsp;
 422
 423   // If a refresh is caused by http-equiv="refresh" we want to set
 424   // aResultPrincipalURI, but we do not want to overwrite the channel's
 425   // ResultPrincipalURI, if it has already been set on the channel by a protocol
 426   // handler.
 427   bool mKeepResultPrincipalURIIfSet;
 428
 429   // If set LOAD_REPLACE flag will be set on the channel. If aOriginalURI is
 430   // null, this argument is ignored.
 431   bool mLoadReplace;
 432
 433   // If this attribute is true and no triggeringPrincipal is specified,
 434   // copy the principal from the referring document.
 435   bool mInheritPrincipal;
 436
 437   // If this attribute is true only ever use the principal specified
 438   // by the triggeringPrincipal and inheritPrincipal attributes.
 439   // If there are security reasons for why this is unsafe, such
 440   // as trying to use a systemprincipal as the triggeringPrincipal
 441   // for a content docshell the load fails.
 442   bool mPrincipalIsExplicit;
 443
 444   bool mNotifiedBeforeUnloadListeners;
 445
 446   // Principal we're inheriting. If null, this means the principal should be
 447   // inherited from the current document. If set to NullPrincipal, the channel
 448   // will fill in principal information later in the load. See internal comments
 449   // of SetupInheritingPrincipal for more info.
 450   //
 451   // When passed to InternalLoad, If this argument is null then
 452   // principalToInherit is computed differently. See nsDocShell::InternalLoad
 453   // for more comments.
 454
 455   nsCOMPtr<nsIPrincipal> mPrincipalToInherit;
 456
 457   nsCOMPtr<nsIPrincipal> mPartitionedPrincipalToInherit;
 458
 459   // If this attribute is true, then a top-level navigation
 460   // to a data URI will be allowed.
 461   bool mForceAllowDataURI;
 462
 463   // If this attribute is true, then the top-level navigaion
 464   // will be exempt from HTTPS-Only-Mode upgrades.
 465   bool mIsExemptFromHTTPSOnlyMode;
 466
 467   // If this attribute is true, this load corresponds to a frame
 468   // element loading its original src (or srcdoc) attribute.
 469   bool mOriginalFrameSrc;
 470
 471   // If this attribute is true, then the load was initiated by a
 472   // form submission. This is important to know for the CSP directive
 473   // navigate-to.
 474   bool mIsFormSubmission;
 475
 476   // Contains a load type as specified by the nsDocShellLoadTypes::load*
 477   // constants
 478   uint32_t mLoadType;
 479
 480   // Active Session History entry (if loading from SH)
 481   nsCOMPtr<nsISHEntry> mSHEntry;
 482
 483   // Loading session history info for the load
 484   mozilla::UniquePtr<mozilla::dom::LoadingSessionHistoryInfo>
 485       mLoadingSessionHistoryInfo;
 486
 487   // Target for load, like _content, _blank etc.
 488   nsString mTarget;
 489
 490   // When set, this is the Target Browsing Context for the navigation
 491   // after retargeting.
 492   MaybeDiscarded<BrowsingContext> mTargetBrowsingContext;
 493
 494   // Post data stream (if POSTing)
 495   nsCOMPtr<nsIInputStream> mPostDataStream;
 496
 497   // Additional Headers
 498   nsCOMPtr<nsIInputStream> mHeadersStream;
 499
 500   // When set, the load will be interpreted as a srcdoc load, where contents of
 501   // this string will be loaded instead of the URI. Setting srcdocData sets
 502   // isSrcdocLoad to true
 503   nsString mSrcdocData;
 504
 505   // When set, this is the Source Browsing Context for the navigation.
 506   MaybeDiscarded<BrowsingContext> mSourceBrowsingContext;
 507
 508   // Used for srcdoc loads to give view-source knowledge of the load's base URI
 509   // as this information isn't embedded in the load's URI.
 510   nsCOMPtr<nsIURI> mBaseURI;
 511
 512   // Set of Load Flags, taken from nsDocShellLoadTypes.h and nsIWebNavigation
 513   uint32_t mLoadFlags;
 514
 515   // Set of internal load flags
 516   uint32_t mInternalLoadFlags;
 517
 518   // Is this a First Party Load?
 519   bool mFirstParty;
 520
 521   // Is this load triggered by a user gesture?
 522   bool mHasValidUserGestureActivation;
 523
 524   // Whether this load can steal the focus from the source browsing context.
 525   bool mAllowFocusMove;
 526
 527   // A hint as to the content-type of the resulting data. If no hint, IsVoid()
 528   // should return true.
 529   nsCString mTypeHint;
 530
 531   // Non-void when the link should be downloaded as the given filename.
 532   // mFileName being non-void but empty means that no filename hint was
 533   // specified, but link should still trigger a download. If not a download,
 534   // mFileName.IsVoid() should return true.
 535   nsString mFileName;
 536
 537   // This will be true if this load is triggered by attribute changes.
 538   // See nsILoadInfo.isFromProcessingFrameAttributes
 539   bool mIsFromProcessingFrameAttributes;
 540
 541   // If set, a pending cross-process redirected channel should be used to
 542   // perform the load. The channel will be stored in this value.
 543   nsCOMPtr<nsIChannel> mPendingRedirectedChannel;
 544
 545   // An optional string representation of mURI, before any
 546   // fixups were applied, so that we can send it to a search
 547   // engine service if needed.
 548   mozilla::Maybe<nsCString> mOriginalURIString;
 549
 550   // An optional value to pass to nsIDocShell::setCancelJSEpoch
 551   // when initiating the load.
 552   mozilla::Maybe<int32_t> mCancelContentJSEpoch;
 553
 554   // If mPendingRedirectChannel is set, then this is the identifier
 555   // that the parent-process equivalent channel has been registered
 556   // with using RedirectChannelRegistrar.
 557   uint64_t mChannelRegistrarId;
 558
 559   // An identifier to make it possible to examine if two loads are
 560   // equal, and which browsing context they belong to (see
 561   // BrowsingContext::{Get, Set}CurrentLoadIdentifier)
 562   const uint64_t mLoadIdentifier;
 563
 564   // Optional value to indicate that a channel has been
 565   // pre-initialized in the parent process.
 566   bool mChannelInitialized;
 567
 568   // True if the load was triggered by a meta refresh.
 569   bool mIsMetaRefresh;
 570
 571   // True if the nsDocShellLoadState was received over IPC.
 572   bool mWasCreatedRemotely = false;
 573
 574   // The original URI before query stripping happened. If it's present, it shows
 575   // the query stripping happened. Otherwise, it will be a nullptr.
 576   nsCOMPtr<nsIURI> mUnstrippedURI;
 577
 578   // If set, the remote type which the load should be completed within.
 579   mozilla::Maybe<nsCString> mRemoteTypeOverride;
 580
 581   // Remote type of the process which originally requested the load.
 582   nsCString mTriggeringRemoteType;
 583 };
 584
 585 #endif /* nsDocShellLoadState_h__ */