path: root/netwerk/ipc/NeckoChannelParams.ipdlh

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 ft=c: */

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

include protocol PHttpChannel;
include ClientIPCTypes;
include URIParams;
include IPCServiceWorkerDescriptor;
include IPCStream;
include PBackgroundSharedTypes;
include DOMTypes;
include ProtocolTypes;

include "mozilla/dom/FetchIPCTypes.h";
include "mozilla/dom/PropertyBagUtils.h";
include "mozilla/dom/ReferrerInfoUtils.h";
include "mozilla/ipc/URIUtils.h";
include "mozilla/net/CacheInfoIPCTypes.h";
include "mozilla/AntiTrackingIPCUtils.h";
include "mozilla/net/ClassOfService.h";

using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using RequestHeaderTuples from "mozilla/net/PHttpChannelParams.h";
using struct nsHttpAtom from "nsHttp.h";
using class mozilla::net::nsHttpResponseHead from "nsHttpResponseHead.h";
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
[RefCounted] using class nsIPropertyBag2 from "nsIPropertyBag2.h";
[RefCounted] using class nsDOMNavigationTiming from "nsDOMNavigationTiming.h";
[RefCounted] using class nsDocShellLoadState from "nsDocShellLoadState.h";
using nsContentPolicyType from "nsIContentPolicy.h";
using mozilla::net::PreferredAlternativeDataDeliveryTypeIPC from "nsICacheInfoChannel.h";
using nsILoadInfo::CrossOriginEmbedderPolicy from "nsILoadInfo.h";
using nsILoadInfo::StoragePermissionState from "nsILoadInfo.h";
using struct mozilla::dom::LoadingSessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";
using mozilla::dom::RequestMode from "mozilla/dom/RequestBinding.h";
using mozilla::net::LinkHeader from "nsNetUtil.h";

namespace mozilla {
namespace net {

//-----------------------------------------------------------------------------
// CookieJarSettings IPDL structs
//-----------------------------------------------------------------------------

struct CookiePermissionData
{
  PrincipalInfo principalInfo;
  uint32_t cookiePermission;
};

struct CookieJarSettingsArgs
{
  // Copy of the cookie jar settings for the top-level document.
  uint32_t cookieBehavior;
  bool isFirstPartyIsolated;
  bool shouldResistFingerprinting;
  bool isOnContentBlockingAllowList;
  CookiePermissionData[] cookiePermissions;
  bool isFixed;
  nsString partitionKey;
};

//-----------------------------------------------------------------------------
// Preferrer alternative data type
//-----------------------------------------------------------------------------

struct PreferredAlternativeDataTypeParams
{
  nsCString type;
  nsCString contentType;
  PreferredAlternativeDataDeliveryTypeIPC deliverAltData;
};

//-----------------------------------------------------------------------------
// LoadInfo IPDL structs
//-----------------------------------------------------------------------------

struct RedirectHistoryEntryInfo
{
  PrincipalInfo       principalInfo;
  URIParams?          referrerUri;
  nsCString           remoteAddress;
};

struct InterceptionInfoArg
{
  PrincipalInfo?              triggeringPrincipalInfo;
  nsContentPolicyType         contentPolicyType;
  RedirectHistoryEntryInfo[]  redirectChain;
  bool                        fromThirdParty;
};

struct LoadInfoArgs
{
  PrincipalInfo?              requestingPrincipalInfo;
  PrincipalInfo               triggeringPrincipalInfo;
  PrincipalInfo?              principalToInheritInfo;
  PrincipalInfo?              topLevelPrincipalInfo;
  URIParams?                  resultPrincipalURI;
  nsCString                   triggeringRemoteType;
  nsID                        sandboxedNullPrincipalID;
  uint32_t                    securityFlags;
  uint32_t                    sandboxFlags;
  uint32_t                    triggeringSandboxFlags;
  nsContentPolicyType         contentPolicyType;
  uint32_t                    tainting;
  bool                        blockAllMixedContent;
  bool                        upgradeInsecureRequests;
  bool                        browserUpgradeInsecureRequests;
  bool                        browserDidUpgradeInsecureRequests;
  bool                        browserWouldUpgradeInsecureRequests;
  bool                        forceAllowDataURI;
  bool                        allowInsecureRedirectToDataURI;
  bool                        skipContentPolicyCheckForWebRequest;
  bool                        originalFrameSrcLoad;
  bool                        forceInheritPrincipalDropped;
  uint64_t                    innerWindowID;
  uint64_t                    browsingContextID;
  uint64_t                    frameBrowsingContextID;
  bool                        initialSecurityCheckDone;
  bool                        isInThirdPartyContext;
  bool?                       isThirdPartyContextToTopWindow;
  bool                        isFormSubmission;
  bool                        sendCSPViolationEvents;
  OriginAttributes            originAttributes;
  RedirectHistoryEntryInfo[]  redirectChainIncludingInternalRedirects;
  RedirectHistoryEntryInfo[]  redirectChain;
  bool                        hasInjectedCookieForCookieBannerHandling;

  /**
   * ClientInfo structure representing the window or worker that triggered
   * this network request.  May be Nothing if its a system internal request.
   */
  IPCClientInfo?              clientInfo;

  /**
   * Non-subresource requests will result in the creation of a window or
   * worker client.  The reserved and initial ClientInfo values represent
   * this resulting client.  An initial ClientInfo represents an initial
   * about:blank window that will be re-used while a reserved ClientInfo
   * represents a to-be-newly-created window/worker.
   */
  IPCClientInfo?              reservedClientInfo;
  IPCClientInfo?              initialClientInfo;

  /**
   * Subresource loads may have a controller set based on their owning
   * window/worker client.  We must send this across IPC to support
   * performing interception in the parent.
   */
  IPCServiceWorkerDescriptor? controller;

  nsCString[]                 corsUnsafeHeaders;
  bool                        forcePreflight;
  bool                        isPreflight;
  bool                        loadTriggeredFromExternal;
  bool                        serviceWorkerTaintingSynthesized;
  bool                        documentHasUserInteracted;
  bool allowListFutureDocumentsCreatedFromThisRedirectChain;
  bool needForCheckingAntiTrackingHeuristic;
  nsString                    cspNonce;
  bool                        skipContentSniffing;
  uint32_t                    httpsOnlyStatus;
  bool                        hasValidUserGestureActivation;
  bool                        allowDeprecatedSystemRequests;
  bool                        isInDevToolsContext;
  bool                        parserCreatedScript;
  bool                        isFromProcessingFrameAttributes;
  bool                        isMediaRequest;
  bool                        isMediaInitialRequest;
  bool                        isFromObjectOrEmbed;
  CookieJarSettingsArgs       cookieJarSettings;
  uint32_t                    requestBlockingReason;
  CSPInfo?                    cspToInheritInfo;
  StoragePermissionState      storagePermission;
  bool                        isMetaRefresh;
  CrossOriginEmbedderPolicy   loadingEmbedderPolicy;
  bool                        originTrialCoepCredentiallessEnabledForTopLevel;
  nsIURI                      unstrippedURI;
  InterceptionInfoArg?        interceptionInfo;
};

/**
 * This structure is used to carry selected properties of a LoadInfo
 * object to child processes to merge LoadInfo changes from the parent
 * process.  We don't want to use LoadInfoArgs for that since it's
 * too huge and we only care about small subpart of properties anyway.
 */
struct ParentLoadInfoForwarderArgs
{
  // WebExtextensions' WebRequest API allows extensions to intercept and
  // redirect a channel to a data URI. This modifications happens in
  // the parent and needs to be mirrored to the child so that security
  // checks can pass.
  bool allowInsecureRedirectToDataURI;

  // The ServiceWorker controller that may be set in the parent when
  // interception occurs.
  IPCServiceWorkerDescriptor? controller;

  // The service worker may synthesize a Response with a particular
  // tainting value.
  uint32_t tainting;

  // This flag is used for any browsing context where we should not sniff
  // the content type. E.g if an iframe has the XCTO nosniff header, then
  // that flag is set to true so we skip content sniffing for that browsing
  bool skipContentSniffing;

  uint32_t httpsOnlyStatus;

  // Returns true if at the time of the loadinfo construction the document
  // that triggered this load has the bit hasValidTransientUserGestureActivation
  // set or the load was triggered from External. (Mostly this bool is used
  // in the context of Sec-Fetch-User.)
  bool hasValidUserGestureActivation;

  // The SystemPrincipal is disallowed to make requests to the public web
  // and all requests will be cancelled. Setting this flag to true prevents
  // the request from being cancelled.
  bool allowDeprecatedSystemRequests;

  bool isInDevToolsContext;

  // Only ever returns true if the loadinfo is of TYPE_SCRIPT and
  // the script was created by the HTML parser.
  bool parserCreatedScript;

  // Sandbox Flags of the Document that triggered the load
  uint32_t triggeringSandboxFlags;

  // We must also note that the tainting value was explicitly set
  // by the service worker.
  bool serviceWorkerTaintingSynthesized;

  bool documentHasUserInteracted;
  bool allowListFutureDocumentsCreatedFromThisRedirectChain;

  CookieJarSettingsArgs? cookieJarSettings;

  uint32_t requestBlockingReason;

  StoragePermissionState storagePermission;

  bool isMetaRefresh;

  bool? isThirdPartyContextToTopWindow;

  bool isInThirdPartyContext;

  nsIURI unstrippedURI;

  // IMPORTANT: when you add new properites here you must also update
  // LoadInfoToParentLoadInfoForwarder and MergeParentLoadInfoForwarder
  // in BackgroundUtils.cpp/.h!
};

/**
 * This structure is used to carry selected properties of a LoadInfo
 * object to the parent process that might have changed in the child
 * during a redirect.  We don't want to use LoadInfoArgs for that since
 * it's too huge and we only care about small subpart of properties
 * anyway.
 */
struct ChildLoadInfoForwarderArgs
{
  // The reserved and initial ClientInfo values may change during a
  // redirect if the new channel is cross-origin to the old channel.
  IPCClientInfo? reservedClientInfo;
  IPCClientInfo? initialClientInfo;

  // The ServiceWorker controller may be cleared in the child during
  // a redirect.
  IPCServiceWorkerDescriptor? controller;

  uint32_t requestBlockingReason;
};

//-----------------------------------------------------------------------------
// HTTP IPDL structs
//-----------------------------------------------------------------------------

struct CorsPreflightArgs
{
  nsCString[]   unsafeHeaders;
};

struct HttpChannelOpenArgs
{
  nsIURI                      uri;
  // - TODO: bug 571161: unclear if any HTTP channel clients ever
  // set originalURI != uri (about:credits?); also not clear if
  // chrome channel would ever need to know.  Get rid of next arg?
  nsIURI                      original;
  nsIURI                      doc;
  nsIReferrerInfo             referrerInfo;
  nsIURI                      apiRedirectTo;
  nsIURI                      topWindowURI;
  uint32_t                    loadFlags;
  RequestHeaderTuples         requestHeaders;
  nsCString                   requestMethod;
  IPCStream?                  uploadStream;
  bool                        uploadStreamHasHeaders;
  int16_t                     priority;
  ClassOfService              classOfService;
  uint8_t                     redirectionLimit;
  bool                        allowSTS;
  uint32_t                    thirdPartyFlags;
  bool                        resumeAt;
  uint64_t                    startPos;
  nsCString                   entityID;
  bool                        chooseApplicationCache;
  nsCString                   appCacheClientID;
  bool                        allowSpdy;
  bool                        allowHttp3;
  bool                        allowAltSvc;
  bool                        beConservative;
  bool                        bypassProxy;
  uint32_t                    tlsFlags;
  LoadInfoArgs?               loadInfo;
  uint32_t                    cacheKey;
  uint64_t                    requestContextID;
  CorsPreflightArgs?          preflightArgs;
  uint32_t                    initialRwin;
  bool                        blockAuthPrompt;
  bool                        allowStaleCacheContent;
  bool                        forceValidateCacheContent;
  bool                        preferCacheLoadOverBypass;
  nsCString                   contentTypeHint;
  RequestMode                 requestMode;
  uint32_t                    redirectMode;
  uint64_t                    channelId;
  nsString                    integrityMetadata;
  uint64_t                    contentWindowId;
  PreferredAlternativeDataTypeParams[] preferredAlternativeTypes;
  uint64_t                    topBrowsingContextId;
  TimeStamp                   launchServiceWorkerStart;
  TimeStamp                   launchServiceWorkerEnd;
  TimeStamp                   dispatchFetchEventStart;
  TimeStamp                   dispatchFetchEventEnd;
  TimeStamp                   handleFetchEventStart;
  TimeStamp                   handleFetchEventEnd;
  bool                        forceMainDocumentChannel;
  TimeStamp                   navigationStartTimeStamp;
  uint64_t                    earlyHintPreloaderId;
};

struct HttpChannelConnectArgs
{
  uint32_t registrarId;
};

union HttpChannelCreationArgs
{
  HttpChannelOpenArgs;      // For AsyncOpen: the common case.
  HttpChannelConnectArgs;   // Used for redirected-to channels
};

struct ProxyInfoCloneArgs
{
  nsCString type;
  nsCString host;
  int32_t port;
  nsCString username;
  nsCString password;
  uint32_t flags;
  uint32_t timeout;
  uint32_t resolveFlags;
  nsCString proxyAuthorizationHeader;
  nsCString connectionIsolationKey;
};

struct HttpConnectionInfoCloneArgs
{
  nsCString host;
  int32_t port;
  nsCString npnToken;
  nsCString username;
  OriginAttributes originAttributes;
  bool endToEndSSL;
  nsCString routedHost;
  int32_t routedPort;
  bool anonymous;
  bool aPrivate; // use prefix to avoid code generation error
  bool insecureScheme;
  bool noSpdy;
  bool beConservative;
  bool bypassProxy;
  bool anonymousAllowClientCert;
  bool fallbackConnection;
  uint32_t tlsFlags;
  bool isolated;
  bool isTrrServiceChannel;
  uint8_t trrMode;
  bool isIPv4Disabled;
  bool isIPv6Disabled;
  nsCString topWindowOrigin;
  bool isHttp3;
  bool webTransport;
  bool hasIPHintAddress;
  nsCString echConfig;
  ProxyInfoCloneArgs[] proxyInfo;
};

struct ConsoleReportCollected {
  uint32_t errorFlags;
  nsCString category;
  uint32_t propertiesFile;
  nsCString sourceFileURI;
  uint32_t lineNumber;
  uint32_t columnNumber;
  nsCString messageName;
  nsString[] stringParams;
};

struct CookieStruct
{
  nsCString name;
  nsCString value;
  nsCString host;
  nsCString path;
  int64_t   expiry;
  int64_t   lastAccessed;
  int64_t   creationTime;
  bool      isHttpOnly;
  bool      isSession;
  bool      isSecure;
  int32_t   sameSite;
  int32_t   rawSameSite;
  uint8_t   schemeMap;
};

struct DocumentCreationArgs {
  bool uriModified;
  bool isXFOError;
};

struct ObjectCreationArgs {
  uint64_t embedderInnerWindowId;
  uint32_t loadFlags;
  nsContentPolicyType contentPolicyType;
  bool isUrgentStart;
};

union DocumentChannelElementCreationArgs {
  DocumentCreationArgs;
  ObjectCreationArgs;
};

struct DocumentChannelCreationArgs {
  nsDocShellLoadState loadState;
  TimeStamp asyncOpenTime;
  uint64_t channelId;
  uint32_t cacheKey;
  nsDOMNavigationTiming? timing;
  IPCClientInfo? initialClientInfo;
  DocumentChannelElementCreationArgs elementCreationArgs;
  uint64_t parentInitiatedNavigationEpoch;
};

struct EarlyHintConnectArgs {
  LinkHeader link;
  uint64_t earlyHintPreloaderId;
};

struct RedirectToRealChannelArgs {
  uint32_t registrarId;
  nsIURI uri;
  uint32_t newLoadFlags;
  ReplacementChannelConfigInit? init;
  LoadInfoArgs? loadInfo;
  uint64_t channelId;
  nsIURI originalURI;
  uint32_t redirectMode;
  uint32_t redirectFlags;
  uint32_t? contentDisposition;
  nsString? contentDispositionFilename;
  nsIPropertyBag2 properties;
  uint32_t loadStateExternalLoadFlags;
  uint32_t loadStateInternalLoadFlags;
  uint32_t loadStateLoadType;
  nsDOMNavigationTiming? timing;
  nsString srcdocData;
  nsIURI baseUri;
  LoadingSessionHistoryInfo? loadingSessionHistoryInfo;
  uint64_t loadIdentifier;
  nsCString? originalUriString;
  EarlyHintConnectArgs[] earlyHints;
};

struct TimingStructArgs {
  TimeStamp domainLookupStart;
  TimeStamp domainLookupEnd;
  TimeStamp connectStart;
  TimeStamp tcpConnectEnd;
  TimeStamp secureConnectionStart;
  TimeStamp connectEnd;
  TimeStamp requestStart;
  TimeStamp responseStart;
  TimeStamp responseEnd;
};

struct ResourceTimingStructArgs {
  TimeStamp domainLookupStart;
  TimeStamp domainLookupEnd;
  TimeStamp connectStart;
  TimeStamp tcpConnectEnd;
  TimeStamp secureConnectionStart;
  TimeStamp connectEnd;
  TimeStamp requestStart;
  TimeStamp responseStart;
  TimeStamp responseEnd;
  TimeStamp fetchStart;
  TimeStamp redirectStart;
  TimeStamp redirectEnd;
  uint64_t transferSize;
  uint64_t encodedBodySize;
  nsCString protocolVersion;

  // Not actually part of resource timing, but not part of the transaction
  // timings either. These need to be passed to HttpChannelChild along with
  // the rest of the timings so the timing information in the child is complete.
  TimeStamp cacheReadStart;
  TimeStamp cacheReadEnd;

  TimeStamp transactionPending;
};

struct HttpActivity
{
  nsCString host;
  int32_t port;
  bool endToEndSSL;
};

struct HttpConnectionActivity
{
  nsCString connInfoKey;
  nsCString host;
  int32_t port;
  bool ssl;
  bool hasECH;
  bool isHttp3;
};

union HttpActivityArgs
{
  uint64_t;
  HttpActivity;
  HttpConnectionActivity;
};

struct TransactionObserverResult
{
  bool versionOk;
  bool authOk;
  nsresult closeReason;
};

struct SpeculativeConnectionOverriderArgs {
  uint32_t parallelSpeculativeConnectLimit;
  bool ignoreIdle;
  bool isFromPredictor;
  bool allow1918;
};

//-----------------------------------------------------------------------------
// GIO IPDL structs
//-----------------------------------------------------------------------------

struct GIOChannelOpenArgs
{
  URIParams                 uri;
  uint64_t                  startPos;
  nsCString                 entityID;
  IPCStream?                uploadStream;
  LoadInfoArgs?             loadInfo;
  uint32_t                  loadFlags;
};

struct GIOChannelConnectArgs
{
  uint32_t channelId;
};

union GIOChannelCreationArgs
{
  GIOChannelOpenArgs;      // For AsyncOpen: the common case.
  GIOChannelConnectArgs;   // Used for redirected-to channels
};

struct RemoteStreamInfo {
  nsIInputStream inputStream;
  nsCString contentType;
  int64_t contentLength;
};
} // namespace net
} // namespace mozilla