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
|
/* -*- 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/. */
#ifndef mozilla_net_SocketProcessChild_h
#define mozilla_net_SocketProcessChild_h
#include "mozilla/net/PSocketProcessChild.h"
#include "mozilla/ipc/InputStreamUtils.h"
#include "mozilla/psm/IPCClientCertsChild.h"
#include "mozilla/Mutex.h"
#include "nsRefPtrHashtable.h"
#include "nsTHashMap.h"
#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
# include "mozilla/PSandboxTestingChild.h"
#endif
namespace mozilla {
class ChildProfilerController;
}
namespace mozilla {
namespace net {
class ProxyAutoConfigChild;
class SocketProcessBackgroundChild;
class SocketProcessBridgeParent;
class BackgroundDataBridgeParent;
// The IPC actor implements PSocketProcessChild in child process.
// This is allocated and kept alive by SocketProcessImpl.
class SocketProcessChild final : public PSocketProcessChild {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SocketProcessChild, final)
SocketProcessChild();
static SocketProcessChild* GetSingleton();
bool Init(mozilla::ipc::UntypedEndpoint&& aEndpoint,
const char* aParentBuildID);
void ActorDestroy(ActorDestroyReason aWhy) override;
mozilla::ipc::IPCResult RecvInit(
const SocketPorcessInitAttributes& aAttributes);
mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref);
mozilla::ipc::IPCResult RecvRequestMemoryReport(
const uint32_t& generation, const bool& anonymize,
const bool& minimizeMemoryUsage,
const Maybe<mozilla::ipc::FileDescriptor>& DMDFile,
const RequestMemoryReportResolver& aResolver);
mozilla::ipc::IPCResult RecvSetOffline(const bool& aOffline);
mozilla::ipc::IPCResult RecvSetConnectivity(const bool& aConnectivity);
mozilla::ipc::IPCResult RecvInitLinuxSandbox(
const Maybe<ipc::FileDescriptor>& aBrokerFd);
mozilla::ipc::IPCResult RecvInitSocketProcessBridgeParent(
const ProcessId& aContentProcessId,
Endpoint<mozilla::net::PSocketProcessBridgeParent>&& aEndpoint);
mozilla::ipc::IPCResult RecvInitProfiler(
Endpoint<mozilla::PProfilerChild>&& aEndpoint);
#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
mozilla::ipc::IPCResult RecvInitSandboxTesting(
Endpoint<PSandboxTestingChild>&& aEndpoint);
#endif
mozilla::ipc::IPCResult RecvSocketProcessTelemetryPing();
PWebrtcTCPSocketChild* AllocPWebrtcTCPSocketChild(const Maybe<TabId>& tabId);
bool DeallocPWebrtcTCPSocketChild(PWebrtcTCPSocketChild* aActor);
already_AddRefed<PHttpTransactionChild> AllocPHttpTransactionChild();
void CleanUp();
void DestroySocketProcessBridgeParent(ProcessId aId);
already_AddRefed<PHttpConnectionMgrChild> AllocPHttpConnectionMgrChild(
const HttpHandlerInitArgs& aArgs);
mozilla::ipc::IPCResult RecvUpdateDeviceModelId(const nsACString& aModelId);
mozilla::ipc::IPCResult RecvOnHttpActivityDistributorActivated(
const bool& aIsActivated);
mozilla::ipc::IPCResult RecvOnHttpActivityDistributorObserveProxyResponse(
const bool& aIsEnabled);
mozilla::ipc::IPCResult RecvOnHttpActivityDistributorObserveConnection(
const bool& aIsEnabled);
already_AddRefed<PInputChannelThrottleQueueChild>
AllocPInputChannelThrottleQueueChild(const uint32_t& aMeanBytesPerSecond,
const uint32_t& aMaxBytesPerSecond);
already_AddRefed<PAltSvcTransactionChild> AllocPAltSvcTransactionChild(
const HttpConnectionInfoCloneArgs& aConnInfo, const uint32_t& aCaps);
bool IsShuttingDown();
already_AddRefed<PDNSRequestChild> AllocPDNSRequestChild(
const nsACString& aHost, const nsACString& aTrrServer,
const int32_t& aPort, const uint16_t& aType,
const OriginAttributes& aOriginAttributes,
const nsIDNSService::DNSFlags& aFlags);
mozilla::ipc::IPCResult RecvPDNSRequestConstructor(
PDNSRequestChild* aActor, const nsACString& aHost,
const nsACString& aTrrServer, const int32_t& aPort, const uint16_t& aType,
const OriginAttributes& aOriginAttributes,
const nsIDNSService::DNSFlags& aFlags) override;
void AddDataBridgeToMap(uint64_t aChannelId,
BackgroundDataBridgeParent* aActor);
void RemoveDataBridgeFromMap(uint64_t aChannelId);
Maybe<RefPtr<BackgroundDataBridgeParent>> GetAndRemoveDataBridge(
uint64_t aChannelId);
mozilla::ipc::IPCResult RecvClearSessionCache(
ClearSessionCacheResolver&& aResolve);
already_AddRefed<PTRRServiceChild> AllocPTRRServiceChild(
const bool& aCaptiveIsPassed, const bool& aParentalControlEnabled,
const nsTArray<nsCString>& aDNSSuffixList);
mozilla::ipc::IPCResult RecvPTRRServiceConstructor(
PTRRServiceChild* aActor, const bool& aCaptiveIsPassed,
const bool& aParentalControlEnabled,
nsTArray<nsCString>&& aDNSSuffixList) override;
already_AddRefed<PNativeDNSResolverOverrideChild>
AllocPNativeDNSResolverOverrideChild();
mozilla::ipc::IPCResult RecvPNativeDNSResolverOverrideConstructor(
PNativeDNSResolverOverrideChild* aActor) override;
mozilla::ipc::IPCResult RecvNotifyObserver(const nsACString& aTopic,
const nsAString& aData);
mozilla::ipc::IPCResult RecvGetSocketData(GetSocketDataResolver&& aResolve);
mozilla::ipc::IPCResult RecvGetDNSCacheEntries(
GetDNSCacheEntriesResolver&& aResolve);
mozilla::ipc::IPCResult RecvGetHttpConnectionData(
GetHttpConnectionDataResolver&& aResolve);
mozilla::ipc::IPCResult RecvGetHttp3ConnectionStatsData(
GetHttp3ConnectionStatsDataResolver&& aResolve);
mozilla::ipc::IPCResult RecvInitProxyAutoConfigChild(
Endpoint<PProxyAutoConfigChild>&& aEndpoint);
mozilla::ipc::IPCResult RecvRecheckIPConnectivity();
mozilla::ipc::IPCResult RecvRecheckDNS();
mozilla::ipc::IPCResult RecvFlushFOGData(FlushFOGDataResolver&& aResolver);
mozilla::ipc::IPCResult RecvTestTriggerMetrics(
TestTriggerMetricsResolver&& aResolve);
#if defined(XP_WIN)
mozilla::ipc::IPCResult RecvGetUntrustedModulesData(
GetUntrustedModulesDataResolver&& aResolver);
mozilla::ipc::IPCResult RecvUnblockUntrustedModulesThread();
#endif // defined(XP_WIN)
already_AddRefed<psm::IPCClientCertsChild> GetIPCClientCertsActor();
void CloseIPCClientCertsActor();
mozilla::ipc::IPCResult RecvAddNetAddrOverride(const NetAddr& aFrom,
const NetAddr& aTo);
mozilla::ipc::IPCResult RecvClearNetAddrOverrides();
protected:
friend class SocketProcessImpl;
~SocketProcessChild();
void InitSocketBackground();
private:
// Mapping of content process id and the SocketProcessBridgeParent.
// This table keeps SocketProcessBridgeParent alive in socket process.
nsRefPtrHashtable<nsUint32HashKey, SocketProcessBridgeParent>
mSocketProcessBridgeParentMap;
RefPtr<ChildProfilerController> mProfilerController;
// Protect the table below.
Mutex mMutex MOZ_UNANNOTATED{"SocketProcessChild::mMutex"};
nsTHashMap<uint64_t, RefPtr<BackgroundDataBridgeParent>>
mBackgroundDataBridgeMap;
bool mShuttingDown MOZ_GUARDED_BY(mMutex) = false;
nsCOMPtr<nsIEventTarget> mSocketThread;
// mIPCClientCertsChild is only accessed on the socket thread.
RefPtr<psm::IPCClientCertsChild> mIPCClientCertsChild;
};
} // namespace net
} // namespace mozilla
#endif // mozilla_net_SocketProcessChild_h
|
