From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- netwerk/system/android/moz.build | 14 ++ .../system/android/nsAndroidNetworkLinkService.cpp | 243 +++++++++++++++++++++ .../system/android/nsAndroidNetworkLinkService.h | 48 ++++ 3 files changed, 305 insertions(+) create mode 100644 netwerk/system/android/moz.build create mode 100644 netwerk/system/android/nsAndroidNetworkLinkService.cpp create mode 100644 netwerk/system/android/nsAndroidNetworkLinkService.h (limited to 'netwerk/system/android') diff --git a/netwerk/system/android/moz.build b/netwerk/system/android/moz.build new file mode 100644 index 0000000000..c60b3e5871 --- /dev/null +++ b/netwerk/system/android/moz.build @@ -0,0 +1,14 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +SOURCES += [ + "nsAndroidNetworkLinkService.cpp", +] + +FINAL_LIBRARY = "xul" +LOCAL_INCLUDES += [ + "/netwerk/base", +] diff --git a/netwerk/system/android/nsAndroidNetworkLinkService.cpp b/netwerk/system/android/nsAndroidNetworkLinkService.cpp new file mode 100644 index 0000000000..850ac5b565 --- /dev/null +++ b/netwerk/system/android/nsAndroidNetworkLinkService.cpp @@ -0,0 +1,243 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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 "nsAndroidNetworkLinkService.h" +#include "nsServiceManagerUtils.h" + +#include "nsIObserverService.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Services.h" +#include "mozilla/Logging.h" + +#include "AndroidBridge.h" +#include "mozilla/java/GeckoAppShellWrappers.h" +#include "mozilla/jni/Utils.h" + +namespace java = mozilla::java; +namespace jni = mozilla::jni; + +static mozilla::LazyLogModule gNotifyAddrLog("nsAndroidNetworkLinkService"); +#define LOG(args) MOZ_LOG(gNotifyAddrLog, mozilla::LogLevel::Debug, args) + +NS_IMPL_ISUPPORTS(nsAndroidNetworkLinkService, nsINetworkLinkService, + nsIObserver) + +nsAndroidNetworkLinkService::nsAndroidNetworkLinkService() + : mStatusIsKnown(false) {} + +nsresult nsAndroidNetworkLinkService::Init() { + nsCOMPtr observerService = + mozilla::services::GetObserverService(); + if (!observerService) { + return NS_ERROR_FAILURE; + } + + nsresult rv; + rv = observerService->AddObserver(this, "xpcom-shutdown-threads", false); + NS_ENSURE_SUCCESS(rv, rv); + + mNetlinkSvc = new mozilla::net::NetlinkService(); + rv = mNetlinkSvc->Init(this); + if (NS_FAILED(rv)) { + mNetlinkSvc = nullptr; + LOG(("Cannot initialize NetlinkService [rv=0x%08" PRIx32 "]", + static_cast(rv))); + return rv; + } + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult nsAndroidNetworkLinkService::Shutdown() { + // remove xpcom shutdown observer + nsCOMPtr observerService = + mozilla::services::GetObserverService(); + if (observerService) + observerService->RemoveObserver(this, "xpcom-shutdown-threads"); + + if (mNetlinkSvc) { + mNetlinkSvc->Shutdown(); + mNetlinkSvc = nullptr; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + if (!strcmp("xpcom-shutdown-threads", topic)) { + Shutdown(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetIsLinkUp(bool* aIsUp) { + if (mNetlinkSvc && mStatusIsKnown) { + mNetlinkSvc->GetIsLinkUp(aIsUp); + return NS_OK; + } + + if (!mozilla::AndroidBridge::Bridge()) { + // Fail soft here and assume a connection exists + NS_WARNING("GetIsLinkUp is not supported without a bridge connection"); + *aIsUp = true; + return NS_OK; + } + + *aIsUp = java::GeckoAppShell::IsNetworkLinkUp(); + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetLinkStatusKnown(bool* aIsKnown) { + if (mStatusIsKnown) { + *aIsKnown = true; + return NS_OK; + } + + NS_ENSURE_TRUE(mozilla::AndroidBridge::Bridge(), NS_ERROR_NOT_IMPLEMENTED); + + *aIsKnown = java::GeckoAppShell::IsNetworkLinkKnown(); + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetLinkType(uint32_t* aLinkType) { + NS_ENSURE_ARG_POINTER(aLinkType); + + if (!mozilla::AndroidBridge::Bridge()) { + // Fail soft here and assume a connection exists + NS_WARNING("GetLinkType is not supported without a bridge connection"); + *aLinkType = nsINetworkLinkService::LINK_TYPE_UNKNOWN; + return NS_OK; + } + + *aLinkType = java::GeckoAppShell::GetNetworkLinkType(); + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetNetworkID(nsACString& aNetworkID) { + if (!mNetlinkSvc) { + return NS_ERROR_NOT_AVAILABLE; + } + + mNetlinkSvc->GetNetworkID(aNetworkID); + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetDnsSuffixList( + nsTArray& aDnsSuffixList) { + aDnsSuffixList.Clear(); + if (!jni::IsAvailable()) { + NS_WARNING("GetDnsSuffixList is not supported without JNI"); + return NS_ERROR_NOT_AVAILABLE; + } + + jni::String::LocalRef suffixList; + nsresult rv = java::GeckoAppShell::GetDNSDomains(&suffixList); + if (NS_FAILED(rv)) { + return rv; + } + + if (!suffixList || !suffixList->Length()) { + return NS_OK; + } + + nsAutoCString list(suffixList->ToCString()); + for (const nsACString& suffix : list.Split(',')) { + aDnsSuffixList.AppendElement(suffix); + } + return NS_OK; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetResolvers( + nsTArray>& aResolvers) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetNativeResolvers( + nsTArray& aResolvers) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsAndroidNetworkLinkService::GetPlatformDNSIndications( + uint32_t* aPlatformDNSIndications) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +void nsAndroidNetworkLinkService::OnNetworkChanged() { + if (mozilla::StaticPrefs::network_notify_changed()) { + RefPtr self = this; + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsAndroidNetworkLinkService::OnNetworkChanged", [self]() { + self->NotifyObservers(NS_NETWORK_LINK_TOPIC, + NS_NETWORK_LINK_DATA_CHANGED); + })); + } +} + +void nsAndroidNetworkLinkService::OnNetworkIDChanged() { + RefPtr self = this; + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsAndroidNetworkLinkService::OnNetworkIDChanged", [self]() { + self->NotifyObservers(NS_NETWORK_ID_CHANGED_TOPIC, nullptr); + })); +} + +void nsAndroidNetworkLinkService::OnLinkUp() { + RefPtr self = this; + NS_DispatchToMainThread( + NS_NewRunnableFunction("nsAndroidNetworkLinkService::OnLinkUp", [self]() { + self->NotifyObservers(NS_NETWORK_LINK_TOPIC, NS_NETWORK_LINK_DATA_UP); + })); +} + +void nsAndroidNetworkLinkService::OnLinkDown() { + RefPtr self = this; + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsAndroidNetworkLinkService::OnLinkDown", [self]() { + self->NotifyObservers(NS_NETWORK_LINK_TOPIC, NS_NETWORK_LINK_DATA_DOWN); + })); +} + +void nsAndroidNetworkLinkService::OnLinkStatusKnown() { mStatusIsKnown = true; } + +void nsAndroidNetworkLinkService::OnDnsSuffixListUpdated() { + RefPtr self = this; + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsAndroidNetworkLinkService::OnDnsSuffixListUpdated", [self]() { + self->NotifyObservers(NS_DNS_SUFFIX_LIST_UPDATED_TOPIC, nullptr); + })); +} + +/* Sends the given event. Assumes aTopic/aData never goes out of scope (static + * strings are ideal). + */ +void nsAndroidNetworkLinkService::NotifyObservers(const char* aTopic, + const char* aData) { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("nsAndroidNetworkLinkService::NotifyObservers: topic:%s data:%s\n", + aTopic, aData ? aData : "")); + + nsCOMPtr observerService = + mozilla::services::GetObserverService(); + + if (observerService) { + observerService->NotifyObservers( + static_cast(this), aTopic, + aData ? NS_ConvertASCIItoUTF16(aData).get() : nullptr); + } +} diff --git a/netwerk/system/android/nsAndroidNetworkLinkService.h b/netwerk/system/android/nsAndroidNetworkLinkService.h new file mode 100644 index 0000000000..eaa3e2de4a --- /dev/null +++ b/netwerk/system/android/nsAndroidNetworkLinkService.h @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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 NSANDROIDNETWORKLINKSERVICE_H_ +#define NSANDROIDNETWORKLINKSERVICE_H_ + +#include "nsINetworkLinkService.h" +#include "nsIObserver.h" +#include "../netlink/NetlinkService.h" + +class nsAndroidNetworkLinkService + : public nsINetworkLinkService, + public nsIObserver, + public mozilla::net::NetlinkServiceListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSINETWORKLINKSERVICE + NS_DECL_NSIOBSERVER + + nsAndroidNetworkLinkService(); + + nsresult Init(); + + void OnNetworkChanged() override; + void OnNetworkIDChanged() override; + void OnLinkUp() override; + void OnLinkDown() override; + void OnLinkStatusKnown() override; + void OnDnsSuffixListUpdated() override; + + private: + virtual ~nsAndroidNetworkLinkService() = default; + + // Called when xpcom-shutdown-threads is received. + nsresult Shutdown(); + + // Sends the network event. + void NotifyObservers(const char* aTopic, const char* aData); + + mozilla::Atomic mStatusIsKnown; + + RefPtr mNetlinkSvc; +}; + +#endif /* NSANDROIDNETWORKLINKSERVICE_H_ */ -- cgit v1.2.3