espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-10-08 00:37:40 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
openthread/tests/nexus/test_dnssd.cpp
T
Jonathan Hui e2e5cba98c [nexus] migrate test_dnssd.py to nexus (#12975) 
This commit migrates the DNS-SD test from the thread-cert Python
framework to the Nexus C++ framework.

The new Nexus test 'test_dnssd.cpp' replicates the original test
scenario and functionality:
- Formation of a Thread network with multiple SRP clients and a
  server.
- Service registration with subtypes via SRP.
- DNS browsing for full service types and specific subtypes.
- DNS address (AAAA) and service (SRV/TXT/AAAA) resolution.
- Specific DNS record queries for SRV and KEY record types.
- Verification of DNS behavior for non-existent records.

The original Python script 'tests/scripts/thread-cert/test_dnssd.py'
is removed as its functionality is now fully covered by Nexus.

Nexus tests provide faster and more scalable network simulations
within a single process, improving CI efficiency and reliability.
2026-04-27 18:57:22 -07:00

525 lines
21 KiB
C++
Raw Permalink Blame History

/*
* Copyright (c) 2026, The OpenThread Authors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <string.h>
#include "common/as_core_type.hpp"
#include "common/string.hpp"
#include "platform/nexus_core.hpp"
#include "platform/nexus_node.hpp"
namespace ot {
namespace Nexus {
namespace {
static constexpr uint32_t kFormNetworkTime = 13 * 1000;
static constexpr uint32_t kJoinNetworkTime = 10 * 1000;
static constexpr uint32_t kStabilizationTime = 200 * 1000;
static constexpr uint32_t kDnsQueryTime = 5 * 1000;
static const char kService[] = "_ipps._tcp";
static const char kFullServiceType[] = "_ipps._tcp.default.service.arpa.";
static const char kSubtype1ServiceType[] = "_s1._sub._ipps._tcp.default.service.arpa.";
static const char kSubtype2ServiceType[] = "_s2._sub._ipps._tcp.default.service.arpa.";
struct BrowseContext
{
Error mError;
uint8_t mCount;
Dns::Name::LabelBuffer mLabels[10];
void Reset(void)
{
mError = kErrorNone;
mCount = 0;
}
bool ContainsInstance(const char *aLabel) const
{
bool found = false;
for (uint8_t i = 0; i < mCount; i++)
{
if (StringMatch(mLabels[i], aLabel, kStringCaseInsensitiveMatch))
{
found = true;
break;
}
}
return found;
}
};
struct ResolveContext
{
Error mError;
Dns::Name::LabelBuffer mInstanceLabel;
Dns::Name::Buffer mFullServiceName;
Dns::Name::Buffer mHostName;
uint8_t mTxtData[128];
Dns::Client::ServiceInfo mServiceInfo;
void Reset(void)
{
mError = kErrorNone;
mInstanceLabel[0] = '\0';
mFullServiceName[0] = '\0';
mHostName[0] = '\0';
ClearAllBytes(mServiceInfo);
mServiceInfo.mHostNameBuffer = mHostName;
mServiceInfo.mHostNameBufferSize = sizeof(mHostName);
mServiceInfo.mTxtData = mTxtData;
mServiceInfo.mTxtDataSize = sizeof(mTxtData);
}
};
struct AddressContext
{
Error mError;
Ip6::Address mAddresses[10];
uint8_t mCount;
void Reset(void)
{
mError = kErrorNone;
mCount = 0;
}
};
struct RecordContext
{
Error mError;
uint8_t mCount;
uint16_t mType;
uint16_t mLength;
uint32_t mTtl;
Dns::Name::Buffer mName;
void Reset(void)
{
mError = kErrorNone;
mCount = 0;
mType = 0;
mLength = 0;
mTtl = 0;
mName[0] = '\0';
}
};
void HandleBrowseResponse(otError aError, const otDnsBrowseResponse *aResponse, void *aContext)
{
BrowseContext *context = static_cast<BrowseContext *>(aContext);
const Dns::Client::BrowseResponse &response = AsCoreType(aResponse);
context->mError = static_cast<Error>(aError);
SuccessOrExit(context->mError);
while (response.GetServiceInstance(context->mCount, context->mLabels[context->mCount],
sizeof(context->mLabels[context->mCount])) == kErrorNone)
{
context->mCount++;
}
exit:
return;
}
void HandleResolveResponse(otError aError, const otDnsServiceResponse *aResponse, void *aContext)
{
ResolveContext *context = static_cast<ResolveContext *>(aContext);
const Dns::Client::ServiceResponse &response = AsCoreType(aResponse);
context->mError = static_cast<Error>(aError);
SuccessOrExit(context->mError);
SuccessOrExit(response.GetServiceName(context->mInstanceLabel, sizeof(context->mInstanceLabel),
context->mFullServiceName, sizeof(context->mFullServiceName)));
SuccessOrExit(response.GetServiceInfo(context->mServiceInfo));
exit:
return;
}
void HandleAddressResolveResponse(otError aError, const otDnsAddressResponse *aResponse, void *aContext)
{
AddressContext *context = static_cast<AddressContext *>(aContext);
const Dns::Client::AddressResponse &response = AsCoreType(aResponse);
uint32_t ttl;
context->mError = static_cast<Error>(aError);
SuccessOrExit(context->mError);
while (response.GetAddress(context->mCount, context->mAddresses[context->mCount], ttl) == kErrorNone)
{
context->mCount++;
}
exit:
return;
}
void HandleRecordQueryResponse(otError aError, const otDnsRecordResponse *aResponse, void *aContext)
{
RecordContext *context = static_cast<RecordContext *>(aContext);
const Dns::Client::RecordResponse &response = AsCoreType(aResponse);
Dns::Client::RecordInfo recordInfo;
context->mError = static_cast<Error>(aError);
SuccessOrExit(context->mError);
recordInfo.mNameBuffer = context->mName;
recordInfo.mNameBufferSize = sizeof(context->mName);
for (uint16_t index = 0; response.GetRecordInfo(index, recordInfo) == kErrorNone; index++)
{
if (recordInfo.mRecordType == context->mType)
{
context->mCount++;
context->mLength = recordInfo.mRecordLength;
context->mTtl = recordInfo.mTtl;
break;
}
}
exit:
return;
}
} // namespace
void TestDnssd(const char *aJsonFileName)
{
Core nexus;
Node &server = nexus.CreateNode();
Node &client1 = nexus.CreateNode();
Node &client2 = nexus.CreateNode();
Node &client3 = nexus.CreateNode();
static Srp::Client::Service srv1, srv2, srv3;
static const char *const kSubtypes1[] = {"_s1", "_s2", nullptr};
static const char *const kSubtypes3[] = {"_s1", nullptr};
static Ip6::Address addrs1[2], addrs2[2], addrs3[2];
server.SetName("Server");
client1.SetName("Client1");
client2.SetName("Client2");
client3.SetName("Client3");
SuccessOrQuit(Instance::SetGlobalLogLevel(kLogLevelNote));
//-----------------------------------------------------------------------------------------
// Step 1: Start topology
Log("Step 1: Start topology");
server.Form();
nexus.AdvanceTime(kFormNetworkTime);
client1.Join(server);
client2.Join(server);
client3.Join(server);
nexus.AdvanceTime(kJoinNetworkTime);
server.Get<Srp::Server>().SetEnabled(true);
SuccessOrQuit(server.Get<Dns::ServiceDiscovery::Server>().Start());
nexus.AdvanceTime(kStabilizationTime);
//-----------------------------------------------------------------------------------------
// Step 2: Register services on clients
Log("Step 2: Register services on clients");
client1.Get<Srp::Client>().EnableAutoStartMode(nullptr, nullptr);
client2.Get<Srp::Client>().EnableAutoStartMode(nullptr, nullptr);
client3.Get<Srp::Client>().EnableAutoStartMode(nullptr, nullptr);
addrs1[0] = client1.Get<Mle::Mle>().GetMeshLocalEid();
addrs1[1] = client1.Get<Mle::Mle>().GetMeshLocalRloc();
SuccessOrQuit(client1.Get<Srp::Client>().SetHostName("host1"));
SuccessOrQuit(client1.Get<Srp::Client>().SetHostAddresses(addrs1, 2));
ClearAllBytes(srv1);
srv1.mName = kService;
srv1.mInstanceName = "ins1";
srv1.mPort = 11111;
srv1.mPriority = 1;
srv1.mWeight = 1;
srv1.mSubTypeLabels = kSubtypes1;
SuccessOrQuit(srv1.Init());
SuccessOrQuit(client1.Get<Srp::Client>().AddService(srv1));
addrs2[0] = client2.Get<Mle::Mle>().GetMeshLocalEid();
addrs2[1] = client2.Get<Mle::Mle>().GetMeshLocalRloc();
SuccessOrQuit(client2.Get<Srp::Client>().SetHostName("host2"));
SuccessOrQuit(client2.Get<Srp::Client>().SetHostAddresses(addrs2, 2));
ClearAllBytes(srv2);
srv2.mName = kService;
srv2.mInstanceName = "ins2";
srv2.mPort = 22222;
srv2.mPriority = 2;
srv2.mWeight = 2;
SuccessOrQuit(srv2.Init());
SuccessOrQuit(client2.Get<Srp::Client>().AddService(srv2));
addrs3[0] = client3.Get<Mle::Mle>().GetMeshLocalEid();
addrs3[1] = client3.Get<Mle::Mle>().GetMeshLocalRloc();
SuccessOrQuit(client3.Get<Srp::Client>().SetHostName("host3"));
SuccessOrQuit(client3.Get<Srp::Client>().SetHostAddresses(addrs3, 2));
ClearAllBytes(srv3);
srv3.mName = kService;
srv3.mInstanceName = "ins3";
srv3.mPort = 33333;
srv3.mPriority = 3;
srv3.mWeight = 3;
srv3.mSubTypeLabels = kSubtypes3;
SuccessOrQuit(srv3.Init());
SuccessOrQuit(client3.Get<Srp::Client>().AddService(srv3));
nexus.AdvanceTime(kStabilizationTime);
//-----------------------------------------------------------------------------------------
// Step 3: Resolve address (AAAA records)
Log("Step 3: Resolve address (AAAA records)");
AddressContext addressContext;
addressContext.Reset();
Dns::Client::QueryConfig queryConfig;
queryConfig.Clear();
AsCoreType(&queryConfig.mServerSockAddr).SetAddress(server.Get<Mle::Mle>().GetMeshLocalEid());
queryConfig.mServerSockAddr.mPort = 53;
client1.Get<Dns::Client>().SetDefaultConfig(queryConfig);
SuccessOrQuit(client1.Get<Dns::Client>().ResolveAddress("host1.default.service.arpa.", HandleAddressResolveResponse,
&addressContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(addressContext.mError);
VerifyOrQuit(addressContext.mCount == 2);
VerifyOrQuit(addressContext.mAddresses[0] == client1.Get<Mle::Mle>().GetMeshLocalEid() ||
addressContext.mAddresses[0] == client1.Get<Mle::Mle>().GetMeshLocalRloc());
VerifyOrQuit(addressContext.mAddresses[1] == client1.Get<Mle::Mle>().GetMeshLocalEid() ||
addressContext.mAddresses[1] == client1.Get<Mle::Mle>().GetMeshLocalRloc());
addressContext.Reset();
SuccessOrQuit(client1.Get<Dns::Client>().ResolveAddress("host2.default.service.arpa.", HandleAddressResolveResponse,
&addressContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(addressContext.mError);
VerifyOrQuit(addressContext.mCount == 2);
VerifyOrQuit(addressContext.mAddresses[0] == client2.Get<Mle::Mle>().GetMeshLocalEid() ||
addressContext.mAddresses[0] == client2.Get<Mle::Mle>().GetMeshLocalRloc());
VerifyOrQuit(addressContext.mAddresses[1] == client2.Get<Mle::Mle>().GetMeshLocalEid() ||
addressContext.mAddresses[1] == client2.Get<Mle::Mle>().GetMeshLocalRloc());
//-----------------------------------------------------------------------------------------
// Step 4: Browsing for services
Log("Step 4: Browsing for services");
BrowseContext browseContext;
browseContext.Reset();
SuccessOrQuit(client1.Get<Dns::Client>().Browse(kFullServiceType, HandleBrowseResponse, &browseContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(browseContext.mError);
VerifyOrQuit(browseContext.mCount == 3);
VerifyOrQuit(browseContext.ContainsInstance("ins1"));
VerifyOrQuit(browseContext.ContainsInstance("ins2"));
VerifyOrQuit(browseContext.ContainsInstance("ins3"));
// Browse for subtype _s1
browseContext.Reset();
SuccessOrQuit(client1.Get<Dns::Client>().Browse(kSubtype1ServiceType, HandleBrowseResponse, &browseContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(browseContext.mError);
VerifyOrQuit(browseContext.mCount == 2);
VerifyOrQuit(browseContext.ContainsInstance("ins1"));
VerifyOrQuit(browseContext.ContainsInstance("ins3"));
// Browse for subtype _s2
browseContext.Reset();
SuccessOrQuit(client1.Get<Dns::Client>().Browse(kSubtype2ServiceType, HandleBrowseResponse, &browseContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(browseContext.mError);
VerifyOrQuit(browseContext.mCount == 1);
VerifyOrQuit(browseContext.ContainsInstance("ins1"));
//-----------------------------------------------------------------------------------------
// Step 5: Resolve service
Log("Step 5: Resolve service");
ResolveContext resolveContext;
resolveContext.Reset();
SuccessOrQuit(
client1.Get<Dns::Client>().ResolveService("ins1", kFullServiceType, HandleResolveResponse, &resolveContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(resolveContext.mError);
VerifyOrQuit(StringMatch(resolveContext.mInstanceLabel, "ins1", kStringCaseInsensitiveMatch));
VerifyOrQuit(StringMatch(resolveContext.mFullServiceName, kFullServiceType, kStringCaseInsensitiveMatch));
VerifyOrQuit(resolveContext.mServiceInfo.mPort == 11111);
VerifyOrQuit(resolveContext.mServiceInfo.mPriority == 1);
VerifyOrQuit(resolveContext.mServiceInfo.mWeight == 1);
VerifyOrQuit(StringMatch(resolveContext.mHostName, "host1.default.service.arpa.", kStringCaseInsensitiveMatch));
VerifyOrQuit(AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client1.Get<Mle::Mle>().GetMeshLocalEid() ||
AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client1.Get<Mle::Mle>().GetMeshLocalRloc());
VerifyOrQuit(resolveContext.mServiceInfo.mTtl > 0);
VerifyOrQuit(resolveContext.mServiceInfo.mHostAddressTtl > 0);
resolveContext.Reset();
SuccessOrQuit(
client1.Get<Dns::Client>().ResolveService("ins2", kFullServiceType, HandleResolveResponse, &resolveContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(resolveContext.mError);
VerifyOrQuit(StringMatch(resolveContext.mInstanceLabel, "ins2", kStringCaseInsensitiveMatch));
VerifyOrQuit(StringMatch(resolveContext.mFullServiceName, kFullServiceType, kStringCaseInsensitiveMatch));
VerifyOrQuit(resolveContext.mServiceInfo.mPort == 22222);
VerifyOrQuit(resolveContext.mServiceInfo.mPriority == 2);
VerifyOrQuit(resolveContext.mServiceInfo.mWeight == 2);
VerifyOrQuit(StringMatch(resolveContext.mHostName, "host2.default.service.arpa.", kStringCaseInsensitiveMatch));
VerifyOrQuit(AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client2.Get<Mle::Mle>().GetMeshLocalEid() ||
AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client2.Get<Mle::Mle>().GetMeshLocalRloc());
resolveContext.Reset();
SuccessOrQuit(
client1.Get<Dns::Client>().ResolveService("ins3", kFullServiceType, HandleResolveResponse, &resolveContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(resolveContext.mError);
VerifyOrQuit(StringMatch(resolveContext.mInstanceLabel, "ins3", kStringCaseInsensitiveMatch));
VerifyOrQuit(StringMatch(resolveContext.mFullServiceName, kFullServiceType, kStringCaseInsensitiveMatch));
VerifyOrQuit(resolveContext.mServiceInfo.mPort == 33333);
VerifyOrQuit(resolveContext.mServiceInfo.mPriority == 3);
VerifyOrQuit(resolveContext.mServiceInfo.mWeight == 3);
VerifyOrQuit(StringMatch(resolveContext.mHostName, "host3.default.service.arpa.", kStringCaseInsensitiveMatch));
VerifyOrQuit(AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client3.Get<Mle::Mle>().GetMeshLocalEid() ||
AsCoreType(&resolveContext.mServiceInfo.mHostAddress) == client3.Get<Mle::Mle>().GetMeshLocalRloc());
//-----------------------------------------------------------------------------------------
// Step 6: Add another service with TXT entries
Log("Step 6: Add another service with TXT entries");
Srp::Client::Service srv4;
{
static const Dns::TxtEntry kTxtEntries[] = {{"KEY", reinterpret_cast<const uint8_t *>("ABC"), 3}};
ClearAllBytes(srv4);
srv4.mName = kService;
srv4.mInstanceName = "ins4";
srv4.mPort = 44444;
srv4.mPriority = 4;
srv4.mWeight = 4;
srv4.mTxtEntries = kTxtEntries;
srv4.mNumTxtEntries = 1;
srv4.mSubTypeLabels = kSubtypes3;
SuccessOrQuit(srv4.Init());
SuccessOrQuit(client3.Get<Srp::Client>().AddService(srv4));
}
nexus.AdvanceTime(kStabilizationTime);
browseContext.Reset();
SuccessOrQuit(client1.Get<Dns::Client>().Browse(kFullServiceType, HandleBrowseResponse, &browseContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(browseContext.mError);
VerifyOrQuit(browseContext.mCount == 4);
VerifyOrQuit(browseContext.ContainsInstance("ins1"));
VerifyOrQuit(browseContext.ContainsInstance("ins2"));
VerifyOrQuit(browseContext.ContainsInstance("ins3"));
VerifyOrQuit(browseContext.ContainsInstance("ins4"));
resolveContext.Reset();
SuccessOrQuit(
client1.Get<Dns::Client>().ResolveService("ins4", kFullServiceType, HandleResolveResponse, &resolveContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(resolveContext.mError);
VerifyOrQuit(StringMatch(resolveContext.mInstanceLabel, "ins4", kStringCaseInsensitiveMatch));
VerifyOrQuit(StringMatch(resolveContext.mFullServiceName, kFullServiceType, kStringCaseInsensitiveMatch));
VerifyOrQuit(resolveContext.mServiceInfo.mPort == 44444);
VerifyOrQuit(resolveContext.mServiceInfo.mPriority == 4);
VerifyOrQuit(resolveContext.mServiceInfo.mWeight == 4);
VerifyOrQuit(resolveContext.mServiceInfo.mTxtDataSize == 8);
VerifyOrQuit(memcmp(resolveContext.mServiceInfo.mTxtData, "\x07KEY=ABC", 8) == 0);
//-----------------------------------------------------------------------------------------
// Step 7: Query for KEY record
Log("Step 7: Query for KEY record");
RecordContext recordContext;
recordContext.Reset();
recordContext.mType = 25; // KEY
SuccessOrQuit(client1.Get<Dns::Client>().QueryRecord(25, nullptr, "ins1._ipps._tcp.default.service.arpa.",
HandleRecordQueryResponse, &recordContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(recordContext.mError);
VerifyOrQuit(recordContext.mCount == 1);
VerifyOrQuit(recordContext.mLength == 78);
VerifyOrQuit(recordContext.mTtl > 0);
VerifyOrQuit(
StringMatch(recordContext.mName, "ins1._ipps._tcp.default.service.arpa.", kStringCaseInsensitiveMatch));
//-----------------------------------------------------------------------------------------
// Step 8: Query for SRV record
Log("Step 8: Query for SRV record");
recordContext.Reset();
recordContext.mType = 33; // SRV
SuccessOrQuit(client1.Get<Dns::Client>().QueryRecord(33, nullptr, "ins1._ipps._tcp.default.service.arpa.",
HandleRecordQueryResponse, &recordContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(recordContext.mError);
VerifyOrQuit(recordContext.mCount == 1);
VerifyOrQuit(recordContext.mLength > 0);
VerifyOrQuit(recordContext.mTtl > 0);
VerifyOrQuit(
StringMatch(recordContext.mName, "ins1._ipps._tcp.default.service.arpa.", kStringCaseInsensitiveMatch));
//-----------------------------------------------------------------------------------------
// Step 9: Query for non-existing A record
Log("Step 9: Query for non-existing A record");
recordContext.Reset();
recordContext.mType = 1; // A
SuccessOrQuit(client1.Get<Dns::Client>().QueryRecord(1, nullptr, "ins1._ipps._tcp.default.service.arpa.",
HandleRecordQueryResponse, &recordContext));
nexus.AdvanceTime(kDnsQueryTime);
SuccessOrQuit(recordContext.mError);
VerifyOrQuit(recordContext.mCount == 0);
nexus.SaveTestInfo(aJsonFileName);
}
} // namespace Nexus
} // namespace ot
int main(int argc, char *argv[])
{
ot::Nexus::TestDnssd((argc > 2) ? argv[2] : "test_dnssd.json");
printf("All tests passed\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink