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
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 PDNSRequest;
include protocol PSocketProcessBridge;
include protocol PProfiler;
include protocol PWebrtcTCPSocket;
include protocol PHttpTransaction;
include protocol PHttpConnectionMgr;
include protocol PInputChannelThrottleQueue;
include protocol PAltService;
include protocol PAltSvcTransaction;
include protocol PTRRService;
include protocol PProxyConfigLookup;
include protocol PNativeDNSResolverOverride;
include protocol PProxyAutoConfig;
include protocol PSocketProcessBackground;
#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
include protocol PSandboxTesting;
#endif
include CrashReporterInitArgs;
include MemoryReportTypes;
include NeckoChannelParams;
include PrefsTypes;
include "mozilla/ipc/ByteBufUtils.h";
using mozilla::dom::NativeThreadId from "mozilla/dom/NativeThreadId.h";
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
using base::ProcessId from "base/process.h";
using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using PRTime from "prtime.h";
[RefCounted] using class nsIURI from "mozilla/ipc/URIUtils.h";
using struct nsID from "nsID.h";
using mozilla::net::SocketInfo from "mozilla/net/DashboardTypes.h";
using mozilla::net::DNSCacheEntries from "mozilla/net/DashboardTypes.h";
using mozilla::net::HttpRetParams from "mozilla/net/DashboardTypes.h";
using mozilla::net::Http3ConnectionStatsParams from "mozilla/net/DashboardTypes.h";
using mozilla::net::NetAddr from "mozilla/net/DNS.h";
using nsIDNSService::DNSFlags from "nsIDNSService.h";
#if defined(XP_WIN)
[MoveOnly] using mozilla::UntrustedModulesData from "mozilla/UntrustedModulesData.h";
[MoveOnly] using mozilla::ModulePaths from "mozilla/UntrustedModulesData.h";
[MoveOnly] using mozilla::ModulesMapResult from "mozilla/UntrustedModulesData.h";
#endif // defined(XP_WIN)
namespace mozilla {
namespace net {
struct HttpHandlerInitArgs {
nsCString mLegacyAppName;
nsCString mLegacyAppVersion;
nsCString mPlatform;
nsCString mOscpu;
nsCString mMisc;
nsCString mProduct;
nsCString mProductSub;
nsCString mAppName;
nsCString mAppVersion;
nsCString mCompatFirefox;
nsCString mCompatDevice;
nsCString mDeviceModelId;
};
struct SocketDataArgs
{
uint64_t totalSent;
uint64_t totalRecv;
SocketInfo[] info;
};
struct SocketPorcessInitAttributes {
bool mOffline;
bool mConnectivity;
bool mInitSandbox;
#if defined(XP_WIN)
bool mIsReadyForBackgroundProcessing;
#endif
FileDescriptor? mSandboxBroker;
};
[NeedsOtherPid, ChildProc=Socket]
sync protocol PSocketProcess
{
manages PDNSRequest;
manages PWebrtcTCPSocket;
manages PHttpTransaction;
manages PHttpConnectionMgr;
manages PInputChannelThrottleQueue;
manages PAltService;
manages PAltSvcTransaction;
manages PTRRService;
manages PProxyConfigLookup;
manages PNativeDNSResolverOverride;
parent:
async InitCrashReporter(CrashReporterInitArgs aInitArgs);
async AddMemoryReport(MemoryReport aReport);
// Messages for sending telemetry to parent process.
async AccumulateChildHistograms(HistogramAccumulation[] accumulations);
async AccumulateChildKeyedHistograms(KeyedHistogramAccumulation[] accumulations);
async UpdateChildScalars(ScalarAction[] actions);
async UpdateChildKeyedScalars(KeyedScalarAction[] actions);
async RecordChildEvents(ChildEventData[] events);
async RecordDiscardedData(DiscardedData data);
/* tabId is only required for web-proxy support, which isn't always needed */
async PWebrtcTCPSocket(TabId? tabId);
async ObserveHttpActivity(HttpActivityArgs aActivityArgs,
uint32_t aActivityType,
uint32_t aActivitySubtype,
PRTime aTimestamp,
uint64_t aExtraSizeData,
nsCString aExtraStringData);
async InitSocketBackground(Endpoint<PSocketProcessBackgroundParent> aEndpoint);
async PAltService();
async PProxyConfigLookup(nullable nsIURI aUri, uint32_t aFlags);
async ExcludeHttp2OrHttp3(HttpConnectionInfoCloneArgs aArgs);
async OnConsoleMessage(nsString aMessage);
// Sent from time-to-time to limit the amount of telemetry vulnerable to loss
// Buffer contains bincoded Rust structs.
// https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/ipc.html
async FOGData(ByteBuf buf);
async GeckoTraceExport(ByteBuf aBuf);
#if defined(XP_WIN)
async GetModulesTrust(ModulePaths aModPaths, bool aRunAtNormalPriority)
returns (ModulesMapResult? modMapResult);
#endif // defined(XP_WIN)
child:
async Init(SocketPorcessInitAttributes aAttributes);
async PreferenceUpdate(Pref pref);
async RequestMemoryReport(uint32_t generation,
bool anonymize,
bool minimizeMemoryUsage,
FileDescriptor? DMDFile)
returns (uint32_t aGeneration);
async SetOffline(bool offline);
async SetConnectivity(bool connectivity);
async InitLinuxSandbox(FileDescriptor? sandboxBroker);
async InitSocketProcessBridgeParent(ProcessId processId, Endpoint<PSocketProcessBridgeParent> endpoint);
async InitProfiler(Endpoint<PProfilerChild> aEndpoint);
#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
async InitSandboxTesting(Endpoint<PSandboxTestingChild> aEndpoint);
#endif
// test-only
async SocketProcessTelemetryPing();
async PHttpTransaction();
async PHttpConnectionMgr(HttpHandlerInitArgs aArgs);
async UpdateDeviceModelId(nsCString aModelId);
async OnHttpActivityDistributorActivated(bool aIsActivated);
async OnHttpActivityDistributorObserveProxyResponse(bool aIsEnabled);
async OnHttpActivityDistributorObserveConnection(bool aIsEnabled);
async PInputChannelThrottleQueue(uint32_t meanBytesPerSecond,
uint32_t maxBytesPerSecond);
async PAltSvcTransaction(HttpConnectionInfoCloneArgs aConnInfo,
uint32_t aCaps);
async ClearSessionCache() returns (void_t ok);
async PTRRService(bool aCaptiveIsPassed,
bool aParentalControlEnabled,
nsCString[] aDNSSuffixList);
async PNativeDNSResolverOverride();
async NotifyObserver(nsCString aTopic, nsString aData);
async GetSocketData()
returns (SocketDataArgs data);
async GetDNSCacheEntries()
returns (DNSCacheEntries[] entries);
async GetHttpConnectionData()
returns (HttpRetParams[] params);
async GetHttp3ConnectionStatsData()
returns (Http3ConnectionStatsParams[] params);
async InitProxyAutoConfigChild(Endpoint<PProxyAutoConfigChild> endpoint);
async RecheckIPConnectivity();
async RecheckDNS();
// Tells the Socket process to flush any pending telemetry.
// Used in tests and ping assembly. Buffer contains bincoded Rust structs.
// https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/ipc.html
async FlushFOGData() returns (ByteBuf buf);
// Test-only method.
// Asks the Socket process to trigger test-only instrumentation.
// The unused returned value is to have a promise we can await.
async TestTriggerMetrics() returns (bool unused);
#if defined(XP_WIN)
async GetUntrustedModulesData() returns (UntrustedModulesData? data);
/**
* This method is used to notifty a child process to start
* processing module loading events in UntrustedModulesProcessor.
* This should be called when the parent process has gone idle.
*/
async UnblockUntrustedModulesThread();
#endif // defined(XP_WIN)
async AddNetAddrOverride(NetAddr aFrom, NetAddr aTo);
async ClearNetAddrOverrides();
both:
async PDNSRequest(nsCString hostName, nsCString trrServer, int32_t port,
uint16_t type, OriginAttributes originAttributes,
DNSFlags flags);
};
} // namespace net
} // namespace mozilla
|
