Symbols ![]()
loading (2/5)...
Files ![]()
loading (4/5)...
ot::Srp::Server class
Implements the SRP server.
Syntax
class Server : public InstanceLocator,
private NonCopyable
{
friend class NetworkData::Publisher;
friend class UpdateMetadata;
friend class Service;
friend class Host;
friend class Dns::ServiceDiscovery::Server;
friend class AdvertisingProxy;
#if OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE
friend class BorderRouter::RoutingManager;
#endif
enum RetainName : bool
{
kDeleteName = false,
kRetainName = true,
};
enum NotifyMode : bool
{
kDoNotNotifyServiceHandler = false,
kNotifyServiceHandler = true,
};
#if OPENTHREAD_CONFIG_SRP_SERVER_ADVERTISING_PROXY_ENABLE
static constexpr Dnssd::RequestId kInvalidRequestId = 0;
#endif
public:
static constexpr uint16_t kUdpPortMin = OPENTHREAD_CONFIG_SRP_SERVER_UDP_PORT_MIN;
static constexpr uint16_t kUdpPortMax = OPENTHREAD_CONFIG_SRP_SERVER_UDP_PORT_MAX;
static_assert(kUdpPortMin <= kUdpPortMax, "invalid port range");
typedef otSrpServerServiceUpdateId ServiceUpdateId;
typedef otSrpServerLeaseInfo LeaseInfo;
enum AddressMode : uint8_t
{
kAddressModeUnicast = OT_SRP_SERVER_ADDRESS_MODE_UNICAST,
kAddressModeAnycast = OT_SRP_SERVER_ADDRESS_MODE_ANYCAST,
};
class Host;
enum State : uint8_t
{
kStateDisabled = OT_SRP_SERVER_STATE_DISABLED,
kStateRunning = OT_SRP_SERVER_STATE_RUNNING,
kStateStopped = OT_SRP_SERVER_STATE_STOPPED,
};
class Service : public otSrpServerService,
public LinkedListEntry<Service>,
private Heap::Allocatable<Service>,
private NonCopyable
{
friend class Server;
friend class LinkedList<Service>;
friend class LinkedListEntry<Service>;
friend class Heap::Allocatable<Service>;
friend class AdvertisingProxy;
public:
bool IsDeleted(void) const { return mIsDeleted; }
const char *GetInstanceName(void) const { return mInstanceName.AsCString(); }
const char *GetInstanceLabel(void) const { return mInstanceLabel.AsCString(); }
const char *GetServiceName(void) const { return mServiceName.AsCString(); }
uint16_t GetNumberOfSubTypes(void) const { return mSubTypes.GetLength(); }
const char *GetSubTypeServiceNameAt(uint16_t aIndex) const;
bool HasSubTypeServiceName(const char *aSubTypeServiceName) const;
static Error ParseSubTypeServiceName(const char *aSubTypeServiceName, char *aLabel, uint8_t aLabelSize);
uint32_t GetTtl(void) const { return mTtl; }
uint16_t GetPort(void) const { return mPort; }
uint16_t GetWeight(void) const { return mWeight; }
uint16_t GetPriority(void) const { return mPriority; }
const uint8_t *GetTxtData(void) const { return mTxtData.GetBytes(); }
uint16_t GetTxtDataLength(void) const { return mTxtData.GetLength(); }
const Host &GetHost(void) const { return *mHost; }
uint32_t GetLease(void) const { return mLease; }
uint32_t GetKeyLease(void) const { return mKeyLease; }
TimeMilli GetExpireTime(void) const;
TimeMilli GetKeyExpireTime(void) const;
void GetLeaseInfo(LeaseInfo &aLeaseInfo) const;
bool MatchesInstanceName(const char *aInstanceName) const;
bool MatchesServiceName(const char *aServiceName) const;
private:
enum Action : uint8_t
{
kAddNew,
kUpdateExisting,
kKeepUnchanged,
kRemoveButRetainName,
kFullyRemove,
kLeaseExpired,
kKeyLeaseExpired,
};
Error Init(const char *aInstanceName, const char *aInstanceLabel, Host &aHost, TimeMilli aUpdateTime);
Error SetTxtDataFromMessage(const Message &aMessage, uint16_t aOffset, uint16_t aLength);
bool Matches(const char *aInstanceName) const;
void Log(Action aAction) const;
template <uint16_t kLabelSize>
static Error ParseSubTypeServiceName(const char *aSubTypeServiceName, char (&aLabel)[kLabelSize])
{
return ParseSubTypeServiceName(aSubTypeServiceName, aLabel, kLabelSize);
}
Service *mNext;
Heap::String mInstanceName;
Heap::String mInstanceLabel;
Heap::String mServiceName;
Heap::Array<Heap::String> mSubTypes;
Host *mHost;
Heap::Data mTxtData;
uint16_t mPriority;
uint16_t mWeight;
uint16_t mPort;
uint32_t mTtl;
uint32_t mLease;
uint32_t mKeyLease;
TimeMilli mUpdateTime;
bool mIsDeleted : 1;
bool mIsCommitted : 1;
bool mParsedDeleteAllRrset : 1;
bool mParsedSrv : 1;
bool mParsedTxt : 1;
#if OPENTHREAD_CONFIG_SRP_SERVER_ADVERTISING_PROXY_ENABLE
bool mIsRegistered : 1;
bool mIsKeyRegistered : 1;
bool mIsReplaced : 1;
bool mShouldAdvertise : 1;
bool mShouldRegisterKey : 1;
Dnssd::RequestId mAdvId;
Dnssd::RequestId mKeyAdvId;
#endif
};
class Host : public otSrpServerHost,
public InstanceLocator,
public LinkedListEntry<Host>,
private Heap::Allocatable<Host>,
private NonCopyable
{
friend class Server;
friend class LinkedListEntry<Host>;
friend class Heap::Allocatable<Host>;
friend class AdvertisingProxy;
public:
typedef Crypto::Ecdsa::P256::PublicKey Key;
bool IsDeleted(void) const { return (mLease == 0); }
const char *GetFullName(void) const { return mFullName.AsCString(); }
const Ip6::Address *GetAddresses(uint8_t &aAddressesNum) const
{
aAddressesNum = ClampToUint8(mAddresses.GetLength());
return mAddresses.AsCArray();
}
uint32_t GetTtl(void) const { return mTtl; }
uint32_t GetLease(void) const { return mLease; }
uint32_t GetKeyLease(void) const { return mKeyLease; }
void GetLeaseInfo(LeaseInfo &aLeaseInfo) const;
const Key &GetKey(void) const { return mKey; }
TimeMilli GetExpireTime(void) const;
TimeMilli GetKeyExpireTime(void) const;
const LinkedList<Service> &GetServices(void) const { return mServices; }
const Service *GetNextService(const Service *aPrevService) const;
bool Matches(const char *aFullName) const;
private:
Host(Instance &aInstance, TimeMilli aUpdateTime);
~Host(void);
Error SetFullName(const char *aFullName);
void SetTtl(uint32_t aTtl) { mTtl = aTtl; }
void SetLease(uint32_t aLease) { mLease = aLease; }
void SetKeyLease(uint32_t aKeyLease) { mKeyLease = aKeyLease; }
void SetUseShortLeaseOption(bool aUse) { mUseShortLeaseOption = aUse; }
bool ShouldUseShortLeaseOption(void) const { return mUseShortLeaseOption; }
Error ProcessTtl(uint32_t aTtl);
Service *AddNewService(const char *aInstanceName, const char *aInstanceLabel, TimeMilli aUpdateTime);
void AddService(Service &aService);
void RemoveService(Service *aService, RetainName aRetainName, NotifyMode aNotifyServiceHandler);
bool HasService(const char *aInstanceName) const;
Service *FindService(const char *aInstanceName);
const Service *FindService(const char *aInstanceName) const;
void FreeAllServices(void);
void ClearResources(void);
Error AddIp6Address(const Ip6::Address &aIp6Address);
Host *mNext;
Heap::String mFullName;
Heap::Array<Ip6::Address> mAddresses;
Key mKey;
uint32_t mTtl;
uint32_t mLease;
uint32_t mKeyLease;
TimeMilli mUpdateTime;
LinkedList<Service> mServices;
bool mParsedKey : 1;
bool mUseShortLeaseOption : 1;
#if OPENTHREAD_CONFIG_SRP_SERVER_ADVERTISING_PROXY_ENABLE
bool mIsRegistered : 1;
bool mIsKeyRegistered : 1;
bool mIsReplaced : 1;
bool mShouldAdvertise : 1;
bool mShouldRegisterKey : 1;
Dnssd::RequestId mAdvId;
Dnssd::RequestId mKeyAdvId;
Dnssd::RequestIdRange mAdvIdRange;
#endif
};
class TtlConfig : public otSrpServerTtlConfig
{
friend class Server;
public:
TtlConfig(void);
private:
bool IsValid(void) const { return mMinTtl <= mMaxTtl; }
uint32_t GrantTtl(uint32_t aLease, uint32_t aTtl) const;
};
class LeaseConfig : public otSrpServerLeaseConfig
{
friend class Server;
public:
LeaseConfig(void);
private:
bool IsValid(void) const;
uint32_t GrantLease(uint32_t aLease) const;
uint32_t GrantKeyLease(uint32_t aKeyLease) const;
};
explicit Server(Instance &aInstance);
void SetServiceHandler(otSrpServerServiceUpdateHandler aServiceHandler, void *aServiceHandlerContext)
{
mServiceUpdateHandler.Set(aServiceHandler, aServiceHandlerContext);
}
const char *GetDomain(void) const { return mDomain.AsCString(); }
Error SetDomain(const char *aDomain);
AddressMode GetAddressMode(void) const { return mAddressMode; }
Error SetAddressMode(AddressMode aMode);
uint8_t GetAnycastModeSequenceNumber(void) const { return mAnycastSequenceNumber; }
Error SetAnycastModeSequenceNumber(uint8_t aSequenceNumber);
State GetState(void) const { return mState; }
uint16_t GetPort(void) const { return (mState == kStateRunning) ? mPort : 0; }
void SetEnabled(bool aEnabled);
#if OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE
void SetAutoEnableMode(bool aEnabled);
bool IsAutoEnableMode(void) const { return mAutoEnable; }
#endif
void GetTtlConfig(TtlConfig &aTtlConfig) const { aTtlConfig = mTtlConfig; }
Error SetTtlConfig(const TtlConfig &aTtlConfig);
void GetLeaseConfig(LeaseConfig &aLeaseConfig) const { aLeaseConfig = mLeaseConfig; }
Error SetLeaseConfig(const LeaseConfig &aLeaseConfig);
const LinkedList<Host> &GetHosts(void) const { return mHosts; }
const Host *GetNextHost(const Host *aHost);
const otSrpServerResponseCounters *GetResponseCounters(void) const { return &mResponseCounters; }
void HandleServiceUpdateResult(ServiceUpdateId aId, Error aError);
private:
static constexpr uint16_t kUdpPayloadSize = Ip6::kMaxDatagramLength - sizeof(Ip6::Udp::Header);
static constexpr uint32_t kDefaultMinLease = 30;
static constexpr uint32_t kDefaultMaxLease = 27u * 3600;
static constexpr uint32_t kDefaultMinKeyLease = 30;
static constexpr uint32_t kDefaultMaxKeyLease = 189u * 3600;
static constexpr uint32_t kDefaultMinTtl = kDefaultMinLease;
static constexpr uint32_t kDefaultMaxTtl = kDefaultMaxLease;
static constexpr uint32_t kDefaultEventsHandlerTimeout = OPENTHREAD_CONFIG_SRP_SERVER_SERVICE_UPDATE_TIMEOUT;
static constexpr AddressMode kDefaultAddressMode =
static_cast<AddressMode>(OPENTHREAD_CONFIG_SRP_SERVER_DEFAULT_ADDRESS_MODE);
static constexpr uint16_t kUninitializedPort = 0;
static constexpr uint16_t kAnycastAddressModePort = 53;
struct MessageMetadata
{
bool IsDirectRxFromClient(void) const { return (mMessageInfo != nullptr); }
Dns::UpdateHeader mDnsHeader;
Dns::Zone mDnsZone;
uint16_t mOffset;
TimeMilli mRxTime;
TtlConfig mTtlConfig;
LeaseConfig mLeaseConfig;
const Ip6::MessageInfo *mMessageInfo;
};
class UpdateMetadata : public InstanceLocator,
public LinkedListEntry<UpdateMetadata>,
public Heap::Allocatable<UpdateMetadata>
{
friend class LinkedListEntry<UpdateMetadata>;
friend class Heap::Allocatable<UpdateMetadata>;
public:
TimeMilli GetExpireTime(void) const { return mExpireTime; }
const Dns::UpdateHeader &GetDnsHeader(void) const { return mDnsHeader; }
ServiceUpdateId GetId(void) const { return mId; }
const TtlConfig &GetTtlConfig(void) const { return mTtlConfig; }
const LeaseConfig &GetLeaseConfig(void) const { return mLeaseConfig; }
Host &GetHost(void) { return mHost; }
const Ip6::MessageInfo &GetMessageInfo(void) const { return mMessageInfo; }
Error GetError(void) const { return mError; }
void SetError(Error aError) { mError = aError; }
bool IsDirectRxFromClient(void) const { return mIsDirectRxFromClient; }
bool Matches(ServiceUpdateId aId) const { return mId == aId; }
private:
UpdateMetadata(Instance &aInstance, Host &aHost, const MessageMetadata &aMessageMetadata);
UpdateMetadata *mNext;
TimeMilli mExpireTime;
Dns::UpdateHeader mDnsHeader;
ServiceUpdateId mId;
TtlConfig mTtlConfig;
LeaseConfig mLeaseConfig;
Host &mHost;
Ip6::MessageInfo mMessageInfo;
Error mError;
bool mIsDirectRxFromClient;
};
void Enable(void);
void Disable(void);
void Start(void);
void Stop(void);
void InitPort(void);
void SelectPort(void);
Error PrepareSocket(void);
Ip6::Udp::Socket &GetSocket(void);
LinkedList<Host> &GetHosts(void) { return mHosts; }
#if OPENTHREAD_CONFIG_DNSSD_SERVER_ENABLE
void HandleDnssdServerStateChange(void);
Error HandleDnssdServerUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
#endif
void HandleNetDataPublisherEvent(NetworkData::Publisher::Event aEvent);
ServiceUpdateId AllocateServiceUpdateId(void) { return mServiceUpdateId++; }
void InformUpdateHandlerOrCommit(Error aError, Host &aHost, const MessageMetadata &aMetadata);
void CommitSrpUpdate(Error aError, Host &aHost, const MessageMetadata &aMessageMetadata);
void CommitSrpUpdate(UpdateMetadata &aUpdateMetadata);
void CommitSrpUpdate(Error aError,
Host &aHost,
const Dns::UpdateHeader &aDnsHeader,
const Ip6::MessageInfo *aMessageInfo,
const TtlConfig &aTtlConfig,
const LeaseConfig &aLeaseConfig);
Error ProcessMessage(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Error ProcessMessage(Message &aMessage,
TimeMilli aRxTime,
const TtlConfig &aTtlConfig,
const LeaseConfig &aLeaseConfig,
const Ip6::MessageInfo *aMessageInfo);
void ProcessDnsUpdate(Message &aMessage, MessageMetadata &aMetadata);
Error ProcessUpdateSection(Host &aHost, const Message &aMessage, MessageMetadata &aMetadata) const;
Error ProcessAdditionalSection(Host *aHost, const Message &aMessage, MessageMetadata &aMetadata) const;
Error VerifySignature(const Host::Key &aKey,
const Message &aMessage,
Dns::UpdateHeader aDnsHeader,
uint16_t aSigOffset,
uint16_t aSigRdataOffset,
uint16_t aSigRdataLength,
const char *aSignerName) const;
Error ProcessZoneSection(const Message &aMessage, MessageMetadata &aMetadata) const;
Error ProcessHostDescriptionInstruction(Host &aHost,
const Message &aMessage,
const MessageMetadata &aMetadata) const;
Error ProcessServiceDiscoveryInstructions(Host &aHost,
const Message &aMessage,
const MessageMetadata &aMetadata) const;
Error ProcessServiceDescriptionInstructions(Host &aHost, const Message &aMessage, MessageMetadata &aMetadata) const;
static bool IsValidDeleteAllRecord(const Dns::ResourceRecord &aRecord);
void HandleUpdate(Host &aHost, const MessageMetadata &aMetadata);
void RemoveHost(Host *aHost, RetainName aRetainName);
bool HasNameConflictsWith(Host &aHost) const;
void SendResponse(const Dns::UpdateHeader &aHeader,
Dns::UpdateHeader::Response aResponseCode,
const Ip6::MessageInfo &aMessageInfo);
void SendResponse(const Dns::UpdateHeader &aHeader,
uint32_t aLease,
uint32_t aKeyLease,
bool mUseShortLeaseOption,
const Ip6::MessageInfo &aMessageInfo);
void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleLeaseTimer(void);
static void HandleOutstandingUpdatesTimer(Timer &aTimer);
void HandleOutstandingUpdatesTimer(void);
void ProcessCompletedUpdates(void);
const UpdateMetadata *FindOutstandingUpdate(const MessageMetadata &aMessageMetadata) const;
static const char *AddressModeToString(AddressMode aMode);
void UpdateResponseCounters(Dns::Header::Response aResponseCode);
void UpdateAddrResolverCacheTable(const Ip6::MessageInfo &aMessageInfo, const Host &aHost);
using LeaseTimer = TimerMilliIn<Server, &Server::HandleLeaseTimer>;
using UpdateTimer = TimerMilliIn<Server, &Server::HandleOutstandingUpdatesTimer>;
using CompletedUpdatesTask = TaskletIn<Server, &Server::ProcessCompletedUpdates>;
using ServerSocket = Ip6::Udp::SocketIn<Server, &Server::HandleUdpReceive>;
ServerSocket mSocket;
Callback<otSrpServerServiceUpdateHandler> mServiceUpdateHandler;
Heap::String mDomain;
TtlConfig mTtlConfig;
LeaseConfig mLeaseConfig;
LinkedList<Host> mHosts;
LeaseTimer mLeaseTimer;
UpdateTimer mOutstandingUpdatesTimer;
LinkedList<UpdateMetadata> mOutstandingUpdates;
LinkedList<UpdateMetadata> mCompletedUpdates;
CompletedUpdatesTask mCompletedUpdateTask;
ServiceUpdateId mServiceUpdateId;
uint16_t mPort;
State mState;
AddressMode mAddressMode;
uint8_t mAnycastSequenceNumber;
bool mHasRegisteredAnyService : 1;
#if OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE
bool mAutoEnable : 1;
#endif
otSrpServerResponseCounters mResponseCounters;
};
Fields
Field
Declared as
ServerSocket
Callback<otSrpServerServiceUpdateHandler>
LeaseTimer
UpdateTimer
CompletedUpdatesTask
uint16_t
bool : 1
References
Code
Location
Scope
Referrer
Class Tree
ot::Srp::Server is inherited by 2 classess:
Instances
Instance
Scope
Location
Project