From 787a21b6febda6fcfa8e4e5c391f3d09c6b73c14 Mon Sep 17 00:00:00 2001 From: Vivien Nicolas Date: Thu, 2 Dec 2021 10:15:00 +0100 Subject: [PATCH] Add a ResolveProxy class to keep track of which controller is issuing a dns request --- src/app/CASESessionManager.cpp | 6 +- src/app/CASESessionManager.h | 3 +- src/app/OperationalDeviceProxy.cpp | 6 +- src/app/OperationalDeviceProxy.h | 4 +- .../clusters/ota-requestor/OTARequestor.cpp | 2 +- .../AbstractDnssdDiscoveryController.cpp | 9 - .../AbstractDnssdDiscoveryController.h | 12 +- .../CHIPCommissionableNodeController.cpp | 17 +- .../CHIPCommissionableNodeController.h | 5 +- src/controller/CHIPDeviceController.cpp | 25 +- src/controller/CHIPDeviceController.h | 1 + .../CHIPDeviceControllerFactory.cpp | 11 + src/lib/dnssd/Discovery_ImplPlatform.cpp | 252 +++++++++--------- src/lib/dnssd/Discovery_ImplPlatform.h | 14 +- src/lib/dnssd/ResolverProxy.h | 69 +++++ src/lib/dnssd/Resolver_ImplMinimalMdns.cpp | 19 ++ 16 files changed, 274 insertions(+), 181 deletions(-) create mode 100644 src/lib/dnssd/ResolverProxy.h diff --git a/src/app/CASESessionManager.cpp b/src/app/CASESessionManager.cpp index 19cc27dc31c4fd..5ce5f23c5cfa8d 100644 --- a/src/app/CASESessionManager.cpp +++ b/src/app/CASESessionManager.cpp @@ -53,7 +53,7 @@ CHIP_ERROR CASESessionManager::FindOrEstablishSession(NodeId nodeId, Callback::C session->OnNodeIdResolved(resolutionData); } - CHIP_ERROR err = session->Connect(onConnection, onFailure); + CHIP_ERROR err = session->Connect(onConnection, onFailure, mConfig.dnsResolver); if (err != CHIP_NO_ERROR) { ReleaseSession(session); @@ -69,8 +69,8 @@ void CASESessionManager::ReleaseSession(NodeId nodeId) CHIP_ERROR CASESessionManager::ResolveDeviceAddress(NodeId nodeId) { - return Dnssd::Resolver::Instance().ResolveNodeId(GetFabricInfo()->GetPeerIdForNode(nodeId), Inet::IPAddressType::kAny, - Dnssd::Resolver::CacheBypass::On); + return mConfig.dnsResolver->ResolveNodeId(GetFabricInfo()->GetPeerIdForNode(nodeId), Inet::IPAddressType::kAny, + Dnssd::Resolver::CacheBypass::On); } void CASESessionManager::OnNodeIdResolved(const Dnssd::ResolvedNodeData & nodeData) diff --git a/src/app/CASESessionManager.h b/src/app/CASESessionManager.h index bf771945348875..72d710d9526017 100644 --- a/src/app/CASESessionManager.h +++ b/src/app/CASESessionManager.h @@ -25,13 +25,14 @@ #include #include -#include +#include namespace chip { struct CASESessionManagerConfig { DeviceProxyInitParams sessionInitParams; + Dnssd::ResolverProxy * dnsResolver = nullptr; Dnssd::DnssdCache * dnsCache = nullptr; }; diff --git a/src/app/OperationalDeviceProxy.cpp b/src/app/OperationalDeviceProxy.cpp index b308764ea065cd..10ac6601e893e8 100644 --- a/src/app/OperationalDeviceProxy.cpp +++ b/src/app/OperationalDeviceProxy.cpp @@ -41,7 +41,8 @@ using namespace chip::Callback; namespace chip { CHIP_ERROR OperationalDeviceProxy::Connect(Callback::Callback * onConnection, - Callback::Callback * onFailure) + Callback::Callback * onFailure, + Dnssd::ResolverProxy * resolver) { CHIP_ERROR err = CHIP_NO_ERROR; @@ -52,7 +53,8 @@ CHIP_ERROR OperationalDeviceProxy::Connect(Callback::Callback break; case State::NeedsAddress: - err = Dnssd::Resolver::Instance().ResolveNodeId(mPeerId, chip::Inet::IPAddressType::kAny); + VerifyOrReturnError(resolver != nullptr, CHIP_ERROR_INVALID_ARGUMENT); + err = resolver->ResolveNodeId(mPeerId, chip::Inet::IPAddressType::kAny); EnqueueConnectionCallbacks(onConnection, onFailure); break; diff --git a/src/app/OperationalDeviceProxy.h b/src/app/OperationalDeviceProxy.h index 5e60c30e9aec32..0209ce08218229 100644 --- a/src/app/OperationalDeviceProxy.h +++ b/src/app/OperationalDeviceProxy.h @@ -40,7 +40,7 @@ #include #include -#include +#include namespace chip { @@ -103,7 +103,7 @@ class DLL_EXPORT OperationalDeviceProxy : public DeviceProxy, SessionReleaseDele * If the session already exists, `onConnection` will be called immediately. */ CHIP_ERROR Connect(Callback::Callback * onConnection, - Callback::Callback * onFailure); + Callback::Callback * onFailure, Dnssd::ResolverProxy * resolver); bool IsConnected() const { return mState == State::SecureConnected; } diff --git a/src/app/clusters/ota-requestor/OTARequestor.cpp b/src/app/clusters/ota-requestor/OTARequestor.cpp index cc489768065bfa..5e1306239df092 100644 --- a/src/app/clusters/ota-requestor/OTARequestor.cpp +++ b/src/app/clusters/ota-requestor/OTARequestor.cpp @@ -284,7 +284,7 @@ void OTARequestor::ConnectToProvider() PeerAddress addr = PeerAddress::UDP(mIpAddress, CHIP_PORT); operationalDeviceProxy->UpdateDeviceData(addr, operationalDeviceProxy->GetMRPConfig()); - CHIP_ERROR err = operationalDeviceProxy->Connect(&mOnConnectedCallback, &mOnConnectionFailureCallback); + CHIP_ERROR err = operationalDeviceProxy->Connect(&mOnConnectedCallback, &mOnConnectionFailureCallback, nullptr); if (err != CHIP_NO_ERROR) { ChipLogError(SoftwareUpdate, "Cannot establish connection to peer device: %" CHIP_ERROR_FORMAT, err.Format()); diff --git a/src/controller/AbstractDnssdDiscoveryController.cpp b/src/controller/AbstractDnssdDiscoveryController.cpp index 8d34292df1bb02..924ca6183086c0 100644 --- a/src/controller/AbstractDnssdDiscoveryController.cpp +++ b/src/controller/AbstractDnssdDiscoveryController.cpp @@ -19,10 +19,6 @@ // module header, comes first #include -#if CONFIG_DEVICE_LAYER -#include -#endif - #include #include @@ -66,11 +62,6 @@ void AbstractDnssdDiscoveryController::OnNodeDiscoveryComplete(const chip::Dnssd CHIP_ERROR AbstractDnssdDiscoveryController::SetUpNodeDiscovery() { -#if CONFIG_DEVICE_LAYER - ReturnErrorOnFailure(mResolver->Init(&DeviceLayer::InetLayer())); -#endif - mResolver->SetResolverDelegate(this); - auto discoveredNodes = GetDiscoveredNodes(); for (auto & discoveredNode : discoveredNodes) { diff --git a/src/controller/AbstractDnssdDiscoveryController.h b/src/controller/AbstractDnssdDiscoveryController.h index aae783c5bb79b9..30d60d8cf03ded 100644 --- a/src/controller/AbstractDnssdDiscoveryController.h +++ b/src/controller/AbstractDnssdDiscoveryController.h @@ -19,7 +19,7 @@ #pragma once #include -#include +#include #include #include @@ -39,11 +39,7 @@ namespace Controller { class DLL_EXPORT AbstractDnssdDiscoveryController : public Dnssd::ResolverDelegate { public: - AbstractDnssdDiscoveryController(chip::Dnssd::Resolver * resolver = &chip::Dnssd::Resolver::Instance()) - { - mResolver = resolver; - } - + AbstractDnssdDiscoveryController() {} virtual ~AbstractDnssdDiscoveryController() {} void OnNodeDiscoveryComplete(const chip::Dnssd::DiscoveredNodeData & nodeData) override; @@ -52,9 +48,9 @@ class DLL_EXPORT AbstractDnssdDiscoveryController : public Dnssd::ResolverDelega using DiscoveredNodeList = FixedSpan; CHIP_ERROR SetUpNodeDiscovery(); const Dnssd::DiscoveredNodeData * GetDiscoveredNode(int idx); - virtual DiscoveredNodeList GetDiscoveredNodes() = 0; - chip::Dnssd::Resolver * mResolver; + virtual DiscoveredNodeList GetDiscoveredNodes() = 0; DeviceDiscoveryDelegate * mDeviceDiscoveryDelegate = nullptr; + Dnssd::ResolverProxy mDNSResolver{ this }; }; } // namespace Controller diff --git a/src/controller/CHIPCommissionableNodeController.cpp b/src/controller/CHIPCommissionableNodeController.cpp index 34d892db70f31c..9a0c3ab96ac96f 100644 --- a/src/controller/CHIPCommissionableNodeController.cpp +++ b/src/controller/CHIPCommissionableNodeController.cpp @@ -19,6 +19,10 @@ // module header, comes first #include +#if CONFIG_DEVICE_LAYER +#include +#endif + #include namespace chip { @@ -27,7 +31,18 @@ namespace Controller { CHIP_ERROR CommissionableNodeController::DiscoverCommissioners(Dnssd::DiscoveryFilter discoveryFilter) { ReturnErrorOnFailure(SetUpNodeDiscovery()); - return mResolver->FindCommissioners(discoveryFilter); + + if (mResolver == nullptr) + { + return mDNSResolver.FindCommissioners(discoveryFilter); + } + else + { +#if CONFIG_DEVICE_LAYER + ReturnErrorOnFailure(mResolver->Init(&DeviceLayer::InetLayer())); +#endif + return mResolver->FindCommissioners(discoveryFilter); + } } const Dnssd::DiscoveredNodeData * CommissionableNodeController::GetDiscoveredCommissioner(int idx) diff --git a/src/controller/CHIPCommissionableNodeController.h b/src/controller/CHIPCommissionableNodeController.h index 8bafe788e8ef9e..af57d1d6abe223 100644 --- a/src/controller/CHIPCommissionableNodeController.h +++ b/src/controller/CHIPCommissionableNodeController.h @@ -19,7 +19,6 @@ #pragma once #include -#include #include #include @@ -37,8 +36,7 @@ namespace Controller { class DLL_EXPORT CommissionableNodeController : public AbstractDnssdDiscoveryController { public: - CommissionableNodeController(chip::Dnssd::Resolver * resolver = &chip::Dnssd::Resolver::Instance()) : - AbstractDnssdDiscoveryController(resolver){}; + CommissionableNodeController(chip::Dnssd::Resolver * resolver = nullptr) : mResolver(resolver) {} virtual ~CommissionableNodeController() {} CHIP_ERROR DiscoverCommissioners(Dnssd::DiscoveryFilter discoveryFilter = Dnssd::DiscoveryFilter()); @@ -66,6 +64,7 @@ class DLL_EXPORT CommissionableNodeController : public AbstractDnssdDiscoveryCon DiscoveredNodeList GetDiscoveredNodes() override { return DiscoveredNodeList(mDiscoveredCommissioners); } private: + Dnssd::Resolver * mResolver = nullptr; Dnssd::DiscoveredNodeData mDiscoveredCommissioners[CHIP_DEVICE_CONFIG_MAX_DISCOVERED_NODES]; }; diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 1157992b489109..d4d81bd9985ff2 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -45,7 +45,6 @@ #include #include -#include #include #include #include @@ -132,14 +131,11 @@ CHIP_ERROR DeviceController::Init(ControllerInitParams params) VerifyOrReturnError(params.systemState->TransportMgr() != nullptr, CHIP_ERROR_INVALID_ARGUMENT); #if CHIP_DEVICE_CONFIG_ENABLE_DNSSD - Dnssd::Resolver::Instance().Init(params.systemState->InetLayer()); - Dnssd::Resolver::Instance().SetResolverDelegate(this); + mDNSResolver.Init(); RegisterDeviceAddressUpdateDelegate(params.deviceAddressUpdateDelegate); RegisterDeviceDiscoveryDelegate(params.deviceDiscoveryDelegate); #endif // CHIP_DEVICE_CONFIG_ENABLE_DNSSD - InitDataModelHandler(params.systemState->ExchangeMgr()); - VerifyOrReturnError(params.operationalCredentialsDelegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT); mOperationalCredentialsDelegate = params.operationalCredentialsDelegate; @@ -156,7 +152,12 @@ CHIP_ERROR DeviceController::Init(ControllerInitParams params) CASESessionManagerConfig sessionManagerConfig = { .sessionInitParams = deviceInitParams, - .dnsCache = &mDNSCache, +#if CHIP_DEVICE_CONFIG_ENABLE_DNSSD + .dnsResolver = &mDNSResolver, +#else + .dnsResolver = nullptr, +#endif + .dnsCache = &mDNSCache, }; mCASESessionManager = chip::Platform::New(sessionManagerConfig); @@ -224,10 +225,6 @@ CHIP_ERROR DeviceController::Shutdown() mState = State::NotInitialized; -#if CHIP_DEVICE_CONFIG_ENABLE_DNSSD - Dnssd::Resolver::Instance().Shutdown(); -#endif // CHIP_DEVICE_CONFIG_ENABLE_DNSSD - mStorageDelegate = nullptr; mSystemState->Fabrics()->ReleaseFabricIndex(mFabricIndex); @@ -235,7 +232,7 @@ CHIP_ERROR DeviceController::Shutdown() mSystemState = nullptr; #if CHIP_DEVICE_CONFIG_ENABLE_DNSSD - Dnssd::Resolver::Instance().SetResolverDelegate(nullptr); + mDNSResolver.Shutdown(); mDeviceAddressUpdateDelegate = nullptr; mDeviceDiscoveryDelegate = nullptr; #endif // CHIP_DEVICE_CONFIG_ENABLE_DNSSD @@ -1518,7 +1515,7 @@ void DeviceCommissioner::OnSessionEstablishmentTimeoutCallback(System::Layer * a CHIP_ERROR DeviceCommissioner::DiscoverCommissionableNodes(Dnssd::DiscoveryFilter filter) { ReturnErrorOnFailure(SetUpNodeDiscovery()); - return chip::Dnssd::Resolver::Instance().FindCommissionableNodes(filter); + return mDNSResolver.FindCommissionableNodes(filter); } const Dnssd::DiscoveredNodeData * DeviceCommissioner::GetDiscoveredDevice(int idx) @@ -1780,7 +1777,7 @@ void DeviceCommissioner::AdvanceCommissioningStage(CHIP_ERROR err) #if CONFIG_DEVICE_LAYER status = DeviceLayer::ConfigurationMgr().GetCountryCode(countryCodeStr, kMaxCountryCodeSize, actualCountryCodeSize); #else - status = CHIP_ERROR_NOT_IMPLEMENTED; + status = CHIP_ERROR_NOT_IMPLEMENTED; #endif if (status != CHIP_NO_ERROR) { @@ -1837,7 +1834,7 @@ void DeviceCommissioner::AdvanceCommissioningStage(CHIP_ERROR err) RendezvousCleanup(CHIP_NO_ERROR); #if CHIP_DEVICE_CONFIG_ENABLE_DNSSD ChipLogProgress(Controller, "Finding node on operational network"); - Dnssd::Resolver::Instance().ResolveNodeId(peerId, Inet::IPAddressType::kAny); + mDNSResolver.ResolveNodeId(peerId, Inet::IPAddressType::kAny); #endif } break; diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 32606dc11a4dcd..48b0c99397f9bb 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -69,6 +69,7 @@ #include #include #include +#include #endif namespace chip { diff --git a/src/controller/CHIPDeviceControllerFactory.cpp b/src/controller/CHIPDeviceControllerFactory.cpp index df423e1b4620f3..50faf4ec3619fb 100644 --- a/src/controller/CHIPDeviceControllerFactory.cpp +++ b/src/controller/CHIPDeviceControllerFactory.cpp @@ -24,6 +24,7 @@ #include +#include #include #if CONFIG_DEVICE_LAYER @@ -140,9 +141,15 @@ CHIP_ERROR DeviceControllerFactory::InitSystemState(FactoryInitParams params) ReturnErrorOnFailure(stateParams.exchangeMgr->Init(stateParams.sessionMgr)); ReturnErrorOnFailure(stateParams.messageCounterManager->Init(stateParams.exchangeMgr)); + InitDataModelHandler(stateParams.exchangeMgr); + stateParams.imDelegate = params.imDelegate; ReturnErrorOnFailure(chip::app::InteractionModelEngine::GetInstance()->Init(stateParams.exchangeMgr, stateParams.imDelegate)); +#if CHIP_DEVICE_CONFIG_ENABLE_DNSSD + ReturnErrorOnFailure(Dnssd::Resolver::Instance().Init(stateParams.inetLayer)); +#endif // CHIP_DEVICE_CONFIG_ENABLE_DNSSD + // store the system state mSystemState = chip::Platform::New(stateParams); ChipLogDetail(Controller, "System State Initialized..."); @@ -220,6 +227,10 @@ CHIP_ERROR DeviceControllerSystemState::Shutdown() ChipLogDetail(Controller, "Shutting down the System State, this will teardown the CHIP Stack"); +#if CHIP_DEVICE_CONFIG_ENABLE_DNSSD + Dnssd::Resolver::Instance().Shutdown(); +#endif // CHIP_DEVICE_CONFIG_ENABLE_DNSSD + // Shut down the interaction model app::InteractionModelEngine::GetInstance()->Shutdown(); diff --git a/src/lib/dnssd/Discovery_ImplPlatform.cpp b/src/lib/dnssd/Discovery_ImplPlatform.cpp index 0f564488f1d126..5cf39aa4b7150d 100644 --- a/src/lib/dnssd/Discovery_ImplPlatform.cpp +++ b/src/lib/dnssd/Discovery_ImplPlatform.cpp @@ -36,10 +36,94 @@ namespace chip { namespace Dnssd { -DiscoveryImplPlatform DiscoveryImplPlatform::sManager; +namespace { + +#if CHIP_CONFIG_MDNS_CACHE_SIZE > 0 +static DnssdCache sDnssdCache; +#endif + +static void HandleNodeResolve(void * context, DnssdService * result, CHIP_ERROR error) +{ + VerifyOrReturn(CHIP_NO_ERROR == error); + + DiscoveredNodeData nodeData; + Platform::CopyString(nodeData.hostName, result->mHostName); + Platform::CopyString(nodeData.instanceName, result->mName); + + if (result->mAddress.HasValue() && nodeData.numIPs < DiscoveredNodeData::kMaxIPAddresses) + { + nodeData.ipAddress[nodeData.numIPs] = result->mAddress.Value(); + nodeData.interfaceId[nodeData.numIPs] = result->mInterface; + nodeData.numIPs++; + } + + nodeData.port = result->mPort; + + for (size_t i = 0; i < result->mTextEntrySize; ++i) + { + ByteSpan key(reinterpret_cast(result->mTextEntries[i].mKey), strlen(result->mTextEntries[i].mKey)); + ByteSpan val(result->mTextEntries[i].mData, result->mTextEntries[i].mDataSize); + FillNodeDataFromTxt(key, val, nodeData); + } + + ResolverProxy * proxy = static_cast(context); + proxy->OnNodeDiscoveryComplete(nodeData); +} + +static void HandleNodeIdResolve(void * context, DnssdService * result, CHIP_ERROR error) +{ + ResolverProxy * proxy = static_cast(context); + VerifyOrReturn(CHIP_NO_ERROR == error, proxy->OnNodeIdResolutionFailed(PeerId(), error)); + VerifyOrReturn(result != nullptr, proxy->OnNodeIdResolutionFailed(PeerId(), CHIP_ERROR_UNKNOWN_RESOURCE_ID)); + + PeerId peerId; + VerifyOrReturn(CHIP_NO_ERROR == ExtractIdFromInstanceName(result->mName, &peerId), + proxy->OnNodeIdResolutionFailed(PeerId(), error)); + + ResolvedNodeData nodeData; + Platform::CopyString(nodeData.mHostName, result->mHostName); + nodeData.mInterfaceId = result->mInterface; + nodeData.mAddress[0] = result->mAddress.ValueOr({}); + nodeData.mPort = result->mPort; + nodeData.mNumIPs = 1; + nodeData.mPeerId = peerId; + // TODO: Use seconds? + const System::Clock::Timestamp currentTime = System::SystemClock().GetMonotonicTimestamp(); + + nodeData.mExpiryTime = currentTime + System::Clock::Seconds16(result->mTtlSeconds); + + for (size_t i = 0; i < result->mTextEntrySize; ++i) + { + ByteSpan key(reinterpret_cast(result->mTextEntries[i].mKey), strlen(result->mTextEntries[i].mKey)); + ByteSpan val(result->mTextEntries[i].mData, result->mTextEntries[i].mDataSize); + FillNodeDataFromTxt(key, val, nodeData); + } + + nodeData.LogNodeIdResolved(); #if CHIP_CONFIG_MDNS_CACHE_SIZE > 0 -DnssdCache DiscoveryImplPlatform::sDnssdCache; + LogErrorOnFailure(sDnssdCache.Insert(nodeData)); #endif + proxy->OnNodeIdResolved(nodeData); +} + +static void HandleNodeBrowse(void * context, DnssdService * services, size_t servicesSize, CHIP_ERROR error) +{ + for (size_t i = 0; i < servicesSize; ++i) + { + // For some platforms browsed services are already resolved, so verify if resolve is really needed or call resolve callback + if (!services[i].mAddress.HasValue()) + { + ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context); + } + else + { + HandleNodeResolve(context, &services[i], error); + } + } +} +} // namespace + +DiscoveryImplPlatform DiscoveryImplPlatform::sManager; DiscoveryImplPlatform::DiscoveryImplPlatform() = default; @@ -460,6 +544,39 @@ CHIP_ERROR DiscoveryImplPlatform::ResolveNodeId(const PeerId & peerId, Inet::IPA Resolver::CacheBypass dnssdCacheBypass) { ReturnErrorOnFailure(InitImpl()); + return mResolverProxy.ResolveNodeId(peerId, type, dnssdCacheBypass); +} + +CHIP_ERROR DiscoveryImplPlatform::FindCommissionableNodes(DiscoveryFilter filter) +{ + ReturnErrorOnFailure(InitImpl()); + return mResolverProxy.FindCommissionableNodes(filter); +} + +CHIP_ERROR DiscoveryImplPlatform::FindCommissioners(DiscoveryFilter filter) +{ + ReturnErrorOnFailure(InitImpl()); + return mResolverProxy.FindCommissioners(filter); +} + +DiscoveryImplPlatform & DiscoveryImplPlatform::GetInstance() +{ + return sManager; +} + +ServiceAdvertiser & chip::Dnssd::ServiceAdvertiser::Instance() +{ + return DiscoveryImplPlatform::GetInstance(); +} + +Resolver & chip::Dnssd::Resolver::Instance() +{ + return DiscoveryImplPlatform::GetInstance(); +} + +CHIP_ERROR ResolverProxy::ResolveNodeId(const PeerId & peerId, Inet::IPAddressType type, Resolver::CacheBypass dnssdCacheBypass) +{ + ReturnErrorOnFailure(chip::Dnssd::Resolver::Instance().Init(nullptr)); #if CHIP_CONFIG_MDNS_CACHE_SIZE > 0 if (dnssdCacheBypass == Resolver::CacheBypass::Off) @@ -483,54 +600,10 @@ CHIP_ERROR DiscoveryImplPlatform::ResolveNodeId(const PeerId & peerId, Inet::IPA return ChipDnssdResolve(&service, Inet::InterfaceId::Null(), HandleNodeIdResolve, this); } -void DiscoveryImplPlatform::HandleNodeBrowse(void * context, DnssdService * services, size_t servicesSize, CHIP_ERROR error) -{ - for (size_t i = 0; i < servicesSize; ++i) - { - // For some platforms browsed services are already resolved, so verify if resolve is really needed or call resolve callback - if (!services[i].mAddress.HasValue()) - { - ChipDnssdResolve(&services[i], services[i].mInterface, HandleNodeResolve, context); - } - else - { - HandleNodeResolve(context, &services[i], error); - } - } -} - -void DiscoveryImplPlatform::HandleNodeResolve(void * context, DnssdService * result, CHIP_ERROR error) +CHIP_ERROR ResolverProxy::FindCommissionableNodes(DiscoveryFilter filter) { - if (error != CHIP_NO_ERROR) - { - return; - } - DiscoveryImplPlatform * mgr = static_cast(context); - DiscoveredNodeData data; - Platform::CopyString(data.hostName, result->mHostName); - Platform::CopyString(data.instanceName, result->mName); - - if (result->mAddress.HasValue() && data.numIPs < DiscoveredNodeData::kMaxIPAddresses) - { - data.ipAddress[data.numIPs] = result->mAddress.Value(); - data.interfaceId[data.numIPs] = result->mInterface; - data.numIPs++; - } - - data.port = result->mPort; - - for (size_t i = 0; i < result->mTextEntrySize; ++i) - { - ByteSpan key(reinterpret_cast(result->mTextEntries[i].mKey), strlen(result->mTextEntries[i].mKey)); - ByteSpan val(result->mTextEntries[i].mData, result->mTextEntries[i].mDataSize); - FillNodeDataFromTxt(key, val, data); - } - mgr->mResolverDelegate->OnNodeDiscoveryComplete(data); -} + ReturnErrorOnFailure(chip::Dnssd::Resolver::Instance().Init(nullptr)); -CHIP_ERROR DiscoveryImplPlatform::FindCommissionableNodes(DiscoveryFilter filter) -{ - ReturnErrorOnFailure(InitImpl()); char serviceName[kMaxCommissionableServiceNameSize]; ReturnErrorOnFailure(MakeServiceTypeName(serviceName, sizeof(serviceName), filter, DiscoveryType::kCommissionableNode)); @@ -538,9 +611,10 @@ CHIP_ERROR DiscoveryImplPlatform::FindCommissionableNodes(DiscoveryFilter filter Inet::InterfaceId::Null(), HandleNodeBrowse, this); } -CHIP_ERROR DiscoveryImplPlatform::FindCommissioners(DiscoveryFilter filter) +CHIP_ERROR ResolverProxy::FindCommissioners(DiscoveryFilter filter) { - ReturnErrorOnFailure(InitImpl()); + ReturnErrorOnFailure(chip::Dnssd::Resolver::Instance().Init(nullptr)); + char serviceName[kMaxCommissionerServiceNameSize]; ReturnErrorOnFailure(MakeServiceTypeName(serviceName, sizeof(serviceName), filter, DiscoveryType::kCommissionerNode)); @@ -548,83 +622,5 @@ CHIP_ERROR DiscoveryImplPlatform::FindCommissioners(DiscoveryFilter filter) Inet::InterfaceId::Null(), HandleNodeBrowse, this); } -void DiscoveryImplPlatform::HandleNodeIdResolve(void * context, DnssdService * result, CHIP_ERROR error) -{ - DiscoveryImplPlatform * mgr = static_cast(context); - - if (mgr->mResolverDelegate == nullptr) - { - return; - } - - if (error != CHIP_NO_ERROR) - { - ChipLogError(Discovery, "Node ID resolved failed with %s", chip::ErrorStr(error)); - mgr->mResolverDelegate->OnNodeIdResolutionFailed(PeerId(), error); - return; - } - - if (result == nullptr) - { - ChipLogError(Discovery, "Node ID resolve not found"); - mgr->mResolverDelegate->OnNodeIdResolutionFailed(PeerId(), CHIP_ERROR_UNKNOWN_RESOURCE_ID); - return; - } - - ResolvedNodeData nodeData; - - error = ExtractIdFromInstanceName(result->mName, &nodeData.mPeerId); - if (error != CHIP_NO_ERROR) - { - ChipLogError(Discovery, "Node ID resolved failed with %s", chip::ErrorStr(error)); - mgr->mResolverDelegate->OnNodeIdResolutionFailed(PeerId(), error); - return; - } - - // TODO: Expand the results to include all the addresses. - Platform::CopyString(nodeData.mHostName, result->mHostName); - nodeData.mInterfaceId = result->mInterface; - nodeData.mAddress[0] = result->mAddress.ValueOr({}); - nodeData.mPort = result->mPort; - nodeData.mNumIPs = 1; - // TODO: Use seconds? - const System::Clock::Timestamp currentTime = System::SystemClock().GetMonotonicTimestamp(); - - nodeData.mExpiryTime = currentTime + System::Clock::Seconds16(result->mTtlSeconds); - - for (size_t i = 0; i < result->mTextEntrySize; ++i) - { - ByteSpan key(reinterpret_cast(result->mTextEntries[i].mKey), strlen(result->mTextEntries[i].mKey)); - ByteSpan val(result->mTextEntries[i].mData, result->mTextEntries[i].mDataSize); - FillNodeDataFromTxt(key, val, nodeData); - } - - nodeData.LogNodeIdResolved(); -#if CHIP_CONFIG_MDNS_CACHE_SIZE > 0 - error = mgr->sDnssdCache.Insert(nodeData); - - if (CHIP_NO_ERROR != error) - { - ChipLogError(Discovery, "DnssdCache insert failed with %s", chip::ErrorStr(error)); - } -#endif - mgr->mResolverDelegate->OnNodeIdResolved(nodeData); -} - -DiscoveryImplPlatform & DiscoveryImplPlatform::GetInstance() -{ - return sManager; -} - -ServiceAdvertiser & chip::Dnssd::ServiceAdvertiser::Instance() -{ - return DiscoveryImplPlatform::GetInstance(); -} - -Resolver & chip::Dnssd::Resolver::Instance() -{ - return DiscoveryImplPlatform::GetInstance(); -} - } // namespace Dnssd } // namespace chip diff --git a/src/lib/dnssd/Discovery_ImplPlatform.h b/src/lib/dnssd/Discovery_ImplPlatform.h index 5ac1753493d6ca..c297ed3df04ec9 100644 --- a/src/lib/dnssd/Discovery_ImplPlatform.h +++ b/src/lib/dnssd/Discovery_ImplPlatform.h @@ -23,6 +23,7 @@ #include #include #include +#include #include #include @@ -48,7 +49,7 @@ class DiscoveryImplPlatform : public ServiceAdvertiser, public Resolver CHIP_ERROR GetCommissionableInstanceName(char * instanceName, size_t maxLength) override; // Members that implement Resolver interface. - void SetResolverDelegate(ResolverDelegate * delegate) override { mResolverDelegate = delegate; } + void SetResolverDelegate(ResolverDelegate * delegate) override { mResolverProxy.SetResolverDelegate(delegate); } CHIP_ERROR ResolveNodeId(const PeerId & peerId, Inet::IPAddressType type, Resolver::CacheBypass dnssdCacheBypass) override; CHIP_ERROR FindCommissionableNodes(DiscoveryFilter filter = DiscoveryFilter()) override; CHIP_ERROR FindCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override; @@ -65,11 +66,8 @@ class DiscoveryImplPlatform : public ServiceAdvertiser, public Resolver CHIP_ERROR PublishUnprovisionedDevice(chip::Inet::IPAddressType addressType, chip::Inet::InterfaceId interface); CHIP_ERROR PublishProvisionedDevice(chip::Inet::IPAddressType addressType, chip::Inet::InterfaceId interface); - static void HandleNodeIdResolve(void * context, DnssdService * result, CHIP_ERROR error); static void HandleDnssdInit(void * context, CHIP_ERROR initError); static void HandleDnssdError(void * context, CHIP_ERROR initError); - static void HandleNodeBrowse(void * context, DnssdService * services, size_t servicesSize, CHIP_ERROR error); - static void HandleNodeResolve(void * context, DnssdService * result, CHIP_ERROR error); static CHIP_ERROR GenerateRotatingDeviceId(char rotatingDeviceIdHexBuffer[], size_t & rotatingDeviceIdHexBufferSize); #ifdef DETAIL_LOGGING static void PrintEntries(const DnssdService * service); @@ -83,13 +81,11 @@ class DiscoveryImplPlatform : public ServiceAdvertiser, public Resolver bool mIsCommissionerPublishing = false; uint8_t mCommissionableInstanceName[sizeof(uint64_t)]; - bool mDnssdInitialized = false; - ResolverDelegate * mResolverDelegate = nullptr; + bool mDnssdInitialized = false; + + ResolverProxy mResolverProxy; static DiscoveryImplPlatform sManager; -#if CHIP_CONFIG_MDNS_CACHE_SIZE > 0 - static DnssdCache sDnssdCache; -#endif }; } // namespace Dnssd diff --git a/src/lib/dnssd/ResolverProxy.h b/src/lib/dnssd/ResolverProxy.h new file mode 100644 index 00000000000000..56dcc936a863bb --- /dev/null +++ b/src/lib/dnssd/ResolverProxy.h @@ -0,0 +1,69 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +namespace chip { +namespace Dnssd { + +class ResolverProxy : public Resolver, public ResolverDelegate +{ +public: + ResolverProxy() {} + ResolverProxy(ResolverDelegate * delegate) : mResolverDelegate(delegate) {} + + // Resolver interface. + CHIP_ERROR Init(Inet::InetLayer * = nullptr) override { return CHIP_NO_ERROR; } + void Shutdown() override { mResolverDelegate = nullptr; }; + void SetResolverDelegate(ResolverDelegate * delegate) override { mResolverDelegate = delegate; } + CHIP_ERROR ResolveNodeId(const PeerId & peerId, Inet::IPAddressType type, + Resolver::CacheBypass dnssdCacheBypass = CacheBypass::Off) override; + CHIP_ERROR FindCommissionableNodes(DiscoveryFilter filter = DiscoveryFilter()) override; + CHIP_ERROR FindCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override; + + /// ResolverDelegate interface + void OnNodeIdResolved(const ResolvedNodeData & nodeData) override + { + if (mResolverDelegate != nullptr) + { + mResolverDelegate->OnNodeIdResolved(nodeData); + } + } + void OnNodeIdResolutionFailed(const PeerId & peerId, CHIP_ERROR error) override + { + if (mResolverDelegate != nullptr) + { + mResolverDelegate->OnNodeIdResolutionFailed(peerId, error); + } + } + void OnNodeDiscoveryComplete(const DiscoveredNodeData & nodeData) override + { + if (mResolverDelegate != nullptr) + { + mResolverDelegate->OnNodeDiscoveryComplete(nodeData); + } + } + +private: + ResolverDelegate * mResolverDelegate = nullptr; +}; + +} // namespace Dnssd +} // namespace chip diff --git a/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp b/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp index a825dc8876efaa..37e3b2a0ec4959 100644 --- a/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp +++ b/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -594,5 +595,23 @@ Resolver & chip::Dnssd::Resolver::Instance() return gResolver; } +CHIP_ERROR ResolverProxy::ResolveNodeId(const PeerId & peerId, Inet::IPAddressType type, Resolver::CacheBypass dnssdCacheBypass) +{ + chip::Dnssd::Resolver::Instance().SetResolverDelegate(this); + return chip::Dnssd::Resolver::Instance().ResolveNodeId(peerId, type, dnssdCacheBypass); +} + +CHIP_ERROR ResolverProxy::FindCommissionableNodes(DiscoveryFilter filter) +{ + chip::Dnssd::Resolver::Instance().SetResolverDelegate(this); + return chip::Dnssd::Resolver::Instance().FindCommissionableNodes(filter); +} + +CHIP_ERROR ResolverProxy::FindCommissioners(DiscoveryFilter filter) +{ + chip::Dnssd::Resolver::Instance().SetResolverDelegate(this); + return chip::Dnssd::Resolver::Instance().FindCommissioners(filter); +} + } // namespace Dnssd } // namespace chip