Line data Source code
1 :
2 : /* vim: set sw=2 ts=8 et tw=80 : */
3 :
4 : /* This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 :
8 : #include "necko-config.h"
9 : #include "nsHttp.h"
10 : #include "mozilla/net/NeckoChild.h"
11 : #include "mozilla/dom/ContentChild.h"
12 : #include "mozilla/dom/TabChild.h"
13 : #include "mozilla/net/HttpChannelChild.h"
14 : #include "mozilla/net/CookieServiceChild.h"
15 : #include "mozilla/net/WyciwygChannelChild.h"
16 : #include "mozilla/net/FTPChannelChild.h"
17 : #include "mozilla/net/WebSocketChannelChild.h"
18 : #include "mozilla/net/WebSocketEventListenerChild.h"
19 : #include "mozilla/net/DNSRequestChild.h"
20 : #include "mozilla/net/ChannelDiverterChild.h"
21 : #include "mozilla/net/IPCTransportProvider.h"
22 : #include "mozilla/dom/network/TCPSocketChild.h"
23 : #include "mozilla/dom/network/TCPServerSocketChild.h"
24 : #include "mozilla/dom/network/UDPSocketChild.h"
25 : #include "mozilla/net/AltDataOutputStreamChild.h"
26 : #ifdef MOZ_WEBRTC
27 : #include "mozilla/net/StunAddrsRequestChild.h"
28 : #endif
29 :
30 : #ifdef NECKO_PROTOCOL_rtsp
31 : #include "mozilla/net/RtspControllerChild.h"
32 : #include "mozilla/net/RtspChannelChild.h"
33 : #endif
34 : #include "SerializedLoadContext.h"
35 : #include "nsGlobalWindow.h"
36 : #include "nsIOService.h"
37 : #include "nsINetworkPredictor.h"
38 : #include "nsINetworkPredictorVerifier.h"
39 : #include "mozilla/ipc/URIUtils.h"
40 : #include "nsNetUtil.h"
41 :
42 : using mozilla::dom::TCPSocketChild;
43 : using mozilla::dom::TCPServerSocketChild;
44 : using mozilla::dom::UDPSocketChild;
45 :
46 : namespace mozilla {
47 : namespace net {
48 :
49 : PNeckoChild *gNeckoChild = nullptr;
50 :
51 : // C++ file contents
52 2 : NeckoChild::NeckoChild()
53 : {
54 2 : }
55 :
56 0 : NeckoChild::~NeckoChild()
57 : {
58 : //Send__delete__(gNeckoChild);
59 0 : gNeckoChild = nullptr;
60 0 : }
61 :
62 3 : void NeckoChild::InitNeckoChild()
63 : {
64 3 : MOZ_ASSERT(IsNeckoChild(), "InitNeckoChild called by non-child!");
65 :
66 3 : if (!gNeckoChild) {
67 : mozilla::dom::ContentChild * cpc =
68 2 : mozilla::dom::ContentChild::GetSingleton();
69 2 : NS_ASSERTION(cpc, "Content Protocol is NULL!");
70 2 : if (NS_WARN_IF(cpc->IsShuttingDown())) {
71 0 : return;
72 : }
73 2 : gNeckoChild = cpc->SendPNeckoConstructor();
74 2 : NS_ASSERTION(gNeckoChild, "PNecko Protocol init failed!");
75 : }
76 : }
77 :
78 : PHttpChannelChild*
79 0 : NeckoChild::AllocPHttpChannelChild(const PBrowserOrId& browser,
80 : const SerializedLoadContext& loadContext,
81 : const HttpChannelCreationArgs& aOpenArgs)
82 : {
83 : // We don't allocate here: instead we always use IPDL constructor that takes
84 : // an existing HttpChildChannel
85 0 : NS_NOTREACHED("AllocPHttpChannelChild should not be called on child");
86 0 : return nullptr;
87 : }
88 :
89 : bool
90 2 : NeckoChild::DeallocPHttpChannelChild(PHttpChannelChild* channel)
91 : {
92 2 : MOZ_ASSERT(IsNeckoChild(), "DeallocPHttpChannelChild called by non-child!");
93 :
94 2 : HttpChannelChild* child = static_cast<HttpChannelChild*>(channel);
95 2 : child->ReleaseIPDLReference();
96 2 : return true;
97 : }
98 :
99 : PStunAddrsRequestChild*
100 0 : NeckoChild::AllocPStunAddrsRequestChild()
101 : {
102 : // We don't allocate here: instead we always use IPDL constructor that takes
103 : // an existing object
104 0 : NS_NOTREACHED("AllocPStunAddrsRequestChild should not be called on child");
105 0 : return nullptr;
106 : }
107 :
108 : bool
109 0 : NeckoChild::DeallocPStunAddrsRequestChild(PStunAddrsRequestChild* aActor)
110 : {
111 : #ifdef MOZ_WEBRTC
112 0 : StunAddrsRequestChild* p = static_cast<StunAddrsRequestChild*>(aActor);
113 0 : p->ReleaseIPDLReference();
114 : #endif
115 0 : return true;
116 : }
117 :
118 : PAltDataOutputStreamChild*
119 0 : NeckoChild::AllocPAltDataOutputStreamChild(
120 : const nsCString& type,
121 : PHttpChannelChild* channel)
122 : {
123 : // We don't allocate here: see HttpChannelChild::OpenAlternativeOutputStream()
124 0 : NS_NOTREACHED("AllocPAltDataOutputStreamChild should not be called");
125 0 : return nullptr;
126 : }
127 :
128 : bool
129 0 : NeckoChild::DeallocPAltDataOutputStreamChild(PAltDataOutputStreamChild* aActor)
130 : {
131 0 : AltDataOutputStreamChild* child = static_cast<AltDataOutputStreamChild*>(aActor);
132 0 : child->ReleaseIPDLReference();
133 0 : return true;
134 : }
135 :
136 : PFTPChannelChild*
137 0 : NeckoChild::AllocPFTPChannelChild(const PBrowserOrId& aBrowser,
138 : const SerializedLoadContext& aSerialized,
139 : const FTPChannelCreationArgs& aOpenArgs)
140 : {
141 : // We don't allocate here: see FTPChannelChild::AsyncOpen()
142 0 : MOZ_CRASH("AllocPFTPChannelChild should not be called");
143 : return nullptr;
144 : }
145 :
146 : bool
147 0 : NeckoChild::DeallocPFTPChannelChild(PFTPChannelChild* channel)
148 : {
149 0 : MOZ_ASSERT(IsNeckoChild(), "DeallocPFTPChannelChild called by non-child!");
150 :
151 0 : FTPChannelChild* child = static_cast<FTPChannelChild*>(channel);
152 0 : child->ReleaseIPDLReference();
153 0 : return true;
154 : }
155 :
156 : PCookieServiceChild*
157 0 : NeckoChild::AllocPCookieServiceChild()
158 : {
159 : // We don't allocate here: see nsCookieService::GetSingleton()
160 0 : NS_NOTREACHED("AllocPCookieServiceChild should not be called");
161 0 : return nullptr;
162 : }
163 :
164 : bool
165 0 : NeckoChild::DeallocPCookieServiceChild(PCookieServiceChild* cs)
166 : {
167 0 : NS_ASSERTION(IsNeckoChild(), "DeallocPCookieServiceChild called by non-child!");
168 :
169 0 : CookieServiceChild *p = static_cast<CookieServiceChild*>(cs);
170 0 : p->Release();
171 0 : return true;
172 : }
173 :
174 : PWyciwygChannelChild*
175 0 : NeckoChild::AllocPWyciwygChannelChild()
176 : {
177 : // We don't allocate here: see nsWyciwygProtocolHandler::NewChannel2()
178 0 : NS_NOTREACHED("AllocPWyciwygChannelChild should not be called");
179 0 : return nullptr;
180 : }
181 :
182 : bool
183 0 : NeckoChild::DeallocPWyciwygChannelChild(PWyciwygChannelChild* channel)
184 : {
185 0 : MOZ_ASSERT(IsNeckoChild(), "DeallocPWyciwygChannelChild called by non-child!");
186 :
187 0 : WyciwygChannelChild *p = static_cast<WyciwygChannelChild*>(channel);
188 0 : p->ReleaseIPDLReference();
189 0 : return true;
190 : }
191 :
192 : PWebSocketChild*
193 0 : NeckoChild::AllocPWebSocketChild(const PBrowserOrId& browser,
194 : const SerializedLoadContext& aSerialized,
195 : const uint32_t& aSerial)
196 : {
197 0 : NS_NOTREACHED("AllocPWebSocketChild should not be called");
198 0 : return nullptr;
199 : }
200 :
201 : bool
202 0 : NeckoChild::DeallocPWebSocketChild(PWebSocketChild* child)
203 : {
204 0 : WebSocketChannelChild* p = static_cast<WebSocketChannelChild*>(child);
205 0 : p->ReleaseIPDLReference();
206 0 : return true;
207 : }
208 :
209 : PWebSocketEventListenerChild*
210 0 : NeckoChild::AllocPWebSocketEventListenerChild(const uint64_t& aInnerWindowID)
211 : {
212 0 : nsCOMPtr<nsIEventTarget> target;
213 0 : if (nsGlobalWindow* win = nsGlobalWindow::GetInnerWindowWithId(aInnerWindowID)) {
214 0 : target = win->EventTargetFor(TaskCategory::Other);
215 : }
216 :
217 : RefPtr<WebSocketEventListenerChild> c =
218 0 : new WebSocketEventListenerChild(aInnerWindowID, target);
219 :
220 0 : if (target) {
221 0 : gNeckoChild->SetEventTargetForActor(c, target);
222 : }
223 :
224 0 : return c.forget().take();
225 : }
226 :
227 : bool
228 0 : NeckoChild::DeallocPWebSocketEventListenerChild(PWebSocketEventListenerChild* aActor)
229 : {
230 : RefPtr<WebSocketEventListenerChild> c =
231 0 : dont_AddRef(static_cast<WebSocketEventListenerChild*>(aActor));
232 0 : MOZ_ASSERT(c);
233 0 : return true;
234 : }
235 :
236 : PDataChannelChild*
237 0 : NeckoChild::AllocPDataChannelChild(const uint32_t& channelId)
238 : {
239 0 : MOZ_ASSERT_UNREACHABLE("Should never get here");
240 : return nullptr;
241 : }
242 :
243 : bool
244 0 : NeckoChild::DeallocPDataChannelChild(PDataChannelChild* child)
245 : {
246 : // NB: See DataChannelChild::ActorDestroy.
247 0 : return true;
248 : }
249 :
250 : PFileChannelChild*
251 0 : NeckoChild::AllocPFileChannelChild(const uint32_t& channelId)
252 : {
253 0 : MOZ_ASSERT_UNREACHABLE("Should never get here");
254 : return nullptr;
255 : }
256 :
257 : bool
258 0 : NeckoChild::DeallocPFileChannelChild(PFileChannelChild* child)
259 : {
260 : // NB: See FileChannelChild::ActorDestroy.
261 0 : return true;
262 : }
263 :
264 : PRtspControllerChild*
265 0 : NeckoChild::AllocPRtspControllerChild()
266 : {
267 0 : NS_NOTREACHED("AllocPRtspController should not be called");
268 0 : return nullptr;
269 : }
270 :
271 : bool
272 0 : NeckoChild::DeallocPRtspControllerChild(PRtspControllerChild* child)
273 : {
274 : #ifdef NECKO_PROTOCOL_rtsp
275 : RtspControllerChild* p = static_cast<RtspControllerChild*>(child);
276 : p->ReleaseIPDLReference();
277 : #endif
278 0 : return true;
279 : }
280 :
281 : PRtspChannelChild*
282 0 : NeckoChild::AllocPRtspChannelChild(const RtspChannelConnectArgs& aArgs)
283 : {
284 0 : NS_NOTREACHED("AllocPRtspController should not be called");
285 0 : return nullptr;
286 : }
287 :
288 : bool
289 0 : NeckoChild::DeallocPRtspChannelChild(PRtspChannelChild* child)
290 : {
291 : #ifdef NECKO_PROTOCOL_rtsp
292 : RtspChannelChild* p = static_cast<RtspChannelChild*>(child);
293 : p->ReleaseIPDLReference();
294 : #endif
295 0 : return true;
296 : }
297 :
298 : PTCPSocketChild*
299 0 : NeckoChild::AllocPTCPSocketChild(const nsString& host,
300 : const uint16_t& port)
301 : {
302 0 : TCPSocketChild* p = new TCPSocketChild(host, port, nullptr);
303 0 : p->AddIPDLReference();
304 0 : return p;
305 : }
306 :
307 : bool
308 0 : NeckoChild::DeallocPTCPSocketChild(PTCPSocketChild* child)
309 : {
310 0 : TCPSocketChild* p = static_cast<TCPSocketChild*>(child);
311 0 : p->ReleaseIPDLReference();
312 0 : return true;
313 : }
314 :
315 : PTCPServerSocketChild*
316 0 : NeckoChild::AllocPTCPServerSocketChild(const uint16_t& aLocalPort,
317 : const uint16_t& aBacklog,
318 : const bool& aUseArrayBuffers)
319 : {
320 0 : NS_NOTREACHED("AllocPTCPServerSocket should not be called");
321 0 : return nullptr;
322 : }
323 :
324 : bool
325 0 : NeckoChild::DeallocPTCPServerSocketChild(PTCPServerSocketChild* child)
326 : {
327 0 : TCPServerSocketChild* p = static_cast<TCPServerSocketChild*>(child);
328 0 : p->ReleaseIPDLReference();
329 0 : return true;
330 : }
331 :
332 : PUDPSocketChild*
333 0 : NeckoChild::AllocPUDPSocketChild(const Principal& aPrincipal,
334 : const nsCString& aFilter)
335 : {
336 0 : NS_NOTREACHED("AllocPUDPSocket should not be called");
337 0 : return nullptr;
338 : }
339 :
340 : bool
341 0 : NeckoChild::DeallocPUDPSocketChild(PUDPSocketChild* child)
342 : {
343 :
344 0 : UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
345 0 : p->ReleaseIPDLReference();
346 0 : return true;
347 : }
348 :
349 : PDNSRequestChild*
350 0 : NeckoChild::AllocPDNSRequestChild(const nsCString& aHost,
351 : const OriginAttributes& aOriginAttributes,
352 : const uint32_t& aFlags,
353 : const nsCString& aNetworkInterface)
354 : {
355 : // We don't allocate here: instead we always use IPDL constructor that takes
356 : // an existing object
357 0 : NS_NOTREACHED("AllocPDNSRequestChild should not be called on child");
358 0 : return nullptr;
359 : }
360 :
361 : bool
362 0 : NeckoChild::DeallocPDNSRequestChild(PDNSRequestChild* aChild)
363 : {
364 0 : DNSRequestChild *p = static_cast<DNSRequestChild*>(aChild);
365 0 : p->ReleaseIPDLReference();
366 0 : return true;
367 : }
368 :
369 : PChannelDiverterChild*
370 0 : NeckoChild::AllocPChannelDiverterChild(const ChannelDiverterArgs& channel)
371 : {
372 0 : return new ChannelDiverterChild();;
373 : }
374 :
375 : bool
376 0 : NeckoChild::DeallocPChannelDiverterChild(PChannelDiverterChild* child)
377 : {
378 0 : delete static_cast<ChannelDiverterChild*>(child);
379 0 : return true;
380 : }
381 :
382 : PTransportProviderChild*
383 0 : NeckoChild::AllocPTransportProviderChild()
384 : {
385 : // This refcount is transferred to the receiver of the message that
386 : // includes the PTransportProviderChild actor.
387 0 : RefPtr<TransportProviderChild> res = new TransportProviderChild();
388 :
389 0 : return res.forget().take();
390 : }
391 :
392 : bool
393 0 : NeckoChild::DeallocPTransportProviderChild(PTransportProviderChild* aActor)
394 : {
395 0 : return true;
396 : }
397 :
398 : mozilla::ipc::IPCResult
399 0 : NeckoChild::RecvAsyncAuthPromptForNestedFrame(const TabId& aNestedFrameId,
400 : const nsCString& aUri,
401 : const nsString& aRealm,
402 : const uint64_t& aCallbackId)
403 : {
404 0 : RefPtr<dom::TabChild> tabChild = dom::TabChild::FindTabChild(aNestedFrameId);
405 0 : if (!tabChild) {
406 0 : MOZ_CRASH();
407 : return IPC_FAIL_NO_REASON(this);
408 : }
409 0 : tabChild->SendAsyncAuthPrompt(aUri, aRealm, aCallbackId);
410 0 : return IPC_OK();
411 : }
412 :
413 : /* Predictor Messages */
414 : mozilla::ipc::IPCResult
415 0 : NeckoChild::RecvPredOnPredictPrefetch(const URIParams& aURI,
416 : const uint32_t& aHttpStatus)
417 : {
418 0 : MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictPrefetch "
419 : "off main thread.");
420 :
421 0 : nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
422 :
423 : // Get the current predictor
424 0 : nsresult rv = NS_OK;
425 : nsCOMPtr<nsINetworkPredictorVerifier> predictor =
426 0 : do_GetService("@mozilla.org/network/predictor;1", &rv);
427 0 : NS_ENSURE_SUCCESS(rv, IPC_FAIL_NO_REASON(this));
428 :
429 0 : predictor->OnPredictPrefetch(uri, aHttpStatus);
430 0 : return IPC_OK();
431 : }
432 :
433 : mozilla::ipc::IPCResult
434 0 : NeckoChild::RecvPredOnPredictPreconnect(const URIParams& aURI)
435 : {
436 0 : MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictPreconnect "
437 : "off main thread.");
438 :
439 0 : nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
440 :
441 : // Get the current predictor
442 0 : nsresult rv = NS_OK;
443 : nsCOMPtr<nsINetworkPredictorVerifier> predictor =
444 0 : do_GetService("@mozilla.org/network/predictor;1", &rv);
445 0 : NS_ENSURE_SUCCESS(rv, IPC_FAIL_NO_REASON(this));
446 :
447 0 : predictor->OnPredictPreconnect(uri);
448 0 : return IPC_OK();
449 : }
450 :
451 : mozilla::ipc::IPCResult
452 0 : NeckoChild::RecvPredOnPredictDNS(const URIParams& aURI)
453 : {
454 0 : MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictDNS off "
455 : "main thread.");
456 :
457 0 : nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
458 :
459 : // Get the current predictor
460 0 : nsresult rv = NS_OK;
461 : nsCOMPtr<nsINetworkPredictorVerifier> predictor =
462 0 : do_GetService("@mozilla.org/network/predictor;1", &rv);
463 0 : NS_ENSURE_SUCCESS(rv, IPC_FAIL_NO_REASON(this));
464 :
465 0 : predictor->OnPredictDNS(uri);
466 0 : return IPC_OK();
467 : }
468 :
469 : mozilla::ipc::IPCResult
470 0 : NeckoChild::RecvSpeculativeConnectRequest()
471 : {
472 0 : nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
473 0 : if (obsService) {
474 0 : obsService->NotifyObservers(nullptr, "speculative-connect-request",
475 0 : nullptr);
476 : }
477 0 : return IPC_OK();
478 : }
479 :
480 : } // namespace net
481 : } // namespace mozilla
482 :
|
