Bug 1746114 - Collect the third-party modules ping from socket process. r=mhowell,necko-reviewers,kershaw

Differential Revision: https://phabricator.services.mozilla.com/D133846

netwerk/ipc/PSocketProcess.ipdl

@@ -50,6 +50,12 @@ 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";
 
+#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 {
 
@@ -147,6 +153,11 @@ parent:
   // https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/ipc.html
   async FOGData(ByteBuf buf);
 
+#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);
@@ -207,6 +218,10 @@ child:
   // 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);
+#endif  // defined(XP_WIN)
+
 both:
   async PFileDescriptorSet(FileDescriptor fd);
   async PDNSRequest(nsCString hostName, nsCString trrServer, uint16_t type,

netwerk/ipc/SocketProcessChild.cpp

@@ -55,6 +55,8 @@
 
 #if defined(XP_WIN)
 #  include <process.h>
+
+#  include "mozilla/WinDllServices.h"
 #else
 #  include <unistd.h>
 #endif
@@ -168,6 +170,12 @@ bool SocketProcessChild::Init(base::ProcessId aParentPid,
   // Initialize DNS Service here, since it needs to be done in main thread.
   nsCOMPtr<nsIDNSService> dns =
       do_GetService("@mozilla.org/network/dns-service;1", &rv);
+
+#if defined(XP_WIN)
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->StartUntrustedModulesProcessor();
+#endif  // defined(XP_WIN)
+
   return NS_SUCCEEDED(rv);
 }
 
@@ -687,5 +695,19 @@ mozilla::ipc::IPCResult SocketProcessChild::RecvTestTriggerMetrics(
   return IPC_OK();
 }
 
+#if defined(XP_WIN)
+mozilla::ipc::IPCResult SocketProcessChild::RecvGetUntrustedModulesData(
+    GetUntrustedModulesDataResolver&& aResolver) {
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->GetUntrustedModulesData()->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [aResolver](Maybe<UntrustedModulesData>&& aData) {
+        aResolver(std::move(aData));
+      },
+      [aResolver](nsresult aReason) { aResolver(Nothing()); });
+  return IPC_OK();
+}
+#endif  // defined(XP_WIN)
+
 }  // namespace net
 }  // namespace mozilla

netwerk/ipc/SocketProcessChild.h

@@ -153,6 +153,11 @@ class SocketProcessChild final
   mozilla::ipc::IPCResult RecvTestTriggerMetrics(
       TestTriggerMetricsResolver&& aResolve);
 
+#if defined(XP_WIN)
+  mozilla::ipc::IPCResult RecvGetUntrustedModulesData(
+      GetUntrustedModulesDataResolver&& aResolver);
+#endif  // defined(XP_WIN)
+
  protected:
   friend class SocketProcessImpl;
   ~SocketProcessChild();

netwerk/ipc/SocketProcessParent.cpp

@@ -476,5 +476,21 @@ mozilla::ipc::IPCResult SocketProcessParent::RecvFOGData(ByteBuf&& aBuf) {
   return IPC_OK();
 }
 
+#if defined(XP_WIN)
+mozilla::ipc::IPCResult SocketProcessParent::RecvGetModulesTrust(
+    ModulePaths&& aModPaths, bool aRunAtNormalPriority,
+    GetModulesTrustResolver&& aResolver) {
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->GetModulesTrust(std::move(aModPaths), aRunAtNormalPriority)
+      ->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          [aResolver](ModulesMapResult&& aResult) {
+            aResolver(Some(ModulesMapResult(std::move(aResult))));
+          },
+          [aResolver](nsresult aRv) { aResolver(Nothing()); });
+  return IPC_OK();
+}
+#endif  // defined(XP_WIN)
+
 }  // namespace net
 }  // namespace mozilla

netwerk/ipc/SocketProcessParent.h

@@ -127,6 +127,12 @@ class SocketProcessParent final
 
   mozilla::ipc::IPCResult RecvFOGData(ByteBuf&& aBuf);
 
+#if defined(XP_WIN)
+  mozilla::ipc::IPCResult RecvGetModulesTrust(
+      ModulePaths&& aModPaths, bool aRunAtNormalPriority,
+      GetModulesTrustResolver&& aResolver);
+#endif  // defined(XP_WIN)
+
  private:
   SocketProcessHost* mHost;
   UniquePtr<dom::MemoryReportRequestHost> mMemoryReportRequest;

toolkit/components/telemetry/other/UntrustedModules.cpp

@@ -8,6 +8,7 @@
 
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/MozPromise.h"
+#include "mozilla/net/SocketProcessParent.h"
 #include "mozilla/RDDChild.h"
 #include "mozilla/RDDProcessManager.h"
 #include "mozilla/WinDllServices.h"
@@ -131,6 +132,10 @@ MultiGetUntrustedModulesData::GetUntrustedModuleLoadEvents() {
     AddPending(contentParent->SendGetUntrustedModulesData());
   }
 
+  if (auto* socketActor = net::SocketProcessParent::GetSingleton()) {
+    AddPending(socketActor->SendGetUntrustedModulesData());
+  }
+
   if (RDDProcessManager* rddMgr = RDDProcessManager::Get()) {
     if (RDDChild* rddChild = rddMgr->GetRDDChild()) {
       AddPending(rddChild->SendGetUntrustedModulesData());

toolkit/xre/dllservices/UntrustedModulesProcessor.cpp

@@ -12,6 +12,7 @@
 #include "mozilla/DebugOnly.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/Likely.h"
+#include "mozilla/net/SocketProcessChild.h"
 #include "mozilla/RDDParent.h"
 #include "mozilla/ScopeExit.h"
 #include "mozilla/Services.h"
@@ -92,6 +93,7 @@ bool UntrustedModulesProcessor::IsSupportedProcessType() {
   switch (XRE_GetProcessType()) {
     case GeckoProcessType_Default:
     case GeckoProcessType_Content:
+    case GeckoProcessType_Socket:
       return Telemetry::CanRecordReleaseData();
     case GeckoProcessType_RDD:
       // For RDD process, we check the telemetry settings in RDDChild::Init()
@@ -695,6 +697,11 @@ UntrustedModulesProcessor::SendGetModulesTrust(ModulePaths&& aModules,
       return ::mozilla::SendGetModulesTrust(RDDParent::GetSingleton(),
                                             std::move(aModules), runNormal);
     }
+    case GeckoProcessType_Socket: {
+      return ::mozilla::SendGetModulesTrust(
+          net::SocketProcessChild::GetSingleton(), std::move(aModules),
+          runNormal);
+    }
     default: {
       MOZ_ASSERT_UNREACHABLE("Unsupported process type");
       return GetModulesTrustIpcPromise::CreateAndReject(