Symbols ![]()
loading...
Files ![]()
loading (2/5)...
ot::Dns::ServiceDiscovery::Server class
Implements DNS-SD server.
Syntax
class Server : public InstanceLocator,
private NonCopyable
{
friend class Srp::Server;
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
friend class ot::Dnssd;
friend class ot::BorderRouter::InfraIf;
#endif
public:
class Counters : public otDnssdCounters, public Clearable<Counters>
{
public:
uint32_t GetTotalQueries(void) const { return mSuccessResponse + GetTotalFailedQueries(); }
uint32_t GetTotalFailedQueries(void) const
{
return mServerFailureResponse + mFormatErrorResponse + mNameErrorResponse + mNotImplementedResponse +
mOtherResponse;
}
};
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
class UpstreamQueryTransaction : public otPlatDnsUpstreamQuery
{
public:
bool IsValid(void) const { return mValid; }
TimeMilli GetExpireTime(void) const { return mExpireTime; }
void Reset(void) { mValid = false; }
void Init(const Ip6::MessageInfo &aMessageInfo);
const Ip6::MessageInfo &GetMessageInfo(void) const { return mMessageInfo; }
private:
Ip6::MessageInfo mMessageInfo;
TimeMilli mExpireTime;
bool mValid;
};
#endif
enum DnsQueryType : uint8_t
{
kDnsQueryNone = OT_DNSSD_QUERY_TYPE_NONE,
kDnsQueryBrowse = OT_DNSSD_QUERY_TYPE_BROWSE,
kDnsQueryResolve = OT_DNSSD_QUERY_TYPE_RESOLVE,
kDnsQueryResolveHost = OT_DNSSD_QUERY_TYPE_RESOLVE_HOST,
};
typedef otDnssdServiceInstanceInfo ServiceInstanceInfo;
typedef otDnssdHostInfo HostInfo;
typedef otDnssdQuerySubscribeCallback SubscribeCallback;
typedef otDnssdQueryUnsubscribeCallback UnsubscribeCallback;
static constexpr uint16_t kPort = OPENTHREAD_CONFIG_DNSSD_SERVER_PORT;
explicit Server(Instance &aInstance);
Error Start(void);
void Stop(void);
void SetQueryCallbacks(SubscribeCallback aSubscribe, UnsubscribeCallback aUnsubscribe, void *aContext);
void HandleDiscoveredServiceInstance(const char *aServiceFullName, const ServiceInstanceInfo &aInstanceInfo);
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
void OnUpstreamQueryDone(UpstreamQueryTransaction &aQueryTransaction, Message *aResponseMessage);
bool IsUpstreamQueryEnabled(void) const { return mEnableUpstreamQuery; }
void SetUpstreamQueryEnabled(bool aEnabled) { mEnableUpstreamQuery = aEnabled; }
#endif
void HandleDiscoveredHost(const char *aHostFullName, const HostInfo &aHostInfo);
const otDnssdQuery *GetNextQuery(const otDnssdQuery *aQuery) const;
static DnsQueryType GetQueryTypeAndName(const otDnssdQuery *aQuery, Dns::Name::Buffer &aName);
const Counters &GetCounters(void) const { return mCounters; };
enum TestModeFlags : uint8_t
{
kTestModeRejectMultiQuestionQuery = 1 << 0,
kTestModeIgnoreMultiQuestionQuery = 1 << 1,
kTestModeEmptyAdditionalSection = 1 << 2,
};
static constexpr uint8_t kTestModeDisabled = 0;
void SetTestMode(uint8_t aTestMode) { mTestMode = aTestMode; }
private:
static constexpr bool kBindUnspecifiedNetif = OPENTHREAD_CONFIG_DNSSD_SERVER_BIND_UNSPECIFIED_NETIF;
static constexpr uint32_t kQueryTimeout = OPENTHREAD_CONFIG_DNSSD_QUERY_TIMEOUT;
static constexpr uint16_t kMaxConcurrentUpstreamQueries = 32;
typedef Header::Response ResponseCode;
typedef Message ProxyQuery;
typedef MessageQueue ProxyQueryList;
enum QueryType : uint8_t
{
kPtrQuery,
kSrvQuery,
kTxtQuery,
kSrvTxtQuery,
kAaaaQuery,
kAQuery,
};
enum Section : uint8_t
{
kAnswerSection,
kAdditionalDataSection,
};
enum AddrType : uint8_t
{
kIp6AddrType,
kIp4AddrType,
};
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
enum ProxyAction : uint8_t
{
kNoAction,
kBrowsing,
kResolvingSrv,
kResolvingTxt,
kResolvingIp6Address,
kResolvingIp4Address
};
#endif
struct Request
{
ResponseCode ParseQuestions(uint8_t aTestMode, bool &aShouldRespond);
const Message *mMessage;
const Ip6::MessageInfo *mMessageInfo;
Header mHeader;
QueryType mType;
};
struct ProxyQueryInfo;
struct NameOffsets : public Clearable<NameOffsets>
{
uint16_t mDomainName;
uint16_t mServiceName;
uint16_t mInstanceName;
uint16_t mHostName;
};
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
union ProxyResult
{
explicit ProxyResult(const Dnssd::BrowseResult &aBrowseResult) { mBrowseResult = &aBrowseResult; }
explicit ProxyResult(const Dnssd::SrvResult &aSrvResult) { mSrvResult = &aSrvResult; }
explicit ProxyResult(const Dnssd::TxtResult &aTxtResult) { mTxtResult = &aTxtResult; }
explicit ProxyResult(const Dnssd::AddressResult &aAddressResult) { mAddressResult = &aAddressResult; }
const Dnssd::BrowseResult *mBrowseResult;
const Dnssd::SrvResult *mSrvResult;
const Dnssd::TxtResult *mTxtResult;
const Dnssd::AddressResult *mAddressResult;
};
#endif
class Response : public InstanceLocator, private NonCopyable
{
public:
explicit Response(Instance &aInstance);
ResponseCode AddQuestionsFrom(const Request &aRequest);
Error AllocateAndInitFrom(const Request &aRequest);
void InitFrom(ProxyQuery &aQuery, const ProxyQueryInfo &aInfo);
void SetResponseCode(ResponseCode aResponseCode) { mHeader.SetResponseCode(aResponseCode); }
Error ParseQueryName(void);
void ReadQueryName(Name::Buffer &aName) const;
bool QueryNameMatches(const char *aName) const;
Error AppendQueryName(void);
Error AppendPtrRecord(const char *aInstanceLabel, uint32_t aTtl);
Error AppendSrvRecord(const ServiceInstanceInfo &aInstanceInfo);
Error AppendSrvRecord(const char *aHostName,
uint32_t aTtl,
uint16_t aPriority,
uint16_t aWeight,
uint16_t aPort);
Error AppendTxtRecord(const ServiceInstanceInfo &aInstanceInfo);
Error AppendTxtRecord(const void *aTxtData, uint16_t aTxtLength, uint32_t aTtl);
Error AppendHostAddresses(AddrType aAddrType, const HostInfo &aHostInfo);
Error AppendHostAddresses(const ServiceInstanceInfo &aInstanceInfo);
Error AppendHostAddresses(AddrType aAddrType, const Ip6::Address *aAddrs, uint16_t aAddrsLength, uint32_t aTtl);
Error AppendAaaaRecord(const Ip6::Address &aAddress, uint32_t aTtl);
Error AppendARecord(const Ip6::Address &aAddress, uint32_t aTtl);
void UpdateRecordLength(ResourceRecord &aRecord, uint16_t aOffset);
void IncResourceRecordCount(void);
void Send(const Ip6::MessageInfo &aMessageInfo);
void Answer(const HostInfo &aHostInfo, const Ip6::MessageInfo &aMessageInfo);
void Answer(const ServiceInstanceInfo &aInstanceInfo, const Ip6::MessageInfo &aMessageInfo);
Error ExtractServiceInstanceLabel(const char *aInstanceName, Name::LabelBuffer &aLabel);
#if OPENTHREAD_CONFIG_SRP_SERVER_ENABLE
Error ResolveBySrp(void);
bool QueryNameMatchesService(const Srp::Server::Service &aService) const;
Error AppendSrvRecord(const Srp::Server::Service &aService);
Error AppendTxtRecord(const Srp::Server::Service &aService);
Error AppendHostAddresses(const Srp::Server::Host &aHost);
#endif
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
Error AppendPtrRecord(const ProxyResult &aResult);
Error AppendSrvRecord(const ProxyResult &aResult);
Error AppendTxtRecord(const ProxyResult &aResult);
Error AppendHostIp6Addresses(const ProxyResult &aResult);
Error AppendHostIp4Addresses(const ProxyResult &aResult);
#endif
#if OT_SHOULD_LOG_AT(OT_LOG_LEVEL_INFO)
void Log(void) const;
static const char *QueryTypeToString(QueryType aType);
#endif
OwnedPtr<Message> mMessage;
Header mHeader;
QueryType mType;
Section mSection;
NameOffsets mOffsets;
};
struct ProxyQueryInfo : Message::FooterData<ProxyQueryInfo>
{
QueryType mType;
Ip6::MessageInfo mMessageInfo;
TimeMilli mExpireTime;
NameOffsets mOffsets;
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
ProxyAction mAction;
#endif
};
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
class DiscoveryProxy : public InstanceLocator, private NonCopyable
{
friend ot::Dnssd;
public:
explicit DiscoveryProxy(Instance &aInstance);
bool IsRunning(void) const { return mIsRunning; }
void UpdateState(void);
void Start(void);
void Stop(void);
void Resolve(ProxyQuery &aQuery, ProxyQueryInfo &aInfo);
void CancelAction(ProxyQuery &aQuery, ProxyQueryInfo &aInfo);
private:
enum Command : uint8_t
{
kStart,
kStop,
};
typedef Error (Response::*ResponseAppender)(const ProxyResult &aResult);
void Perform(ProxyAction aAction, ProxyQuery &aQuery, ProxyQueryInfo &aInfo);
void ReadNameFor(ProxyAction aAction, ProxyQuery &aQuery, ProxyQueryInfo &aInfo, Name::Buffer &aName) const;
bool HasActive(ProxyAction aAction, const Name::Buffer &aName) const;
bool QueryMatches(const ProxyQuery &aQuery,
const ProxyQueryInfo &aInfo,
ProxyAction aAction,
const Name::Buffer &aName) const;
void UpdateProxy(Command aCommand,
ProxyAction aAction,
const ProxyQuery &aQuery,
const ProxyQueryInfo &aInfo,
Name::Buffer &aName);
void StartOrStopBrowser(Command aCommand, Name::Buffer &aServiceName);
void StartOrStopSrvResolver(Command aCommand, const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo);
void StartOrStopTxtResolver(Command aCommand, const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo);
void StartOrStopIp6Resolver(Command aCommand, Name::Buffer &aHostName);
void StartOrStopIp4Resolver(Command aCommand, Name::Buffer &aHostName);
static void HandleBrowseResult(otInstance *aInstance, const otPlatDnssdBrowseResult *aResult);
static void HandleSrvResult(otInstance *aInstance, const otPlatDnssdSrvResult *aResult);
static void HandleTxtResult(otInstance *aInstance, const otPlatDnssdTxtResult *aResult);
static void HandleIp6AddressResult(otInstance *aInstance, const otPlatDnssdAddressResult *aResult);
static void HandleIp4AddressResult(otInstance *aInstance, const otPlatDnssdAddressResult *aResult);
void HandleBrowseResult(const Dnssd::BrowseResult &aResult);
void HandleSrvResult(const Dnssd::SrvResult &aResult);
void HandleTxtResult(const Dnssd::TxtResult &aResult);
void HandleIp6AddressResult(const Dnssd::AddressResult &aResult);
void HandleIp4AddressResult(const Dnssd::AddressResult &aResult);
void HandleResult(ProxyAction aAction,
const Name::Buffer &aName,
ResponseAppender aAppender,
const ProxyResult &aResult);
static bool IsActionForAdditionalSection(ProxyAction aAction, QueryType aQueryType);
bool mIsRunning;
};
#endif
bool IsRunning(void) const { return mSocket.IsBound(); }
void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void ProcessQuery(Request &aRequest);
void ResolveByProxy(Response &aResponse, const Ip6::MessageInfo &aMessageInfo);
void RemoveQueryAndPrepareResponse(ProxyQuery &aQuery, ProxyQueryInfo &aInfo, Response &aResponse);
void Finalize(ProxyQuery &aQuery, ResponseCode aResponseCode);
static void ReadQueryName(const Message &aQuery, Name::Buffer &aName);
static bool QueryNameMatches(const Message &aQuery, const char *aName);
static void ReadQueryInstanceName(const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo, Name::Buffer &aName);
static void ReadQueryInstanceName(const ProxyQuery &aQuery,
const ProxyQueryInfo &aInfo,
Name::LabelBuffer &aInstanceLabel,
Name::Buffer &aServiceType);
static bool QueryInstanceNameMatches(const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo, const char *aName);
static void ReadQueryHostName(const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo, Name::Buffer &aName);
static bool QueryHostNameMatches(const ProxyQuery &aQuery, const ProxyQueryInfo &aInfo, const char *aName);
static Error StripDomainName(const char *aFullName, Name::Buffer &aLabels);
static Error StripDomainName(Name::Buffer &aName);
static void ConstructFullName(const char *aLabels, Name::Buffer &aFullName);
static void ConstructFullInstanceName(const char *aInstanceLabel,
const char *aServiceType,
Name::Buffer &aFullName);
static void ConstructFullServiceSubTypeName(const char *aServiceType,
const char *aSubTypeLabel,
Name::Buffer &aFullName);
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
void HandleInfraIfStateChanged(void) { mDiscoveryProxy.UpdateState(); }
void HandleDnssdPlatformStateChange(void) { mDiscoveryProxy.UpdateState(); }
static bool IsProxyAddressValid(const Ip6::Address &aAddress);
#endif
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
static bool ShouldForwardToUpstream(const Request &aRequest);
UpstreamQueryTransaction *AllocateUpstreamQueryTransaction(const Ip6::MessageInfo &aMessageInfo);
void ResetUpstreamQueryTransaction(UpstreamQueryTransaction &aTxn, Error aError);
Error ResolveByUpstream(const Request &aRequest);
#endif
void HandleTimer(void);
void ResetTimer(void);
void UpdateResponseCounters(ResponseCode aResponseCode);
using ServerTimer = TimerMilliIn<Server, &Server::HandleTimer>;
using ServerSocket = Ip6::Udp::SocketIn<Server, &Server::HandleUdpReceive>;
static const char kDefaultDomainName[];
static const char kSubLabel[];
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
static const char *kBlockedDomains[];
#endif
ServerSocket mSocket;
ProxyQueryList mProxyQueries;
Callback<SubscribeCallback> mQuerySubscribe;
Callback<UnsubscribeCallback> mQueryUnsubscribe;
#if OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
DiscoveryProxy mDiscoveryProxy;
#endif
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
bool mEnableUpstreamQuery;
UpstreamQueryTransaction mUpstreamQueryTransactions[kMaxConcurrentUpstreamQueries];
#endif
ServerTimer mTimer;
Counters mCounters;
uint8_t mTestMode;
};
Fields
Field
Declared as
ServerSocket
Callback<SubscribeCallback>
Callback<UnsubscribeCallback>
ServerTimer
References
Code
Location
Scope
Referrer
Class Tree
ot::Dns::ServiceDiscovery::Server is inherited by 2 classess:
Instances
Instance
Scope
Location
Project