summaryrefslogtreecommitdiffstats
path: root/netwerk/ipc/NeckoChannelParams.ipdlh
blob: 44af8d48085bb53051e0c9eafb4310393ee98317 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
/* -*- 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 mozilla::net::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;
  bool hasFingerprintingRandomizationKey;
  uint8_t[] fingerprintingRandomizationKey;
};

//-----------------------------------------------------------------------------
// 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;
  uint64_t                    triggeringWindowId;
  bool                        triggeringStorageAccess;
  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;
  bool                        wasSchemelessInput;

  /**
   * 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;
  nsString                    integrityMetadata;
  bool                        skipContentSniffing;
  uint32_t                    httpsOnlyStatus;
  bool                        hstsStatus;
  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;
  uint64_t?                   overriddenFingerprintingSettings;
  bool                        isMetaRefresh;
  CrossOriginEmbedderPolicy   loadingEmbedderPolicy;
  bool                        originTrialCoepCredentiallessEnabledForTopLevel;
  nullable 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;

  bool hstsStatus;

  // 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;

  // Window ID and UsingStorageAccess of the Document that triggered the load.
  // Used by the Storage Access API to determine if SubDocument loads should
  // be partitioned or not.
  uint64_t triggeringWindowId;
  bool triggeringStorageAccess;

  // 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;

  uint64_t? overriddenFingerprintingSettings;

  bool isMetaRefresh;

  bool? isThirdPartyContextToTopWindow;

  bool isInThirdPartyContext;

  nullable 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
{
  nullable 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?
  nullable nsIURI             original;
  nullable nsIURI             doc;
  nullable nsIReferrerInfo    referrerInfo;
  nullable nsIURI             apiRedirectTo;
  nullable nsIURI             topWindowURI;
  RequestHeaderTuples         requestHeaders;
  PreferredAlternativeDataTypeParams[] preferredAlternativeTypes;
  TimeStamp                   launchServiceWorkerStart;
  TimeStamp                   launchServiceWorkerEnd;
  TimeStamp                   dispatchFetchEventStart;
  TimeStamp                   dispatchFetchEventEnd;
  TimeStamp                   handleFetchEventStart;
  TimeStamp                   handleFetchEventEnd;
  TimeStamp                   navigationStartTimeStamp;
  uint64_t                    startPos;
  uint64_t                    requestContextID;
  uint64_t                    channelId;
  uint64_t                    contentWindowId;
  uint64_t                    browserId;
  uint64_t                    earlyHintPreloaderId;
  nsCString                   requestMethod;
  ClassOfService              classOfService;
  nsCString                   entityID;
  nsCString                   appCacheClientID;
  CorsPreflightArgs?          preflightArgs;
  nsCString                   contentTypeHint;
  nsString                    integrityMetadata;
  IPCStream?                  uploadStream;
  LoadInfoArgs                loadInfo;
  uint32_t                    loadFlags;
  uint32_t                    thirdPartyFlags;
  uint32_t                    tlsFlags;
  uint32_t                    cacheKey;
  uint32_t                    initialRwin;
  uint32_t                    redirectMode;
  int16_t                     priority;
  bool                        uploadStreamHasHeaders;
  bool                        allowSTS;
  bool                        resumeAt;
  bool                        allowSpdy;
  bool                        allowHttp3;
  bool                        allowAltSvc;
  bool                        beConservative;
  bool                        bypassProxy;
  bool                        blockAuthPrompt;
  bool                        allowStaleCacheContent;
  RequestMode                 requestMode;
  bool                        forceValidateCacheContent;
  bool                        preferCacheLoadOverBypass;
  bool                        forceMainDocumentChannel;
  uint8_t                     redirectionLimit;
  nsString                    classicScriptHintCharset;
  nsString                    documentCharacterSet;
  bool                        isUserAgentHeaderModified;
};

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;
  bool      isPartitioned;
  int32_t   sameSite;
  int32_t   rawSameSite;
  uint8_t   schemeMap;
};

struct DocumentCreationArgs {
  bool uriModified;
  bool isEmbeddingBlockedError;
};

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;
  nullable nsDOMNavigationTiming timing;
  IPCClientInfo? initialClientInfo;
  DocumentChannelElementCreationArgs elementCreationArgs;
  uint64_t parentInitiatedNavigationEpoch;
};

struct EarlyHintConnectArgs {
  LinkHeader link;
  uint64_t earlyHintPreloaderId;
};

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

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

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;

  // 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 {
  nullable nsIInputStream inputStream;
  nsCString contentType;
  int64_t contentLength;
};
} // namespace net
} // namespace mozilla