netwerk/ipc/SocketProcessParent.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "SocketProcessParent.h"
   7 #include "SocketProcessLogging.h"
   8
   9 #include "AltServiceParent.h"
  10 #include "CachePushChecker.h"
  11 #include "HttpTransactionParent.h"
  12 #include "SocketProcessHost.h"
  13 #include "TLSClientAuthCertSelection.h"
  14 #include "mozilla/Components.h"
  15 #include "mozilla/dom/MemoryReportRequest.h"
  16 #include "mozilla/FOGIPC.h"
  17 #include "mozilla/net/DNSRequestParent.h"
  18 #include "mozilla/net/ProxyConfigLookupParent.h"
  19 #include "mozilla/net/SocketProcessBackgroundParent.h"
  20 #include "mozilla/RemoteLazyInputStreamParent.h"
  21 #include "mozilla/Telemetry.h"
  22 #include "mozilla/TelemetryIPC.h"
  23 #include "nsIConsoleService.h"
  24 #include "nsIHttpActivityObserver.h"
  25 #include "nsIObserverService.h"
  26 #include "nsNSSCertificate.h"
  27 #include "nsNSSComponent.h"
  28 #include "nsIOService.h"
  29 #include "nsHttpHandler.h"
  30 #include "nsHttpConnectionInfo.h"
  31 #include "secerr.h"
  32 #ifdef MOZ_WEBRTC
  33 #  include "mozilla/dom/ContentProcessManager.h"
  34 #  include "mozilla/dom/BrowserParent.h"
  35 #  include "mozilla/net/WebrtcTCPSocketParent.h"
  36 #endif
  37 #if defined(MOZ_WIDGET_ANDROID)
  38 #  include "mozilla/java/GeckoProcessManagerWrappers.h"
  39 #  include "mozilla/java/GeckoProcessTypeWrappers.h"
  40 #endif  // defined(MOZ_WIDGET_ANDROID)
  41 #if defined(XP_WIN)
  42 #  include "mozilla/WinDllServices.h"
  43 #endif
  44
  45 namespace mozilla {
  46 namespace net {
  47
  48 static SocketProcessParent* sSocketProcessParent;
  49
  50 SocketProcessParent::SocketProcessParent(SocketProcessHost* aHost)
  51     : mHost(aHost) {
  52   MOZ_ASSERT(NS_IsMainThread());
  53   MOZ_ASSERT(mHost);
  54
  55   MOZ_COUNT_CTOR(SocketProcessParent);
  56   sSocketProcessParent = this;
  57 }
  58
  59 SocketProcessParent::~SocketProcessParent() {
  60   MOZ_ASSERT(NS_IsMainThread());
  61
  62   MOZ_COUNT_DTOR(SocketProcessParent);
  63   sSocketProcessParent = nullptr;
  64 }
  65
  66 /* static */
  67 SocketProcessParent* SocketProcessParent::GetSingleton() {
  68   MOZ_ASSERT(NS_IsMainThread());
  69
  70   return sSocketProcessParent;
  71 }
  72
  73 void SocketProcessParent::ActorDestroy(ActorDestroyReason aWhy) {
  74 #if defined(MOZ_WIDGET_ANDROID)
  75   nsCOMPtr<nsIEventTarget> launcherThread(ipc::GetIPCLauncher());
  76   MOZ_ASSERT(launcherThread);
  77
  78   auto procType = java::GeckoProcessType::SOCKET();
  79   auto selector =
  80       java::GeckoProcessManager::Selector::New(procType, OtherPid());
  81
  82   launcherThread->Dispatch(NS_NewRunnableFunction(
  83       "SocketProcessParent::ActorDestroy",
  84       [selector = java::GeckoProcessManager::Selector::GlobalRef(selector)]() {
  85         java::GeckoProcessManager::ShutdownProcess(selector);
  86       }));
  87 #endif  // defined(MOZ_WIDGET_ANDROID)
  88
  89   if (aWhy == AbnormalShutdown) {
  90     GenerateCrashReport(OtherPid());
  91     MaybeTerminateProcess();
  92   }
  93
  94   if (mHost) {
  95     mHost->OnChannelClosed();
  96   }
  97 }
  98
  99 bool SocketProcessParent::SendRequestMemoryReport(
 100     const uint32_t& aGeneration, const bool& aAnonymize,
 101     const bool& aMinimizeMemoryUsage,
 102     const Maybe<ipc::FileDescriptor>& aDMDFile) {
 103   mMemoryReportRequest = MakeUnique<dom::MemoryReportRequestHost>(aGeneration);
 104
 105   PSocketProcessParent::SendRequestMemoryReport(
 106       aGeneration, aAnonymize, aMinimizeMemoryUsage, aDMDFile,
 107       [&](const uint32_t& aGeneration2) {
 108         MOZ_ASSERT(gIOService);
 109         if (!gIOService->SocketProcess()) {
 110           return;
 111         }
 112         SocketProcessParent* actor = gIOService->SocketProcess()->GetActor();
 113         if (!actor) {
 114           return;
 115         }
 116         if (actor->mMemoryReportRequest) {
 117           actor->mMemoryReportRequest->Finish(aGeneration2);
 118           actor->mMemoryReportRequest = nullptr;
 119         }
 120       },
 121       [&](mozilla::ipc::ResponseRejectReason) {
 122         MOZ_ASSERT(gIOService);
 123         if (!gIOService->SocketProcess()) {
 124           return;
 125         }
 126         SocketProcessParent* actor = gIOService->SocketProcess()->GetActor();
 127         if (!actor) {
 128           return;
 129         }
 130         actor->mMemoryReportRequest = nullptr;
 131       });
 132
 133   return true;
 134 }
 135
 136 mozilla::ipc::IPCResult SocketProcessParent::RecvAddMemoryReport(
 137     const MemoryReport& aReport) {
 138   if (mMemoryReportRequest) {
 139     mMemoryReportRequest->RecvReport(aReport);
 140   }
 141   return IPC_OK();
 142 }
 143
 144 mozilla::ipc::IPCResult SocketProcessParent::RecvAccumulateChildHistograms(
 145     nsTArray<HistogramAccumulation>&& aAccumulations) {
 146   TelemetryIPC::AccumulateChildHistograms(Telemetry::ProcessID::Socket,
 147                                           aAccumulations);
 148   return IPC_OK();
 149 }
 150
 151 mozilla::ipc::IPCResult SocketProcessParent::RecvAccumulateChildKeyedHistograms(
 152     nsTArray<KeyedHistogramAccumulation>&& aAccumulations) {
 153   TelemetryIPC::AccumulateChildKeyedHistograms(Telemetry::ProcessID::Socket,
 154                                                aAccumulations);
 155   return IPC_OK();
 156 }
 157
 158 mozilla::ipc::IPCResult SocketProcessParent::RecvUpdateChildScalars(
 159     nsTArray<ScalarAction>&& aScalarActions) {
 160   TelemetryIPC::UpdateChildScalars(Telemetry::ProcessID::Socket,
 161                                    aScalarActions);
 162   return IPC_OK();
 163 }
 164
 165 mozilla::ipc::IPCResult SocketProcessParent::RecvUpdateChildKeyedScalars(
 166     nsTArray<KeyedScalarAction>&& aScalarActions) {
 167   TelemetryIPC::UpdateChildKeyedScalars(Telemetry::ProcessID::Socket,
 168                                         aScalarActions);
 169   return IPC_OK();
 170 }
 171
 172 mozilla::ipc::IPCResult SocketProcessParent::RecvRecordChildEvents(
 173     nsTArray<mozilla::Telemetry::ChildEventData>&& aEvents) {
 174   TelemetryIPC::RecordChildEvents(Telemetry::ProcessID::Socket, aEvents);
 175   return IPC_OK();
 176 }
 177
 178 mozilla::ipc::IPCResult SocketProcessParent::RecvRecordDiscardedData(
 179     const mozilla::Telemetry::DiscardedData& aDiscardedData) {
 180   TelemetryIPC::RecordDiscardedData(Telemetry::ProcessID::Socket,
 181                                     aDiscardedData);
 182   return IPC_OK();
 183 }
 184
 185 PWebrtcTCPSocketParent* SocketProcessParent::AllocPWebrtcTCPSocketParent(
 186     const Maybe<TabId>& aTabId) {
 187 #ifdef MOZ_WEBRTC
 188   WebrtcTCPSocketParent* parent = new WebrtcTCPSocketParent(aTabId);
 189   parent->AddRef();
 190   return parent;
 191 #else
 192   return nullptr;
 193 #endif
 194 }
 195
 196 bool SocketProcessParent::DeallocPWebrtcTCPSocketParent(
 197     PWebrtcTCPSocketParent* aActor) {
 198 #ifdef MOZ_WEBRTC
 199   WebrtcTCPSocketParent* parent = static_cast<WebrtcTCPSocketParent*>(aActor);
 200   parent->Release();
 201 #endif
 202   return true;
 203 }
 204
 205 already_AddRefed<PDNSRequestParent> SocketProcessParent::AllocPDNSRequestParent(
 206     const nsACString& aHost, const nsACString& aTrrServer, const int32_t& port,
 207     const uint16_t& aType, const OriginAttributes& aOriginAttributes,
 208     const nsIDNSService::DNSFlags& aFlags) {
 209   RefPtr<DNSRequestHandler> handler = new DNSRequestHandler();
 210   RefPtr<DNSRequestParent> actor = new DNSRequestParent(handler);
 211   return actor.forget();
 212 }
 213
 214 mozilla::ipc::IPCResult SocketProcessParent::RecvPDNSRequestConstructor(
 215     PDNSRequestParent* aActor, const nsACString& aHost,
 216     const nsACString& aTrrServer, const int32_t& port, const uint16_t& aType,
 217     const OriginAttributes& aOriginAttributes,
 218     const nsIDNSService::DNSFlags& aFlags) {
 219   RefPtr<DNSRequestParent> actor = static_cast<DNSRequestParent*>(aActor);
 220   RefPtr<DNSRequestHandler> handler =
 221       actor->GetDNSRequest()->AsDNSRequestHandler();
 222   handler->DoAsyncResolve(aHost, aTrrServer, port, aType, aOriginAttributes,
 223                           aFlags);
 224   return IPC_OK();
 225 }
 226
 227 mozilla::ipc::IPCResult SocketProcessParent::RecvObserveHttpActivity(
 228     const HttpActivityArgs& aArgs, const uint32_t& aActivityType,
 229     const uint32_t& aActivitySubtype, const PRTime& aTimestamp,
 230     const uint64_t& aExtraSizeData, const nsACString& aExtraStringData) {
 231   nsCOMPtr<nsIHttpActivityDistributor> activityDistributor =
 232       components::HttpActivityDistributor::Service();
 233   MOZ_ASSERT(activityDistributor);
 234
 235   Unused << activityDistributor->ObserveActivityWithArgs(
 236       aArgs, aActivityType, aActivitySubtype, aTimestamp, aExtraSizeData,
 237       aExtraStringData);
 238   return IPC_OK();
 239 }
 240
 241 mozilla::ipc::IPCResult SocketProcessParent::RecvInitSocketBackground(
 242     Endpoint<PSocketProcessBackgroundParent>&& aEndpoint) {
 243   if (!aEndpoint.IsValid()) {
 244     return IPC_FAIL(this, "Invalid endpoint");
 245   }
 246
 247   nsCOMPtr<nsISerialEventTarget> transportQueue;
 248   if (NS_FAILED(NS_CreateBackgroundTaskQueue("SocketBackgroundParentQueue",
 249                                              getter_AddRefs(transportQueue)))) {
 250     return IPC_FAIL(this, "NS_CreateBackgroundTaskQueue failed");
 251   }
 252
 253   transportQueue->Dispatch(
 254       NS_NewRunnableFunction("BindSocketBackgroundParent",
 255                              [endpoint = std::move(aEndpoint)]() mutable {
 256                                RefPtr<SocketProcessBackgroundParent> parent =
 257                                    new SocketProcessBackgroundParent();
 258                                endpoint.Bind(parent);
 259                              }));
 260   return IPC_OK();
 261 }
 262
 263 already_AddRefed<PAltServiceParent>
 264 SocketProcessParent::AllocPAltServiceParent() {
 265   RefPtr<AltServiceParent> actor = new AltServiceParent();
 266   return actor.forget();
 267 }
 268
 269 already_AddRefed<PProxyConfigLookupParent>
 270 SocketProcessParent::AllocPProxyConfigLookupParent(
 271     nsIURI* aURI, const uint32_t& aProxyResolveFlags) {
 272   RefPtr<ProxyConfigLookupParent> actor =
 273       new ProxyConfigLookupParent(aURI, aProxyResolveFlags);
 274   return actor.forget();
 275 }
 276
 277 mozilla::ipc::IPCResult SocketProcessParent::RecvPProxyConfigLookupConstructor(
 278     PProxyConfigLookupParent* aActor, nsIURI* aURI,
 279     const uint32_t& aProxyResolveFlags) {
 280   static_cast<ProxyConfigLookupParent*>(aActor)->DoProxyLookup();
 281   return IPC_OK();
 282 }
 283
 284 mozilla::ipc::IPCResult SocketProcessParent::RecvCachePushCheck(
 285     nsIURI* aPushedURL, OriginAttributes&& aOriginAttributes,
 286     nsCString&& aRequestString, CachePushCheckResolver&& aResolver) {
 287   RefPtr<CachePushChecker> checker = new CachePushChecker(
 288       aPushedURL, aOriginAttributes, aRequestString, aResolver);
 289   if (NS_FAILED(checker->DoCheck())) {
 290     aResolver(false);
 291   }
 292   return IPC_OK();
 293 }
 294
 295 // To ensure that IPDL is finished before SocketParent gets deleted.
 296 class DeferredDeleteSocketProcessParent : public Runnable {
 297  public:
 298   explicit DeferredDeleteSocketProcessParent(
 299       RefPtr<SocketProcessParent>&& aParent)
 300       : Runnable("net::DeferredDeleteSocketProcessParent"),
 301         mParent(std::move(aParent)) {}
 302
 303   NS_IMETHODIMP Run() override { return NS_OK; }
 304
 305  private:
 306   RefPtr<SocketProcessParent> mParent;
 307 };
 308
 309 /* static */
 310 void SocketProcessParent::Destroy(RefPtr<SocketProcessParent>&& aParent) {
 311   NS_DispatchToMainThread(
 312       new DeferredDeleteSocketProcessParent(std::move(aParent)));
 313 }
 314
 315 mozilla::ipc::IPCResult SocketProcessParent::RecvExcludeHttp2OrHttp3(
 316     const HttpConnectionInfoCloneArgs& aArgs) {
 317   RefPtr<nsHttpConnectionInfo> cinfo =
 318       nsHttpConnectionInfo::DeserializeHttpConnectionInfoCloneArgs(aArgs);
 319   if (!cinfo) {
 320     MOZ_ASSERT(false, "failed to deserizlize http connection info");
 321     return IPC_OK();
 322   }
 323
 324   if (cinfo->IsHttp3()) {
 325     gHttpHandler->ExcludeHttp3(cinfo);
 326   } else {
 327     gHttpHandler->ExcludeHttp2(cinfo);
 328   }
 329   return IPC_OK();
 330 }
 331
 332 mozilla::ipc::IPCResult SocketProcessParent::RecvOnConsoleMessage(
 333     const nsString& aMessage) {
 334   nsCOMPtr<nsIConsoleService> consoleService =
 335       do_GetService(NS_CONSOLESERVICE_CONTRACTID);
 336   if (consoleService) {
 337     consoleService->LogStringMessage(aMessage.get());
 338   }
 339   return IPC_OK();
 340 }
 341
 342 mozilla::ipc::IPCResult SocketProcessParent::RecvFOGData(ByteBuf&& aBuf) {
 343   glean::FOGData(std::move(aBuf));
 344   return IPC_OK();
 345 }
 346
 347 #if defined(XP_WIN)
 348 mozilla::ipc::IPCResult SocketProcessParent::RecvGetModulesTrust(
 349     ModulePaths&& aModPaths, bool aRunAtNormalPriority,
 350     GetModulesTrustResolver&& aResolver) {
 351   RefPtr<DllServices> dllSvc(DllServices::Get());
 352   dllSvc->GetModulesTrust(std::move(aModPaths), aRunAtNormalPriority)
 353       ->Then(
 354           GetMainThreadSerialEventTarget(), __func__,
 355           [aResolver](ModulesMapResult&& aResult) {
 356             aResolver(Some(ModulesMapResult(std::move(aResult))));
 357           },
 358           [aResolver](nsresult aRv) { aResolver(Nothing()); });
 359   return IPC_OK();
 360 }
 361 #endif  // defined(XP_WIN)
 362
 363 }  // namespace net
 364 }  // namespace mozilla