From 7a0ec6862ad5fbde0a9b290d566d73032c17f3d7 Mon Sep 17 00:00:00 2001 From: Tom Ritter Date: Fri, 17 Dec 2021 15:46:32 +0000 Subject: [PATCH] Bug 1432983 - Remove mdns r=necko-reviewers,kershaw Differential Revision: https://phabricator.services.mozilla.com/D134147 --- .../dns/mdns/libmdns/DNSServiceDiscovery.jsm | 216 ---- .../mdns/libmdns/MDNSResponderOperator.cpp | 719 ------------- .../dns/mdns/libmdns/MDNSResponderOperator.h | 133 --- .../dns/mdns/libmdns/MDNSResponderReply.cpp | 216 ---- netwerk/dns/mdns/libmdns/MDNSResponderReply.h | 130 --- .../dns/mdns/libmdns/MulticastDNSAndroid.jsm | 262 ----- netwerk/dns/mdns/libmdns/components.conf | 24 - .../dns/mdns/libmdns/fallback/DNSPacket.jsm | 304 ------ .../dns/mdns/libmdns/fallback/DNSRecord.jsm | 71 -- .../libmdns/fallback/DNSResourceRecord.jsm | 221 ---- .../dns/mdns/libmdns/fallback/DNSTypes.jsm | 99 -- .../dns/mdns/libmdns/fallback/DataReader.jsm | 134 --- .../dns/mdns/libmdns/fallback/DataWriter.jsm | 97 -- .../mdns/libmdns/fallback/MulticastDNS.jsm | 985 ------------------ netwerk/dns/mdns/libmdns/moz.build | 48 - .../mdns/libmdns/nsDNSServiceDiscovery.cpp | 229 ---- .../dns/mdns/libmdns/nsDNSServiceDiscovery.h | 47 - netwerk/dns/mdns/libmdns/nsDNSServiceInfo.cpp | 170 --- netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h | 49 - netwerk/dns/mdns/moz.build | 13 - netwerk/dns/mdns/nsIDNSServiceDiscovery.idl | 219 ---- netwerk/dns/moz.build | 2 +- 22 files changed, 1 insertion(+), 4387 deletions(-) delete mode 100644 netwerk/dns/mdns/libmdns/DNSServiceDiscovery.jsm delete mode 100644 netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp delete mode 100644 netwerk/dns/mdns/libmdns/MDNSResponderOperator.h delete mode 100644 netwerk/dns/mdns/libmdns/MDNSResponderReply.cpp delete mode 100644 netwerk/dns/mdns/libmdns/MDNSResponderReply.h delete mode 100644 netwerk/dns/mdns/libmdns/MulticastDNSAndroid.jsm delete mode 100644 netwerk/dns/mdns/libmdns/components.conf delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DNSPacket.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DNSRecord.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DNSResourceRecord.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DNSTypes.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DataReader.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/DataWriter.jsm delete mode 100644 netwerk/dns/mdns/libmdns/fallback/MulticastDNS.jsm delete mode 100644 netwerk/dns/mdns/libmdns/moz.build delete mode 100644 netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.cpp delete mode 100644 netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.h delete mode 100644 netwerk/dns/mdns/libmdns/nsDNSServiceInfo.cpp delete mode 100644 netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h delete mode 100644 netwerk/dns/mdns/moz.build delete mode 100644 netwerk/dns/mdns/nsIDNSServiceDiscovery.idl diff --git a/netwerk/dns/mdns/libmdns/DNSServiceDiscovery.jsm b/netwerk/dns/mdns/libmdns/DNSServiceDiscovery.jsm deleted file mode 100644 index 12e02232ad42f..0000000000000 --- a/netwerk/dns/mdns/libmdns/DNSServiceDiscovery.jsm +++ /dev/null @@ -1,216 +0,0 @@ -/* 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/. */ -"use strict"; - -const { AppConstants } = ChromeUtils.import( - "resource://gre/modules/AppConstants.jsm" -); -const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); - -const { MulticastDNS } = ChromeUtils.import( - AppConstants.platform == "android" && - !Services.prefs.getBoolPref("network.mdns.use_js_fallback") - ? "resource://gre/modules/MulticastDNSAndroid.jsm" - : "resource://gre/modules/MulticastDNS.jsm" -); - -const DNSSERVICEINFO_CONTRACT_ID = - "@mozilla.org/toolkit/components/mdnsresponder/dns-info;1"; - -function log(aMsg) { - dump("-*- nsDNSServiceDiscovery.js : " + aMsg + "\n"); -} - -function generateUuid() { - return Services.uuid.generateUUID().toString(); -} - -// Helper class to transform return objects to correct type. -function ListenerWrapper(aListener, aMdns) { - this.listener = aListener; - this.mdns = aMdns; - - this.discoveryStarting = false; - this.stopDiscovery = false; - - this.registrationStarting = false; - this.stopRegistration = false; - - this.uuid = generateUuid(); -} - -ListenerWrapper.prototype = { - // Helper function for transforming an Object into nsIDNSServiceInfo. - makeServiceInfo(aServiceInfo) { - let serviceInfo = Cc[DNSSERVICEINFO_CONTRACT_ID].createInstance( - Ci.nsIDNSServiceInfo - ); - - for (let name of [ - "host", - "address", - "port", - "serviceName", - "serviceType", - ]) { - try { - serviceInfo[name] = aServiceInfo[name]; - } catch (e) { - // ignore exceptions - } - } - - let attributes; - try { - attributes = _toPropertyBag2(aServiceInfo.attributes); - } catch (err) { - // Ignore unset attributes in object. - log("Caught unset attributes error: " + err + " - " + err.stack); - attributes = Cc["@mozilla.org/hash-property-bag;1"].createInstance( - Ci.nsIWritablePropertyBag2 - ); - } - serviceInfo.attributes = attributes; - - return serviceInfo; - }, - - /* transparent types */ - onDiscoveryStarted(aServiceType) { - this.discoveryStarting = false; - this.listener.onDiscoveryStarted(aServiceType); - - if (this.stopDiscovery) { - this.mdns.stopDiscovery(aServiceType, this); - } - }, - onDiscoveryStopped(aServiceType) { - this.listener.onDiscoveryStopped(aServiceType); - }, - onStartDiscoveryFailed(aServiceType, aErrorCode) { - log("onStartDiscoveryFailed: " + aServiceType + " (" + aErrorCode + ")"); - this.discoveryStarting = false; - this.stopDiscovery = true; - this.listener.onStartDiscoveryFailed(aServiceType, aErrorCode); - }, - onStopDiscoveryFailed(aServiceType, aErrorCode) { - log("onStopDiscoveryFailed: " + aServiceType + " (" + aErrorCode + ")"); - this.listener.onStopDiscoveryFailed(aServiceType, aErrorCode); - }, - - /* transform types */ - onServiceFound(aServiceInfo) { - this.listener.onServiceFound(this.makeServiceInfo(aServiceInfo)); - }, - onServiceLost(aServiceInfo) { - this.listener.onServiceLost(this.makeServiceInfo(aServiceInfo)); - }, - onServiceRegistered(aServiceInfo) { - this.registrationStarting = false; - this.listener.onServiceRegistered(this.makeServiceInfo(aServiceInfo)); - - if (this.stopRegistration) { - this.mdns.unregisterService(aServiceInfo, this); - } - }, - onServiceUnregistered(aServiceInfo) { - this.listener.onServiceUnregistered(this.makeServiceInfo(aServiceInfo)); - }, - onServiceResolved(aServiceInfo) { - this.listener.onServiceResolved(this.makeServiceInfo(aServiceInfo)); - }, - - onRegistrationFailed(aServiceInfo, aErrorCode) { - log("onRegistrationFailed: (" + aErrorCode + ")"); - this.registrationStarting = false; - this.stopRegistration = true; - this.listener.onRegistrationFailed( - this.makeServiceInfo(aServiceInfo), - aErrorCode - ); - }, - onUnregistrationFailed(aServiceInfo, aErrorCode) { - log("onUnregistrationFailed: (" + aErrorCode + ")"); - this.listener.onUnregistrationFailed( - this.makeServiceInfo(aServiceInfo), - aErrorCode - ); - }, - onResolveFailed(aServiceInfo, aErrorCode) { - log("onResolveFailed: (" + aErrorCode + ")"); - this.listener.onResolveFailed( - this.makeServiceInfo(aServiceInfo), - aErrorCode - ); - }, -}; - -function nsDNSServiceDiscovery() { - log("nsDNSServiceDiscovery"); - this.mdns = new MulticastDNS(); -} - -nsDNSServiceDiscovery.prototype = { - QueryInterface: ChromeUtils.generateQI([ - "nsISupportsWeakReference", - "nsIDNSServiceDiscovery", - ]), - - startDiscovery(aServiceType, aListener) { - log("startDiscovery"); - let listener = new ListenerWrapper(aListener, this.mdns); - listener.discoveryStarting = true; - this.mdns.startDiscovery(aServiceType, listener); - - return { - QueryInterface: ChromeUtils.generateQI(["nsICancelable"]), - cancel: function() { - if (this.discoveryStarting || this.stopDiscovery) { - this.stopDiscovery = true; - return; - } - this.mdns.stopDiscovery(aServiceType, listener); - }.bind(listener), - }; - }, - - registerService(aServiceInfo, aListener) { - log("registerService"); - let listener = new ListenerWrapper(aListener, this.mdns); - listener.registrationStarting = true; - this.mdns.registerService(aServiceInfo, listener); - - return { - QueryInterface: ChromeUtils.generateQI(["nsICancelable"]), - cancel: function() { - if (this.registrationStarting || this.stopRegistration) { - this.stopRegistration = true; - return; - } - this.mdns.unregisterService(aServiceInfo, listener); - }.bind(listener), - }; - }, - - resolveService(aServiceInfo, aListener) { - log("resolveService"); - this.mdns.resolveService(aServiceInfo, new ListenerWrapper(aListener)); - }, -}; - -var EXPORTED_SYMBOLS = ["nsDNSServiceDiscovery"]; - -function _toPropertyBag2(obj) { - if (obj.QueryInterface) { - return obj.QueryInterface(Ci.nsIPropertyBag2); - } - - let result = Cc["@mozilla.org/hash-property-bag;1"].createInstance( - Ci.nsIWritablePropertyBag2 - ); - for (let name in obj) { - result.setPropertyAsAString(name, obj[name]); - } - return result; -} diff --git a/netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp b/netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp deleted file mode 100644 index ae780b614d537..0000000000000 --- a/netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp +++ /dev/null @@ -1,719 +0,0 @@ -/* -*- 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/. */ - -#include "MDNSResponderOperator.h" -#include "MDNSResponderReply.h" -#include "mozilla/EndianUtils.h" -#include "mozilla/Logging.h" -#include "mozilla/ScopeExit.h" -#include "mozilla/Unused.h" -#include "nsComponentManagerUtils.h" -#include "nsCOMPtr.h" -#include "nsDebug.h" -#include "nsDNSServiceInfo.h" -#include "nsHashPropertyBag.h" -#include "nsIProperty.h" -#include "nsISimpleEnumerator.h" -#include "nsIVariant.h" -#include "nsServiceManagerUtils.h" -#include "nsNetAddr.h" -#include "nsNetCID.h" -#include "nsSocketTransportService2.h" -#include "nsThreadUtils.h" -#include "nsXPCOMCID.h" -#include "private/pprio.h" - -#include "nsASocketHandler.h" - -namespace mozilla { -namespace net { - -static LazyLogModule gMDNSLog("MDNSResponderOperator"); -#undef LOG_I -#define LOG_I(...) \ - MOZ_LOG(mozilla::net::gMDNSLog, mozilla::LogLevel::Debug, (__VA_ARGS__)) -#undef LOG_E -#define LOG_E(...) \ - MOZ_LOG(mozilla::net::gMDNSLog, mozilla::LogLevel::Error, (__VA_ARGS__)) - -class MDNSResponderOperator::ServiceWatcher final : public nsASocketHandler { - public: - NS_DECL_THREADSAFE_ISUPPORTS - - // nsASocketHandler methods - virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) override { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - MOZ_ASSERT(fd == mFD); - - if (outFlags & (PR_POLL_ERR | PR_POLL_HUP | PR_POLL_NVAL)) { - LOG_E("error polling on listening socket (%p)", fd); - mCondition = NS_ERROR_UNEXPECTED; - } - - if (!(outFlags & PR_POLL_READ)) { - return; - } - - DNSServiceProcessResult(mService); - } - - virtual void OnSocketDetached(PRFileDesc* fd) override { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - MOZ_ASSERT(mThread); - MOZ_ASSERT(fd == mFD); - - if (!mFD) { - return; - } - - // Bug 1175387: do not double close the handle here. - PR_ChangeFileDescNativeHandle(mFD, -1); - PR_Close(mFD); - mFD = nullptr; - - mThread->Dispatch( - NewRunnableMethod("MDNSResponderOperator::ServiceWatcher::Deallocate", - this, &ServiceWatcher::Deallocate), - NS_DISPATCH_NORMAL); - } - - virtual void IsLocal(bool* aIsLocal) override { *aIsLocal = true; } - - virtual void KeepWhenOffline(bool* aKeepWhenOffline) override { - *aKeepWhenOffline = true; - } - - virtual uint64_t ByteCountSent() override { return 0; } - virtual uint64_t ByteCountReceived() override { return 0; } - - explicit ServiceWatcher(DNSServiceRef aService, - MDNSResponderOperator* aOperator) - : mThread(nullptr), - mSts(nullptr), - mOperatorHolder(aOperator), - mService(aService), - mFD(nullptr), - mAttached(false) { - if (!gSocketTransportService) { - nsCOMPtr sts = - do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID); - } - } - - nsresult Init() { - MOZ_ASSERT(!OnSocketThread(), "on socket thread"); - mThread = NS_GetCurrentThread(); - - if (!mService) { - return NS_OK; - } - - if (!gSocketTransportService) { - return NS_ERROR_FAILURE; - } - mSts = gSocketTransportService; - - int osfd = DNSServiceRefSockFD(mService); - if (osfd == -1) { - return NS_ERROR_FAILURE; - } - - mFD = PR_ImportFile(osfd); - return PostEvent("MDNSResponderOperator::ServiceWatcher::OnMsgAttach", - &ServiceWatcher::OnMsgAttach); - } - - void Close() { - MOZ_ASSERT(!OnSocketThread(), "on socket thread"); - - if (!gSocketTransportService) { - Deallocate(); - return; - } - - PostEvent("MDNSResponderOperator::ServiceWatcher::OnMsgClose", - &ServiceWatcher::OnMsgClose); - } - - private: - ~ServiceWatcher() = default; - - void Deallocate() { - if (mService) { - DNSServiceRefDeallocate(mService); - mService = nullptr; - } - mOperatorHolder = nullptr; - } - - nsresult PostEvent(const char* aName, void (ServiceWatcher::*func)(void)) { - return gSocketTransportService->Dispatch( - NewRunnableMethod(aName, this, func), NS_DISPATCH_NORMAL); - } - - void OnMsgClose() { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - if (NS_FAILED(mCondition)) { - return; - } - - // tear down socket. this signals the STS to detach our socket handler. - mCondition = NS_BINDING_ABORTED; - - // if we are attached, then socket transport service will call our - // OnSocketDetached method automatically. Otherwise, we have to call it - // (and thus close the socket) manually. - if (!mAttached) { - OnSocketDetached(mFD); - } - } - - void OnMsgAttach() { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - if (NS_FAILED(mCondition)) { - return; - } - - mCondition = TryAttach(); - - // if we hit an error while trying to attach then bail... - if (NS_FAILED(mCondition)) { - NS_ASSERTION(!mAttached, "should not be attached already"); - OnSocketDetached(mFD); - } - } - - nsresult TryAttach() { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - nsresult rv; - - if (!gSocketTransportService) { - return NS_ERROR_FAILURE; - } - - // - // find out if it is going to be ok to attach another socket to the STS. - // if not then we have to wait for the STS to tell us that it is ok. - // the notification is asynchronous, which means that when we could be - // in a race to call AttachSocket once notified. for this reason, when - // we get notified, we just re-enter this function. as a result, we are - // sure to ask again before calling AttachSocket. in this way we deal - // with the race condition. though it isn't the most elegant solution, - // it is far simpler than trying to build a system that would guarantee - // FIFO ordering (which wouldn't even be that valuable IMO). see bug - // 194402 for more info. - // - if (!gSocketTransportService->CanAttachSocket()) { - nsCOMPtr event = NewRunnableMethod( - "MDNSResponderOperator::ServiceWatcher::OnMsgAttach", this, - &ServiceWatcher::OnMsgAttach); - - nsresult rv = gSocketTransportService->NotifyWhenCanAttachSocket(event); - if (NS_FAILED(rv)) { - return rv; - } - } - - // - // ok, we can now attach our socket to the STS for polling - // - rv = gSocketTransportService->AttachSocket(mFD, this); - if (NS_FAILED(rv)) { - return rv; - } - - mAttached = true; - - // - // now, configure our poll flags for listening... - // - mPollFlags = (PR_POLL_READ | PR_POLL_EXCEPT); - - return NS_OK; - } - - nsCOMPtr mThread; - RefPtr mSts; - RefPtr mOperatorHolder; - DNSServiceRef mService; - PRFileDesc* mFD; - bool mAttached; -}; - -NS_IMPL_ISUPPORTS(MDNSResponderOperator::ServiceWatcher, nsISupports) - -MDNSResponderOperator::MDNSResponderOperator() - : mService(nullptr), - mWatcher(nullptr), - mThread(NS_GetCurrentThread()), - mIsCancelled(false) {} - -MDNSResponderOperator::~MDNSResponderOperator() { Stop(); } - -nsresult MDNSResponderOperator::Start() { - if (mIsCancelled) { - return NS_OK; - } - - if (IsServing()) { - Stop(); - } - - return NS_OK; -} - -nsresult MDNSResponderOperator::Stop() { return ResetService(nullptr); } - -nsresult MDNSResponderOperator::ResetService(DNSServiceRef aService) { - nsresult rv; - - if (aService != mService) { - if (mWatcher) { - mWatcher->Close(); - mWatcher = nullptr; - } - - if (aService) { - RefPtr watcher = new ServiceWatcher(aService, this); - if (NS_WARN_IF(NS_FAILED(rv = watcher->Init()))) { - return rv; - } - mWatcher = watcher; - } - - mService = aService; - } - return NS_OK; -} - -BrowseOperator::BrowseOperator(const nsACString& aServiceType, - nsIDNSServiceDiscoveryListener* aListener) - : MDNSResponderOperator(), - mServiceType(aServiceType), - mListener(aListener) {} - -nsresult BrowseOperator::Start() { - nsresult rv; - if (NS_WARN_IF(NS_FAILED(rv = MDNSResponderOperator::Start()))) { - return rv; - } - - DNSServiceRef service = nullptr; - DNSServiceErrorType err = DNSServiceBrowse( - &service, 0, kDNSServiceInterfaceIndexAny, mServiceType.get(), nullptr, - &BrowseReplyRunnable::Reply, this); - NS_WARNING_ASSERTION(kDNSServiceErr_NoError == err, "DNSServiceBrowse fail"); - - if (mListener) { - if (kDNSServiceErr_NoError == err) { - mListener->OnDiscoveryStarted(mServiceType); - } else { - mListener->OnStartDiscoveryFailed(mServiceType, err); - } - } - - if (NS_WARN_IF(kDNSServiceErr_NoError != err)) { - return NS_ERROR_FAILURE; - } - - return ResetService(service); -} - -nsresult BrowseOperator::Stop() { - bool isServing = IsServing(); - nsresult rv = MDNSResponderOperator::Stop(); - - if (isServing && mListener) { - if (NS_SUCCEEDED(rv)) { - mListener->OnDiscoveryStopped(mServiceType); - } else { - mListener->OnStopDiscoveryFailed(mServiceType, static_cast(rv)); - } - } - - return rv; -} - -void BrowseOperator::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const nsACString& aServiceName, - const nsACString& aRegType, - const nsACString& aReplyDomain) { - MOZ_ASSERT(GetThread() == NS_GetCurrentThread()); - - if (NS_WARN_IF(kDNSServiceErr_NoError != aErrorCode)) { - LOG_E("BrowseOperator::Reply (%d)", aErrorCode); - if (mListener) { - mListener->OnStartDiscoveryFailed(mServiceType, aErrorCode); - } - return; - } - - if (!mListener) { - return; - } - nsCOMPtr info = new nsDNSServiceInfo(); - - if (NS_WARN_IF(!info)) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetServiceName(aServiceName)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetServiceType(aRegType)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetDomainName(aReplyDomain)))) { - return; - } - - if (aFlags & kDNSServiceFlagsAdd) { - mListener->OnServiceFound(info); - } else { - mListener->OnServiceLost(info); - } -} - -RegisterOperator::RegisterOperator(nsIDNSServiceInfo* aServiceInfo, - nsIDNSRegistrationListener* aListener) - : MDNSResponderOperator(), - mServiceInfo(aServiceInfo), - mListener(aListener) {} - -nsresult RegisterOperator::Start() { - nsresult rv; - - rv = MDNSResponderOperator::Start(); - if (NS_WARN_IF(NS_FAILED(rv))) { - return rv; - } - uint16_t port; - if (NS_WARN_IF(NS_FAILED(rv = mServiceInfo->GetPort(&port)))) { - return rv; - } - nsAutoCString type; - if (NS_WARN_IF(NS_FAILED(rv = mServiceInfo->GetServiceType(type)))) { - return rv; - } - - TXTRecordRef txtRecord; - char buf[TXT_BUFFER_SIZE] = {0}; - TXTRecordCreate(&txtRecord, TXT_BUFFER_SIZE, buf); - - nsCOMPtr attributes; - if (NS_FAILED(rv = mServiceInfo->GetAttributes(getter_AddRefs(attributes)))) { - LOG_I("register: no attributes"); - } else { - nsCOMPtr enumerator; - if (NS_WARN_IF(NS_FAILED( - rv = attributes->GetEnumerator(getter_AddRefs(enumerator))))) { - return rv; - } - - bool hasMoreElements; - while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) && - hasMoreElements) { - nsCOMPtr element; - MOZ_ALWAYS_SUCCEEDS(enumerator->GetNext(getter_AddRefs(element))); - nsCOMPtr property = do_QueryInterface(element); - MOZ_ASSERT(property); - - nsAutoString name; - nsCOMPtr value; - MOZ_ALWAYS_SUCCEEDS(property->GetName(name)); - MOZ_ALWAYS_SUCCEEDS(property->GetValue(getter_AddRefs(value))); - - nsAutoCString str; - if (NS_WARN_IF(NS_FAILED(value->GetAsACString(str)))) { - continue; - } - - TXTRecordSetValue(&txtRecord, - /* it's safe because key name is ASCII only. */ - NS_LossyConvertUTF16toASCII(name).get(), str.Length(), - str.get()); - } - } - - nsAutoCString host; - nsAutoCString name; - nsAutoCString domain; - - DNSServiceRef service = nullptr; - DNSServiceErrorType err = DNSServiceRegister( - &service, 0, 0, - NS_SUCCEEDED(mServiceInfo->GetServiceName(name)) ? name.get() : nullptr, - type.get(), - NS_SUCCEEDED(mServiceInfo->GetDomainName(domain)) ? domain.get() - : nullptr, - NS_SUCCEEDED(mServiceInfo->GetHost(host)) ? host.get() : nullptr, - NativeEndian::swapToNetworkOrder(port), TXTRecordGetLength(&txtRecord), - TXTRecordGetBytesPtr(&txtRecord), &RegisterReplyRunnable::Reply, this); - NS_WARNING_ASSERTION(kDNSServiceErr_NoError == err, - "DNSServiceRegister fail"); - - TXTRecordDeallocate(&txtRecord); - - if (NS_WARN_IF(kDNSServiceErr_NoError != err)) { - if (mListener) { - mListener->OnRegistrationFailed(mServiceInfo, err); - } - return NS_ERROR_FAILURE; - } - - return ResetService(service); -} - -nsresult RegisterOperator::Stop() { - bool isServing = IsServing(); - nsresult rv = MDNSResponderOperator::Stop(); - - if (isServing && mListener) { - if (NS_SUCCEEDED(rv)) { - mListener->OnServiceUnregistered(mServiceInfo); - } else { - mListener->OnUnregistrationFailed(mServiceInfo, - static_cast(rv)); - } - } - - return rv; -} - -void RegisterOperator::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, - const nsACString& aName, - const nsACString& aRegType, - const nsACString& aDomain) { - MOZ_ASSERT(GetThread() == NS_GetCurrentThread()); - - if (kDNSServiceErr_NoError != aErrorCode) { - LOG_E("RegisterOperator::Reply (%d)", aErrorCode); - } - - if (!mListener) { - return; - } - nsCOMPtr info = new nsDNSServiceInfo(mServiceInfo); - if (NS_WARN_IF(NS_FAILED(info->SetServiceName(aName)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetServiceType(aRegType)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetDomainName(aDomain)))) { - return; - } - - if (kDNSServiceErr_NoError == aErrorCode) { - if (aFlags & kDNSServiceFlagsAdd) { - mListener->OnServiceRegistered(info); - } else { - // If a successfully-registered name later suffers a name conflict - // or similar problem and has to be deregistered, the callback will - // be invoked with the kDNSServiceFlagsAdd flag not set. - LOG_E("RegisterOperator::Reply: deregister"); - if (NS_WARN_IF(NS_FAILED(Stop()))) { - return; - } - } - } else { - mListener->OnRegistrationFailed(info, aErrorCode); - } -} - -ResolveOperator::ResolveOperator(nsIDNSServiceInfo* aServiceInfo, - nsIDNSServiceResolveListener* aListener) - : MDNSResponderOperator(), - mServiceInfo(aServiceInfo), - mListener(aListener) {} - -nsresult ResolveOperator::Start() { - nsresult rv; - if (NS_WARN_IF(NS_FAILED(rv = MDNSResponderOperator::Start()))) { - return rv; - } - - nsAutoCString name; - mServiceInfo->GetServiceName(name); - nsAutoCString type; - mServiceInfo->GetServiceType(type); - nsAutoCString domain; - mServiceInfo->GetDomainName(domain); - - LOG_I("Resolve: (%s), (%s), (%s)", name.get(), type.get(), domain.get()); - - DNSServiceRef service = nullptr; - DNSServiceErrorType err = DNSServiceResolve( - &service, 0, kDNSServiceInterfaceIndexAny, name.get(), type.get(), - domain.get(), (DNSServiceResolveReply)&ResolveReplyRunnable::Reply, this); - - if (NS_WARN_IF(kDNSServiceErr_NoError != err)) { - if (mListener) { - mListener->OnResolveFailed(mServiceInfo, err); - } - return NS_ERROR_FAILURE; - } - - return ResetService(service); -} - -void ResolveOperator::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const nsACString& aFullName, - const nsACString& aHostTarget, uint16_t aPort, - uint16_t aTxtLen, const unsigned char* aTxtRecord) { - MOZ_ASSERT(GetThread() == NS_GetCurrentThread()); - - auto guard = MakeScopeExit([&] { Unused << NS_WARN_IF(NS_FAILED(Stop())); }); - - if (NS_WARN_IF(kDNSServiceErr_NoError != aErrorCode)) { - LOG_E("ResolveOperator::Reply (%d)", aErrorCode); - return; - } - - // Resolve TXT record - int count = TXTRecordGetCount(aTxtLen, aTxtRecord); - LOG_I("resolve: txt count = %d, len = %d", count, aTxtLen); - nsCOMPtr attributes = new nsHashPropertyBag(); - if (NS_WARN_IF(!attributes)) { - return; - } - if (count) { - for (int i = 0; i < count; ++i) { - char key[TXT_BUFFER_SIZE] = {'\0'}; - uint8_t vSize = 0; - const void* value = nullptr; - if (kDNSServiceErr_NoError != - TXTRecordGetItemAtIndex(aTxtLen, aTxtRecord, i, TXT_BUFFER_SIZE, key, - &vSize, &value)) { - break; - } - - nsAutoCString str(reinterpret_cast(value), vSize); - LOG_I("resolve TXT: (%d) %s=%s", vSize, key, str.get()); - - if (NS_WARN_IF(NS_FAILED(attributes->SetPropertyAsACString( - /* it's safe to convert because key name is ASCII only. */ - NS_ConvertASCIItoUTF16(key), str)))) { - break; - } - } - } - - if (!mListener) { - return; - } - nsCOMPtr info = new nsDNSServiceInfo(mServiceInfo); - if (NS_WARN_IF(NS_FAILED(info->SetHost(aHostTarget)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetPort(aPort)))) { - return; - } - if (NS_WARN_IF(NS_FAILED(info->SetAttributes(attributes)))) { - return; - } - - if (kDNSServiceErr_NoError == aErrorCode) { - GetAddrInfor(info); - } else { - mListener->OnResolveFailed(info, aErrorCode); - Unused << NS_WARN_IF(NS_FAILED(Stop())); - } -} - -void ResolveOperator::GetAddrInfor(nsIDNSServiceInfo* aServiceInfo) { - RefPtr getAddreOp = - new GetAddrInfoOperator(aServiceInfo, mListener); - Unused << NS_WARN_IF(NS_FAILED(getAddreOp->Start())); -} - -GetAddrInfoOperator::GetAddrInfoOperator( - nsIDNSServiceInfo* aServiceInfo, nsIDNSServiceResolveListener* aListener) - : MDNSResponderOperator(), - mServiceInfo(aServiceInfo), - mListener(aListener) {} - -nsresult GetAddrInfoOperator::Start() { - nsresult rv; - if (NS_WARN_IF(NS_FAILED(rv = MDNSResponderOperator::Start()))) { - return rv; - } - - nsAutoCString host; - mServiceInfo->GetHost(host); - - LOG_I("GetAddrInfo: (%s)", host.get()); - - DNSServiceRef service = nullptr; - DNSServiceErrorType err = DNSServiceGetAddrInfo( - &service, kDNSServiceFlagsForceMulticast, kDNSServiceInterfaceIndexAny, - kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6, host.get(), - (DNSServiceGetAddrInfoReply)&GetAddrInfoReplyRunnable::Reply, this); - - if (NS_WARN_IF(kDNSServiceErr_NoError != err)) { - if (mListener) { - mListener->OnResolveFailed(mServiceInfo, err); - } - return NS_ERROR_FAILURE; - } - - return ResetService(service); -} - -void GetAddrInfoOperator::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const nsACString& aHostName, - const NetAddr& aAddress, uint32_t aTTL) { - MOZ_ASSERT(GetThread() == NS_GetCurrentThread()); - - auto guard = MakeScopeExit([&] { Unused << NS_WARN_IF(NS_FAILED(Stop())); }); - - if (NS_WARN_IF(kDNSServiceErr_NoError != aErrorCode)) { - LOG_E("GetAddrInfoOperator::Reply (%d)", aErrorCode); - return; - } - - if (!mListener) { - return; - } - - NetAddr addr = aAddress; - nsCOMPtr address = new nsNetAddr(&addr); - nsCString addressStr; - if (NS_WARN_IF(NS_FAILED(address->GetAddress(addressStr)))) { - return; - } - - nsCOMPtr info = new nsDNSServiceInfo(mServiceInfo); - if (NS_WARN_IF(NS_FAILED(info->SetAddress(addressStr)))) { - return; - } - - /** - * |kDNSServiceFlagsMoreComing| means this callback will be one or more - * callback events later, so this instance should be kept alive until all - * follow-up events are processed. - */ - if (aFlags & kDNSServiceFlagsMoreComing) { - guard.release(); - } - - if (kDNSServiceErr_NoError == aErrorCode) { - mListener->OnServiceResolved(info); - } else { - mListener->OnResolveFailed(info, aErrorCode); - } -} - -} // namespace net -} // namespace mozilla diff --git a/netwerk/dns/mdns/libmdns/MDNSResponderOperator.h b/netwerk/dns/mdns/libmdns/MDNSResponderOperator.h deleted file mode 100644 index 394f68777c116..0000000000000 --- a/netwerk/dns/mdns/libmdns/MDNSResponderOperator.h +++ /dev/null @@ -1,133 +0,0 @@ -/* -*- 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_netwerk_dns_mdns_libmdns_MDNSResponderOperator_h -#define mozilla_netwerk_dns_mdns_libmdns_MDNSResponderOperator_h - -#include "dns_sd.h" -#include "mozilla/Atomics.h" -#include "mozilla/RefPtr.h" -#include "nsCOMPtr.h" -#include "nsIDNSServiceDiscovery.h" -#include "nsIThread.h" -#include "nsString.h" - -namespace mozilla { -namespace net { - -class MDNSResponderOperator { - NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MDNSResponderOperator) - - public: - MDNSResponderOperator(); - - virtual nsresult Start(); - virtual nsresult Stop(); - void Cancel() { mIsCancelled = true; } - nsIThread* GetThread() const { return mThread; } - - protected: - virtual ~MDNSResponderOperator(); - - bool IsServing() const { return mService; } - nsresult ResetService(DNSServiceRef aService); - - private: - class ServiceWatcher; - - DNSServiceRef mService; - RefPtr mWatcher; - nsCOMPtr mThread; // remember caller thread for callback - Atomic mIsCancelled; -}; - -class BrowseOperator final : public MDNSResponderOperator { - public: - BrowseOperator(const nsACString& aServiceType, - nsIDNSServiceDiscoveryListener* aListener); - - nsresult Start() override; - nsresult Stop() override; - - void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const nsACString& aServiceName, const nsACString& aRegType, - const nsACString& aReplyDomain); - - private: - ~BrowseOperator() = default; - - nsCString mServiceType; - nsCOMPtr mListener; -}; - -class RegisterOperator final : public MDNSResponderOperator { - enum { TXT_BUFFER_SIZE = 256 }; - - public: - RegisterOperator(nsIDNSServiceInfo* aServiceInfo, - nsIDNSRegistrationListener* aListener); - - nsresult Start() override; - nsresult Stop() override; - - void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, const nsACString& aName, - const nsACString& aRegType, const nsACString& aDomain); - - private: - ~RegisterOperator() = default; - - nsCOMPtr mServiceInfo; - nsCOMPtr mListener; -}; - -class ResolveOperator final : public MDNSResponderOperator { - enum { TXT_BUFFER_SIZE = 256 }; - - public: - ResolveOperator(nsIDNSServiceInfo* aServiceInfo, - nsIDNSServiceResolveListener* aListener); - - nsresult Start() override; - - void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const nsACString& aFullName, const nsACString& aHostTarget, - uint16_t aPort, uint16_t aTxtLen, const unsigned char* aTxtRecord); - - private: - ~ResolveOperator() = default; - void GetAddrInfor(nsIDNSServiceInfo* aServiceInfo); - - nsCOMPtr mServiceInfo; - nsCOMPtr mListener; -}; - -union NetAddr; - -class GetAddrInfoOperator final : public MDNSResponderOperator { - public: - GetAddrInfoOperator(nsIDNSServiceInfo* aServiceInfo, - nsIDNSServiceResolveListener* aListener); - - nsresult Start() override; - - void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const nsACString& aHostName, const NetAddr& aAddress, - uint32_t aTTL); - - private: - ~GetAddrInfoOperator() = default; - - nsCOMPtr mServiceInfo; - nsCOMPtr mListener; -}; - -} // namespace net -} // namespace mozilla - -#endif // mozilla_netwerk_dns_mdns_libmdns_MDNSResponderOperator_h diff --git a/netwerk/dns/mdns/libmdns/MDNSResponderReply.cpp b/netwerk/dns/mdns/libmdns/MDNSResponderReply.cpp deleted file mode 100644 index 346ebd421472c..0000000000000 --- a/netwerk/dns/mdns/libmdns/MDNSResponderReply.cpp +++ /dev/null @@ -1,216 +0,0 @@ -/* -*- 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/. */ - -#include "MDNSResponderReply.h" -#include "mozilla/EndianUtils.h" -#include "nsHttpHandler.h" // for OnSocketThread() -#include "private/pprio.h" - -namespace mozilla { -namespace net { - -BrowseReplyRunnable::BrowseReplyRunnable( - DNSServiceRef aSdRef, DNSServiceFlags aFlags, uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, const nsACString& aServiceName, - const nsACString& aRegType, const nsACString& aReplyDomain, - BrowseOperator* aContext) - : Runnable("net::BrowseReplyRunnable"), - mSdRef(aSdRef), - mFlags(aFlags), - mInterfaceIndex(aInterfaceIndex), - mErrorCode(aErrorCode), - mServiceName(aServiceName), - mRegType(aRegType), - mReplyDomain(aReplyDomain), - mContext(aContext) {} - -NS_IMETHODIMP -BrowseReplyRunnable::Run() { - MOZ_ASSERT(mContext); - mContext->Reply(mSdRef, mFlags, mInterfaceIndex, mErrorCode, mServiceName, - mRegType, mReplyDomain); - return NS_OK; -} - -void BrowseReplyRunnable::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const char* aServiceName, const char* aRegType, - const char* aReplyDomain, void* aContext) { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - BrowseOperator* obj(reinterpret_cast(aContext)); - if (!obj) { - return; - } - - nsCOMPtr thread(obj->GetThread()); - if (!thread) { - return; - } - - thread->Dispatch( - new BrowseReplyRunnable(aSdRef, aFlags, aInterfaceIndex, aErrorCode, - nsCString(aServiceName), nsCString(aRegType), - nsCString(aReplyDomain), obj), - NS_DISPATCH_NORMAL); -} - -RegisterReplyRunnable::RegisterReplyRunnable(DNSServiceRef aSdRef, - DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, - const nsACString& aName, - const nsACString& aRegType, - const nsACString& domain, - RegisterOperator* aContext) - : Runnable("net::RegisterReplyRunnable"), - mSdRef(aSdRef), - mFlags(aFlags), - mErrorCode(aErrorCode), - mName(aName), - mRegType(aRegType), - mDomain(domain), - mContext(aContext) {} - -NS_IMETHODIMP -RegisterReplyRunnable::Run() { - MOZ_ASSERT(mContext); - - mContext->Reply(mSdRef, mFlags, mErrorCode, mName, mRegType, mDomain); - return NS_OK; -} - -void RegisterReplyRunnable::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, - const char* aName, const char* aRegType, - const char* domain, void* aContext) { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - RegisterOperator* obj(reinterpret_cast(aContext)); - if (!obj) { - return; - } - - nsCOMPtr thread(obj->GetThread()); - if (!thread) { - return; - } - - thread->Dispatch( - new RegisterReplyRunnable(aSdRef, aFlags, aErrorCode, nsCString(aName), - nsCString(aRegType), nsCString(domain), obj), - NS_DISPATCH_NORMAL); -} - -ResolveReplyRunnable::ResolveReplyRunnable( - DNSServiceRef aSdRef, DNSServiceFlags aFlags, uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, const nsACString& aFullName, - const nsACString& aHostTarget, uint16_t aPort, uint16_t aTxtLen, - const unsigned char* aTxtRecord, ResolveOperator* aContext) - : Runnable("net::ResolveReplyRunnable"), - mSdRef(aSdRef), - mFlags(aFlags), - mInterfaceIndex(aInterfaceIndex), - mErrorCode(aErrorCode), - mFullname(aFullName), - mHosttarget(aHostTarget), - mPort(aPort), - mTxtLen(aTxtLen), - mTxtRecord(new unsigned char[aTxtLen]), - mContext(aContext) { - if (mTxtRecord) { - memcpy(mTxtRecord.get(), aTxtRecord, aTxtLen); - } -} - -NS_IMETHODIMP -ResolveReplyRunnable::Run() { - MOZ_ASSERT(mContext); - mContext->Reply(mSdRef, mFlags, mInterfaceIndex, mErrorCode, mFullname, - mHosttarget, mPort, mTxtLen, mTxtRecord.get()); - return NS_OK; -} - -void ResolveReplyRunnable::Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const char* aFullName, const char* aHostTarget, - uint16_t aPort, uint16_t aTxtLen, - const unsigned char* aTxtRecord, - void* aContext) { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - ResolveOperator* obj(reinterpret_cast(aContext)); - if (!obj) { - return; - } - - nsCOMPtr thread(obj->GetThread()); - if (!thread) { - return; - } - - thread->Dispatch( - new ResolveReplyRunnable(aSdRef, aFlags, aInterfaceIndex, aErrorCode, - nsCString(aFullName), nsCString(aHostTarget), - NativeEndian::swapFromNetworkOrder(aPort), - aTxtLen, aTxtRecord, obj), - NS_DISPATCH_NORMAL); -} - -GetAddrInfoReplyRunnable::GetAddrInfoReplyRunnable( - DNSServiceRef aSdRef, DNSServiceFlags aFlags, uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, const nsACString& aHostName, - const mozilla::net::NetAddr& aAddress, uint32_t aTTL, - GetAddrInfoOperator* aContext) - : Runnable("net::GetAddrInfoReplyRunnable"), - mSdRef(aSdRef), - mFlags(aFlags), - mInterfaceIndex(aInterfaceIndex), - mErrorCode(aErrorCode), - mHostName(aHostName), - mAddress(aAddress), - mTTL(aTTL), - mContext(aContext) {} - -NS_IMETHODIMP -GetAddrInfoReplyRunnable::Run() { - MOZ_ASSERT(mContext); - mContext->Reply(mSdRef, mFlags, mInterfaceIndex, mErrorCode, mHostName, - mAddress, mTTL); - return NS_OK; -} - -void GetAddrInfoReplyRunnable::Reply( - DNSServiceRef aSdRef, DNSServiceFlags aFlags, uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, const char* aHostName, - const struct sockaddr* aAddress, uint32_t aTTL, void* aContext) { - MOZ_ASSERT(OnSocketThread(), "not on socket thread"); - - GetAddrInfoOperator* obj(reinterpret_cast(aContext)); - if (!obj) { - return; - } - - nsCOMPtr thread(obj->GetThread()); - if (!thread) { - return; - } - - NetAddr address; - address.raw.family = aAddress->sa_family; - - static_assert(sizeof(address.raw.data) >= sizeof(aAddress->sa_data), - "size of sockaddr.sa_data is too big"); - memcpy(&address.raw.data, aAddress->sa_data, sizeof(aAddress->sa_data)); - - thread->Dispatch( - new GetAddrInfoReplyRunnable(aSdRef, aFlags, aInterfaceIndex, aErrorCode, - nsCString(aHostName), address, aTTL, obj), - NS_DISPATCH_NORMAL); -} - -} // namespace net -} // namespace mozilla diff --git a/netwerk/dns/mdns/libmdns/MDNSResponderReply.h b/netwerk/dns/mdns/libmdns/MDNSResponderReply.h deleted file mode 100644 index 120bb6dae7ace..0000000000000 --- a/netwerk/dns/mdns/libmdns/MDNSResponderReply.h +++ /dev/null @@ -1,130 +0,0 @@ -/* -*- 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_netwerk_dns_mdns_libmdns_MDNSResponderReply_h -#define mozilla_netwerk_dns_mdns_libmdns_MDNSResponderReply_h - -#include "dns_sd.h" -#include "MDNSResponderOperator.h" -#include "mozilla/UniquePtr.h" -#include "mozilla/net/DNS.h" -#include "mozilla/RefPtr.h" -#include "nsThreadUtils.h" - -namespace mozilla { -namespace net { - -class BrowseReplyRunnable final : public Runnable { - public: - BrowseReplyRunnable(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const nsACString& aServiceName, - const nsACString& aRegType, - const nsACString& aReplyDomain, BrowseOperator* aContext); - - NS_IMETHOD Run() override; - - static void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const char* aServiceName, const char* aRegType, - const char* aReplyDomain, void* aContext); - - private: - DNSServiceRef mSdRef; - DNSServiceFlags mFlags; - uint32_t mInterfaceIndex; - DNSServiceErrorType mErrorCode; - nsCString mServiceName; - nsCString mRegType; - nsCString mReplyDomain; - RefPtr mContext; -}; - -class RegisterReplyRunnable final : public Runnable { - public: - RegisterReplyRunnable(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, const nsACString& aName, - const nsACString& aRegType, const nsACString& aDomain, - RegisterOperator* aContext); - - NS_IMETHOD Run() override; - - static void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - DNSServiceErrorType aErrorCode, const char* aName, - const char* aRegType, const char* aDomain, void* aContext); - - private: - DNSServiceRef mSdRef; - DNSServiceFlags mFlags; - DNSServiceErrorType mErrorCode; - nsCString mName; - nsCString mRegType; - nsCString mDomain; - RefPtr mContext; -}; - -class ResolveReplyRunnable final : public Runnable { - public: - ResolveReplyRunnable(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const nsACString& aFullName, - const nsACString& aHostTarget, uint16_t aPort, - uint16_t aTxtLen, const unsigned char* aTxtRecord, - ResolveOperator* aContext); - ~ResolveReplyRunnable() = default; - - NS_IMETHOD Run() override; - - static void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const char* aFullName, const char* aHostTarget, - uint16_t aPort, uint16_t aTxtLen, - const unsigned char* aTxtRecord, void* aContext); - - private: - DNSServiceRef mSdRef; - DNSServiceFlags mFlags; - uint32_t mInterfaceIndex; - DNSServiceErrorType mErrorCode; - nsCString mFullname; - nsCString mHosttarget; - uint16_t mPort; - uint16_t mTxtLen; - UniquePtr mTxtRecord; - RefPtr mContext; -}; - -class GetAddrInfoReplyRunnable final : public Runnable { - public: - GetAddrInfoReplyRunnable(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, - DNSServiceErrorType aErrorCode, - const nsACString& aHostName, - const mozilla::net::NetAddr& aAddress, uint32_t aTTL, - GetAddrInfoOperator* aContext); - ~GetAddrInfoReplyRunnable() = default; - - NS_IMETHOD Run() override; - - static void Reply(DNSServiceRef aSdRef, DNSServiceFlags aFlags, - uint32_t aInterfaceIndex, DNSServiceErrorType aErrorCode, - const char* aHostName, const struct sockaddr* aAddress, - uint32_t aTTL, void* aContext); - - private: - DNSServiceRef mSdRef; - DNSServiceFlags mFlags; - uint32_t mInterfaceIndex; - DNSServiceErrorType mErrorCode; - nsCString mHostName; - mozilla::net::NetAddr mAddress; - uint32_t mTTL; - RefPtr mContext; -}; - -} // namespace net -} // namespace mozilla - -#endif // mozilla_netwerk_dns_mdns_libmdns_MDNSResponderReply_h diff --git a/netwerk/dns/mdns/libmdns/MulticastDNSAndroid.jsm b/netwerk/dns/mdns/libmdns/MulticastDNSAndroid.jsm deleted file mode 100644 index d94e90efaa654..0000000000000 --- a/netwerk/dns/mdns/libmdns/MulticastDNSAndroid.jsm +++ /dev/null @@ -1,262 +0,0 @@ -// -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*- -/* 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["MulticastDNS"]; - -const { EventDispatcher } = ChromeUtils.import( - "resource://gre/modules/Messaging.jsm" -); - -const DEBUG = false; - -var log = function(s) {}; -if (DEBUG) { - log = ChromeUtils.import( - "resource://gre/modules/AndroidLog.jsm", - {} - ).AndroidLog.d.bind(null, "MulticastDNS"); -} - -const FAILURE_INTERNAL_ERROR = -65537; - -// Helper function for sending commands to Java. -function send(type, data, callback) { - let msg = { - type, - }; - - for (let i in data) { - try { - msg[i] = data[i]; - } catch (e) {} - } - - EventDispatcher.instance.sendRequestForResult(msg).then( - result => callback(result, null), - err => - callback(null, typeof err === "number" ? err : FAILURE_INTERNAL_ERROR) - ); -} - -// Receives service found/lost event from NsdManager -function ServiceManager() {} - -ServiceManager.prototype = { - listeners: {}, - numListeners: 0, - - onEvent(event, data, callback) { - if (event === "NsdManager:ServiceFound") { - this.onServiceFound(); - } else if (event === "NsdManager:ServiceLost") { - this.onServiceLost(); - } - }, - - registerEvent() { - log("registerEvent"); - EventDispatcher.instance.registerListener(this, [ - "NsdManager:ServiceFound", - "NsdManager:ServiceLost", - ]); - }, - - unregisterEvent() { - log("unregisterEvent"); - EventDispatcher.instance.unregisterListener(this, [ - "NsdManager:ServiceFound", - "NsdManager:ServiceLost", - ]); - }, - - addListener(aServiceType, aListener) { - log("addListener: " + aServiceType + ", " + aListener); - - if (!this.listeners[aServiceType]) { - this.listeners[aServiceType] = []; - } - if (this.listeners[aServiceType].includes(aListener)) { - log("listener already exists"); - return; - } - - this.listeners[aServiceType].push(aListener); - ++this.numListeners; - - if (this.numListeners === 1) { - this.registerEvent(); - } - - log("listener added: " + this); - }, - - removeListener(aServiceType, aListener) { - log("removeListener: " + aServiceType + ", " + aListener); - - if (!this.listeners[aServiceType]) { - log("listener doesn't exist"); - return; - } - let index = this.listeners[aServiceType].indexOf(aListener); - if (index < 0) { - log("listener doesn't exist"); - return; - } - - this.listeners[aServiceType].splice(index, 1); - --this.numListeners; - - if (this.numListeners === 0) { - this.unregisterEvent(); - } - - log("listener removed" + this); - }, - - onServiceFound(aServiceInfo) { - let listeners = this.listeners[aServiceInfo.serviceType]; - if (listeners) { - for (let listener of listeners) { - listener.onServiceFound(aServiceInfo); - } - } else { - log("no listener"); - } - return {}; - }, - - onServiceLost(aServiceInfo) { - let listeners = this.listeners[aServiceInfo.serviceType]; - if (listeners) { - for (let listener of listeners) { - listener.onServiceLost(aServiceInfo); - } - } else { - log("no listener"); - } - return {}; - }, -}; - -// make an object from nsIPropertyBag2 -function parsePropertyBag2(bag) { - if (!bag || !(bag instanceof Ci.nsIPropertyBag2)) { - throw new TypeError("Not a property bag"); - } - - let attributes = []; - for (let { name } of bag.enumerator) { - let value = bag.getPropertyAsACString(name); - attributes.push({ - name, - value, - }); - } - - return attributes; -} - -function MulticastDNS() { - this.serviceManager = new ServiceManager(); -} - -MulticastDNS.prototype = { - startDiscovery(aServiceType, aListener) { - this.serviceManager.addListener(aServiceType, aListener); - - let serviceInfo = { - serviceType: aServiceType, - uniqueId: aListener.uuid, - }; - - send("NsdManager:DiscoverServices", serviceInfo, (result, err) => { - if (err) { - log("onStartDiscoveryFailed: " + aServiceType + " (" + err + ")"); - this.serviceManager.removeListener(aServiceType, aListener); - aListener.onStartDiscoveryFailed(aServiceType, err); - } else { - aListener.onDiscoveryStarted(result); - } - }); - }, - - stopDiscovery(aServiceType, aListener) { - this.serviceManager.removeListener(aServiceType, aListener); - - let serviceInfo = { - uniqueId: aListener.uuid, - }; - - send("NsdManager:StopServiceDiscovery", serviceInfo, (result, err) => { - if (err) { - log("onStopDiscoveryFailed: " + aServiceType + " (" + err + ")"); - aListener.onStopDiscoveryFailed(aServiceType, err); - } else { - aListener.onDiscoveryStopped(aServiceType); - } - }); - }, - - registerService(aServiceInfo, aListener) { - let serviceInfo = { - port: aServiceInfo.port, - serviceType: aServiceInfo.serviceType, - uniqueId: aListener.uuid, - }; - - try { - serviceInfo.host = aServiceInfo.host; - } catch (e) { - // host unspecified - } - try { - serviceInfo.serviceName = aServiceInfo.serviceName; - } catch (e) { - // serviceName unspecified - } - try { - serviceInfo.attributes = parsePropertyBag2(aServiceInfo.attributes); - } catch (e) { - // attributes unspecified - } - - send("NsdManager:RegisterService", serviceInfo, (result, err) => { - if (err) { - log("onRegistrationFailed: (" + err + ")"); - aListener.onRegistrationFailed(aServiceInfo, err); - } else { - aListener.onServiceRegistered(result); - } - }); - }, - - unregisterService(aServiceInfo, aListener) { - let serviceInfo = { - uniqueId: aListener.uuid, - }; - - send("NsdManager:UnregisterService", serviceInfo, (result, err) => { - if (err) { - log("onUnregistrationFailed: (" + err + ")"); - aListener.onUnregistrationFailed(aServiceInfo, err); - } else { - aListener.onServiceUnregistered(aServiceInfo); - } - }); - }, - - resolveService(aServiceInfo, aListener) { - send("NsdManager:ResolveService", aServiceInfo, (result, err) => { - if (err) { - log("onResolveFailed: (" + err + ")"); - aListener.onResolveFailed(aServiceInfo, err); - } else { - aListener.onServiceResolved(result); - } - }); - }, -}; diff --git a/netwerk/dns/mdns/libmdns/components.conf b/netwerk/dns/mdns/libmdns/components.conf deleted file mode 100644 index 6e64140c820ed..0000000000000 --- a/netwerk/dns/mdns/libmdns/components.conf +++ /dev/null @@ -1,24 +0,0 @@ -# -*- 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/. - -Classes = [ - { - 'cid': '{14a50f2b-7ff6-48a5-88e3-615fd111f5d3}', - 'contract_ids': ['@mozilla.org/toolkit/components/mdnsresponder/dns-info;1'], - 'type': 'mozilla::net::nsDNSServiceInfo', - 'headers': ['/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h'], - }, -] - -if buildconfig.substs['MOZ_WIDGET_TOOLKIT'] != 'cocoa': - Classes += [ - { - 'cid': '{f9346d98-f27a-4e89-b744-493843416480}', - 'contract_ids': ['@mozilla.org/toolkit/components/mdnsresponder/dns-sd;1'], - 'jsm': 'resource://gre/modules/DNSServiceDiscovery.jsm', - 'constructor': 'nsDNSServiceDiscovery', - }, - ] diff --git a/netwerk/dns/mdns/libmdns/fallback/DNSPacket.jsm b/netwerk/dns/mdns/libmdns/fallback/DNSPacket.jsm deleted file mode 100644 index 1dd859c6d0559..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DNSPacket.jsm +++ /dev/null @@ -1,304 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["DNSPacket"]; - -const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); - -const { DataReader } = ChromeUtils.import( - "resource://gre/modules/DataReader.jsm" -); -const { DataWriter } = ChromeUtils.import( - "resource://gre/modules/DataWriter.jsm" -); -const { DNSRecord } = ChromeUtils.import( - "resource://gre/modules/DNSRecord.jsm" -); -const { DNSResourceRecord } = ChromeUtils.import( - "resource://gre/modules/DNSResourceRecord.jsm" -); - -const DEBUG = true; - -function debug(msg) { - Services.console.logStringMessage("DNSPacket: " + msg); -} - -let DNS_PACKET_SECTION_TYPES = [ - "QD", // Question - "AN", // Answer - "NS", // Authority - "AR", // Additional -]; - -/** - * DNS Packet Structure - * ************************************************* - * - * Header - * ====== - * - * 00 2-Bytes 15 - * ------------------------------------------------- - * |00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15| - * ------------------------------------------------- - * |<==================== ID =====================>| - * |QR|<== OP ===>|AA|TC|RD|RA|UN|AD|CD|<== RC ===>| - * |<================== QDCOUNT ==================>| - * |<================== ANCOUNT ==================>| - * |<================== NSCOUNT ==================>| - * |<================== ARCOUNT ==================>| - * ------------------------------------------------- - * - * ID: 2-Bytes - * FLAGS: 2-Bytes - * - QR: 1-Bit - * - OP: 4-Bits - * - AA: 1-Bit - * - TC: 1-Bit - * - RD: 1-Bit - * - RA: 1-Bit - * - UN: 1-Bit - * - AD: 1-Bit - * - CD: 1-Bit - * - RC: 4-Bits - * QDCOUNT: 2-Bytes - * ANCOUNT: 2-Bytes - * NSCOUNT: 2-Bytes - * ARCOUNT: 2-Bytes - * - * - * Data - * ==== - * - * 00 2-Bytes 15 - * ------------------------------------------------- - * |00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15| - * ------------------------------------------------- - * || - * || - * || - * || - * ------------------------------------------------- - * - * QD: ??-Bytes - * AN: ??-Bytes - * NS: ??-Bytes - * AR: ??-Bytes - * - * - * Question Record - * =============== - * - * 00 2-Bytes 15 - * ------------------------------------------------- - * |00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15| - * ------------------------------------------------- - * || - * |<=================== TYPE ====================>| - * |<=================== CLASS ===================>| - * ------------------------------------------------- - * - * NAME: ??-Bytes - * TYPE: 2-Bytes - * CLASS: 2-Bytes - * - * - * Resource Record - * =============== - * - * 00 4-Bytes 31 - * ------------------------------------------------- - * |00|02|04|06|08|10|12|14|16|18|20|22|24|26|28|30| - * ------------------------------------------------- - * || - * |<======= TYPE ========>|<======= CLASS =======>| - * |<==================== TTL ====================>| - * |<====== DATALEN ======>|| - * ------------------------------------------------- - * - * NAME: ??-Bytes - * TYPE: 2-Bytes - * CLASS: 2-Bytes - * DATALEN: 2-Bytes - * DATA: ??-Bytes (Specified By DATALEN) - */ -class DNSPacket { - constructor() { - this._flags = _valueToFlags(0x0000); - this._records = {}; - - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - this._records[sectionType] = []; - }); - } - - static parse(data) { - let reader = new DataReader(data); - if (reader.getValue(2) !== 0x0000) { - throw new Error("Packet must start with 0x0000"); - } - - let packet = new DNSPacket(); - packet._flags = _valueToFlags(reader.getValue(2)); - - let recordCounts = {}; - - // Parse the record counts. - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - recordCounts[sectionType] = reader.getValue(2); - }); - - // Parse the actual records. - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - let recordCount = recordCounts[sectionType]; - for (let i = 0; i < recordCount; i++) { - if (sectionType === "QD") { - packet.addRecord( - sectionType, - DNSRecord.parseFromPacketReader(reader) - ); - } else { - packet.addRecord( - sectionType, - DNSResourceRecord.parseFromPacketReader(reader) - ); - } - } - }); - - if (!reader.eof) { - DEBUG && debug("Did not complete parsing packet data"); - } - - return packet; - } - - getFlag(flag) { - return this._flags[flag]; - } - - setFlag(flag, value) { - this._flags[flag] = value; - } - - addRecord(sectionType, record) { - this._records[sectionType].push(record); - } - - getRecords(sectionTypes, recordType) { - let records = []; - - sectionTypes.forEach(sectionType => { - records = records.concat(this._records[sectionType]); - }); - - if (!recordType) { - return records; - } - - return records.filter(r => r.recordType === recordType); - } - - serialize() { - let writer = new DataWriter(); - - // Write leading 0x0000 (2 bytes) - writer.putValue(0x0000, 2); - - // Write `flags` (2 bytes) - writer.putValue(_flagsToValue(this._flags), 2); - - // Write lengths of record sections (2 bytes each) - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - writer.putValue(this._records[sectionType].length, 2); - }); - - // Write records - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - this._records[sectionType].forEach(record => { - writer.putBytes(record.serialize()); - }); - }); - - return writer.data; - } - - toJSON() { - return JSON.stringify(this.toJSONObject()); - } - - toJSONObject() { - let result = { flags: this._flags }; - DNS_PACKET_SECTION_TYPES.forEach(sectionType => { - result[sectionType] = []; - - let records = this._records[sectionType]; - records.forEach(record => { - result[sectionType].push(record.toJSONObject()); - }); - }); - - return result; - } -} - -/** - * @private - */ -function _valueToFlags(value) { - return { - QR: (value & 0x8000) >> 15, - OP: (value & 0x7800) >> 11, - AA: (value & 0x0400) >> 10, - TC: (value & 0x0200) >> 9, - RD: (value & 0x0100) >> 8, - RA: (value & 0x0080) >> 7, - UN: (value & 0x0040) >> 6, - AD: (value & 0x0020) >> 5, - CD: (value & 0x0010) >> 4, - RC: (value & 0x000f) >> 0, - }; -} - -/** - * @private - */ -function _flagsToValue(flags) { - let value = 0x0000; - - value += flags.QR & 0x01; - - value <<= 4; - value += flags.OP & 0x0f; - - value <<= 1; - value += flags.AA & 0x01; - - value <<= 1; - value += flags.TC & 0x01; - - value <<= 1; - value += flags.RD & 0x01; - - value <<= 1; - value += flags.RA & 0x01; - - value <<= 1; - value += flags.UN & 0x01; - - value <<= 1; - value += flags.AD & 0x01; - - value <<= 1; - value += flags.CD & 0x01; - - value <<= 4; - value += flags.RC & 0x0f; - - return value; -} diff --git a/netwerk/dns/mdns/libmdns/fallback/DNSRecord.jsm b/netwerk/dns/mdns/libmdns/fallback/DNSRecord.jsm deleted file mode 100644 index 682fd8b1034bc..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DNSRecord.jsm +++ /dev/null @@ -1,71 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["DNSRecord"]; - -const { DataWriter } = ChromeUtils.import( - "resource://gre/modules/DataWriter.jsm" -); -const { DNS_CLASS_CODES, DNS_RECORD_TYPES } = ChromeUtils.import( - "resource://gre/modules/DNSTypes.jsm" -); - -class DNSRecord { - constructor(properties = {}) { - this.name = properties.name || ""; - this.recordType = properties.recordType || DNS_RECORD_TYPES.ANY; - this.classCode = properties.classCode || DNS_CLASS_CODES.IN; - this.cacheFlush = properties.cacheFlush || false; - } - - static parseFromPacketReader(reader) { - let name = reader.getLabel(); - let recordType = reader.getValue(2); - let classCode = reader.getValue(2); - let cacheFlush = !!(classCode & 0x8000); - classCode &= 0xff; - - return new this({ - name, - recordType, - classCode, - cacheFlush, - }); - } - - serialize() { - let writer = new DataWriter(); - - // Write `name` (ends with trailing 0x00 byte) - writer.putLabel(this.name); - - // Write `recordType` (2 bytes) - writer.putValue(this.recordType, 2); - - // Write `classCode` (2 bytes) - let classCode = this.classCode; - if (this.cacheFlush) { - classCode |= 0x8000; - } - writer.putValue(classCode, 2); - - return writer.data; - } - - toJSON() { - return JSON.stringify(this.toJSONObject()); - } - - toJSONObject() { - return { - name: this.name, - recordType: this.recordType, - classCode: this.classCode, - cacheFlush: this.cacheFlush, - }; - } -} diff --git a/netwerk/dns/mdns/libmdns/fallback/DNSResourceRecord.jsm b/netwerk/dns/mdns/libmdns/fallback/DNSResourceRecord.jsm deleted file mode 100644 index e89f418410511..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DNSResourceRecord.jsm +++ /dev/null @@ -1,221 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["DNSResourceRecord"]; - -const { DataReader } = ChromeUtils.import( - "resource://gre/modules/DataReader.jsm" -); -const { DataWriter } = ChromeUtils.import( - "resource://gre/modules/DataWriter.jsm" -); -const { DNSRecord } = ChromeUtils.import( - "resource://gre/modules/DNSRecord.jsm" -); -const { DNS_RECORD_TYPES } = ChromeUtils.import( - "resource://gre/modules/DNSTypes.jsm" -); - -const DNS_RESOURCE_RECORD_DEFAULT_TTL = 120; // 120 seconds - -class DNSResourceRecord extends DNSRecord { - constructor(properties = {}) { - super(properties); - - this.ttl = properties.ttl || DNS_RESOURCE_RECORD_DEFAULT_TTL; - this.data = properties.data || {}; - } - - static parseFromPacketReader(reader) { - let record = super.parseFromPacketReader(reader); - - let ttl = reader.getValue(4); - let recordData = reader.getBytes(reader.getValue(2)); - let packetData = reader.data; - - let data; - - switch (record.recordType) { - case DNS_RECORD_TYPES.A: - data = _parseA(recordData, packetData); - break; - case DNS_RECORD_TYPES.PTR: - data = _parsePTR(recordData, packetData); - break; - case DNS_RECORD_TYPES.TXT: - data = _parseTXT(recordData, packetData); - break; - case DNS_RECORD_TYPES.SRV: - data = _parseSRV(recordData, packetData); - break; - default: - data = null; - break; - } - - record.ttl = ttl; - record.data = data; - - return record; - } - - serialize() { - let writer = new DataWriter(super.serialize()); - - // Write `ttl` (4 bytes) - writer.putValue(this.ttl, 4); - - let data; - - switch (this.recordType) { - case DNS_RECORD_TYPES.A: - data = _serializeA(this.data); - break; - case DNS_RECORD_TYPES.PTR: - data = _serializePTR(this.data); - break; - case DNS_RECORD_TYPES.TXT: - data = _serializeTXT(this.data); - break; - case DNS_RECORD_TYPES.SRV: - data = _serializeSRV(this.data); - break; - default: - data = new Uint8Array(); - break; - } - - // Write `data` length. - writer.putValue(data.length, 2); - - // Write `data` (ends with trailing 0x00 byte) - writer.putBytes(data); - - return writer.data; - } - - toJSON() { - return JSON.stringify(this.toJSONObject()); - } - - toJSONObject() { - let result = super.toJSONObject(); - result.ttl = this.ttl; - result.data = this.data; - return result; - } -} - -/** - * @private - */ -function _parseA(recordData, packetData) { - let reader = new DataReader(recordData); - - let parts = []; - for (let i = 0; i < 4; i++) { - parts.push(reader.getValue(1)); - } - - return parts.join("."); -} - -/** - * @private - */ -function _parsePTR(recordData, packetData) { - let reader = new DataReader(recordData); - - return reader.getLabel(packetData); -} - -/** - * @private - */ -function _parseTXT(recordData, packetData) { - let reader = new DataReader(recordData); - - let result = {}; - - let label = reader.getLabel(packetData); - if (label.length > 0) { - let parts = label.split("."); - parts.forEach(part => { - let [name] = part.split("=", 1); - let value = part.substr(name.length + 1); - result[name] = value; - }); - } - - return result; -} - -/** - * @private - */ -function _parseSRV(recordData, packetData) { - let reader = new DataReader(recordData); - - let priority = reader.getValue(2); - let weight = reader.getValue(2); - let port = reader.getValue(2); - let target = reader.getLabel(packetData); - - return { priority, weight, port, target }; -} - -/** - * @private - */ -function _serializeA(data) { - let writer = new DataWriter(); - - let parts = data.split("."); - for (let i = 0; i < 4; i++) { - writer.putValue(parseInt(parts[i], 10) || 0); - } - - return writer.data; -} - -/** - * @private - */ -function _serializePTR(data) { - let writer = new DataWriter(); - - writer.putLabel(data); - - return writer.data; -} - -/** - * @private - */ -function _serializeTXT(data) { - let writer = new DataWriter(); - - for (let name in data) { - writer.putLengthString(name + "=" + data[name]); - } - - return writer.data; -} - -/** - * @private - */ -function _serializeSRV(data) { - let writer = new DataWriter(); - - writer.putValue(data.priority || 0, 2); - writer.putValue(data.weight || 0, 2); - writer.putValue(data.port || 0, 2); - writer.putLabel(data.target); - - return writer.data; -} diff --git a/netwerk/dns/mdns/libmdns/fallback/DNSTypes.jsm b/netwerk/dns/mdns/libmdns/fallback/DNSTypes.jsm deleted file mode 100644 index 878e22917d973..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DNSTypes.jsm +++ /dev/null @@ -1,99 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = [ - "DNS_QUERY_RESPONSE_CODES", - "DNS_AUTHORITATIVE_ANSWER_CODES", - "DNS_CLASS_CODES", - "DNS_RECORD_TYPES", -]; - -let DNS_QUERY_RESPONSE_CODES = { - QUERY: 0, // RFC 1035 - Query - RESPONSE: 1, // RFC 1035 - Reponse -}; - -let DNS_AUTHORITATIVE_ANSWER_CODES = { - NO: 0, // RFC 1035 - Not Authoritative - YES: 1, // RFC 1035 - Is Authoritative -}; - -let DNS_CLASS_CODES = { - IN: 0x01, // RFC 1035 - Internet - CS: 0x02, // RFC 1035 - CSNET - CH: 0x03, // RFC 1035 - CHAOS - HS: 0x04, // RFC 1035 - Hesiod - NONE: 0xfe, // RFC 2136 - None - ANY: 0xff, // RFC 1035 - Any -}; - -let DNS_RECORD_TYPES = { - SIGZERO: 0, // RFC 2931 - A: 1, // RFC 1035 - NS: 2, // RFC 1035 - MD: 3, // RFC 1035 - MF: 4, // RFC 1035 - CNAME: 5, // RFC 1035 - SOA: 6, // RFC 1035 - MB: 7, // RFC 1035 - MG: 8, // RFC 1035 - MR: 9, // RFC 1035 - NULL: 10, // RFC 1035 - WKS: 11, // RFC 1035 - PTR: 12, // RFC 1035 - HINFO: 13, // RFC 1035 - MINFO: 14, // RFC 1035 - MX: 15, // RFC 1035 - TXT: 16, // RFC 1035 - RP: 17, // RFC 1183 - AFSDB: 18, // RFC 1183 - X25: 19, // RFC 1183 - ISDN: 20, // RFC 1183 - RT: 21, // RFC 1183 - NSAP: 22, // RFC 1706 - NSAP_PTR: 23, // RFC 1348 - SIG: 24, // RFC 2535 - KEY: 25, // RFC 2535 - PX: 26, // RFC 2163 - GPOS: 27, // RFC 1712 - AAAA: 28, // RFC 1886 - LOC: 29, // RFC 1876 - NXT: 30, // RFC 2535 - EID: 31, // RFC ???? - NIMLOC: 32, // RFC ???? - SRV: 33, // RFC 2052 - ATMA: 34, // RFC ???? - NAPTR: 35, // RFC 2168 - KX: 36, // RFC 2230 - CERT: 37, // RFC 2538 - DNAME: 39, // RFC 2672 - OPT: 41, // RFC 2671 - APL: 42, // RFC 3123 - DS: 43, // RFC 4034 - SSHFP: 44, // RFC 4255 - IPSECKEY: 45, // RFC 4025 - RRSIG: 46, // RFC 4034 - NSEC: 47, // RFC 4034 - DNSKEY: 48, // RFC 4034 - DHCID: 49, // RFC 4701 - NSEC3: 50, // RFC ???? - NSEC3PARAM: 51, // RFC ???? - HIP: 55, // RFC 5205 - SPF: 99, // RFC 4408 - UINFO: 100, // RFC ???? - UID: 101, // RFC ???? - GID: 102, // RFC ???? - UNSPEC: 103, // RFC ???? - TKEY: 249, // RFC 2930 - TSIG: 250, // RFC 2931 - IXFR: 251, // RFC 1995 - AXFR: 252, // RFC 1035 - MAILB: 253, // RFC 1035 - MAILA: 254, // RFC 1035 - ANY: 255, // RFC 1035 - DLV: 32769, // RFC 4431 -}; diff --git a/netwerk/dns/mdns/libmdns/fallback/DataReader.jsm b/netwerk/dns/mdns/libmdns/fallback/DataReader.jsm deleted file mode 100644 index 978ab4dde0385..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DataReader.jsm +++ /dev/null @@ -1,134 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["DataReader"]; - -class DataReader { - // `data` is `Uint8Array` - constructor(data, startByte = 0) { - this._data = data; - this._cursor = startByte; - } - - get buffer() { - return this._data.buffer; - } - - get data() { - return this._data; - } - - get eof() { - return this._cursor >= this._data.length; - } - - getBytes(length = 1) { - if (!length) { - return new Uint8Array(); - } - - let end = this._cursor + length; - if (end > this._data.length) { - return new Uint8Array(); - } - - let uint8Array = new Uint8Array(this.buffer.slice(this._cursor, end)); - this._cursor += length; - - return uint8Array; - } - - getString(length) { - let uint8Array = this.getBytes(length); - return _uint8ArrayToString(uint8Array); - } - - getValue(length) { - let uint8Array = this.getBytes(length); - return _uint8ArrayToValue(uint8Array); - } - - getLabel(decompressData) { - let parts = []; - let partLength; - - while ((partLength = this.getValue(1))) { - // If a length has been specified instead of a pointer, - // read the string of the specified length. - if (partLength !== 0xc0) { - parts.push(this.getString(partLength)); - continue; - } - - // TODO: Handle case where we have a pointer to the label - parts.push(String.fromCharCode(0xc0) + this.getString(1)); - break; - } - - let label = parts.join("."); - - return _decompressLabel(label, decompressData || this._data); - } -} - -/** - * @private - */ -function _uint8ArrayToValue(uint8Array) { - let length = uint8Array.length; - if (length === 0) { - return null; - } - - let value = 0; - for (let i = 0; i < length; i++) { - value = value << 8; - value += uint8Array[i]; - } - - return value; -} - -/** - * @private - */ -function _uint8ArrayToString(uint8Array) { - let length = uint8Array.length; - if (length === 0) { - return ""; - } - - let results = []; - for (let i = 0; i < length; i += 1024) { - results.push( - String.fromCharCode.apply(null, uint8Array.subarray(i, i + 1024)) - ); - } - - return results.join(""); -} - -/** - * @private - */ -function _decompressLabel(label, decompressData) { - let result = ""; - - for (let i = 0, length = label.length; i < length; i++) { - if (label.charCodeAt(i) !== 0xc0) { - result += label.charAt(i); - continue; - } - - i++; - - let reader = new DataReader(decompressData, label.charCodeAt(i)); - result += _decompressLabel(reader.getLabel(), decompressData); - } - - return result; -} diff --git a/netwerk/dns/mdns/libmdns/fallback/DataWriter.jsm b/netwerk/dns/mdns/libmdns/fallback/DataWriter.jsm deleted file mode 100644 index 05949a1d05b7d..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/DataWriter.jsm +++ /dev/null @@ -1,97 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["DataWriter"]; - -class DataWriter { - constructor(data, maxBytes = 512) { - if (typeof data === "number") { - maxBytes = data; - data = undefined; - } - - this._buffer = new ArrayBuffer(maxBytes); - this._data = new Uint8Array(this._buffer); - this._cursor = 0; - - if (data) { - this.putBytes(data); - } - } - - get buffer() { - return this._buffer.slice(0, this._cursor); - } - - get data() { - return new Uint8Array(this.buffer); - } - - // `data` is `Uint8Array` - putBytes(data) { - if (this._cursor + data.length > this._data.length) { - throw new Error("DataWriter buffer is exceeded"); - } - - for (let i = 0, length = data.length; i < length; i++) { - this._data[this._cursor] = data[i]; - this._cursor++; - } - } - - putByte(byte) { - if (this._cursor + 1 > this._data.length) { - throw new Error("DataWriter buffer is exceeded"); - } - - this._data[this._cursor] = byte; - this._cursor++; - } - - putValue(value, length) { - length = length || 1; - if (length == 1) { - this.putByte(value); - } else { - this.putBytes(_valueToUint8Array(value, length)); - } - } - - putLabel(label) { - // Eliminate any trailing '.'s in the label (valid in text representation). - label = label.replace(/\.$/, ""); - let parts = label.split("."); - parts.forEach(part => { - this.putLengthString(part); - }); - this.putValue(0); - } - - putLengthString(string) { - if (string.length > 0xff) { - throw new Error("String too long."); - } - this.putValue(string.length); - for (let i = 0; i < string.length; i++) { - this.putValue(string.charCodeAt(i)); - } - } -} - -/** - * @private - */ -function _valueToUint8Array(value, length) { - let arrayBuffer = new ArrayBuffer(length); - let uint8Array = new Uint8Array(arrayBuffer); - for (let i = length - 1; i >= 0; i--) { - uint8Array[i] = value & 0xff; - value = value >> 8; - } - - return uint8Array; -} diff --git a/netwerk/dns/mdns/libmdns/fallback/MulticastDNS.jsm b/netwerk/dns/mdns/libmdns/fallback/MulticastDNS.jsm deleted file mode 100644 index efc21fe5231f3..0000000000000 --- a/netwerk/dns/mdns/libmdns/fallback/MulticastDNS.jsm +++ /dev/null @@ -1,985 +0,0 @@ -/* -*- Mode: js; js-indent-level: 2; indent-tabs-mode: nil; tab-width: 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/. */ - -"use strict"; - -var EXPORTED_SYMBOLS = ["MulticastDNS"]; - -const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); -const { clearTimeout, setTimeout } = ChromeUtils.import( - "resource://gre/modules/Timer.jsm" -); - -const { DNSPacket } = ChromeUtils.import( - "resource://gre/modules/DNSPacket.jsm" -); -const { DNSRecord } = ChromeUtils.import( - "resource://gre/modules/DNSRecord.jsm" -); -const { DNSResourceRecord } = ChromeUtils.import( - "resource://gre/modules/DNSResourceRecord.jsm" -); -const { - DNS_AUTHORITATIVE_ANSWER_CODES, - DNS_CLASS_CODES, - DNS_QUERY_RESPONSE_CODES, - DNS_RECORD_TYPES, -} = ChromeUtils.import("resource://gre/modules/DNSTypes.jsm"); - -const NS_NETWORK_LINK_TOPIC = "network:link-status-changed"; - -let networkInfoService = Cc[ - "@mozilla.org/network-info-service;1" -].createInstance(Ci.nsINetworkInfoService); - -const DEBUG = true; - -const MDNS_MULTICAST_GROUP = "224.0.0.251"; -const MDNS_PORT = 5353; -const DEFAULT_TTL = 120; - -function debug(msg) { - dump("MulticastDNS: " + msg + "\n"); -} - -function ServiceKey(svc) { - return ( - "" + - svc.serviceType.length + - "/" + - svc.serviceType + - "|" + - svc.serviceName.length + - "/" + - svc.serviceName + - "|" + - svc.port - ); -} - -function TryGet(obj, name) { - try { - return obj[name]; - } catch (err) { - return undefined; - } -} - -function IsIpv4Address(addr) { - let parts = addr.split("."); - if (parts.length != 4) { - return false; - } - for (let part of parts) { - let partInt = Number.parseInt(part, 10); - if (partInt.toString() != part) { - return false; - } - if (partInt < 0 || partInt >= 256) { - return false; - } - } - return true; -} - -class PublishedService { - constructor(attrs) { - this.serviceType = attrs.serviceType.replace(/\.$/, ""); - this.serviceName = attrs.serviceName; - this.domainName = TryGet(attrs, "domainName") || "local"; - this.address = TryGet(attrs, "address") || "0.0.0.0"; - this.port = attrs.port; - this.serviceAttrs = _propertyBagToObject(TryGet(attrs, "attributes") || {}); - this.host = TryGet(attrs, "host"); - this.key = this.generateKey(); - this.lastAdvertised = undefined; - this.advertiseTimer = undefined; - } - - equals(svc) { - return ( - this.port == svc.port && - this.serviceName == svc.serviceName && - this.serviceType == svc.serviceType - ); - } - - generateKey() { - return ServiceKey(this); - } - - ptrMatch(name) { - return name == this.serviceType + "." + this.domainName; - } - - clearAdvertiseTimer() { - if (!this.advertiseTimer) { - return; - } - clearTimeout(this.advertiseTimer); - this.advertiseTimer = undefined; - } -} - -class MulticastDNS { - constructor() { - this._listeners = new Map(); - this._sockets = new Map(); - this._services = new Map(); - this._discovered = new Map(); - this._querySocket = undefined; - this._broadcastReceiverSocket = undefined; - this._broadcastTimer = undefined; - - this._networkLinkObserver = { - observe: (subject, topic, data) => { - DEBUG && - debug( - NS_NETWORK_LINK_TOPIC + - "(" + - data + - "); Clearing list of previously discovered services" - ); - this._discovered.clear(); - }, - }; - } - - _attachNetworkLinkObserver() { - if (this._networkLinkObserverTimeout) { - clearTimeout(this._networkLinkObserverTimeout); - } - - if (!this._isNetworkLinkObserverAttached) { - DEBUG && debug("Attaching observer " + NS_NETWORK_LINK_TOPIC); - Services.obs.addObserver( - this._networkLinkObserver, - NS_NETWORK_LINK_TOPIC - ); - this._isNetworkLinkObserverAttached = true; - } - } - - _detachNetworkLinkObserver() { - if (this._isNetworkLinkObserverAttached) { - if (this._networkLinkObserverTimeout) { - clearTimeout(this._networkLinkObserverTimeout); - } - - this._networkLinkObserverTimeout = setTimeout(() => { - DEBUG && debug("Detaching observer " + NS_NETWORK_LINK_TOPIC); - Services.obs.removeObserver( - this._networkLinkObserver, - NS_NETWORK_LINK_TOPIC - ); - this._isNetworkLinkObserverAttached = false; - this._networkLinkObserverTimeout = null; - }, 5000); - } - } - - startDiscovery(aServiceType, aListener) { - DEBUG && debug('startDiscovery("' + aServiceType + '")'); - let { serviceType } = _parseServiceDomainName(aServiceType); - - this._attachNetworkLinkObserver(); - this._addServiceListener(serviceType, aListener); - - try { - this._query(serviceType + ".local"); - aListener.onDiscoveryStarted(serviceType); - } catch (e) { - DEBUG && debug('startDiscovery("' + serviceType + '") FAILED: ' + e); - this._removeServiceListener(serviceType, aListener); - aListener.onStartDiscoveryFailed(serviceType, Cr.NS_ERROR_FAILURE); - } - } - - stopDiscovery(aServiceType, aListener) { - DEBUG && debug('stopDiscovery("' + aServiceType + '")'); - let { serviceType } = _parseServiceDomainName(aServiceType); - - this._detachNetworkLinkObserver(); - this._removeServiceListener(serviceType, aListener); - - aListener.onDiscoveryStopped(serviceType); - - this._checkCloseSockets(); - } - - resolveService(aServiceInfo, aListener) { - DEBUG && debug("resolveService(): " + aServiceInfo.serviceName); - - // Address info is already resolved during discovery - setTimeout(() => aListener.onServiceResolved(aServiceInfo)); - } - - registerService(aServiceInfo, aListener) { - DEBUG && debug("registerService(): " + aServiceInfo.serviceName); - - // Initialize the broadcast receiver socket in case it - // hasn't already been started so we can listen for - // multicast queries/announcements on all interfaces. - this._getBroadcastReceiverSocket(); - - for (let name of ["port", "serviceName", "serviceType"]) { - if (!TryGet(aServiceInfo, name)) { - aListener.onRegistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE); - throw new Error('Invalid nsIDNSServiceInfo; Missing "' + name + '"'); - } - } - - let publishedService; - try { - publishedService = new PublishedService(aServiceInfo); - } catch (e) { - DEBUG && - debug("Error constructing PublishedService: " + e + " - " + e.stack); - setTimeout(() => - aListener.onRegistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - // Ensure such a service does not already exist. - if (this._services.get(publishedService.key)) { - setTimeout(() => - aListener.onRegistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - // Make sure that the service addr is '0.0.0.0', or there is at least one - // socket open on the address the service is open on. - this._getSockets().then(sockets => { - if ( - publishedService.address != "0.0.0.0" && - !sockets.get(publishedService.address) - ) { - setTimeout(() => - aListener.onRegistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - this._services.set(publishedService.key, publishedService); - - // Service registered.. call onServiceRegistered on next tick. - setTimeout(() => aListener.onServiceRegistered(aServiceInfo)); - - // Set a timeout to start advertising the service too. - publishedService.advertiseTimer = setTimeout(() => { - this._advertiseService(publishedService.key, /* firstAdv = */ true); - }); - }); - } - - unregisterService(aServiceInfo, aListener) { - DEBUG && debug("unregisterService(): " + aServiceInfo.serviceName); - - let serviceKey; - try { - serviceKey = ServiceKey(aServiceInfo); - } catch (e) { - setTimeout(() => - aListener.onUnregistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - let publishedService = this._services.get(serviceKey); - if (!publishedService) { - setTimeout(() => - aListener.onUnregistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - // Clear any advertise timeout for this published service. - publishedService.clearAdvertiseTimer(); - - // Delete the service from the service map. - if (!this._services.delete(serviceKey)) { - setTimeout(() => - aListener.onUnregistrationFailed(aServiceInfo, Cr.NS_ERROR_FAILURE) - ); - return; - } - - // Check the broadcast timer again to rejig when it should run next. - this._checkStartBroadcastTimer(); - - // Check to see if sockets should be closed, and if so close them. - this._checkCloseSockets(); - - aListener.onServiceUnregistered(aServiceInfo); - } - - _respondToQuery(serviceKey, message) { - let address = message.fromAddr.address; - let port = message.fromAddr.port; - DEBUG && - debug( - "_respondToQuery(): key=" + - serviceKey + - ", fromAddr=" + - address + - ":" + - port - ); - - let publishedService = this._services.get(serviceKey); - if (!publishedService) { - debug("_respondToQuery Could not find service (key=" + serviceKey + ")"); - return; - } - - DEBUG && - debug("_respondToQuery(): key=" + serviceKey + ": SENDING RESPONSE"); - this._advertiseServiceHelper(publishedService, { address, port }); - } - - _advertiseService(serviceKey, firstAdv) { - DEBUG && debug("_advertiseService(): key=" + serviceKey); - let publishedService = this._services.get(serviceKey); - if (!publishedService) { - debug( - "_advertiseService Could not find service to advertise (key=" + - serviceKey + - ")" - ); - return; - } - - publishedService.advertiseTimer = undefined; - - this._advertiseServiceHelper(publishedService, null).then(() => { - // If first advertisement, re-advertise in 1 second. - // Otherwise, set the lastAdvertised time. - if (firstAdv) { - publishedService.advertiseTimer = setTimeout(() => { - this._advertiseService(serviceKey); - }, 1000); - } else { - publishedService.lastAdvertised = Date.now(); - this._checkStartBroadcastTimer(); - } - }); - } - - _advertiseServiceHelper(svc, target) { - if (!target) { - target = { address: MDNS_MULTICAST_GROUP, port: MDNS_PORT }; - } - - return this._getSockets().then(sockets => { - sockets.forEach((socket, address) => { - if (svc.address == "0.0.0.0" || address == svc.address) { - let packet = this._makeServicePacket(svc, [address]); - let data = packet.serialize(); - try { - socket.send(target.address, target.port, data); - } catch (err) { - DEBUG && - debug( - "Failed to send packet to " + target.address + ":" + target.port - ); - } - } - }); - }); - } - - _cancelBroadcastTimer() { - if (!this._broadcastTimer) { - return; - } - clearTimeout(this._broadcastTimer); - this._broadcastTimer = undefined; - } - - _checkStartBroadcastTimer() { - DEBUG && debug("_checkStartBroadcastTimer()"); - // Cancel any existing broadcasting timer. - this._cancelBroadcastTimer(); - - let now = Date.now(); - - // Go through services and find services to broadcast. - let bcastServices = []; - let nextBcastWait = undefined; - for (let [, publishedService] of this._services) { - // if lastAdvertised is undefined, service hasn't finished it's initial - // two broadcasts. - if (publishedService.lastAdvertised === undefined) { - continue; - } - - // Otherwise, check lastAdvertised against now. - let msSinceAdv = now - publishedService.lastAdvertised; - - // If msSinceAdv is more than 90% of the way to the TTL, advertise now. - if (msSinceAdv > DEFAULT_TTL * 1000 * 0.9) { - bcastServices.push(publishedService); - continue; - } - - // Otherwise, calculate the next time to advertise for this service. - // We set that at 95% of the time to the TTL expiry. - let nextAdvWait = DEFAULT_TTL * 1000 * 0.95 - msSinceAdv; - if (nextBcastWait === undefined || nextBcastWait > nextAdvWait) { - nextBcastWait = nextAdvWait; - } - } - - // Schedule an immediate advertisement of all services to be advertised now. - for (let svc of bcastServices) { - svc.advertiseTimer = setTimeout(() => this._advertiseService(svc.key)); - } - - // Schedule next broadcast check for the next bcast time. - if (nextBcastWait !== undefined) { - DEBUG && - debug( - "_checkStartBroadcastTimer(): Scheduling next check in " + - nextBcastWait + - "ms" - ); - this._broadcastTimer = setTimeout( - () => this._checkStartBroadcastTimer(), - nextBcastWait - ); - } - } - - _query(name) { - DEBUG && debug('query("' + name + '")'); - let packet = new DNSPacket(); - packet.setFlag("QR", DNS_QUERY_RESPONSE_CODES.QUERY); - - // PTR Record - packet.addRecord( - "QD", - new DNSRecord({ - name, - recordType: DNS_RECORD_TYPES.PTR, - classCode: DNS_CLASS_CODES.IN, - cacheFlush: true, - }) - ); - - let data = packet.serialize(); - - // Initialize the broadcast receiver socket in case it - // hasn't already been started so we can listen for - // multicast queries/announcements on all interfaces. - this._getBroadcastReceiverSocket(); - - this._getQuerySocket().then(querySocket => { - DEBUG && debug('sending query on query socket ("' + name + '")'); - querySocket.send(MDNS_MULTICAST_GROUP, MDNS_PORT, data); - }); - - // Automatically announce previously-discovered - // services that match and haven't expired yet. - setTimeout(() => { - DEBUG && - debug('announcing previously discovered services ("' + name + '")'); - let { serviceType } = _parseServiceDomainName(name); - - this._clearExpiredDiscoveries(); - this._discovered.forEach((discovery, key) => { - let serviceInfo = discovery.serviceInfo; - if (serviceInfo.serviceType !== serviceType) { - return; - } - - let listeners = this._listeners.get(serviceInfo.serviceType) || []; - listeners.forEach(listener => { - listener.onServiceFound(serviceInfo); - }); - }); - }); - } - - _clearExpiredDiscoveries() { - this._discovered.forEach((discovery, key) => { - if (discovery.expireTime < Date.now()) { - this._discovered.delete(key); - } - }); - } - - _handleQueryPacket(packet, message) { - packet.getRecords(["QD"]).forEach(record => { - // Don't respond if the query's class code is not IN or ANY. - if ( - record.classCode !== DNS_CLASS_CODES.IN && - record.classCode !== DNS_CLASS_CODES.ANY - ) { - return; - } - - // Don't respond if the query's record type is not PTR or ANY. - if ( - record.recordType !== DNS_RECORD_TYPES.PTR && - record.recordType !== DNS_RECORD_TYPES.ANY - ) { - return; - } - - for (let [serviceKey, publishedService] of this._services) { - DEBUG && debug("_handleQueryPacket: " + packet.toJSON()); - if (publishedService.ptrMatch(record.name)) { - this._respondToQuery(serviceKey, message); - } - } - }); - } - - _makeServicePacket(service, addresses) { - let packet = new DNSPacket(); - packet.setFlag("QR", DNS_QUERY_RESPONSE_CODES.RESPONSE); - packet.setFlag("AA", DNS_AUTHORITATIVE_ANSWER_CODES.YES); - - let host = service.host || _hostname; - - // e.g.: foo-bar-service._http._tcp.local - let serviceDomainName = - service.serviceName + "." + service.serviceType + ".local"; - - // PTR Record - packet.addRecord( - "AN", - new DNSResourceRecord({ - name: service.serviceType + ".local", // e.g.: _http._tcp.local - recordType: DNS_RECORD_TYPES.PTR, - data: serviceDomainName, - }) - ); - - // SRV Record - packet.addRecord( - "AR", - new DNSResourceRecord({ - name: serviceDomainName, - recordType: DNS_RECORD_TYPES.SRV, - classCode: DNS_CLASS_CODES.IN, - cacheFlush: true, - data: { - priority: 0, - weight: 0, - port: service.port, - target: host, // e.g.: My-Android-Phone.local - }, - }) - ); - - // A Records - for (let address of addresses) { - packet.addRecord( - "AR", - new DNSResourceRecord({ - name: host, - recordType: DNS_RECORD_TYPES.A, - data: address, - }) - ); - } - - // TXT Record - packet.addRecord( - "AR", - new DNSResourceRecord({ - name: serviceDomainName, - recordType: DNS_RECORD_TYPES.TXT, - classCode: DNS_CLASS_CODES.IN, - cacheFlush: true, - data: service.serviceAttrs || {}, - }) - ); - - return packet; - } - - _handleResponsePacket(packet, message) { - let services = {}; - let hosts = {}; - - let srvRecords = packet.getRecords(["AN", "AR"], DNS_RECORD_TYPES.SRV); - let txtRecords = packet.getRecords(["AN", "AR"], DNS_RECORD_TYPES.TXT); - let ptrRecords = packet.getRecords(["AN", "AR"], DNS_RECORD_TYPES.PTR); - let aRecords = packet.getRecords(["AN", "AR"], DNS_RECORD_TYPES.A); - - srvRecords.forEach(record => { - let data = record.data || {}; - - services[record.name] = { - host: data.target, - port: data.port, - ttl: record.ttl, - }; - }); - - txtRecords.forEach(record => { - if (!services[record.name]) { - return; - } - - services[record.name].attributes = record.data; - }); - - aRecords.forEach(record => { - if (IsIpv4Address(record.data)) { - hosts[record.name] = record.data; - } - }); - - ptrRecords.forEach(record => { - let name = record.data; - if (!services[name]) { - return; - } - - let { host, port } = services[name]; - if (!host || !port) { - return; - } - - let { serviceName, serviceType, domainName } = _parseServiceDomainName( - name - ); - if (!serviceName || !serviceType || !domainName) { - return; - } - - let address = hosts[host]; - if (!address) { - return; - } - - let ttl = services[name].ttl || 0; - let serviceInfo = { - serviceName, - serviceType, - host, - address, - port, - domainName, - attributes: services[name].attributes || {}, - }; - - this._onServiceFound(serviceInfo, ttl); - }); - } - - _onServiceFound(serviceInfo, ttl = 0) { - let expireTime = Date.now() + ttl * 1000; - let key = - serviceInfo.serviceName + - "." + - serviceInfo.serviceType + - "." + - serviceInfo.domainName + - " @" + - serviceInfo.address + - ":" + - serviceInfo.port; - - // If this service was already discovered, just update - // its expiration time and don't re-emit it. - if (this._discovered.has(key)) { - this._discovered.get(key).expireTime = expireTime; - return; - } - - this._discovered.set(key, { - serviceInfo, - expireTime, - }); - - let listeners = this._listeners.get(serviceInfo.serviceType) || []; - listeners.forEach(listener => { - listener.onServiceFound(serviceInfo); - }); - - DEBUG && debug("_onServiceFound()" + serviceInfo.serviceName); - } - - /** - * Gets a non-exclusive socket on 0.0.0.0:{random} to send - * multicast queries on all interfaces. This socket does - * not need to join a multicast group since it is still - * able to *send* multicast queries, but it does not need - * to *listen* for multicast queries/announcements since - * the `_broadcastReceiverSocket` is already handling them. - */ - _getQuerySocket() { - return new Promise((resolve, reject) => { - if (!this._querySocket) { - this._querySocket = _openSocket("0.0.0.0", 0, { - onPacketReceived: this._onPacketReceived.bind(this), - onStopListening: this._onStopListening.bind(this), - }); - } - resolve(this._querySocket); - }); - } - - /** - * Gets a non-exclusive socket on 0.0.0.0:5353 to listen - * for multicast queries/announcements on all interfaces. - * Since this socket needs to listen for multicast queries - * and announcements, this socket joins the multicast - * group on *all* interfaces (0.0.0.0). - */ - _getBroadcastReceiverSocket() { - return new Promise((resolve, reject) => { - if (!this._broadcastReceiverSocket) { - this._broadcastReceiverSocket = _openSocket( - "0.0.0.0", - MDNS_PORT, - { - onPacketReceived: this._onPacketReceived.bind(this), - onStopListening: this._onStopListening.bind(this), - }, - /* multicastInterface = */ "0.0.0.0" - ); - } - resolve(this._broadcastReceiverSocket); - }); - } - - /** - * Gets a non-exclusive socket for each interface on - * {iface-ip}:5353 for sending query responses as - * well as for listening for unicast queries. These - * sockets do not need to join a multicast group - * since they are still able to *send* multicast - * query responses, but they do not need to *listen* - * for multicast queries since the `_querySocket` is - * already handling them. - */ - _getSockets() { - return new Promise(resolve => { - if (this._sockets.size > 0) { - resolve(this._sockets); - return; - } - - Promise.all([getAddresses(), getHostname()]).then(() => { - _addresses.forEach(address => { - let socket = _openSocket(address, MDNS_PORT, null); - this._sockets.set(address, socket); - }); - - resolve(this._sockets); - }); - }); - } - - _checkCloseSockets() { - // Nothing to do if no sockets to close. - if (this._sockets.size == 0) { - return; - } - - // Don't close sockets if discovery listeners are still present. - if (this._listeners.size > 0) { - return; - } - - // Don't close sockets if advertised services are present. - // Since we need to listen for service queries and respond to them. - if (this._services.size > 0) { - return; - } - - this._closeSockets(); - } - - _closeSockets() { - this._sockets.forEach(socket => socket.close()); - this._sockets.clear(); - } - - _onPacketReceived(socket, message) { - let packet = DNSPacket.parse(message.rawData); - - switch (packet.getFlag("QR")) { - case DNS_QUERY_RESPONSE_CODES.QUERY: - this._handleQueryPacket(packet, message); - break; - case DNS_QUERY_RESPONSE_CODES.RESPONSE: - this._handleResponsePacket(packet, message); - break; - default: - break; - } - } - - _onStopListening(socket, status) { - DEBUG && debug("_onStopListening() " + status); - } - - _addServiceListener(serviceType, listener) { - let listeners = this._listeners.get(serviceType); - if (!listeners) { - listeners = []; - this._listeners.set(serviceType, listeners); - } - - if (!listeners.find(l => l === listener)) { - listeners.push(listener); - } - } - - _removeServiceListener(serviceType, listener) { - let listeners = this._listeners.get(serviceType); - if (!listeners) { - return; - } - - let index = listeners.findIndex(l => l === listener); - if (index >= 0) { - listeners.splice(index, 1); - } - - if (listeners.length === 0) { - this._listeners.delete(serviceType); - } - } -} - -let _addresses; - -/** - * @private - */ -function getAddresses() { - return new Promise((resolve, reject) => { - if (_addresses) { - resolve(_addresses); - return; - } - - networkInfoService.listNetworkAddresses({ - onListedNetworkAddresses(aAddressArray) { - _addresses = aAddressArray.filter(address => { - return ( - !address.includes("%p2p") && // No WiFi Direct interfaces - !address.includes(":") && // XXX: No IPv6 for now - address != "127.0.0.1" - ); // No ipv4 loopback addresses. - }); - - DEBUG && debug("getAddresses(): " + _addresses); - resolve(_addresses); - }, - - onListNetworkAddressesFailed() { - DEBUG && debug("getAddresses() FAILED!"); - resolve([]); - }, - }); - }); -} - -let _hostname; - -/** - * @private - */ -function getHostname() { - return new Promise(resolve => { - if (_hostname) { - resolve(_hostname); - return; - } - - networkInfoService.getHostname({ - onGotHostname(aHostname) { - _hostname = aHostname.replace(/\s/g, "-") + ".local"; - - DEBUG && debug("getHostname(): " + _hostname); - resolve(_hostname); - }, - - onGetHostnameFailed() { - DEBUG && debug("getHostname() FAILED"); - resolve("localhost"); - }, - }); - }); -} - -/** - * Parse fully qualified domain name to service name, instance name, - * and domain name. See https://tools.ietf.org/html/rfc6763#section-7. - * - * Example: 'foo-bar-service._http._tcp.local' -> { - * serviceName: 'foo-bar-service', - * serviceType: '_http._tcp', - * domainName: 'local' - * } - * - * @private - */ -function _parseServiceDomainName(serviceDomainName) { - let parts = serviceDomainName.split("."); - let index = Math.max(parts.lastIndexOf("_tcp"), parts.lastIndexOf("_udp")); - - return { - serviceName: parts.splice(0, index - 1).join("."), - serviceType: parts.splice(0, 2).join("."), - domainName: parts.join("."), - }; -} - -/** - * @private - */ -function _propertyBagToObject(propBag) { - let result = {}; - if (propBag.QueryInterface) { - propBag.QueryInterface(Ci.nsIPropertyBag2); - for (let prop of propBag.enumerator) { - result[prop.name] = prop.value.toString(); - } - } else { - for (let name in propBag) { - result[name] = propBag[name].toString(); - } - } - return result; -} - -/** - * @private - */ -function _openSocket(addr, port, handler, multicastInterface) { - let socket = Cc["@mozilla.org/network/udp-socket;1"].createInstance( - Ci.nsIUDPSocket - ); - socket.init2( - addr, - port, - Services.scriptSecurityManager.getSystemPrincipal(), - true - ); - - if (handler) { - socket.asyncListen({ - onPacketReceived: handler.onPacketReceived, - onStopListening: handler.onStopListening, - }); - } - - if (multicastInterface) { - socket.joinMulticast(MDNS_MULTICAST_GROUP, multicastInterface); - } - - return socket; -} diff --git a/netwerk/dns/mdns/libmdns/moz.build b/netwerk/dns/mdns/libmdns/moz.build deleted file mode 100644 index 17110bf8aa13e..0000000000000 --- a/netwerk/dns/mdns/libmdns/moz.build +++ /dev/null @@ -1,48 +0,0 @@ -# -*- 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/. - -if CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa": - UNIFIED_SOURCES += [ - "MDNSResponderOperator.cpp", - "MDNSResponderReply.cpp", - "nsDNSServiceDiscovery.cpp", - ] - - LOCAL_INCLUDES += [ - "/netwerk/base", - ] - -else: - EXTRA_JS_MODULES += [ - "DNSServiceDiscovery.jsm", - "fallback/DataReader.jsm", - "fallback/DataWriter.jsm", - "fallback/DNSPacket.jsm", - "fallback/DNSRecord.jsm", - "fallback/DNSResourceRecord.jsm", - "fallback/DNSTypes.jsm", - "fallback/MulticastDNS.jsm", - ] - - if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android": - EXTRA_JS_MODULES += [ - "MulticastDNSAndroid.jsm", - ] - -UNIFIED_SOURCES += [ - "nsDNSServiceInfo.cpp", -] - -XPCOM_MANIFESTS += [ - "components.conf", -] - -LOCAL_INCLUDES += [ - "/netwerk/protocol/http", # for nsHttpHandler.h -] - -include("/ipc/chromium/chromium-config.mozbuild") -FINAL_LIBRARY = "xul" diff --git a/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.cpp b/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.cpp deleted file mode 100644 index 83a6f1cf2ad75..0000000000000 --- a/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.cpp +++ /dev/null @@ -1,229 +0,0 @@ -/* -*- 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/. */ - -#include "nsDNSServiceDiscovery.h" -#include "MainThreadUtils.h" -#include "MDNSResponderOperator.h" -#include "nsICancelable.h" -#include "nsXULAppAPI.h" -#include "private/pprio.h" - -namespace mozilla { -namespace net { - -namespace { - -inline void StartService() {} - -inline void StopService() {} - -class ServiceCounter { - public: - static bool IsServiceRunning() { return !!sUseCount; } - - private: - static uint32_t sUseCount; - - protected: - ServiceCounter() { - MOZ_ASSERT(NS_IsMainThread()); - if (!sUseCount++) { - StartService(); - } - } - - virtual ~ServiceCounter() { - MOZ_ASSERT(NS_IsMainThread()); - if (!--sUseCount) { - StopService(); - } - } -}; - -uint32_t ServiceCounter::sUseCount = 0; - -class DiscoveryRequest final : public nsICancelable, private ServiceCounter { - public: - NS_DECL_ISUPPORTS - NS_DECL_NSICANCELABLE - - explicit DiscoveryRequest(nsDNSServiceDiscovery* aService, - nsIDNSServiceDiscoveryListener* aListener); - - private: - virtual ~DiscoveryRequest() { Cancel(NS_OK); } - - RefPtr mService; - nsIDNSServiceDiscoveryListener* mListener; -}; - -NS_IMPL_ISUPPORTS(DiscoveryRequest, nsICancelable) - -DiscoveryRequest::DiscoveryRequest(nsDNSServiceDiscovery* aService, - nsIDNSServiceDiscoveryListener* aListener) - : mService(aService), mListener(aListener) {} - -NS_IMETHODIMP -DiscoveryRequest::Cancel(nsresult aReason) { - if (mService) { - mService->StopDiscovery(mListener); - } - - mService = nullptr; - return NS_OK; -} - -class RegisterRequest final : public nsICancelable, private ServiceCounter { - public: - NS_DECL_ISUPPORTS - NS_DECL_NSICANCELABLE - - explicit RegisterRequest(nsDNSServiceDiscovery* aService, - nsIDNSRegistrationListener* aListener); - - private: - virtual ~RegisterRequest() { Cancel(NS_OK); } - - RefPtr mService; - nsIDNSRegistrationListener* mListener; -}; - -NS_IMPL_ISUPPORTS(RegisterRequest, nsICancelable) - -RegisterRequest::RegisterRequest(nsDNSServiceDiscovery* aService, - nsIDNSRegistrationListener* aListener) - : mService(aService), mListener(aListener) {} - -NS_IMETHODIMP -RegisterRequest::Cancel(nsresult aReason) { - if (mService) { - mService->UnregisterService(mListener); - } - - mService = nullptr; - return NS_OK; -} - -} // namespace - -NS_IMPL_ISUPPORTS(nsDNSServiceDiscovery, nsIDNSServiceDiscovery) - -nsresult nsDNSServiceDiscovery::Init() { - if (!XRE_IsParentProcess()) { - MOZ_ASSERT(false, - "nsDNSServiceDiscovery can only be used in parent process"); - return NS_ERROR_FAILURE; - } - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceDiscovery::StartDiscovery(const nsACString& aServiceType, - nsIDNSServiceDiscoveryListener* aListener, - nsICancelable** aRetVal) { - MOZ_ASSERT(aRetVal); - - nsresult rv; - if (NS_WARN_IF(NS_FAILED(rv = StopDiscovery(aListener)))) { - return rv; - } - - nsCOMPtr req = new DiscoveryRequest(this, aListener); - RefPtr browserOp = - new BrowseOperator(aServiceType, aListener); - if (NS_WARN_IF(NS_FAILED(rv = browserOp->Start()))) { - return rv; - } - - mDiscoveryMap.InsertOrUpdate(aListener, std::move(browserOp)); - - req.forget(aRetVal); - - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceDiscovery::StopDiscovery( - nsIDNSServiceDiscoveryListener* aListener) { - nsresult rv; - - RefPtr browserOp; - if (!mDiscoveryMap.Get(aListener, getter_AddRefs(browserOp))) { - return NS_OK; - } - - browserOp->Cancel(); // cancel non-started operation - if (NS_WARN_IF(NS_FAILED(rv = browserOp->Stop()))) { - return rv; - } - - mDiscoveryMap.Remove(aListener); - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceDiscovery::RegisterService(nsIDNSServiceInfo* aServiceInfo, - nsIDNSRegistrationListener* aListener, - nsICancelable** aRetVal) { - MOZ_ASSERT(aRetVal); - - nsresult rv; - if (NS_WARN_IF(NS_FAILED(rv = UnregisterService(aListener)))) { - return rv; - } - - nsCOMPtr req = new RegisterRequest(this, aListener); - RefPtr registerOp = - new RegisterOperator(aServiceInfo, aListener); - if (NS_WARN_IF(NS_FAILED(rv = registerOp->Start()))) { - return rv; - } - - mRegisterMap.InsertOrUpdate(aListener, std::move(registerOp)); - - req.forget(aRetVal); - - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceDiscovery::UnregisterService( - nsIDNSRegistrationListener* aListener) { - nsresult rv; - - RefPtr registerOp; - if (!mRegisterMap.Get(aListener, getter_AddRefs(registerOp))) { - return NS_OK; - } - - registerOp->Cancel(); // cancel non-started operation - if (NS_WARN_IF(NS_FAILED(rv = registerOp->Stop()))) { - return rv; - } - - mRegisterMap.Remove(aListener); - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceDiscovery::ResolveService(nsIDNSServiceInfo* aServiceInfo, - nsIDNSServiceResolveListener* aListener) { - if (!ServiceCounter::IsServiceRunning()) { - return NS_ERROR_FAILURE; - } - - nsresult rv; - - RefPtr resolveOp = - new ResolveOperator(aServiceInfo, aListener); - if (NS_WARN_IF(NS_FAILED(rv = resolveOp->Start()))) { - return rv; - } - - return NS_OK; -} - -} // namespace net -} // namespace mozilla diff --git a/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.h b/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.h deleted file mode 100644 index 0acc9198bde40..0000000000000 --- a/netwerk/dns/mdns/libmdns/nsDNSServiceDiscovery.h +++ /dev/null @@ -1,47 +0,0 @@ -/* -*- 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_netwerk_dns_mdns_libmdns_nsDNSServiceDiscovery_h -#define mozilla_netwerk_dns_mdns_libmdns_nsDNSServiceDiscovery_h - -#include "nsIDNSServiceDiscovery.h" -#include "nsCOMPtr.h" -#include "mozilla/RefPtr.h" -#include "nsRefPtrHashtable.h" - -namespace mozilla { -namespace net { - -class BrowseOperator; -class RegisterOperator; - -class nsDNSServiceDiscovery final : public nsIDNSServiceDiscovery { - public: - NS_DECL_THREADSAFE_ISUPPORTS - NS_DECL_NSIDNSSERVICEDISCOVERY - - explicit nsDNSServiceDiscovery() = default; - - /* - ** The mDNS service is started on demand. If no one uses, mDNS service will - ** not start. Therefore, all operations before service started will fail - ** and get error code |kDNSServiceErr_ServiceNotRunning| defined in dns_sd.h. - **/ - nsresult Init(); - - nsresult StopDiscovery(nsIDNSServiceDiscoveryListener* aListener); - nsresult UnregisterService(nsIDNSRegistrationListener* aListener); - - private: - virtual ~nsDNSServiceDiscovery() = default; - - nsRefPtrHashtable mDiscoveryMap; - nsRefPtrHashtable mRegisterMap; -}; - -} // namespace net -} // namespace mozilla - -#endif // mozilla_netwerk_dns_mdns_libmdns_nsDNSServiceDiscovery_h diff --git a/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.cpp b/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.cpp deleted file mode 100644 index 81de0891164e5..0000000000000 --- a/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.cpp +++ /dev/null @@ -1,170 +0,0 @@ -/* -*- 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/. */ - -#include "nsDNSServiceInfo.h" -#include "nsHashPropertyBag.h" -#include "nsIProperty.h" -#include "nsISimpleEnumerator.h" -#include "nsISupportsImpl.h" -#include "mozilla/Unused.h" - -namespace mozilla { -namespace net { - -NS_IMPL_ISUPPORTS(nsDNSServiceInfo, nsIDNSServiceInfo) - -nsDNSServiceInfo::nsDNSServiceInfo(nsIDNSServiceInfo* aServiceInfo) { - if (NS_WARN_IF(!aServiceInfo)) { - return; - } - - nsAutoCString str; - uint16_t value; - - if (NS_SUCCEEDED(aServiceInfo->GetHost(str))) { - Unused << NS_WARN_IF(NS_FAILED(SetHost(str))); - } - if (NS_SUCCEEDED(aServiceInfo->GetAddress(str))) { - Unused << NS_WARN_IF(NS_FAILED(SetAddress(str))); - } - if (NS_SUCCEEDED(aServiceInfo->GetPort(&value))) { - Unused << NS_WARN_IF(NS_FAILED(SetPort(value))); - } - if (NS_SUCCEEDED(aServiceInfo->GetServiceName(str))) { - Unused << NS_WARN_IF(NS_FAILED(SetServiceName(str))); - } - if (NS_SUCCEEDED(aServiceInfo->GetServiceType(str))) { - Unused << NS_WARN_IF(NS_FAILED(SetServiceType(str))); - } - if (NS_SUCCEEDED(aServiceInfo->GetDomainName(str))) { - Unused << NS_WARN_IF(NS_FAILED(SetDomainName(str))); - } - - nsCOMPtr attributes; // deep copy - if (NS_SUCCEEDED(aServiceInfo->GetAttributes(getter_AddRefs(attributes)))) { - RefPtr newAttributes = new nsHashPropertyBag(); - newAttributes->CopyFrom(attributes); - Unused << NS_WARN_IF(NS_FAILED(SetAttributes(newAttributes))); - } -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetHost(nsACString& aHost) { - if (!mIsHostSet) { - return NS_ERROR_NOT_INITIALIZED; - } - aHost = mHost; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetHost(const nsACString& aHost) { - mHost = aHost; - mIsHostSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetAddress(nsACString& aAddress) { - if (!mIsAddressSet) { - return NS_ERROR_NOT_INITIALIZED; - } - aAddress = mAddress; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetAddress(const nsACString& aAddress) { - mAddress = aAddress; - mIsAddressSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetPort(uint16_t* aPort) { - if (NS_WARN_IF(!aPort)) { - return NS_ERROR_INVALID_ARG; - } - if (!mIsPortSet) { - return NS_ERROR_NOT_INITIALIZED; - } - *aPort = mPort; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetPort(uint16_t aPort) { - mPort = aPort; - mIsPortSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetServiceName(nsACString& aServiceName) { - if (!mIsServiceNameSet) { - return NS_ERROR_NOT_INITIALIZED; - } - aServiceName = mServiceName; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetServiceName(const nsACString& aServiceName) { - mServiceName = aServiceName; - mIsServiceNameSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetServiceType(nsACString& aServiceType) { - if (!mIsServiceTypeSet) { - return NS_ERROR_NOT_INITIALIZED; - } - aServiceType = mServiceType; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetServiceType(const nsACString& aServiceType) { - mServiceType = aServiceType; - mIsServiceTypeSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetDomainName(nsACString& aDomainName) { - if (!mIsDomainNameSet) { - return NS_ERROR_NOT_INITIALIZED; - } - aDomainName = mDomainName; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetDomainName(const nsACString& aDomainName) { - mDomainName = aDomainName; - mIsDomainNameSet = true; - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::GetAttributes(nsIPropertyBag2** aAttributes) { - if (!mIsAttributesSet) { - return NS_ERROR_NOT_INITIALIZED; - } - nsCOMPtr attributes(mAttributes); - attributes.forget(aAttributes); - return NS_OK; -} - -NS_IMETHODIMP -nsDNSServiceInfo::SetAttributes(nsIPropertyBag2* aAttributes) { - mAttributes = aAttributes; - mIsAttributesSet = aAttributes != nullptr; - return NS_OK; -} - -} // namespace net -} // namespace mozilla diff --git a/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h b/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h deleted file mode 100644 index 31fffcc74e499..0000000000000 --- a/netwerk/dns/mdns/libmdns/nsDNSServiceInfo.h +++ /dev/null @@ -1,49 +0,0 @@ -/* -*- 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_netwerk_dns_mdns_libmdns_nsDNSServiceInfo_h -#define mozilla_netwerk_dns_mdns_libmdns_nsDNSServiceInfo_h - -#include "nsCOMPtr.h" -#include "nsIDNSServiceDiscovery.h" -#include "nsIPropertyBag2.h" -#include "nsString.h" - -namespace mozilla { -namespace net { - -class nsDNSServiceInfo final : public nsIDNSServiceInfo { - public: - NS_DECL_ISUPPORTS - NS_DECL_NSIDNSSERVICEINFO - - explicit nsDNSServiceInfo() = default; - explicit nsDNSServiceInfo(nsIDNSServiceInfo* aServiceInfo); - - private: - virtual ~nsDNSServiceInfo() = default; - - private: - nsCString mHost; - nsCString mAddress; - uint16_t mPort = 0; - nsCString mServiceName; - nsCString mServiceType; - nsCString mDomainName; - nsCOMPtr mAttributes; - - bool mIsHostSet = false; - bool mIsAddressSet = false; - bool mIsPortSet = false; - bool mIsServiceNameSet = false; - bool mIsServiceTypeSet = false; - bool mIsDomainNameSet = false; - bool mIsAttributesSet = false; -}; - -} // namespace net -} // namespace mozilla - -#endif // mozilla_netwerk_dns_mdns_libmdns_nsDNSServiceInfo_h diff --git a/netwerk/dns/mdns/moz.build b/netwerk/dns/mdns/moz.build deleted file mode 100644 index 561031af9645f..0000000000000 --- a/netwerk/dns/mdns/moz.build +++ /dev/null @@ -1,13 +0,0 @@ -# -*- 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/. - -DIRS += ["libmdns"] - -XPIDL_SOURCES += [ - "nsIDNSServiceDiscovery.idl", -] - -XPIDL_MODULE = "necko_mdns" diff --git a/netwerk/dns/mdns/nsIDNSServiceDiscovery.idl b/netwerk/dns/mdns/nsIDNSServiceDiscovery.idl deleted file mode 100644 index 23c678ecccdbe..0000000000000 --- a/netwerk/dns/mdns/nsIDNSServiceDiscovery.idl +++ /dev/null @@ -1,219 +0,0 @@ -/* 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 "nsISupports.idl" - -interface nsICancelable; -interface nsIPropertyBag2; - -/** - * Service information - */ -[scriptable, uuid(670ed0f9-2fa5-4544-bf1e-ea58ac179374)] -interface nsIDNSServiceInfo : nsISupports -{ - /** - * The host name of the service. (E.g. "Android.local.") - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute AUTF8String host; - - /** - * The IP address of the service. - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute AUTF8String address; - - /** - * The port number of the service. (E.g. 80) - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute unsigned short port; - - /** - * The service name of the service for display. (E.g. "My TV") - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute AUTF8String serviceName; - - /** - * The type of the service. (E.g. "_http._tcp") - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute AUTF8String serviceType; - - /** - * The domain name of the service. (E.g. "local.") - * @throws NS_ERROR_NOT_INITIALIZED when getting unset value. - */ - attribute AUTF8String domainName; - - /** - * The attributes of the service. - */ - attribute nsIPropertyBag2 attributes; -}; - -/** - * The callback interface for service discovery - */ -[scriptable, uuid(3025b7f2-97bb-435b-b43d-26731b3f5fc4)] -interface nsIDNSServiceDiscoveryListener : nsISupports -{ - /** - * Callback when the discovery begins. - * @param aServiceType - * the service type of |startDiscovery|. - */ - void onDiscoveryStarted(in AUTF8String aServiceType); - - /** - * Callback when the discovery ends. - * @param aServiceType - * the service type of |startDiscovery|. - */ - void onDiscoveryStopped(in AUTF8String aServiceType); - - /** - * Callback when the a service is found. - * @param aServiceInfo - * the info about the found service, where |serviceName|, |aServiceType|, and |domainName| are set. - */ - void onServiceFound(in nsIDNSServiceInfo aServiceInfo); - - /** - * Callback when the a service is lost. - * @param aServiceInfo - * the info about the lost service, where |serviceName|, |aServiceType|, and |domainName| are set. - */ - void onServiceLost(in nsIDNSServiceInfo aServiceInfo); - - /** - * Callback when the discovery cannot start. - * @param aServiceType - * the service type of |startDiscovery|. - * @param aErrorCode - * the error code. - */ - void onStartDiscoveryFailed(in AUTF8String aServiceType, in long aErrorCode); - - /** - * Callback when the discovery cannot stop. - * @param aServiceType - * the service type of |startDiscovery|. - * @param aErrorCode - * the error code. - */ - void onStopDiscoveryFailed(in AUTF8String aServiceType, in long aErrorCode); -}; - -/** - * The callback interface for service registration - */ -[scriptable, uuid(e165e4be-abf4-4963-a66d-ed3ca116e5e4)] -interface nsIDNSRegistrationListener : nsISupports -{ - const long ERROR_SERVICE_NOT_RUNNING = -65563; - - /** - * Callback when the service is registered successfully. - * @param aServiceInfo - * the info about the registered service, - * where |serviceName|, |aServiceType|, and |domainName| are set. - */ - void onServiceRegistered(in nsIDNSServiceInfo aServiceInfo); - - /** - * Callback when the service is unregistered successfully. - * @param aServiceInfo - * the info about the unregistered service. - */ - void onServiceUnregistered(in nsIDNSServiceInfo aServiceInfo); - - /** - * Callback when the service cannot be registered. - * @param aServiceInfo - * the info about the service to be registered. - * @param aErrorCode - * the error code. - */ - void onRegistrationFailed(in nsIDNSServiceInfo aServiceInfo, in long aErrorCode); - - /** - * Callback when the service cannot be unregistered. - * @param aServiceInfo - * the info about the registered service. - * @param aErrorCode - * the error code. - */ - void onUnregistrationFailed(in nsIDNSServiceInfo aServiceInfo, in long aErrorCode); -}; - -/** - * The callback interface for service resolve - */ -[scriptable, uuid(24ee6408-648e-421d-accf-c6e5adeccf97)] -interface nsIDNSServiceResolveListener : nsISupports -{ - /** - * Callback when the service is resolved successfully. - * @param aServiceInfo - * the info about the resolved service, where |host| and |port| are set. - */ - void onServiceResolved(in nsIDNSServiceInfo aServiceInfo); - - /** - * Callback when the service cannot be resolved. - * @param aServiceInfo - * the info about the service to be resolved. - * @param aErrorCode - * the error code. - */ - void onResolveFailed(in nsIDNSServiceInfo aServiceInfo, in long aErrorCode); -}; - -/** - * The interface for DNS service discovery/registration/resolve - */ -[scriptable, uuid(6487899b-beb1-455a-ba65-e4fd465066d7)] -interface nsIDNSServiceDiscovery : nsISupports -{ - /** - * Browse for instances of a service. - * @param aServiceType - * the service type to be discovered, E.g. "_http._tcp". - * @param aListener - * callback interface for discovery notifications. - * @return An object that can be used to cancel the service discovery. - */ - nsICancelable startDiscovery(in AUTF8String aServiceType, in nsIDNSServiceDiscoveryListener aListener); - - /** - * Register a service that is discovered via |startDiscovery| and |resolveService| calls. - * @param aServiceInfo - * the service information to be registered. - * |port| and |aServiceType| are required attributes. - * @param aListener - * callback interface for registration notifications. - * @return An object that can be used to cancel the service registration. - */ - nsICancelable registerService(in nsIDNSServiceInfo aServiceInfo, in nsIDNSRegistrationListener aListener); - - /** - * Resolve a service name discovered via |startDiscovery| to a target host name, port number. - * @param aServiceInfo - * the service information to be registered. - * |serviceName|, |aServiceType|, and |domainName| are required attributes as reported to the |onServiceFound| callback. - * @param aListener - * callback interface for registration notifications. - */ - void resolveService(in nsIDNSServiceInfo aServiceInfo, in nsIDNSServiceResolveListener aListener); -}; - -%{ C++ -#define DNSSERVICEDISCOVERY_CONTRACT_ID \ - "@mozilla.org/toolkit/components/mdnsresponder/dns-sd;1" -#define DNSSERVICEINFO_CONTRACT_ID \ - "@mozilla.org/toolkit/components/mdnsresponder/dns-info;1" -%} diff --git a/netwerk/dns/moz.build b/netwerk/dns/moz.build index f769e270faf73..860b5c0532869 100644 --- a/netwerk/dns/moz.build +++ b/netwerk/dns/moz.build @@ -7,7 +7,7 @@ with Files("**"): BUG_COMPONENT = ("Core", "Networking: DNS") -DIRS += ["mdns", "tests"] +DIRS += ["tests"] XPIDL_SOURCES += [ "nsIDNSByTypeRecord.idl",