From 812c36f6581967b3d9af8361f00716c75f47473c Mon Sep 17 00:00:00 2001 From: Abtin Keshavarzian Date: Thu, 6 Oct 2022 18:32:22 -0700 Subject: [PATCH] [tmf] new model for handling TMF URI resources (#8233) This commit updates and simplifies the handling of TMF URI resources. The new model centralizes the processing and dispatching of URI handlers in `Tmf::Agent`. It should help reduce memory (RAM and code) use as well. - A new enumeration `Uri` type is defined specifying all the TMF URIs along with functions to map between `Uri` and the related URI path string. - We use binary search in a sorted table to match a path string (e.g., from a received CoAP message) to its corresponding URI. - `Coap` class is updated to allow sub-classes to register an optional `ResourceHandler` to handle URI resources. - `Tmf::Agent` uses the new `ResourceHandler` to process the TMF URI resources and invoke the related handlers on the proper module (e.g., passing `kUriAddressQuery` to `AddressResolver` module, `kUriActiveSet` to `MeshCoP::ActiveDatasetManager`, etc). - The TMF handlers are defined as `HandleTmf()` template method specializations which are defined on the proper module. - Most URI handlers can be processed at any time but some perform additional checks, e.g., `kUriAddressSolicit` is passed to `Mle::MleRouter` which checks that device role is leader before processing the request. --- src/core/backbone_router/bbr_manager.cpp | 44 +++--- src/core/backbone_router/bbr_manager.hpp | 20 +-- src/core/coap/coap.cpp | 44 ++++-- src/core/coap/coap.hpp | 74 ++++++--- src/core/coap/coap_message.cpp | 8 +- src/core/coap/coap_message.hpp | 9 +- src/core/common/instance.hpp | 15 ++ src/core/meshcop/announce_begin_client.cpp | 2 +- src/core/meshcop/border_agent.cpp | 68 ++++---- src/core/meshcop/border_agent.hpp | 15 +- src/core/meshcop/commissioner.cpp | 34 ++-- src/core/meshcop/commissioner.hpp | 15 +- src/core/meshcop/dataset_manager.cpp | 35 +---- src/core/meshcop/dataset_manager.hpp | 61 +++----- src/core/meshcop/dataset_manager_ftd.cpp | 30 +--- src/core/meshcop/energy_scan_client.cpp | 12 +- src/core/meshcop/energy_scan_client.hpp | 10 +- src/core/meshcop/joiner.cpp | 11 +- src/core/meshcop/joiner.hpp | 12 +- src/core/meshcop/joiner_router.cpp | 13 +- src/core/meshcop/joiner_router.hpp | 9 +- src/core/meshcop/meshcop_leader.cpp | 20 +-- src/core/meshcop/meshcop_leader.hpp | 29 ++-- src/core/meshcop/panid_query_client.cpp | 12 +- src/core/meshcop/panid_query_client.hpp | 11 +- src/core/thread/address_resolver.cpp | 38 ++--- src/core/thread/address_resolver.hpp | 48 +++--- src/core/thread/announce_begin_server.cpp | 10 +- src/core/thread/announce_begin_server.hpp | 11 +- src/core/thread/anycast_locator.cpp | 20 +-- src/core/thread/anycast_locator.hpp | 16 +- src/core/thread/dua_manager.cpp | 14 +- src/core/thread/dua_manager.hpp | 9 +- src/core/thread/energy_scan_server.cpp | 13 +- src/core/thread/energy_scan_server.hpp | 10 +- src/core/thread/mle_router.cpp | 32 +--- src/core/thread/mle_router.hpp | 15 +- src/core/thread/mlr_manager.cpp | 2 +- src/core/thread/network_data.cpp | 2 +- src/core/thread/network_data_leader_ftd.cpp | 46 ++---- src/core/thread/network_data_leader_ftd.hpp | 28 +--- src/core/thread/network_diagnostic.cpp | 59 ++----- src/core/thread/network_diagnostic.hpp | 26 ++-- src/core/thread/panid_query_server.cpp | 12 +- src/core/thread/panid_query_server.hpp | 11 +- src/core/thread/tmf.cpp | 111 +++++++++++++ src/core/thread/tmf.hpp | 28 +++- src/core/thread/uri_paths.cpp | 164 +++++++++++++++----- src/core/thread/uri_paths.hpp | 106 ++++++++----- 49 files changed, 746 insertions(+), 698 deletions(-) diff --git a/src/core/backbone_router/bbr_manager.cpp b/src/core/backbone_router/bbr_manager.cpp index 7a6d30a44..417dc1eda 100644 --- a/src/core/backbone_router/bbr_manager.cpp +++ b/src/core/backbone_router/bbr_manager.cpp @@ -55,13 +55,9 @@ RegisterLogModule("BbrManager"); Manager::Manager(Instance &aInstance) : InstanceLocator(aInstance) -#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE - , mMulticastListenerRegistration(UriPath::kMlr, Manager::HandleMulticastListenerRegistration, this) -#endif #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE - , mDuaRegistration(UriPath::kDuaRegistrationRequest, Manager::HandleDuaRegistration, this) - , mBackboneQuery(UriPath::kBackboneQuery, Manager::HandleBackboneQuery, this) - , mBackboneAnswer(UriPath::kBackboneAnswer, Manager::HandleBackboneAnswer, this) + , mBackboneQuery(kUriBackboneQuery, Manager::HandleBackboneQuery, this) + , mBackboneAnswer(kUriBackboneAnswer, Manager::HandleBackboneAnswer, this) , mNdProxyTable(aInstance) #endif #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE @@ -99,11 +95,7 @@ void Manager::HandleNotifierEvents(Events aEvents) if (Get().GetState() == OT_BACKBONE_ROUTER_STATE_DISABLED) { #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE - Get().RemoveResource(mMulticastListenerRegistration); mMulticastListenersTable.Clear(); -#endif -#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE - Get().RemoveResource(mDuaRegistration); #endif mTimer.Stop(); @@ -120,12 +112,6 @@ void Manager::HandleNotifierEvents(Events aEvents) } else { -#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE - Get().AddResource(mMulticastListenerRegistration); -#endif -#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE - Get().AddResource(mDuaRegistration); -#endif if (!mTimer.IsRunning()) { mTimer.Start(kTimerInterval); @@ -152,6 +138,15 @@ void Manager::HandleTimer(void) } #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE +template <> void Manager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +{ + VerifyOrExit(Get().GetState() != OT_BACKBONE_ROUTER_STATE_DISABLED); + HandleMulticastListenerRegistration(aMessage, aMessageInfo); + +exit: + return; +} + void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; @@ -339,7 +334,7 @@ void Manager::SendBackboneMulticastListenerRegistration(const Ip6::Address *aAdd OT_ASSERT(aAddressNum >= Ip6AddressesTlv::kMinAddresses && aAddressNum <= Ip6AddressesTlv::kMaxAddresses); - message = backboneTmf.NewNonConfirmablePostMessage(UriPath::kBackboneMlr); + message = backboneTmf.NewNonConfirmablePostMessage(kUriBackboneMlr); VerifyOrExit(message != nullptr, error = kErrorNoBufs); addressesTlv.Init(); @@ -364,6 +359,17 @@ exit: #endif // OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE + +template <> +void Manager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +{ + VerifyOrExit(Get().GetState() != OT_BACKBONE_ROUTER_STATE_DISABLED); + HandleDuaRegistration(aMessage, aMessageInfo); + +exit: + return; +} + void Manager::HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; @@ -525,7 +531,7 @@ Error Manager::SendBackboneQuery(const Ip6::Address &aDua, uint16_t aRloc16) VerifyOrExit(Get().IsPrimary(), error = kErrorInvalidState); - message = mBackboneTmfAgent.NewPriorityNonConfirmablePostMessage(UriPath::kBackboneQuery); + message = mBackboneTmfAgent.NewPriorityNonConfirmablePostMessage(kUriBackboneQuery); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, aDua)); @@ -665,7 +671,7 @@ Error Manager::SendBackboneAnswer(const Ip6::Address & aDstAddr, VerifyOrExit((message = mBackboneTmfAgent.NewPriorityMessage()) != nullptr, error = kErrorNoBufs); SuccessOrExit(error = message->Init(proactive ? Coap::kTypeNonConfirmable : Coap::kTypeConfirmable, Coap::kCodePost, - UriPath::kBackboneAnswer)); + kUriBackboneAnswer)); SuccessOrExit(error = message->SetPayloadMarker()); SuccessOrExit(error = Tlv::Append(*message, aDua)); diff --git a/src/core/backbone_router/bbr_manager.hpp b/src/core/backbone_router/bbr_manager.hpp index d0a001988..394a5e09a 100644 --- a/src/core/backbone_router/bbr_manager.hpp +++ b/src/core/backbone_router/bbr_manager.hpp @@ -49,6 +49,7 @@ #include "common/non_copyable.hpp" #include "net/netif.hpp" #include "thread/network_data.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -61,6 +62,7 @@ namespace BackboneRouter { class Manager : public InstanceLocator, private NonCopyable { friend class ot::Notifier; + friend class Tmf::Agent; public: /** @@ -171,14 +173,9 @@ public: private: static constexpr uint32_t kTimerInterval = 1000; + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE - static void HandleMulticastListenerRegistration(void * aContext, - otMessage * aMessage, - const otMessageInfo *aMessageInfo) - { - static_cast(aContext)->HandleMulticastListenerRegistration( - *static_cast(aMessage), *static_cast(aMessageInfo)); - } void HandleMulticastListenerRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); void SendMulticastListenerRegistrationResponse(const Coap::Message & aMessage, @@ -192,11 +189,6 @@ private: #endif #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE - static void HandleDuaRegistration(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) - { - static_cast(aContext)->HandleDuaRegistration(*static_cast(aMessage), - *static_cast(aMessageInfo)); - } void HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleBackboneQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); void HandleBackboneQuery(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); @@ -232,11 +224,7 @@ private: using BbrTimer = TimerMilliIn; -#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE - Coap::Resource mMulticastListenerRegistration; -#endif #if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE - Coap::Resource mDuaRegistration; Coap::Resource mBackboneQuery; Coap::Resource mBackboneAnswer; NdProxyTable mNdProxyTable; diff --git a/src/core/coap/coap.cpp b/src/core/coap/coap.cpp index 88f948236..bb4e493ec 100644 --- a/src/core/coap/coap.cpp +++ b/src/core/coap/coap.cpp @@ -59,6 +59,7 @@ CoapBase::CoapBase(Instance &aInstance, Sender aSender) , mResponsesQueue(aInstance) , mDefaultHandler(nullptr) , mDefaultHandlerContext(nullptr) + , mResourceHandler(nullptr) , mSender(aSender) #if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE , mLastResponse(nullptr) @@ -139,24 +140,24 @@ exit: return message; } -Message *CoapBase::NewPriorityConfirmablePostMessage(const char *aUriPath) +Message *CoapBase::NewPriorityConfirmablePostMessage(Uri aUri) { - return InitMessage(NewPriorityMessage(), kTypeConfirmable, aUriPath); + return InitMessage(NewPriorityMessage(), kTypeConfirmable, aUri); } -Message *CoapBase::NewConfirmablePostMessage(const char *aUriPath) +Message *CoapBase::NewConfirmablePostMessage(Uri aUri) { - return InitMessage(NewMessage(), kTypeConfirmable, aUriPath); + return InitMessage(NewMessage(), kTypeConfirmable, aUri); } -Message *CoapBase::NewPriorityNonConfirmablePostMessage(const char *aUriPath) +Message *CoapBase::NewPriorityNonConfirmablePostMessage(Uri aUri) { - return InitMessage(NewPriorityMessage(), kTypeNonConfirmable, aUriPath); + return InitMessage(NewPriorityMessage(), kTypeNonConfirmable, aUri); } -Message *CoapBase::NewNonConfirmablePostMessage(const char *aUriPath) +Message *CoapBase::NewNonConfirmablePostMessage(Uri aUri) { - return InitMessage(NewMessage(), kTypeNonConfirmable, aUriPath); + return InitMessage(NewMessage(), kTypeNonConfirmable, aUri); } Message *CoapBase::NewPriorityResponseMessage(const Message &aRequest) @@ -169,13 +170,13 @@ Message *CoapBase::NewResponseMessage(const Message &aRequest) return InitResponse(NewMessage(), aRequest); } -Message *CoapBase::InitMessage(Message *aMessage, Type aType, const char *aUriPath) +Message *CoapBase::InitMessage(Message *aMessage, Type aType, Uri aUri) { Error error = kErrorNone; VerifyOrExit(aMessage != nullptr); - SuccessOrExit(error = aMessage->Init(aType, kCodePost, aUriPath)); + SuccessOrExit(error = aMessage->Init(aType, kCodePost, aUri)); SuccessOrExit(error = aMessage->SetPayloadMarker()); exit: @@ -1433,6 +1434,12 @@ void CoapBase::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo SuccessOrExit(error = aMessage.ReadUriPathOptions(uriPath)); #endif // OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE + if ((mResourceHandler != nullptr) && mResourceHandler(*this, uriPath, aMessage, aMessageInfo)) + { + error = kErrorNone; + ExitNow(); + } + for (const Resource &resource : mResources) { if (strcmp(resource.mUriPath, uriPath) == 0) @@ -1695,6 +1702,23 @@ const otCoapTxParameters TxParameters::kDefaultTxParameters = { kDefaultMaxRetransmit, }; +//---------------------------------------------------------------------------------------------------------------------- + +Resource::Resource(const char *aUriPath, RequestHandler aHandler, void *aContext) +{ + mUriPath = aUriPath; + mHandler = aHandler; + mContext = aContext; + mNext = nullptr; +} + +Resource::Resource(Uri aUri, RequestHandler aHandler, void *aContext) + : Resource(PathForUri(aUri), aHandler, aContext) +{ +} + +//---------------------------------------------------------------------------------------------------------------------- + Coap::Coap(Instance &aInstance) : CoapBase(aInstance, &Coap::Send) , mSocket(aInstance) diff --git a/src/core/coap/coap.hpp b/src/core/coap/coap.hpp index cfebb9d9b..f5fcd1a3c 100644 --- a/src/core/coap/coap.hpp +++ b/src/core/coap/coap.hpp @@ -44,6 +44,7 @@ #include "net/ip6.hpp" #include "net/netif.hpp" #include "net/udp6.hpp" +#include "thread/uri_paths.hpp" /** * @file @@ -150,14 +151,19 @@ public: * @param[in] aUriPath A pointer to a null-terminated string for the URI path. * @param[in] aHandler A function pointer that is called when receiving a CoAP message for @p aUriPath. * @param[in] aContext A pointer to arbitrary context information. + * */ - Resource(const char *aUriPath, RequestHandler aHandler, void *aContext) - { - mUriPath = aUriPath; - mHandler = aHandler; - mContext = aContext; - mNext = nullptr; - } + Resource(const char *aUriPath, RequestHandler aHandler, void *aContext); + + /** + * This constructor initializes the resource. + * + * @param[in] aUri A Thread URI. + * @param[in] aHandler A function pointer that is called when receiving a CoAP message for the URI. + * @param[in] aContext A pointer to arbitrary context information. + * + */ + Resource(Uri aUri, RequestHandler aHandler, void *aContext); /** * This method returns a pointer to the URI path. @@ -463,58 +469,58 @@ public: * Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and * remove the payload marker when there is no payload. * - * @param[in] aUriPath The URI path string. + * @param[in] aUri The URI. * * @returns A pointer to the message or `nullptr` if failed to allocate message. * */ - Message *NewPriorityConfirmablePostMessage(const char *aUriPath); + Message *NewPriorityConfirmablePostMessage(Uri aUri); /** * This method allocates and initializes a new CoAP Confirmable Post message with normal priority level. * - * The CoAP header is initialized as `kTypeConfirmable` and `kCodePost` with a given URI path and a randomly + * The CoAP header is initialized as `kTypeConfirmable` and `kCodePost` with a given URI and a randomly * generated token (of default length). This method also sets the payload marker (calling `SetPayloadMarker()`). * Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and * remove the payload marker when there is no payload. * - * @param[in] aUriPath The URI path string. + * @param[in] aUri The URI. * * @returns A pointer to the message or `nullptr` if failed to allocate message. * */ - Message *NewConfirmablePostMessage(const char *aUriPath); + Message *NewConfirmablePostMessage(Uri aUri); /** * This method allocates and initializes a new CoAP Non-confirmable Post message with Network Control priority * level. * - * The CoAP header is initialized as `kTypeNonConfirmable` and `kCodePost` with a given URI path and a randomly + * The CoAP header is initialized as `kTypeNonConfirmable` and `kCodePost` with a given URI and a randomly * generated token (of default length). This method also sets the payload marker (calling `SetPayloadMarker()`). * Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and * remove the payload marker when there is no payload. * - * @param[in] aUriPath The URI path string. + * @param[in] aUri The URI. * * @returns A pointer to the message or `nullptr` if failed to allocate message. * */ - Message *NewPriorityNonConfirmablePostMessage(const char *aUriPath); + Message *NewPriorityNonConfirmablePostMessage(Uri aUri); /** * This method allocates and initializes a new CoAP Non-confirmable Post message with normal priority level. * - * The CoAP header is initialized as `kTypeNonConfirmable` and `kCodePost` with a given URI path and a randomly + * The CoAP header is initialized as `kTypeNonConfirmable` and `kCodePost` with a given URI and a randomly * generated token (of default length). This method also sets the payload marker (calling `SetPayloadMarker()`). * Even if message has no payload, calling `SetPayloadMarker()` is harmless, since `SendMessage()` will check and * remove the payload marker when there is no payload. * - * @param[in] aUriPath The URI path string. + * @param[in] aUri The URI. * * @returns A pointer to the message or `nullptr` if failed to allocate message. * */ - Message *NewNonConfirmablePostMessage(const char *aUriPath); + Message *NewNonConfirmablePostMessage(Uri aUri); /** * This method allocates and initializes a new CoAP response message with Network Control priority level for a @@ -742,6 +748,26 @@ public: const MessageQueue &GetCachedResponses(void) const { return mResponsesQueue.GetResponses(); } protected: + /** + * This type defines function pointer to handle a CoAP resource. + * + * When processing a received request, this handler is called first with the URI path before checking the list of + * added `Resource` entries to match against the URI path. + * + * @param[in] aCoapBase A reference the CoAP agent. + * @param[in] aUriPath The URI Path string. + * @param[in] aMessage The received message. + * @param[in] aMessageInfo The message info associated with @p aMessage. + * + * @retval TRUE Indicates that the URI path was known and the message was processed by the handler. + * @retval FALSE Indicates that URI path was not known and the message was not processed by the handler. + * + */ + typedef bool (*ResourceHandler)(CoapBase & aCoapBase, + const char * aUriPath, + Message & aMessage, + const Ip6::MessageInfo &aMessageInfo); + /** * This function pointer is called to send a CoAP message. * @@ -774,6 +800,14 @@ protected: */ void Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + /** + * This method sets the resource handler function. + * + * @param[in] aResourceHandler The resource handler function pointer. + * + */ + void SetResourceHandler(ResourceHandler aHandler) { mResourceHandler = aHandler; } + private: struct Metadata { @@ -807,7 +841,7 @@ private: #endif }; - Message *InitMessage(Message *aMessage, Type aType, const char *aUriPath); + Message *InitMessage(Message *aMessage, Type aType, Uri aUri); Message *InitResponse(Message *aMessage, const Message &aResponse); static void HandleRetransmissionTimer(Timer &aTimer); @@ -873,6 +907,8 @@ private: RequestHandler mDefaultHandler; void * mDefaultHandlerContext; + ResourceHandler mResourceHandler; + const Sender mSender; #if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE diff --git a/src/core/coap/coap_message.cpp b/src/core/coap/coap_message.cpp index bd1c152b5..395e9ef86 100644 --- a/src/core/coap/coap_message.cpp +++ b/src/core/coap/coap_message.cpp @@ -67,21 +67,21 @@ void Message::Init(Type aType, Code aCode) SetCode(aCode); } -Error Message::Init(Type aType, Code aCode, const char *aUriPath) +Error Message::Init(Type aType, Code aCode, Uri aUri) { Error error; Init(aType, aCode); SuccessOrExit(error = GenerateRandomToken(kDefaultTokenLength)); - SuccessOrExit(error = AppendUriPathOptions(aUriPath)); + SuccessOrExit(error = AppendUriPathOptions(PathForUri(aUri))); exit: return error; } -Error Message::InitAsPost(const Ip6::Address &aDestination, const char *aUriPath) +Error Message::InitAsPost(const Ip6::Address &aDestination, Uri aUri) { - return Init(aDestination.IsMulticast() ? kTypeNonConfirmable : kTypeConfirmable, kCodePost, aUriPath); + return Init(aDestination.IsMulticast() ? kTypeNonConfirmable : kTypeConfirmable, kCodePost, aUri); } bool Message::IsConfirmablePostRequest(void) const diff --git a/src/core/coap/coap_message.hpp b/src/core/coap/coap_message.hpp index 0687201eb..dbb0f5ccf 100644 --- a/src/core/coap/coap_message.hpp +++ b/src/core/coap/coap_message.hpp @@ -47,6 +47,7 @@ #include "net/ip6.hpp" #include "net/ip6_address.hpp" #include "net/udp6.hpp" +#include "thread/uri_paths.hpp" namespace ot { @@ -208,13 +209,13 @@ public: * * @param[in] aType The Type value. * @param[in] aCode The Code value. - * @param[in] aUriPath A pointer to a null-terminated string. + * @param[in] aUri The URI. * * @retval kErrorNone Successfully appended the option. * @retval kErrorNoBufs The option length exceeds the buffer size. * */ - Error Init(Type aType, Code aCode, const char *aUriPath); + Error Init(Type aType, Code aCode, Uri aUri); /** * This method initializes the CoAP header as `kCodePost` with a given URI Path with its type determined from a @@ -222,13 +223,13 @@ public: * * @param[in] aDestination The message destination IPv6 address used to determine the CoAP type, * `kTypeNonConfirmable` if multicast address, `kTypeConfirmable` otherwise. - * @param[in] aUriPath A pointer to a null-terminated string. + * @param[in] aUri The URI. * * @retval kErrorNone Successfully appended the option. * @retval kErrorNoBufs The option length exceeds the buffer size. * */ - Error InitAsPost(const Ip6::Address &aDestination, const char *aUriPath); + Error InitAsPost(const Ip6::Address &aDestination, Uri aUri); /** * This method writes header to the message. This must be called before sending the message. diff --git a/src/core/common/instance.hpp b/src/core/common/instance.hpp index 8dabb6054..39827bc3e 100644 --- a/src/core/common/instance.hpp +++ b/src/core/common/instance.hpp @@ -941,6 +941,21 @@ template <> inline MeshCoP::Commissioner &Instance::Get(void) { return mCommissioner; } + +template <> inline AnnounceBeginClient &Instance::Get(void) +{ + return mCommissioner.GetAnnounceBeginClient(); +} + +template <> inline EnergyScanClient &Instance::Get(void) +{ + return mCommissioner.GetEnergyScanClient(); +} + +template <> inline PanIdQueryClient &Instance::Get(void) +{ + return mCommissioner.GetPanIdQueryClient(); +} #endif #if OPENTHREAD_CONFIG_JOINER_ENABLE diff --git a/src/core/meshcop/announce_begin_client.cpp b/src/core/meshcop/announce_begin_client.cpp index b1bb69999..5f164acb8 100644 --- a/src/core/meshcop/announce_begin_client.cpp +++ b/src/core/meshcop/announce_begin_client.cpp @@ -68,7 +68,7 @@ Error AnnounceBeginClient::SendRequest(uint32_t aChannelMask, VerifyOrExit(Get().IsActive(), error = kErrorInvalidState); VerifyOrExit((message = Get().NewPriorityMessage()) != nullptr, error = kErrorNoBufs); - SuccessOrExit(error = message->InitAsPost(aAddress, UriPath::kAnnounceBegin)); + SuccessOrExit(error = message->InitAsPost(aAddress, kUriAnnounceBegin)); SuccessOrExit(error = message->SetPayloadMarker()); SuccessOrExit( diff --git a/src/core/meshcop/border_agent.cpp b/src/core/meshcop/border_agent.cpp index 79ad790a7..d63c8ae6d 100644 --- a/src/core/meshcop/border_agent.cpp +++ b/src/core/meshcop/border_agent.cpp @@ -226,7 +226,7 @@ void BorderAgent::HandleRequest(void *aContext, otMessage *aMessage, const otMes { IgnoreError(static_cast(aContext)->ForwardToLeader( AsCoapMessage(aMessage), AsCoreType(aMessageInfo), - (static_cast(aContext)->*aResource).GetUriPath(), false, false)); + UriFromPath((static_cast(aContext)->*aResource).GetUriPath()), false, false)); } template <> @@ -235,7 +235,7 @@ void BorderAgent::HandleRequest<&BorderAgent::mCommissionerPetition>(void * const otMessageInfo *aMessageInfo) { IgnoreError(static_cast(aContext)->ForwardToLeader(AsCoapMessage(aMessage), AsCoreType(aMessageInfo), - UriPath::kLeaderPetition, true, true)); + kUriLeaderPetition, true, true)); } template <> @@ -255,15 +255,6 @@ void BorderAgent::HandleRequest<&BorderAgent::mRelayTransmit>(void * static_cast(aContext)->HandleRelayTransmit(AsCoapMessage(aMessage)); } -template <> -void BorderAgent::HandleRequest<&BorderAgent::mRelayReceive>(void * aContext, - otMessage * aMessage, - const otMessageInfo *aMessageInfo) -{ - OT_UNUSED_VARIABLE(aMessageInfo); - static_cast(aContext)->HandleRelayReceive(AsCoapMessage(aMessage)); -} - template <> void BorderAgent::HandleRequest<&BorderAgent::mProxyTransmit>(void * aContext, otMessage * aMessage, @@ -275,21 +266,20 @@ void BorderAgent::HandleRequest<&BorderAgent::mProxyTransmit>(void * BorderAgent::BorderAgent(Instance &aInstance) : InstanceLocator(aInstance) - , mCommissionerPetition(UriPath::kCommissionerPetition, + , mCommissionerPetition(kUriCommissionerPetition, BorderAgent::HandleRequest<&BorderAgent::mCommissionerPetition>, this) - , mCommissionerKeepAlive(UriPath::kCommissionerKeepAlive, + , mCommissionerKeepAlive(kUriCommissionerKeepAlive, BorderAgent::HandleRequest<&BorderAgent::mCommissionerKeepAlive>, this) - , mRelayTransmit(UriPath::kRelayTx, BorderAgent::HandleRequest<&BorderAgent::mRelayTransmit>, this) - , mRelayReceive(UriPath::kRelayRx, BorderAgent::HandleRequest<&BorderAgent::mRelayReceive>, this) - , mCommissionerGet(UriPath::kCommissionerGet, BorderAgent::HandleRequest<&BorderAgent::mCommissionerGet>, this) - , mCommissionerSet(UriPath::kCommissionerSet, BorderAgent::HandleRequest<&BorderAgent::mCommissionerSet>, this) - , mActiveGet(UriPath::kActiveGet, BorderAgent::HandleRequest<&BorderAgent::mActiveGet>, this) - , mActiveSet(UriPath::kActiveSet, BorderAgent::HandleRequest<&BorderAgent::mActiveSet>, this) - , mPendingGet(UriPath::kPendingGet, BorderAgent::HandleRequest<&BorderAgent::mPendingGet>, this) - , mPendingSet(UriPath::kPendingSet, BorderAgent::HandleRequest<&BorderAgent::mPendingSet>, this) - , mProxyTransmit(UriPath::kProxyTx, BorderAgent::HandleRequest<&BorderAgent::mProxyTransmit>, this) + , mRelayTransmit(kUriRelayTx, BorderAgent::HandleRequest<&BorderAgent::mRelayTransmit>, this) + , mCommissionerGet(kUriCommissionerGet, BorderAgent::HandleRequest<&BorderAgent::mCommissionerGet>, this) + , mCommissionerSet(kUriCommissionerSet, BorderAgent::HandleRequest<&BorderAgent::mCommissionerSet>, this) + , mActiveGet(kUriActiveGet, BorderAgent::HandleRequest<&BorderAgent::mActiveGet>, this) + , mActiveSet(kUriActiveSet, BorderAgent::HandleRequest<&BorderAgent::mActiveSet>, this) + , mPendingGet(kUriPendingGet, BorderAgent::HandleRequest<&BorderAgent::mPendingGet>, this) + , mPendingSet(kUriPendingSet, BorderAgent::HandleRequest<&BorderAgent::mPendingSet>, this) + , mProxyTransmit(kUriProxyTx, BorderAgent::HandleRequest<&BorderAgent::mProxyTransmit>, this) , mUdpReceiver(BorderAgent::HandleUdpReceive, this) , mTimer(aInstance) , mState(kStateStopped) @@ -367,7 +357,7 @@ bool BorderAgent::HandleUdpReceive(const Message &aMessage, const Ip6::MessageIn VerifyOrExit(aMessage.GetLength() > 0, error = kErrorNone); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kProxyRx); + message = Get().NewPriorityNonConfirmablePostMessage(kUriProxyRx); VerifyOrExit(message != nullptr, error = kErrorNoBufs); { @@ -390,7 +380,7 @@ bool BorderAgent::HandleUdpReceive(const Message &aMessage, const Ip6::MessageIn SuccessOrExit(error = Get().SendMessage(*message, Get().GetMessageInfo())); - LogInfo("Sent to commissioner on %s", UriPath::kProxyRx); + LogInfo("Sent to commissioner on ProxyRx (c/ur)"); exit: FreeMessageOnError(message, error); @@ -402,18 +392,22 @@ exit: return error != kErrorDestinationAddressFiltered; } -void BorderAgent::HandleRelayReceive(const Coap::Message &aMessage) +template <> void BorderAgent::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { + OT_UNUSED_VARIABLE(aMessageInfo); + Coap::Message *message = nullptr; - Error error; + Error error = kErrorNone; + + VerifyOrExit(mState != kStateStopped); VerifyOrExit(aMessage.IsNonConfirmablePostRequest(), error = kErrorDrop); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kRelayRx); + message = Get().NewPriorityNonConfirmablePostMessage(kUriRelayRx); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = ForwardToCommissioner(*message, aMessage)); - LogInfo("Sent to commissioner on %s", UriPath::kRelayRx); + LogInfo("Sent to commissioner on RelayRx (c/rx)"); exit: FreeMessageOnError(message, error); @@ -442,7 +436,7 @@ void BorderAgent::HandleKeepAlive(const Coap::Message &aMessage, const Ip6::Mess { Error error; - error = ForwardToLeader(aMessage, aMessageInfo, UriPath::kLeaderKeepAlive, false, true); + error = ForwardToLeader(aMessage, aMessageInfo, kUriLeaderKeepAlive, false, true); if (error == kErrorNone) { @@ -462,7 +456,7 @@ void BorderAgent::HandleRelayTransmit(const Coap::Message &aMessage) SuccessOrExit(error = Tlv::Find(aMessage, joinerRouterRloc)); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kRelayTx); + message = Get().NewPriorityNonConfirmablePostMessage(kUriRelayTx); VerifyOrExit(message != nullptr, error = kErrorNoBufs); offset = message->GetLength(); @@ -474,7 +468,7 @@ void BorderAgent::HandleRelayTransmit(const Coap::Message &aMessage) SuccessOrExit(error = Get().SendMessage(*message, messageInfo)); - LogInfo("Sent to joiner router request on %s", UriPath::kRelayTx); + LogInfo("Sent to joiner router request on %s", kUriRelayTx); exit: FreeMessageOnError(message, error); @@ -483,7 +477,7 @@ exit: Error BorderAgent::ForwardToLeader(const Coap::Message & aMessage, const Ip6::MessageInfo &aMessageInfo, - const char * aPath, + Uri aUri, bool aPetition, bool aSeparate) { @@ -493,6 +487,8 @@ Error BorderAgent::ForwardToLeader(const Coap::Message & aMessage, Coap::Message * message = nullptr; uint16_t offset = 0; + VerifyOrExit(aUri != kUriUnknown); + if (aSeparate) { SuccessOrExit(error = Get().SendAck(aMessage, aMessageInfo)); @@ -503,7 +499,7 @@ Error BorderAgent::ForwardToLeader(const Coap::Message & aMessage, forwardContext->Init(GetInstance(), aMessage, aPetition, aSeparate); - message = Get().NewPriorityConfirmablePostMessage(aPath); + message = Get().NewPriorityConfirmablePostMessage(aUri); VerifyOrExit(message != nullptr, error = kErrorNoBufs); offset = message->GetLength(); @@ -518,7 +514,7 @@ Error BorderAgent::ForwardToLeader(const Coap::Message & aMessage, // HandleCoapResponse is responsible to free this forward context. forwardContext = nullptr; - LogInfo("Forwarded request to leader on %s", aPath); + LogInfo("Forwarded request to leader on %s", PathForUri(aUri)); exit: LogError("forward to leader", error); @@ -591,8 +587,6 @@ void BorderAgent::Start(void) coaps.AddResource(mProxyTransmit); coaps.AddResource(mRelayTransmit); - Get().AddResource(mRelayReceive); - mState = kStateStarted; mUdpProxyPort = 0; @@ -633,8 +627,6 @@ void BorderAgent::Stop(void) coaps.RemoveResource(mProxyTransmit); coaps.RemoveResource(mRelayTransmit); - Get().RemoveResource(mRelayReceive); - coaps.Stop(); mState = kStateStopped; diff --git a/src/core/meshcop/border_agent.hpp b/src/core/meshcop/border_agent.hpp index 44a403401..8e7e09df2 100644 --- a/src/core/meshcop/border_agent.hpp +++ b/src/core/meshcop/border_agent.hpp @@ -40,12 +40,13 @@ #include -#include "coap/coap.hpp" #include "common/as_core_type.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "common/notifier.hpp" #include "net/udp6.hpp" +#include "thread/tmf.hpp" +#include "thread/uri_paths.hpp" namespace ot { @@ -54,6 +55,7 @@ namespace MeshCoP { class BorderAgent : public InstanceLocator, private NonCopyable { friend class ot::Notifier; + friend class Tmf::Agent; public: /** @@ -145,11 +147,12 @@ private: static void HandleConnected(bool aConnected, void *aContext); void HandleConnected(bool aConnected); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - static void HandleTimeout(Timer &aTimer); - void HandleTimeout(void); + void HandleTimeout(void); static void HandleCoapResponse(void * aContext, otMessage * aMessage, @@ -159,13 +162,12 @@ private: Error ForwardToLeader(const Coap::Message & aMessage, const Ip6::MessageInfo &aMessageInfo, - const char * aPath, + Uri aUri, bool aPetition, bool aSeparate); Error ForwardToCommissioner(Coap::Message &aForwardMessage, const Message &aMessage); void HandleKeepAlive(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); void HandleRelayTransmit(const Coap::Message &aMessage); - void HandleRelayReceive(const Coap::Message &aMessage); void HandleProxyTransmit(const Coap::Message &aMessage); static bool HandleUdpReceive(void *aContext, const otMessage *aMessage, const otMessageInfo *aMessageInfo) { @@ -182,7 +184,6 @@ private: Coap::Resource mCommissionerPetition; Coap::Resource mCommissionerKeepAlive; Coap::Resource mRelayTransmit; - Coap::Resource mRelayReceive; Coap::Resource mCommissionerGet; Coap::Resource mCommissionerSet; Coap::Resource mActiveGet; @@ -199,6 +200,8 @@ private: uint16_t mUdpProxyPort; }; +DeclareTmfHandler(BorderAgent, kUriRelayRx); + } // namespace MeshCoP DefineMapEnum(otBorderAgentState, MeshCoP::BorderAgent::State); diff --git a/src/core/meshcop/commissioner.cpp b/src/core/meshcop/commissioner.cpp index 8c4facb8d..331d74e49 100644 --- a/src/core/meshcop/commissioner.cpp +++ b/src/core/meshcop/commissioner.cpp @@ -66,9 +66,7 @@ Commissioner::Commissioner(Instance &aInstance) , mTransmitAttempts(0) , mJoinerExpirationTimer(aInstance) , mTimer(aInstance) - , mRelayReceive(UriPath::kRelayRx, &Commissioner::HandleRelayReceive, this) - , mDatasetChanged(UriPath::kDatasetChanged, &Commissioner::HandleDatasetChanged, this) - , mJoinerFinalize(UriPath::kJoinerFinalize, &Commissioner::HandleJoinerFinalize, this) + , mJoinerFinalize(kUriJoinerFinalize, &Commissioner::HandleJoinerFinalize, this) , mAnnounceBegin(aInstance) , mEnergyScan(aInstance) , mPanIdQuery(aInstance) @@ -141,15 +139,11 @@ exit: void Commissioner::AddCoapResources(void) { - Get().AddResource(mRelayReceive); - Get().AddResource(mDatasetChanged); Get().AddResource(mJoinerFinalize); } void Commissioner::RemoveCoapResources(void) { - Get().RemoveResource(mRelayReceive); - Get().RemoveResource(mDatasetChanged); Get().RemoveResource(mJoinerFinalize); } @@ -705,7 +699,7 @@ Error Commissioner::SendMgmtCommissionerGetRequest(const uint8_t *aTlvs, uint8_t Tmf::MessageInfo messageInfo(GetInstance()); Tlv tlv; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kCommissionerGet); + message = Get().NewPriorityConfirmablePostMessage(kUriCommissionerGet); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aLength > 0) @@ -755,7 +749,7 @@ Error Commissioner::SendMgmtCommissionerSetRequest(const Dataset &aDataset, cons Coap::Message * message; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewPriorityConfirmablePostMessage(UriPath::kCommissionerSet); + message = Get().NewPriorityConfirmablePostMessage(kUriCommissionerSet); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aDataset.IsLocatorSet()) @@ -827,7 +821,7 @@ Error Commissioner::SendPetition(void) mTransmitAttempts++; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kLeaderPetition); + message = Get().NewPriorityConfirmablePostMessage(kUriLeaderPetition); VerifyOrExit(message != nullptr, error = kErrorNoBufs); commissionerIdTlv.Init(); @@ -917,7 +911,7 @@ void Commissioner::SendKeepAlive(uint16_t aSessionId) Coap::Message * message = nullptr; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewPriorityConfirmablePostMessage(UriPath::kLeaderKeepAlive); + message = Get().NewPriorityConfirmablePostMessage(kUriLeaderKeepAlive); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit( @@ -968,12 +962,7 @@ exit: return; } -void Commissioner::HandleRelayReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleRelayReceive(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Commissioner::HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Commissioner::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { OT_UNUSED_VARIABLE(aMessageInfo); @@ -1036,13 +1025,10 @@ exit: return; } -void Commissioner::HandleDatasetChanged(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDatasetChanged(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Commissioner::HandleDatasetChanged(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void Commissioner::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { + VerifyOrExit(mState == kStateActive); VerifyOrExit(aMessage.IsConfirmablePostRequest()); LogInfo("received dataset changed"); @@ -1153,7 +1139,7 @@ Error Commissioner::SendRelayTransmit(Message &aMessage, const Ip6::MessageInfo Get().ExtractKek(kek); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kRelayTx); + message = Get().NewPriorityNonConfirmablePostMessage(kUriRelayTx); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, mJoinerPort)); diff --git a/src/core/meshcop/commissioner.hpp b/src/core/meshcop/commissioner.hpp index d2129ac36..846e503c7 100644 --- a/src/core/meshcop/commissioner.hpp +++ b/src/core/meshcop/commissioner.hpp @@ -40,7 +40,6 @@ #include -#include "coap/coap.hpp" #include "coap/coap_secure.hpp" #include "common/as_core_type.hpp" #include "common/clearable.hpp" @@ -57,6 +56,7 @@ #include "net/udp6.hpp" #include "thread/key_manager.hpp" #include "thread/mle.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -64,6 +64,8 @@ namespace MeshCoP { class Commissioner : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This enumeration type represents the Commissioner State. @@ -575,11 +577,9 @@ private: static void HandleCoapsConnected(bool aConnected, void *aContext); void HandleCoapsConnected(bool aConnected); - static void HandleRelayReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - static void HandleDatasetChanged(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDatasetChanged(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + void HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleJoinerFinalize(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); void HandleJoinerFinalize(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); @@ -615,8 +615,6 @@ private: JoinerExpirationTimer mJoinerExpirationTimer; CommissionerTimer mTimer; - Coap::Resource mRelayReceive; - Coap::Resource mDatasetChanged; Coap::Resource mJoinerFinalize; AnnounceBeginClient mAnnounceBegin; @@ -635,6 +633,9 @@ private: void * mCallbackContext; }; +DeclareTmfHandler(Commissioner, kUriDatasetChanged); +DeclareTmfHandler(Commissioner, kUriRelayRx); + } // namespace MeshCoP DefineMapEnum(otCommissionerState, MeshCoP::Commissioner::State); diff --git a/src/core/meshcop/dataset_manager.cpp b/src/core/meshcop/dataset_manager.cpp index cab4dc217..ca7f3b748 100644 --- a/src/core/meshcop/dataset_manager.cpp +++ b/src/core/meshcop/dataset_manager.cpp @@ -278,8 +278,7 @@ void DatasetManager::SendSet(void) } } - message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveSet - : UriPath::kPendingSet); + message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? kUriActiveSet : kUriPendingSet); VerifyOrExit(message != nullptr, error = kErrorNoBufs); IgnoreError(Read(dataset)); @@ -481,8 +480,7 @@ Error DatasetManager::SendSetRequest(const Dataset::Info & aDatasetInfo, VerifyOrExit(!mMgmtPending, error = kErrorBusy); - message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveSet - : UriPath::kPendingSet); + message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? kUriActiveSet : kUriPendingSet); VerifyOrExit(message != nullptr, error = kErrorNoBufs); #if OPENTHREAD_CONFIG_COMMISSIONER_ENABLE && OPENTHREAD_FTD @@ -606,8 +604,7 @@ Error DatasetManager::SendGetRequest(const Dataset::Components &aDatasetComponen datasetTlvs[length++] = Tlv::kChannelMask; } - message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveGet - : UriPath::kPendingGet); + message = Get().NewPriorityConfirmablePostMessage(IsActiveDataset() ? kUriActiveGet : kUriPendingGet); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aLength + length > 0) @@ -646,12 +643,7 @@ exit: ActiveDatasetManager::ActiveDatasetManager(Instance &aInstance) : DatasetManager(aInstance, Dataset::kActive, ActiveDatasetManager::HandleTimer) - , mResourceGet(UriPath::kActiveGet, &ActiveDatasetManager::HandleGet, this) -#if OPENTHREAD_FTD - , mResourceSet(UriPath::kActiveSet, &ActiveDatasetManager::HandleSet, this) -#endif { - Get().AddResource(mResourceGet); } bool ActiveDatasetManager::IsPartiallyComplete(void) const @@ -689,12 +681,8 @@ exit: return error; } -void ActiveDatasetManager::HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void ActiveDatasetManager::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const +template <> +void ActiveDatasetManager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { DatasetManager::HandleGet(aMessage, aMessageInfo); } @@ -707,12 +695,7 @@ void ActiveDatasetManager::HandleTimer(Timer &aTimer) PendingDatasetManager::PendingDatasetManager(Instance &aInstance) : DatasetManager(aInstance, Dataset::kPending, PendingDatasetManager::HandleTimer) , mDelayTimer(aInstance) - , mResourceGet(UriPath::kPendingGet, &PendingDatasetManager::HandleGet, this) -#if OPENTHREAD_FTD - , mResourceSet(UriPath::kPendingSet, &PendingDatasetManager::HandleSet, this) -#endif { - Get().AddResource(mResourceGet); } void PendingDatasetManager::Clear(void) @@ -837,12 +820,8 @@ exit: return; } -void PendingDatasetManager::HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void PendingDatasetManager::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const +template <> +void PendingDatasetManager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { DatasetManager::HandleGet(aMessage, aMessageInfo); } diff --git a/src/core/meshcop/dataset_manager.hpp b/src/core/meshcop/dataset_manager.hpp index 2fa54af4f..17cef4f82 100644 --- a/src/core/meshcop/dataset_manager.hpp +++ b/src/core/meshcop/dataset_manager.hpp @@ -37,7 +37,6 @@ #include "openthread-core-config.h" -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "common/timer.hpp" @@ -45,6 +44,7 @@ #include "meshcop/dataset.hpp" #include "meshcop/dataset_local.hpp" #include "net/udp6.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -365,6 +365,8 @@ private: class ActiveDatasetManager : public DatasetManager, private NonCopyable { + friend class Tmf::Agent; + public: /** * This constructor initializes the ActiveDatasetManager object. @@ -469,12 +471,6 @@ public: */ void StartLeader(void); - /** - * This method stops the Leader functions for maintaining the Active Operational Dataset. - * - */ - void StopLeader(void); - /** * This method generate a default Active Operational Dataset. * @@ -487,26 +483,21 @@ public: #endif private: + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + static void HandleTimer(Timer &aTimer); void HandleTimer(void) { DatasetManager::HandleTimer(); } - - static void HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const; - -#if OPENTHREAD_FTD - static void HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); -#endif - - Coap::Resource mResourceGet; - -#if OPENTHREAD_FTD - Coap::Resource mResourceSet; -#endif }; +DeclareTmfHandler(ActiveDatasetManager, kUriActiveGet); +#if OPENTHREAD_FTD +DeclareTmfHandler(ActiveDatasetManager, kUriActiveSet); +#endif + class PendingDatasetManager : public DatasetManager, private NonCopyable { + friend class Tmf::Agent; + public: /** * This constructor initializes the PendingDatasetManager object. @@ -591,12 +582,6 @@ public: */ void StartLeader(void); - /** - * This method stops the Leader functions for maintaining the Active Operational Dataset. - * - */ - void StopLeader(void); - /** * This method generates a Pending Dataset from an Active Dataset. * @@ -613,27 +598,19 @@ private: static void HandleTimer(Timer &aTimer); void HandleTimer(void) { DatasetManager::HandleTimer(); } - void HandleDelayTimer(void); - - static void HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const; - -#if OPENTHREAD_FTD - static void HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); -#endif + void HandleDelayTimer(void); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); using DelayTimer = TimerMilliIn; DelayTimer mDelayTimer; - - Coap::Resource mResourceGet; - -#if OPENTHREAD_FTD - Coap::Resource mResourceSet; -#endif }; +DeclareTmfHandler(PendingDatasetManager, kUriPendingGet); +#if OPENTHREAD_FTD +DeclareTmfHandler(PendingDatasetManager, kUriPendingSet); +#endif + } // namespace MeshCoP } // namespace ot diff --git a/src/core/meshcop/dataset_manager_ftd.cpp b/src/core/meshcop/dataset_manager_ftd.cpp index 4face84c5..5ba94ec0f 100644 --- a/src/core/meshcop/dataset_manager_ftd.cpp +++ b/src/core/meshcop/dataset_manager_ftd.cpp @@ -397,21 +397,12 @@ exit: void ActiveDatasetManager::StartLeader(void) { IgnoreError(GenerateLocal()); - Get().AddResource(mResourceSet); } -void ActiveDatasetManager::StopLeader(void) -{ - Get().RemoveResource(mResourceSet); -} - -void ActiveDatasetManager::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void ActiveDatasetManager::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void ActiveDatasetManager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { + VerifyOrExit(Get().IsLeader()); SuccessOrExit(DatasetManager::HandleSet(aMessage, aMessageInfo)); IgnoreError(ApplyConfiguration()); @@ -422,21 +413,12 @@ exit: void PendingDatasetManager::StartLeader(void) { StartDelayTimer(); - Get().AddResource(mResourceSet); } -void PendingDatasetManager::StopLeader(void) -{ - Get().RemoveResource(mResourceSet); -} - -void PendingDatasetManager::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void PendingDatasetManager::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void PendingDatasetManager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { + VerifyOrExit(Get().IsLeader()); SuccessOrExit(DatasetManager::HandleSet(aMessage, aMessageInfo)); StartDelayTimer(); diff --git a/src/core/meshcop/energy_scan_client.cpp b/src/core/meshcop/energy_scan_client.cpp index ab80da113..30b3d5763 100644 --- a/src/core/meshcop/energy_scan_client.cpp +++ b/src/core/meshcop/energy_scan_client.cpp @@ -57,9 +57,7 @@ EnergyScanClient::EnergyScanClient(Instance &aInstance) : InstanceLocator(aInstance) , mCallback(nullptr) , mContext(nullptr) - , mEnergyScan(UriPath::kEnergyReport, &EnergyScanClient::HandleReport, this) { - Get().AddResource(mEnergyScan); } Error EnergyScanClient::SendQuery(uint32_t aChannelMask, @@ -78,7 +76,7 @@ Error EnergyScanClient::SendQuery(uint32_t aChannelMas VerifyOrExit(Get().IsActive(), error = kErrorInvalidState); VerifyOrExit((message = Get().NewPriorityMessage()) != nullptr, error = kErrorNoBufs); - SuccessOrExit(error = message->InitAsPost(aAddress, UriPath::kEnergyScan)); + SuccessOrExit(error = message->InitAsPost(aAddress, kUriEnergyScan)); SuccessOrExit(error = message->SetPayloadMarker()); SuccessOrExit( @@ -105,12 +103,8 @@ exit: return error; } -void EnergyScanClient::HandleReport(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleReport(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void EnergyScanClient::HandleReport(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void EnergyScanClient::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint32_t mask; MeshCoP::EnergyListTlv energyListTlv; diff --git a/src/core/meshcop/energy_scan_client.hpp b/src/core/meshcop/energy_scan_client.hpp index 238344cbe..359fb0c1f 100644 --- a/src/core/meshcop/energy_scan_client.hpp +++ b/src/core/meshcop/energy_scan_client.hpp @@ -44,6 +44,7 @@ #include "common/locator.hpp" #include "net/ip6_address.hpp" #include "net/udp6.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -53,6 +54,8 @@ namespace ot { */ class EnergyScanClient : public InstanceLocator { + friend class Tmf::Agent; + public: /** * This constructor initializes the object. @@ -84,15 +87,14 @@ public: void * aContext); private: - static void HandleReport(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleReport(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); otCommissionerEnergyReportCallback mCallback; void * mContext; - - Coap::Resource mEnergyScan; }; +DeclareTmfHandler(EnergyScanClient, kUriEnergyReport); + /** * @} */ diff --git a/src/core/meshcop/joiner.cpp b/src/core/meshcop/joiner.cpp index 0dac6b5fe..ca4f0afa3 100644 --- a/src/core/meshcop/joiner.cpp +++ b/src/core/meshcop/joiner.cpp @@ -67,12 +67,10 @@ Joiner::Joiner(Instance &aInstance) , mJoinerRouterIndex(0) , mFinalizeMessage(nullptr) , mTimer(aInstance) - , mJoinerEntrust(UriPath::kJoinerEntrust, &Joiner::HandleJoinerEntrust, this) { SetIdFromIeeeEui64(); mDiscerner.Clear(); memset(mJoinerRouters, 0, sizeof(mJoinerRouters)); - Get().AddResource(mJoinerEntrust); } void Joiner::SetIdFromIeeeEui64(void) @@ -442,7 +440,7 @@ Error Joiner::PrepareJoinerFinalizeMessage(const char *aProvisioningUrl, VendorStackVersionTlv vendorStackVersionTlv; ProvisioningUrlTlv provisioningUrlTlv; - mFinalizeMessage = Get().NewPriorityConfirmablePostMessage(UriPath::kJoinerFinalize); + mFinalizeMessage = Get().NewPriorityConfirmablePostMessage(kUriJoinerFinalize); VerifyOrExit(mFinalizeMessage != nullptr, error = kErrorNoBufs); mFinalizeMessage->SetOffset(mFinalizeMessage->GetLength()); @@ -557,12 +555,7 @@ exit: IgnoreError(Get().RemoveUnsecurePort(kJoinerUdpPort)); } -void Joiner::HandleJoinerEntrust(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleJoinerEntrust(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Joiner::HandleJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Joiner::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error; Dataset::Info datasetInfo; diff --git a/src/core/meshcop/joiner.hpp b/src/core/meshcop/joiner.hpp index 76950b7f0..168537b1d 100644 --- a/src/core/meshcop/joiner.hpp +++ b/src/core/meshcop/joiner.hpp @@ -40,7 +40,6 @@ #include -#include "coap/coap.hpp" #include "coap/coap_message.hpp" #include "coap/coap_secure.hpp" #include "common/as_core_type.hpp" @@ -53,6 +52,7 @@ #include "meshcop/meshcop.hpp" #include "meshcop/meshcop_tlvs.hpp" #include "thread/discover_scanner.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -60,6 +60,8 @@ namespace MeshCoP { class Joiner : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This enumeration type defines the Joiner State. @@ -205,8 +207,7 @@ private: Error aResult); void HandleJoinerFinalizeResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aResult); - static void HandleJoinerEntrust(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); void HandleTimer(void); @@ -246,10 +247,11 @@ private: Coap::Message *mFinalizeMessage; - JoinerTimer mTimer; - Coap::Resource mJoinerEntrust; + JoinerTimer mTimer; }; +DeclareTmfHandler(Joiner, kUriJoinerEntrust); + } // namespace MeshCoP DefineMapEnum(otJoinerState, MeshCoP::Joiner::State); diff --git a/src/core/meshcop/joiner_router.cpp b/src/core/meshcop/joiner_router.cpp index d6bb0f629..cc0749a70 100644 --- a/src/core/meshcop/joiner_router.cpp +++ b/src/core/meshcop/joiner_router.cpp @@ -57,12 +57,10 @@ RegisterLogModule("JoinerRouter"); JoinerRouter::JoinerRouter(Instance &aInstance) : InstanceLocator(aInstance) , mSocket(aInstance) - , mRelayTransmit(UriPath::kRelayTx, &JoinerRouter::HandleRelayTransmit, this) , mTimer(aInstance) , mJoinerUdpPort(0) , mIsJoinerPortConfigured(false) { - Get().AddResource(mRelayTransmit); } void JoinerRouter::HandleNotifierEvents(Events aEvents) @@ -142,7 +140,7 @@ void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &a SuccessOrExit(error = GetBorderAgentRloc(Get(), borderAgentRloc)); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kRelayRx); + message = Get().NewPriorityNonConfirmablePostMessage(kUriRelayRx); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, aMessageInfo.GetPeerPort())); @@ -166,12 +164,7 @@ exit: FreeMessageOnError(message, error); } -void JoinerRouter::HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleRelayTransmit(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void JoinerRouter::HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void JoinerRouter::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { OT_UNUSED_VARIABLE(aMessageInfo); @@ -308,7 +301,7 @@ Coap::Message *JoinerRouter::PrepareJoinerEntrustMessage(void) const Tlv * tlv; NetworkKey networkKey; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kJoinerEntrust); + message = Get().NewPriorityConfirmablePostMessage(kUriJoinerEntrust); VerifyOrExit(message != nullptr, error = kErrorNoBufs); message->SetSubType(Message::kSubTypeJoinerEntrust); diff --git a/src/core/meshcop/joiner_router.hpp b/src/core/meshcop/joiner_router.hpp index 7386be64f..f739e477f 100644 --- a/src/core/meshcop/joiner_router.hpp +++ b/src/core/meshcop/joiner_router.hpp @@ -38,7 +38,6 @@ #if OPENTHREAD_FTD -#include "coap/coap.hpp" #include "coap/coap_message.hpp" #include "common/locator.hpp" #include "common/message.hpp" @@ -49,6 +48,7 @@ #include "meshcop/meshcop_tlvs.hpp" #include "net/udp6.hpp" #include "thread/key_manager.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -57,6 +57,7 @@ namespace MeshCoP { class JoinerRouter : public InstanceLocator, private NonCopyable { friend class ot::Notifier; + friend class Tmf::Agent; public: /** @@ -101,8 +102,7 @@ private: static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - static void HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleJoinerEntrustResponse(void * aContext, otMessage * aMessage, @@ -121,7 +121,6 @@ private: using JoinerRouterTimer = TimerMilliIn; Ip6::Udp::Socket mSocket; - Coap::Resource mRelayTransmit; JoinerRouterTimer mTimer; MessageQueue mDelayedJoinEnts; @@ -131,6 +130,8 @@ private: bool mIsJoinerPortConfigured : 1; }; +DeclareTmfHandler(JoinerRouter, kUriRelayTx); + } // namespace MeshCoP } // namespace ot diff --git a/src/core/meshcop/meshcop_leader.cpp b/src/core/meshcop/meshcop_leader.cpp index a420e2c33..a90439157 100644 --- a/src/core/meshcop/meshcop_leader.cpp +++ b/src/core/meshcop/meshcop_leader.cpp @@ -57,22 +57,13 @@ RegisterLogModule("MeshCoPLeader"); Leader::Leader(Instance &aInstance) : InstanceLocator(aInstance) - , mPetition(UriPath::kLeaderPetition, Leader::HandlePetition, this) - , mKeepAlive(UriPath::kLeaderKeepAlive, Leader::HandleKeepAlive, this) , mTimer(aInstance) , mDelayTimerMinimal(DelayTimerTlv::kDelayTimerMinimal) , mSessionId(Random::NonCrypto::GetUint16()) { - Get().AddResource(mPetition); - Get().AddResource(mKeepAlive); } -void Leader::HandlePetition(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandlePetition(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Leader::HandlePetition(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Leader::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { OT_UNUSED_VARIABLE(aMessageInfo); @@ -152,12 +143,7 @@ exit: LogError("send petition response", error); } -void Leader::HandleKeepAlive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleKeepAlive(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Leader::HandleKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Leader::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint8_t state; uint16_t sessionId; @@ -229,7 +215,7 @@ void Leader::SendDatasetChanged(const Ip6::Address &aAddress) Tmf::MessageInfo messageInfo(GetInstance()); Coap::Message * message; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kDatasetChanged); + message = Get().NewPriorityConfirmablePostMessage(kUriDatasetChanged); VerifyOrExit(message != nullptr, error = kErrorNoBufs); messageInfo.SetSockAddrToRlocPeerAddrTo(aAddress); diff --git a/src/core/meshcop/meshcop_leader.hpp b/src/core/meshcop/meshcop_leader.hpp index 1bd315dab..1695f491c 100644 --- a/src/core/meshcop/meshcop_leader.hpp +++ b/src/core/meshcop/meshcop_leader.hpp @@ -38,13 +38,13 @@ #if OPENTHREAD_FTD -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "common/timer.hpp" #include "meshcop/meshcop_tlvs.hpp" #include "net/udp6.hpp" #include "thread/mle.hpp" +#include "thread/tmf.hpp" namespace ot { namespace MeshCoP { @@ -66,6 +66,8 @@ public: class Leader : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This constructor initializes the Leader object. @@ -113,17 +115,15 @@ private: void HandleTimer(void); - static void HandlePetition(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandlePetition(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - void SendPetitionResponse(const Coap::Message & aRequest, - const Ip6::MessageInfo &aMessageInfo, - StateTlv::State aState); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - static void HandleKeepAlive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - void SendKeepAliveResponse(const Coap::Message & aRequest, - const Ip6::MessageInfo &aMessageInfo, - StateTlv::State aState); + void SendPetitionResponse(const Coap::Message & aRequest, + const Ip6::MessageInfo &aMessageInfo, + StateTlv::State aState); + + void SendKeepAliveResponse(const Coap::Message & aRequest, + const Ip6::MessageInfo &aMessageInfo, + StateTlv::State aState); static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); @@ -131,9 +131,7 @@ private: using LeaderTimer = TimerMilliIn; - Coap::Resource mPetition; - Coap::Resource mKeepAlive; - LeaderTimer mTimer; + LeaderTimer mTimer; uint32_t mDelayTimerMinimal; @@ -141,6 +139,9 @@ private: uint16_t mSessionId; }; +DeclareTmfHandler(Leader, kUriLeaderPetition); +DeclareTmfHandler(Leader, kUriLeaderKeepAlive); + } // namespace MeshCoP } // namespace ot diff --git a/src/core/meshcop/panid_query_client.cpp b/src/core/meshcop/panid_query_client.cpp index 7bacc80c0..0a0961a49 100644 --- a/src/core/meshcop/panid_query_client.cpp +++ b/src/core/meshcop/panid_query_client.cpp @@ -55,9 +55,7 @@ PanIdQueryClient::PanIdQueryClient(Instance &aInstance) : InstanceLocator(aInstance) , mCallback(nullptr) , mContext(nullptr) - , mPanIdQuery(UriPath::kPanIdConflict, &PanIdQueryClient::HandleConflict, this) { - Get().AddResource(mPanIdQuery); } Error PanIdQueryClient::SendQuery(uint16_t aPanId, @@ -74,7 +72,7 @@ Error PanIdQueryClient::SendQuery(uint16_t aPanId, VerifyOrExit(Get().IsActive(), error = kErrorInvalidState); VerifyOrExit((message = Get().NewPriorityMessage()) != nullptr, error = kErrorNoBufs); - SuccessOrExit(error = message->InitAsPost(aAddress, UriPath::kPanIdQuery)); + SuccessOrExit(error = message->InitAsPost(aAddress, kUriPanIdQuery)); SuccessOrExit(error = message->SetPayloadMarker()); SuccessOrExit( @@ -99,12 +97,8 @@ exit: return error; } -void PanIdQueryClient::HandleConflict(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleConflict(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void PanIdQueryClient::HandleConflict(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void PanIdQueryClient::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t panId; Ip6::MessageInfo responseInfo(aMessageInfo); diff --git a/src/core/meshcop/panid_query_client.hpp b/src/core/meshcop/panid_query_client.hpp index 35071508f..89230c573 100644 --- a/src/core/meshcop/panid_query_client.hpp +++ b/src/core/meshcop/panid_query_client.hpp @@ -40,10 +40,10 @@ #include -#include "coap/coap.hpp" #include "common/locator.hpp" #include "net/ip6_address.hpp" #include "net/udp6.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -53,6 +53,8 @@ namespace ot { */ class PanIdQueryClient : public InstanceLocator { + friend class Tmf::Agent; + public: /** * This constructor initializes the object. @@ -80,15 +82,14 @@ public: void * aContext); private: - static void HandleConflict(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleConflict(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); otCommissionerPanIdConflictCallback mCallback; void * mContext; - - Coap::Resource mPanIdQuery; }; +DeclareTmfHandler(PanIdQueryClient, kUriPanIdConflict); + /** * @} */ diff --git a/src/core/thread/address_resolver.cpp b/src/core/thread/address_resolver.cpp index 34938a3a0..d88f165cc 100644 --- a/src/core/thread/address_resolver.cpp +++ b/src/core/thread/address_resolver.cpp @@ -54,19 +54,12 @@ RegisterLogModule("AddrResolver"); AddressResolver::AddressResolver(Instance &aInstance) : InstanceLocator(aInstance) - , mAddressError(UriPath::kAddressError, &AddressResolver::HandleAddressError, this) #if OPENTHREAD_FTD - , mAddressQuery(UriPath::kAddressQuery, &AddressResolver::HandleAddressQuery, this) - , mAddressNotification(UriPath::kAddressNotify, &AddressResolver::HandleAddressNotification, this) , mCacheEntryPool(aInstance) , mIcmpHandler(&AddressResolver::HandleIcmpReceive, this) #endif { - Get().AddResource(mAddressError); #if OPENTHREAD_FTD - Get().AddResource(mAddressQuery); - Get().AddResource(mAddressNotification); - IgnoreError(Get().RegisterHandler(mIcmpHandler)); #endif } @@ -561,7 +554,7 @@ Error AddressResolver::SendAddressQuery(const Ip6::Address &aEid) Coap::Message * message; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewPriorityNonConfirmablePostMessage(UriPath::kAddressQuery); + message = Get().NewPriorityNonConfirmablePostMessage(kUriAddressQuery); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, aEid)); @@ -591,13 +584,8 @@ exit: return error; } -void AddressResolver::HandleAddressNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAddressNotification(AsCoapMessage(aMessage), - AsCoreType(aMessageInfo)); -} - -void AddressResolver::HandleAddressNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void AddressResolver::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Ip6::Address target; Ip6::InterfaceIdentifier meshLocalIid; @@ -676,7 +664,7 @@ void AddressResolver::SendAddressError(const Ip6::Address & aTarget, VerifyOrExit((message = Get().NewMessage()) != nullptr, error = kErrorNoBufs); message->Init(aDestination == nullptr ? Coap::kTypeNonConfirmable : Coap::kTypeConfirmable, Coap::kCodePost); - SuccessOrExit(error = message->AppendUriPathOptions(UriPath::kAddressError)); + SuccessOrExit(error = message->AppendUriPathOptions(PathForUri(kUriAddressError))); SuccessOrExit(error = message->SetPayloadMarker()); SuccessOrExit(error = Tlv::Append(*message, aTarget)); @@ -706,12 +694,8 @@ exit: #endif // OPENTHREAD_FTD -void AddressResolver::HandleAddressError(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAddressError(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void AddressResolver::HandleAddressError(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void AddressResolver::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; Ip6::Address target; @@ -792,12 +776,8 @@ exit: #if OPENTHREAD_FTD -void AddressResolver::HandleAddressQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAddressQuery(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void AddressResolver::HandleAddressQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void AddressResolver::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Ip6::Address target; uint32_t lastTransactionTime; @@ -854,7 +834,7 @@ void AddressResolver::SendAddressQueryResponse(const Ip6::Address & a Coap::Message * message; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewPriorityConfirmablePostMessage(UriPath::kAddressNotify); + message = Get().NewPriorityConfirmablePostMessage(kUriAddressNotify); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, aTarget)); diff --git a/src/core/thread/address_resolver.hpp b/src/core/thread/address_resolver.hpp index 8ac629975..0b76af9be 100644 --- a/src/core/thread/address_resolver.hpp +++ b/src/core/thread/address_resolver.hpp @@ -47,6 +47,7 @@ #include "net/icmp6.hpp" #include "net/udp6.hpp" #include "thread/thread_tlvs.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -66,6 +67,7 @@ namespace ot { class AddressResolver : public InstanceLocator, private NonCopyable { friend class TimeTicker; + friend class Tmf::Agent; class CacheEntry; class CacheEntryList; @@ -343,15 +345,9 @@ private: #endif // OPENTHREAD_FTD - static void HandleAddressError(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAddressError(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); #if OPENTHREAD_FTD - static void HandleAddressQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAddressQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - - static void HandleAddressNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAddressNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleIcmpReceive(void * aContext, otMessage * aMessage, @@ -361,33 +357,31 @@ private: const Ip6::MessageInfo & aMessageInfo, const Ip6::Icmp::Header &aIcmpHeader); - void HandleTimeTick(void); - - void LogCacheEntryChange(EntryChange aChange, - Reason aReason, - const CacheEntry &aEntry, - CacheEntryList * aList = nullptr); - + void HandleTimeTick(void); + void LogCacheEntryChange(EntryChange aChange, + Reason aReason, + const CacheEntry &aEntry, + CacheEntryList * aList = nullptr); const char *ListToString(const CacheEntryList *aList) const; static AddressResolver::CacheEntry *GetEntryAfter(CacheEntry *aPrev, CacheEntryList &aList); -#endif // OPENTHREAD_FTD - Coap::Resource mAddressError; -#if OPENTHREAD_FTD - Coap::Resource mAddressQuery; - Coap::Resource mAddressNotification; - - CacheEntryPool mCacheEntryPool; - CacheEntryList mCachedList; - CacheEntryList mSnoopedList; - CacheEntryList mQueryList; - CacheEntryList mQueryRetryList; - + CacheEntryPool mCacheEntryPool; + CacheEntryList mCachedList; + CacheEntryList mSnoopedList; + CacheEntryList mQueryList; + CacheEntryList mQueryRetryList; Ip6::Icmp::Handler mIcmpHandler; -#endif // OPENTHREAD_FTD + +#endif // OPENTHREAD_FTD }; +DeclareTmfHandler(AddressResolver, kUriAddressError); +#if OPENTHREAD_FTD +DeclareTmfHandler(AddressResolver, kUriAddressQuery); +DeclareTmfHandler(AddressResolver, kUriAddressNotify); +#endif + /** * @} */ diff --git a/src/core/thread/announce_begin_server.cpp b/src/core/thread/announce_begin_server.cpp index ddac782fa..ba22e023c 100644 --- a/src/core/thread/announce_begin_server.cpp +++ b/src/core/thread/announce_begin_server.cpp @@ -52,9 +52,7 @@ RegisterLogModule("MeshCoP"); AnnounceBeginServer::AnnounceBeginServer(Instance &aInstance) : AnnounceSenderBase(aInstance, AnnounceBeginServer::HandleTimer) - , mAnnounceBegin(UriPath::kAnnounceBegin, &AnnounceBeginServer::HandleRequest, this) { - Get().AddResource(mAnnounceBegin); } void AnnounceBeginServer::SendAnnounce(uint32_t aChannelMask, uint8_t aCount, uint16_t aPeriod) @@ -65,12 +63,8 @@ void AnnounceBeginServer::SendAnnounce(uint32_t aChannelMask, uint8_t aCount, ui AnnounceSenderBase::SendAnnounce(aCount); } -void AnnounceBeginServer::HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleRequest(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void AnnounceBeginServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void AnnounceBeginServer::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint32_t mask; uint8_t count; diff --git a/src/core/thread/announce_begin_server.hpp b/src/core/thread/announce_begin_server.hpp index aef72e2d4..a5aafd1f3 100644 --- a/src/core/thread/announce_begin_server.hpp +++ b/src/core/thread/announce_begin_server.hpp @@ -36,11 +36,11 @@ #include "openthread-core-config.h" -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/timer.hpp" #include "net/ip6_address.hpp" #include "thread/announce_sender.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -50,6 +50,8 @@ namespace ot { */ class AnnounceBeginServer : public AnnounceSenderBase { + friend class Tmf::Agent; + public: /** * This constructor initializes the object. @@ -72,14 +74,13 @@ private: static constexpr uint16_t kDefaultPeriod = 1000; static constexpr uint16_t kDefaultJitter = 0; - static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleTimer(Timer &aTimer); - - Coap::Resource mAnnounceBegin; }; +DeclareTmfHandler(AnnounceBeginServer, kUriAnnounceBegin); + /** * @} */ diff --git a/src/core/thread/anycast_locator.cpp b/src/core/thread/anycast_locator.cpp index a8989cdbf..28777a815 100644 --- a/src/core/thread/anycast_locator.cpp +++ b/src/core/thread/anycast_locator.cpp @@ -48,14 +48,8 @@ AnycastLocator::AnycastLocator(Instance &aInstance) : InstanceLocator(aInstance) , mCallback(nullptr) , mContext(nullptr) -#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE - , mAnycastLocate(UriPath::kAnycastLocate, HandleAnycastLocate, this) -#endif { -#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE - Get().AddResource(mAnycastLocate); -#endif } Error AnycastLocator::Locate(const Ip6::Address &aAnycastAddress, Callback aCallback, void *aContext) @@ -67,7 +61,7 @@ Error AnycastLocator::Locate(const Ip6::Address &aAnycastAddress, Callback aCall VerifyOrExit((aCallback != nullptr) && Get().IsAnycastLocator(aAnycastAddress), error = kErrorInvalidArgs); - message = Get().NewConfirmablePostMessage(UriPath::kAnycastLocate); + message = Get().NewConfirmablePostMessage(kUriAnycastLocate); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (mCallback != nullptr) @@ -129,18 +123,14 @@ exit: #if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE -void AnycastLocator::HandleAnycastLocate(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAnycastLocate(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void AnycastLocator::HandleAnycastLocate(const Coap::Message &aRequest, const Ip6::MessageInfo &aMessageInfo) +template <> +void AnycastLocator::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Coap::Message *message = nullptr; - VerifyOrExit(aRequest.IsConfirmablePostRequest()); + VerifyOrExit(aMessage.IsConfirmablePostRequest()); - message = Get().NewResponseMessage(aRequest); + message = Get().NewResponseMessage(aMessage); VerifyOrExit(message != nullptr); SuccessOrExit(Tlv::Append(*message, Get().GetMeshLocal64().GetIid())); diff --git a/src/core/thread/anycast_locator.hpp b/src/core/thread/anycast_locator.hpp index 5ae937f45..65f34b20d 100644 --- a/src/core/thread/anycast_locator.hpp +++ b/src/core/thread/anycast_locator.hpp @@ -38,10 +38,10 @@ #if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "net/ip6_address.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -54,6 +54,8 @@ namespace ot { */ class AnycastLocator : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This function pointer type defines the callback to notify the outcome of a request. @@ -99,18 +101,16 @@ private: void HandleResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aError); -#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE - static void HandleAnycastLocate(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAnycastLocate(const Coap::Message &aRequest, const Ip6::MessageInfo &aMessageInfo); -#endif + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); Callback mCallback; void * mContext; -#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE - Coap::Resource mAnycastLocate; -#endif }; +#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE +DeclareTmfHandler(AnycastLocator, kUriAnycastLocate); +#endif + } // namespace ot #endif // OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE diff --git a/src/core/thread/dua_manager.cpp b/src/core/thread/dua_manager.cpp index 132d9f9dd..a10b8e374 100644 --- a/src/core/thread/dua_manager.cpp +++ b/src/core/thread/dua_manager.cpp @@ -55,7 +55,6 @@ RegisterLogModule("DuaManager"); DuaManager::DuaManager(Instance &aInstance) : InstanceLocator(aInstance) , mRegistrationTask(aInstance) - , mDuaNotification(UriPath::kDuaRegistrationNotify, &DuaManager::HandleDuaNotification, this) , mIsDuaPending(false) #if OPENTHREAD_CONFIG_DUA_ENABLE , mDuaState(kNotExist) @@ -77,8 +76,6 @@ DuaManager::DuaManager(Instance &aInstance) mChildDuaMask.Clear(); mChildDuaRegisteredMask.Clear(); #endif - - Get().AddResource(mDuaNotification); } void DuaManager::HandleDomainPrefixUpdate(BackboneRouter::Leader::DomainPrefixState aState) @@ -450,7 +447,7 @@ void DuaManager::PerformNextRegistration(void) } // Prepare DUA.req - message = Get().NewPriorityConfirmablePostMessage(UriPath::kDuaRegistrationRequest); + message = Get().NewPriorityConfirmablePostMessage(kUriDuaRegistrationRequest); VerifyOrExit(message != nullptr, error = kErrorNoBufs); #if OPENTHREAD_CONFIG_DUA_ENABLE @@ -580,11 +577,8 @@ exit: LogInfo("Received DUA.rsp: %s", ErrorToString(error)); } -void DuaManager::HandleDuaNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDuaNotification(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} -void DuaManager::HandleDuaNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void DuaManager::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { OT_UNUSED_VARIABLE(aMessageInfo); @@ -721,7 +715,7 @@ void DuaManager::SendAddressNotification(Ip6::Address & aAddress, Tmf::MessageInfo messageInfo(GetInstance()); Error error; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kDuaRegistrationNotify); + message = Get().NewPriorityConfirmablePostMessage(kUriDuaRegistrationNotify); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, aStatus)); diff --git a/src/core/thread/dua_manager.hpp b/src/core/thread/dua_manager.hpp index 587ad38db..03ed43dd2 100644 --- a/src/core/thread/dua_manager.hpp +++ b/src/core/thread/dua_manager.hpp @@ -47,7 +47,6 @@ #endif #include "backbone_router/bbr_leader.hpp" -#include "coap/coap.hpp" #include "coap/coap_message.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" @@ -58,6 +57,7 @@ #include "common/timer.hpp" #include "net/netif.hpp" #include "thread/thread_tlvs.hpp" +#include "thread/tmf.hpp" #include "thread/topology.hpp" namespace ot { @@ -84,6 +84,7 @@ class DuaManager : public InstanceLocator, private NonCopyable { friend class ot::Notifier; friend class ot::TimeTicker; + friend class Tmf::Agent; public: /** @@ -203,8 +204,7 @@ private: Error aResult); void HandleDuaResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aResult); - static void HandleDuaNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDuaNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); Error ProcessDuaResponse(Coap::Message &aMessage); @@ -215,7 +215,6 @@ private: using RegistrationTask = TaskletIn; RegistrationTask mRegistrationTask; - Coap::Resource mDuaNotification; Ip6::Address mRegisteringDua; bool mIsDuaPending : 1; @@ -258,6 +257,8 @@ private: #endif }; +DeclareTmfHandler(DuaManager, kUriDuaRegistrationNotify); + } // namespace ot #endif // OPENTHREAD_CONFIG_DUA_ENABLE || (OPENTHREAD_FTD && OPENTHREAD_CONFIG_TMF_PROXY_DUA_ENABLE) diff --git a/src/core/thread/energy_scan_server.cpp b/src/core/thread/energy_scan_server.cpp index 06728ea99..fe9a70cfb 100644 --- a/src/core/thread/energy_scan_server.cpp +++ b/src/core/thread/energy_scan_server.cpp @@ -43,7 +43,6 @@ #include "meshcop/meshcop.hpp" #include "meshcop/meshcop_tlvs.hpp" #include "thread/thread_netif.hpp" -#include "thread/uri_paths.hpp" namespace ot { @@ -58,17 +57,11 @@ EnergyScanServer::EnergyScanServer(Instance &aInstance) , mCount(0) , mReportMessage(nullptr) , mTimer(aInstance) - , mEnergyScan(UriPath::kEnergyScan, &EnergyScanServer::HandleRequest, this) { - Get().AddResource(mEnergyScan); } -void EnergyScanServer::HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleRequest(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void EnergyScanServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void EnergyScanServer::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint8_t count; uint16_t period; @@ -86,7 +79,7 @@ void EnergyScanServer::HandleRequest(Coap::Message &aMessage, const Ip6::Message VerifyOrExit((mask = MeshCoP::ChannelMaskTlv::GetChannelMask(aMessage)) != 0); FreeMessage(mReportMessage); - mReportMessage = Get().NewPriorityConfirmablePostMessage(UriPath::kEnergyReport); + mReportMessage = Get().NewPriorityConfirmablePostMessage(kUriEnergyReport); VerifyOrExit(mReportMessage != nullptr); channelMaskTlv.Init(); diff --git a/src/core/thread/energy_scan_server.hpp b/src/core/thread/energy_scan_server.hpp index da01da667..ca7c7a506 100644 --- a/src/core/thread/energy_scan_server.hpp +++ b/src/core/thread/energy_scan_server.hpp @@ -36,7 +36,6 @@ #include "openthread-core-config.h" -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "common/notifier.hpp" @@ -44,6 +43,7 @@ #include "net/ip6_address.hpp" #include "net/udp6.hpp" #include "thread/thread_tlvs.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -54,6 +54,7 @@ namespace ot { class EnergyScanServer : public InstanceLocator, private NonCopyable { friend class ot::Notifier; + friend class Tmf::Agent; public: /** @@ -66,8 +67,7 @@ private: static constexpr uint32_t kScanDelay = 1000; // SCAN_DELAY (milliseconds) static constexpr uint32_t kReportDelay = 500; // Delay before sending a report (milliseconds) - static void HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleScanResult(Mac::EnergyScanResult *aResult, void *aContext); void HandleScanResult(Mac::EnergyScanResult *aResult); @@ -89,10 +89,10 @@ private: uint8_t mNumScanResults; Coap::Message *mReportMessage; ScanTimer mTimer; - - Coap::Resource mEnergyScan; }; +DeclareTmfHandler(EnergyScanServer, kUriEnergyScan); + /** * @} */ diff --git a/src/core/thread/mle_router.cpp b/src/core/thread/mle_router.cpp index d11160726..c9070b5ba 100644 --- a/src/core/thread/mle_router.cpp +++ b/src/core/thread/mle_router.cpp @@ -63,8 +63,6 @@ RegisterLogModule("Mle"); MleRouter::MleRouter(Instance &aInstance) : Mle(aInstance) , mAdvertiseTrickleTimer(aInstance, MleRouter::HandleAdvertiseTrickleTimer) - , mAddressSolicit(UriPath::kAddressSolicit, &MleRouter::HandleAddressSolicit, this) - , mAddressRelease(UriPath::kAddressRelease, &MleRouter::HandleAddressRelease, this) , mChildTable(aInstance) , mRouterTable(aInstance) , mChallengeTimeout(0) @@ -279,12 +277,7 @@ exit: void MleRouter::StopLeader(void) { - Get().RemoveResource(mAddressSolicit); - Get().RemoveResource(mAddressRelease); - Get().StopLeader(); - Get().StopLeader(); StopAdvertiseTrickleTimer(); - Get().Stop(); Get().UnsubscribeAllRoutersMulticast(); } @@ -388,7 +381,6 @@ void MleRouter::SetStateRouter(uint16_t aRloc16) Get().SubscribeAllRoutersMulticast(); mPreviousPartitionIdRouter = mLeaderData.GetPartitionId(); - Get().Stop(); Get().SetForwardingEnabled(true); Get().SetTimerExpirations(kMplRouterDataMessageTimerExpirations); Get().SetBeaconEnabled(true); @@ -430,8 +422,6 @@ void MleRouter::SetStateLeader(uint16_t aRloc16, LeaderStartMode aStartMode) Get().Start(aStartMode); Get().StartLeader(); Get().StartLeader(); - Get().AddResource(mAddressSolicit); - Get().AddResource(mAddressRelease); Get().SetForwardingEnabled(true); Get().SetTimerExpirations(kMplRouterDataMessageTimerExpirations); Get().SetBeaconEnabled(true); @@ -3719,7 +3709,7 @@ Error MleRouter::SendAddressSolicit(ThreadStatusTlv::Status aStatus) VerifyOrExit(!mAddressSolicitPending); - message = Get().NewPriorityConfirmablePostMessage(UriPath::kAddressSolicit); + message = Get().NewPriorityConfirmablePostMessage(kUriAddressSolicit); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, Get().GetExtAddress())); @@ -3753,7 +3743,7 @@ void MleRouter::SendAddressRelease(void) Tmf::MessageInfo messageInfo(GetInstance()); Coap::Message * message; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kAddressRelease); + message = Get().NewPriorityConfirmablePostMessage(kUriAddressRelease); VerifyOrExit(message != nullptr, error = kErrorNoBufs); SuccessOrExit(error = Tlv::Append(*message, Rloc16FromRouterId(mRouterId))); @@ -3889,12 +3879,7 @@ bool MleRouter::IsExpectedToBecomeRouterSoon(void) const mAddressSolicitPending); } -void MleRouter::HandleAddressSolicit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAddressSolicit(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void MleRouter::HandleAddressSolicit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void MleRouter::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; ThreadStatusTlv::Status responseStatus = ThreadStatusTlv::kNoAddressAvailable; @@ -3903,6 +3888,8 @@ void MleRouter::HandleAddressSolicit(Coap::Message &aMessage, const Ip6::Message uint16_t rloc16; uint8_t status; + VerifyOrExit(mRole == kRoleLeader, error = kErrorInvalidState); + VerifyOrExit(aMessage.IsConfirmablePostRequest(), error = kErrorParse); Log(kMessageReceive, kTypeAddressSolicit, aMessageInfo.GetPeerAddr()); @@ -4024,18 +4011,15 @@ exit: FreeMessage(message); } -void MleRouter::HandleAddressRelease(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleAddressRelease(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void MleRouter::HandleAddressRelease(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void MleRouter::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t rloc16; Mac::ExtAddress extAddress; uint8_t routerId; Router * router; + VerifyOrExit(mRole == kRoleLeader); + VerifyOrExit(aMessage.IsConfirmablePostRequest()); Log(kMessageReceive, kTypeAddressRelease, aMessageInfo.GetPeerAddr()); diff --git a/src/core/thread/mle_router.hpp b/src/core/thread/mle_router.hpp index 4dca318ba..2eae12a68 100644 --- a/src/core/thread/mle_router.hpp +++ b/src/core/thread/mle_router.hpp @@ -38,7 +38,6 @@ #include -#include "coap/coap.hpp" #include "coap/coap_message.hpp" #include "common/time_ticker.hpp" #include "common/timer.hpp" @@ -52,6 +51,7 @@ #include "thread/mle_tlvs.hpp" #include "thread/router_table.hpp" #include "thread/thread_tlvs.hpp" +#include "thread/tmf.hpp" #include "thread/topology.hpp" namespace ot { @@ -77,6 +77,7 @@ class MleRouter : public Mle friend class Mle; friend class ot::Instance; friend class ot::TimeTicker; + friend class Tmf::Agent; public: /** @@ -638,10 +639,8 @@ private: const otMessageInfo *aMessageInfo, Error aResult); void HandleAddressSolicitResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aResult); - static void HandleAddressRelease(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAddressRelease(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - static void HandleAddressSolicit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleAddressSolicit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static bool IsSingleton(const RouteTlv &aRouteTlv); @@ -660,9 +659,6 @@ private: TrickleTimer mAdvertiseTrickleTimer; - Coap::Resource mAddressSolicit; - Coap::Resource mAddressRelease; - ChildTable mChildTable; RouterTable mRouterTable; @@ -712,6 +708,9 @@ private: void * mDiscoveryRequestCallbackContext; }; +DeclareTmfHandler(MleRouter, kUriAddressSolicit); +DeclareTmfHandler(MleRouter, kUriAddressRelease); + #endif // OPENTHREAD_FTD #if OPENTHREAD_MTD diff --git a/src/core/thread/mlr_manager.cpp b/src/core/thread/mlr_manager.cpp index 98272febe..ac9e1fa90 100644 --- a/src/core/thread/mlr_manager.cpp +++ b/src/core/thread/mlr_manager.cpp @@ -404,7 +404,7 @@ Error MlrManager::SendMulticastListenerRegistrationMessage(const otIp6Address * VerifyOrExit(Get().HasPrimary(), error = kErrorInvalidState); - message = Get().NewConfirmablePostMessage(UriPath::kMlr); + message = Get().NewConfirmablePostMessage(kUriMlr); VerifyOrExit(message != nullptr, error = kErrorNoBufs); addressesTlv.Init(); diff --git a/src/core/thread/network_data.cpp b/src/core/thread/network_data.cpp index 9f15cb6af..f505aec52 100644 --- a/src/core/thread/network_data.cpp +++ b/src/core/thread/network_data.cpp @@ -644,7 +644,7 @@ Error NetworkData::SendServerDataNotification(uint16_t aRloc16, Coap::Message * message; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewPriorityConfirmablePostMessage(UriPath::kServerData); + message = Get().NewPriorityConfirmablePostMessage(kUriServerData); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aAppendNetDataTlv) diff --git a/src/core/thread/network_data_leader_ftd.cpp b/src/core/thread/network_data_leader_ftd.cpp index b10dca8c1..27654e3aa 100644 --- a/src/core/thread/network_data_leader_ftd.cpp +++ b/src/core/thread/network_data_leader_ftd.cpp @@ -62,9 +62,6 @@ Leader::Leader(Instance &aInstance) : LeaderBase(aInstance) , mWaitingForNetDataSync(false) , mTimer(aInstance) - , mServerData(UriPath::kServerData, &Leader::HandleServerData, this) - , mCommissioningDataGet(UriPath::kCommissionerGet, &Leader::HandleCommissioningGet, this) - , mCommissioningDataSet(UriPath::kCommissionerSet, &Leader::HandleCommissioningSet, this) { Reset(); } @@ -86,17 +83,6 @@ void Leader::Start(Mle::LeaderStartMode aStartMode) { mTimer.Start(kMaxNetDataSyncWait); } - - Get().AddResource(mServerData); - Get().AddResource(mCommissioningDataGet); - Get().AddResource(mCommissioningDataSet); -} - -void Leader::Stop(void) -{ - Get().RemoveResource(mServerData); - Get().RemoveResource(mCommissioningDataGet); - Get().RemoveResource(mCommissioningDataSet); } void Leader::IncrementVersion(void) @@ -142,16 +128,13 @@ void Leader::RemoveBorderRouter(uint16_t aRloc16, MatchMode aMatchMode) IncrementVersions(flags); } -void Leader::HandleServerData(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleServerData(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Leader::HandleServerData(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Leader::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { ThreadNetworkDataTlv networkDataTlv; uint16_t rloc16; + VerifyOrExit(Get().IsLeader()); + LogInfo("Received network data registration"); VerifyOrExit(!mWaitingForNetDataSync); @@ -188,12 +171,7 @@ exit: return; } -void Leader::HandleCommissioningSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleCommissioningSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Leader::HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Leader::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t offset = aMessage.GetOffset(); uint16_t length = aMessage.GetLength() - aMessage.GetOffset(); @@ -207,6 +185,8 @@ void Leader::HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageI MeshCoP::Tlv *cur; MeshCoP::Tlv *end; + VerifyOrExit(Get().IsLeader()); + VerifyOrExit(length <= sizeof(tlvs)); VerifyOrExit(Get().IsLeader()); @@ -290,21 +270,21 @@ exit: } } -void Leader::HandleCommissioningGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleCommissioningGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void Leader::HandleCommissioningGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> void Leader::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t length = 0; uint16_t offset; + VerifyOrExit(Get().IsLeader()); + SuccessOrExit(Tlv::FindTlvValueOffset(aMessage, MeshCoP::Tlv::kGet, offset, length)); aMessage.SetOffset(offset); exit: - SendCommissioningGetResponse(aMessage, length, aMessageInfo); + if (Get().IsLeader()) + { + SendCommissioningGetResponse(aMessage, length, aMessageInfo); + } } void Leader::SendCommissioningGetResponse(const Coap::Message & aRequest, diff --git a/src/core/thread/network_data_leader_ftd.hpp b/src/core/thread/network_data_leader_ftd.hpp index 69ff9f595..4ae30d84d 100644 --- a/src/core/thread/network_data_leader_ftd.hpp +++ b/src/core/thread/network_data_leader_ftd.hpp @@ -40,12 +40,12 @@ #include -#include "coap/coap.hpp" #include "common/non_copyable.hpp" #include "common/timer.hpp" #include "net/ip6_address.hpp" #include "thread/mle_router.hpp" #include "thread/network_data.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -67,6 +67,8 @@ namespace NetworkData { */ class Leader : public LeaderBase, private NonCopyable { + friend class Tmf::Agent; + public: /** * This enumeration defines the match mode constants to compare two RLOC16 values. @@ -105,12 +107,6 @@ public: */ void Start(Mle::LeaderStartMode aStartMode); - /** - * This method stops the Leader services. - * - */ - void Stop(void); - /** * This method increments the Thread Network Data version. * @@ -223,8 +219,7 @@ private: kTlvUpdated, // TLV stable flag is updated based on its sub TLVs. }; - static void HandleServerData(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleServerData(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); void HandleTimer(void); @@ -292,12 +287,6 @@ private: UpdateStatus UpdateService(ServiceTlv &aService); UpdateStatus UpdateTlv(NetworkDataTlv &aTlv, const NetworkDataTlv *aSubTlvs); - static void HandleCommissioningSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - - static void HandleCommissioningGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleCommissioningGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - void SendCommissioningGetResponse(const Coap::Message & aRequest, uint16_t aLength, const Ip6::MessageInfo &aMessageInfo); @@ -320,13 +309,12 @@ private: TimeMilli mContextLastUsed[kNumContextIds]; uint32_t mContextIdReuseDelay; UpdateTimer mTimer; - - Coap::Resource mServerData; - - Coap::Resource mCommissioningDataGet; - Coap::Resource mCommissioningDataSet; }; +DeclareTmfHandler(Leader, kUriServerData); +DeclareTmfHandler(Leader, kUriCommissionerGet); +DeclareTmfHandler(Leader, kUriCommissionerSet); + /** * @} */ diff --git a/src/core/thread/network_diagnostic.cpp b/src/core/thread/network_diagnostic.cpp index 5eaab1c56..537fc6989 100644 --- a/src/core/thread/network_diagnostic.cpp +++ b/src/core/thread/network_diagnostic.cpp @@ -50,7 +50,6 @@ #include "thread/mle_router.hpp" #include "thread/thread_netif.hpp" #include "thread/thread_tlvs.hpp" -#include "thread/uri_paths.hpp" namespace ot { @@ -60,17 +59,9 @@ namespace NetworkDiagnostic { NetworkDiagnostic::NetworkDiagnostic(Instance &aInstance) : InstanceLocator(aInstance) - , mDiagnosticGetRequest(UriPath::kDiagnosticGetRequest, &NetworkDiagnostic::HandleDiagnosticGetRequest, this) - , mDiagnosticGetQuery(UriPath::kDiagnosticGetQuery, &NetworkDiagnostic::HandleDiagnosticGetQuery, this) - , mDiagnosticGetAnswer(UriPath::kDiagnosticGetAnswer, &NetworkDiagnostic::HandleDiagnosticGetAnswer, this) - , mDiagnosticReset(UriPath::kDiagnosticReset, &NetworkDiagnostic::HandleDiagnosticReset, this) , mReceiveDiagnosticGetCallback(nullptr) , mReceiveDiagnosticGetCallbackContext(nullptr) { - Get().AddResource(mDiagnosticGetRequest); - Get().AddResource(mDiagnosticGetQuery); - Get().AddResource(mDiagnosticGetAnswer); - Get().AddResource(mDiagnosticReset); } Error NetworkDiagnostic::SendDiagnosticGet(const Ip6::Address & aDestination, @@ -86,13 +77,13 @@ Error NetworkDiagnostic::SendDiagnosticGet(const Ip6::Address & aDesti if (aDestination.IsMulticast()) { - message = Get().NewNonConfirmablePostMessage(UriPath::kDiagnosticGetQuery); + message = Get().NewNonConfirmablePostMessage(kUriDiagnosticGetQuery); messageInfo.SetMulticastLoop(true); } else { handler = &NetworkDiagnostic::HandleDiagnosticGetResponse; - message = Get().NewConfirmablePostMessage(UriPath::kDiagnosticGetRequest); + message = Get().NewConfirmablePostMessage(kUriDiagnosticGetRequest); } VerifyOrExit(message != nullptr, error = kErrorNoBufs); @@ -153,15 +144,9 @@ exit: return; } -void NetworkDiagnostic::HandleDiagnosticGetAnswer(void * aContext, - otMessage * aMessage, - const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDiagnosticGetAnswer(AsCoapMessage(aMessage), - AsCoreType(aMessageInfo)); -} - -void NetworkDiagnostic::HandleDiagnosticGetAnswer(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void NetworkDiagnostic::HandleTmf(Coap::Message & aMessage, + const Ip6::MessageInfo &aMessageInfo) { VerifyOrExit(aMessage.IsConfirmablePostRequest()); @@ -450,13 +435,8 @@ exit: return error; } -void NetworkDiagnostic::HandleDiagnosticGetQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDiagnosticGetQuery(AsCoapMessage(aMessage), - AsCoreType(aMessageInfo)); -} - -void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void NetworkDiagnostic::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; Coap::Message * message = nullptr; @@ -480,7 +460,7 @@ void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Message &aMessage, const } } - message = Get().NewConfirmablePostMessage(UriPath::kDiagnosticGetAnswer); + message = Get().NewConfirmablePostMessage(kUriDiagnosticGetAnswer); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aMessageInfo.GetPeerAddr().IsLinkLocal()) @@ -504,15 +484,9 @@ exit: FreeMessageOnError(message, error); } -void NetworkDiagnostic::HandleDiagnosticGetRequest(void * aContext, - otMessage * aMessage, - const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDiagnosticGetRequest(AsCoapMessage(aMessage), - AsCoreType(aMessageInfo)); -} - -void NetworkDiagnostic::HandleDiagnosticGetRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void NetworkDiagnostic::HandleTmf(Coap::Message & aMessage, + const Ip6::MessageInfo &aMessageInfo) { Error error = kErrorNone; Coap::Message * message = nullptr; @@ -548,7 +522,7 @@ Error NetworkDiagnostic::SendDiagnosticReset(const Ip6::Address &aDestination, Coap::Message * message = nullptr; Tmf::MessageInfo messageInfo(GetInstance()); - message = Get().NewConfirmablePostMessage(UriPath::kDiagnosticReset); + message = Get().NewConfirmablePostMessage(kUriDiagnosticReset); VerifyOrExit(message != nullptr, error = kErrorNoBufs); if (aCount > 0) @@ -576,13 +550,8 @@ exit: return error; } -void NetworkDiagnostic::HandleDiagnosticReset(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleDiagnosticReset(AsCoapMessage(aMessage), - AsCoreType(aMessageInfo)); -} - -void NetworkDiagnostic::HandleDiagnosticReset(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void NetworkDiagnostic::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t offset = 0; uint8_t type; diff --git a/src/core/thread/network_diagnostic.hpp b/src/core/thread/network_diagnostic.hpp index ade893fd9..0f0c0def6 100644 --- a/src/core/thread/network_diagnostic.hpp +++ b/src/core/thread/network_diagnostic.hpp @@ -40,11 +40,11 @@ #include -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "net/udp6.hpp" #include "thread/network_diagnostic_tlvs.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -65,6 +65,8 @@ namespace NetworkDiagnostic { */ class NetworkDiagnostic : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This type represents an iterator used to iterate through Network Diagnostic TLVs from `GetNextDiagTlv()`. @@ -129,33 +131,23 @@ private: void FillMacCountersTlv(MacCountersTlv &aMacCountersTlv); Error FillRequestedTlvs(const Message &aRequest, Message &aResponse, NetworkDiagnosticTlv &aNetworkDiagnosticTlv); - static void HandleDiagnosticGetRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDiagnosticGetRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - - static void HandleDiagnosticGetQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDiagnosticGetQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - static void HandleDiagnosticGetResponse(void * aContext, otMessage * aMessage, const otMessageInfo *aMessageInfo, Error aResult); void HandleDiagnosticGetResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aResult); - static void HandleDiagnosticGetAnswer(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDiagnosticGetAnswer(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - - static void HandleDiagnosticReset(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleDiagnosticReset(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); - - Coap::Resource mDiagnosticGetRequest; - Coap::Resource mDiagnosticGetQuery; - Coap::Resource mDiagnosticGetAnswer; - Coap::Resource mDiagnosticReset; + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); otReceiveDiagnosticGetCallback mReceiveDiagnosticGetCallback; void * mReceiveDiagnosticGetCallbackContext; }; +DeclareTmfHandler(NetworkDiagnostic, kUriDiagnosticGetRequest); +DeclareTmfHandler(NetworkDiagnostic, kUriDiagnosticGetQuery); +DeclareTmfHandler(NetworkDiagnostic, kUriDiagnosticGetAnswer); +DeclareTmfHandler(NetworkDiagnostic, kUriDiagnosticReset); + /** * @} */ diff --git a/src/core/thread/panid_query_server.cpp b/src/core/thread/panid_query_server.cpp index dc2deeefd..b58d430e8 100644 --- a/src/core/thread/panid_query_server.cpp +++ b/src/core/thread/panid_query_server.cpp @@ -54,17 +54,11 @@ PanIdQueryServer::PanIdQueryServer(Instance &aInstance) , mChannelMask(0) , mPanId(Mac::kPanIdBroadcast) , mTimer(aInstance) - , mPanIdQuery(UriPath::kPanIdQuery, &PanIdQueryServer::HandleQuery, this) { - Get().AddResource(mPanIdQuery); } -void PanIdQueryServer::HandleQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo) -{ - static_cast(aContext)->HandleQuery(AsCoapMessage(aMessage), AsCoreType(aMessageInfo)); -} - -void PanIdQueryServer::HandleQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +template <> +void PanIdQueryServer::HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { uint16_t panId; Ip6::MessageInfo responseInfo(aMessageInfo); @@ -117,7 +111,7 @@ void PanIdQueryServer::SendConflict(void) Tmf::MessageInfo messageInfo(GetInstance()); Coap::Message * message; - message = Get().NewPriorityConfirmablePostMessage(UriPath::kPanIdConflict); + message = Get().NewPriorityConfirmablePostMessage(kUriPanIdConflict); VerifyOrExit(message != nullptr, error = kErrorNoBufs); channelMask.Init(); diff --git a/src/core/thread/panid_query_server.hpp b/src/core/thread/panid_query_server.hpp index 39f14ddff..70deaf9e9 100644 --- a/src/core/thread/panid_query_server.hpp +++ b/src/core/thread/panid_query_server.hpp @@ -36,13 +36,13 @@ #include "openthread-core-config.h" -#include "coap/coap.hpp" #include "common/locator.hpp" #include "common/non_copyable.hpp" #include "common/timer.hpp" #include "mac/mac.hpp" #include "net/ip6_address.hpp" #include "net/udp6.hpp" +#include "thread/tmf.hpp" namespace ot { @@ -52,6 +52,8 @@ namespace ot { */ class PanIdQueryServer : public InstanceLocator, private NonCopyable { + friend class Tmf::Agent; + public: /** * This constructor initializes the object. @@ -62,8 +64,7 @@ public: private: static constexpr uint32_t kScanDelay = 1000; ///< SCAN_DELAY (in msec) - static void HandleQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo); - void HandleQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); static void HandleScanResult(Mac::ActiveScanResult *aScanResult, void *aContext); void HandleScanResult(Mac::ActiveScanResult *aScanResult); @@ -81,10 +82,10 @@ private: uint16_t mPanId; DelayTimer mTimer; - - Coap::Resource mPanIdQuery; }; +DeclareTmfHandler(PanIdQueryServer, kUriPanIdQuery); + /** * @} */ diff --git a/src/core/thread/tmf.cpp b/src/core/thread/tmf.cpp index 05e7f015d..d3eada012 100644 --- a/src/core/thread/tmf.cpp +++ b/src/core/thread/tmf.cpp @@ -80,11 +80,122 @@ void MessageInfo::SetSockAddrToRlocPeerAddrTo(const Ip6::Address &aPeerAddress) //---------------------------------------------------------------------------------------------------------------------- // Agent +Agent::Agent(Instance &aInstance) + : Coap::Coap(aInstance) +{ + SetInterceptor(&Filter, this); + SetResourceHandler(&HandleResource); +} + Error Agent::Start(void) { return Coap::Start(kUdpPort, Ip6::kNetifThread); } +template <> void Agent::HandleTmf(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +{ + OT_UNUSED_VARIABLE(aMessage); + OT_UNUSED_VARIABLE(aMessageInfo); + +#if (OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE) + Get().HandleTmf(aMessage, aMessageInfo); +#endif +#if OPENTHREAD_CONFIG_BORDER_AGENT_ENABLE + Get().HandleTmf(aMessage, aMessageInfo); +#endif +} + +bool Agent::HandleResource(CoapBase & aCoapBase, + const char * aUriPath, + Message & aMessage, + const Ip6::MessageInfo &aMessageInfo) +{ + return static_cast(aCoapBase).HandleResource(aUriPath, aMessage, aMessageInfo); +} + +bool Agent::HandleResource(const char *aUriPath, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) +{ + bool didHandle = true; + Uri uri = UriFromPath(aUriPath); + +#define Case(kUri, Type) \ + case kUri: \ + Get().HandleTmf(aMessage, aMessageInfo); \ + break + + switch (uri) + { + Case(kUriAddressError, AddressResolver); + Case(kUriEnergyScan, EnergyScanServer); + Case(kUriActiveGet, MeshCoP::ActiveDatasetManager); + Case(kUriPendingGet, MeshCoP::PendingDatasetManager); + +#if OPENTHREAD_FTD + Case(kUriAddressQuery, AddressResolver); + Case(kUriAddressNotify, AddressResolver); + Case(kUriAddressSolicit, Mle::MleRouter); + Case(kUriAddressRelease, Mle::MleRouter); + Case(kUriActiveSet, MeshCoP::ActiveDatasetManager); + Case(kUriPendingSet, MeshCoP::PendingDatasetManager); + Case(kUriLeaderPetition, MeshCoP::Leader); + Case(kUriLeaderKeepAlive, MeshCoP::Leader); + Case(kUriServerData, NetworkData::Leader); + Case(kUriCommissionerGet, NetworkData::Leader); + Case(kUriCommissionerSet, NetworkData::Leader); + Case(kUriAnnounceBegin, AnnounceBeginServer); + Case(kUriPanIdQuery, PanIdQueryServer); + Case(kUriRelayTx, MeshCoP::JoinerRouter); +#endif + +#if OPENTHREAD_CONFIG_JOINER_ENABLE + Case(kUriJoinerEntrust, MeshCoP::Joiner); +#endif + +#if OPENTHREAD_CONFIG_COMMISSIONER_ENABLE && OPENTHREAD_FTD + Case(kUriPanIdConflict, PanIdQueryClient); + Case(kUriEnergyReport, EnergyScanClient); + Case(kUriDatasetChanged, MeshCoP::Commissioner); + // kUriRelayRx is handled below +#endif + +#if OPENTHREAD_CONFIG_BORDER_AGENT_ENABLE || (OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE) + Case(kUriRelayRx, Agent); +#endif + +#if OPENTHREAD_CONFIG_DUA_ENABLE || (OPENTHREAD_FTD && OPENTHREAD_CONFIG_TMF_PROXY_DUA_ENABLE) + Case(kUriDuaRegistrationNotify, DuaManager); +#endif + +#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE + Case(kUriAnycastLocate, AnycastLocator); +#endif + +#if OPENTHREAD_FTD || OPENTHREAD_CONFIG_TMF_NETWORK_DIAG_MTD_ENABLE + Case(kUriDiagnosticGetRequest, NetworkDiagnostic::NetworkDiagnostic); + Case(kUriDiagnosticGetQuery, NetworkDiagnostic::NetworkDiagnostic); + Case(kUriDiagnosticGetAnswer, NetworkDiagnostic::NetworkDiagnostic); + Case(kUriDiagnosticReset, NetworkDiagnostic::NetworkDiagnostic); +#endif + +#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE +#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE + Case(kUriMlr, BackboneRouter::Manager); +#endif +#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE + Case(kUriDuaRegistrationRequest, BackboneRouter::Manager); +#endif +#endif + + default: + didHandle = false; + break; + } + +#undef Case + + return didHandle; +} + Error Agent::Filter(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext) { OT_UNUSED_VARIABLE(aMessage); diff --git a/src/core/thread/tmf.hpp b/src/core/thread/tmf.hpp index 39e0185cd..3f40c2c37 100644 --- a/src/core/thread/tmf.hpp +++ b/src/core/thread/tmf.hpp @@ -42,6 +42,20 @@ namespace ot { namespace Tmf { +/** + * This macro declares a TMF handler (a full template specialization of `HandleTmf` method) in a given `Type`. + * + * The class `Type` MUST declare a template method of the following format: + * + * template void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + * + * @param[in] Type The `Type` in which the TMF handler is declared. + * @param[in] kUri The `Uri` which is handled. + * + */ +#define DeclareTmfHandler(Type, kUri) \ + template <> void Type::HandleTmf(Coap::Message & aMessage, const Ip6::MessageInfo &aMessageInfo) + constexpr uint16_t kUdpPort = 61631; ///< TMF UDP Port typedef Coap::Message Message; ///< A TMF message. @@ -137,11 +151,7 @@ public: * @param[in] aInstance A reference to the OpenThread instance. * */ - explicit Agent(Instance &aInstance) - : Coap::Coap(aInstance) - { - SetInterceptor(&Filter, this); - } + explicit Agent(Instance &aInstance); /** * This method starts the TMF agent. @@ -172,6 +182,14 @@ public: bool IsTmfMessage(const Ip6::Address &aSourceAddress, const Ip6::Address &aDestAddress, uint16_t aDestPort) const; private: + template void HandleTmf(Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + + static bool HandleResource(CoapBase & aCoapBase, + const char * aUriPath, + Message & aMessage, + const Ip6::MessageInfo &aMessageInfo); + bool HandleResource(const char *aUriPath, Message &aMessage, const Ip6::MessageInfo &aMessageInfo); + static Error Filter(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext); }; diff --git a/src/core/thread/uri_paths.cpp b/src/core/thread/uri_paths.cpp index 9f72a6aef..112de3611 100644 --- a/src/core/thread/uri_paths.cpp +++ b/src/core/thread/uri_paths.cpp @@ -33,46 +33,132 @@ #include "uri_paths.hpp" +#include "common/binary_search.hpp" +#include "common/debug.hpp" +#include "common/string.hpp" + +#include + namespace ot { -const char UriPath::kAddressQuery[] = "a/aq"; -const char UriPath::kAddressNotify[] = "a/an"; -const char UriPath::kAddressError[] = "a/ae"; -const char UriPath::kAddressRelease[] = "a/ar"; -const char UriPath::kAddressSolicit[] = "a/as"; -const char UriPath::kAnycastLocate[] = "a/yl"; -const char UriPath::kActiveGet[] = "c/ag"; -const char UriPath::kActiveSet[] = "c/as"; -const char UriPath::kDatasetChanged[] = "c/dc"; -const char UriPath::kEnergyScan[] = "c/es"; -const char UriPath::kEnergyReport[] = "c/er"; -const char UriPath::kPendingGet[] = "c/pg"; -const char UriPath::kPendingSet[] = "c/ps"; -const char UriPath::kServerData[] = "a/sd"; -const char UriPath::kAnnounceBegin[] = "c/ab"; -const char UriPath::kProxyRx[] = "c/ur"; -const char UriPath::kProxyTx[] = "c/ut"; -const char UriPath::kRelayRx[] = "c/rx"; -const char UriPath::kRelayTx[] = "c/tx"; -const char UriPath::kJoinerFinalize[] = "c/jf"; -const char UriPath::kJoinerEntrust[] = "c/je"; -const char UriPath::kLeaderPetition[] = "c/lp"; -const char UriPath::kLeaderKeepAlive[] = "c/la"; -const char UriPath::kPanIdConflict[] = "c/pc"; -const char UriPath::kPanIdQuery[] = "c/pq"; -const char UriPath::kCommissionerGet[] = "c/cg"; -const char UriPath::kCommissionerKeepAlive[] = "c/ca"; -const char UriPath::kCommissionerPetition[] = "c/cp"; -const char UriPath::kCommissionerSet[] = "c/cs"; -const char UriPath::kDiagnosticGetRequest[] = "d/dg"; -const char UriPath::kDiagnosticGetQuery[] = "d/dq"; -const char UriPath::kDiagnosticGetAnswer[] = "d/da"; -const char UriPath::kDiagnosticReset[] = "d/dr"; -const char UriPath::kMlr[] = "n/mr"; -const char UriPath::kDuaRegistrationRequest[] = "n/dr"; -const char UriPath::kDuaRegistrationNotify[] = "n/dn"; -const char UriPath::kBackboneQuery[] = "b/bq"; -const char UriPath::kBackboneAnswer[] = "b/ba"; -const char UriPath::kBackboneMlr[] = "b/bmr"; +namespace UriList { + +struct Entry +{ + const char *mPath; + + constexpr static bool AreInOrder(const Entry &aFirst, const Entry &aSecond) + { + return AreStringsInOrder(aFirst.mPath, aSecond.mPath); + } + + int Compare(const char *aPath) const { return strcmp(aPath, mPath); } +}; + +// The list of URI paths (MUST be sorted alphabetically) +static constexpr Entry kEntries[] = { + {"a/ae"}, // (0) kUriAddressError + {"a/an"}, // (1) kUriAddressNotify + {"a/aq"}, // (2) kUriAddressQuery + {"a/ar"}, // (3) kUriAddressRelease + {"a/as"}, // (4) kUriAddressSolicit + {"a/sd"}, // (5) kUriServerData + {"a/yl"}, // (6) kUriAnycastLocate + {"b/ba"}, // (7) kUriBackboneAnswer + {"b/bmr"}, // (8) kUriBackboneMlr + {"b/bq"}, // (9) kUriBackboneQuery + {"c/ab"}, // (10) kUriAnnounceBegin + {"c/ag"}, // (11) kUriActiveGet + {"c/as"}, // (12) kUriActiveSet + {"c/ca"}, // (13) kUriCommissionerKeepAlive + {"c/cg"}, // (14) kUriCommissionerGet + {"c/cp"}, // (15) kUriCommissionerPetition + {"c/cs"}, // (16) kUriCommissionerSet + {"c/dc"}, // (17) kUriDatasetChanged + {"c/er"}, // (18) kUriEnergyReport + {"c/es"}, // (19) kUriEnergyScan + {"c/je"}, // (20) kUriJoinerEntrust + {"c/jf"}, // (21) kUriJoinerFinalize + {"c/la"}, // (22) kUriLeaderKeepAlive + {"c/lp"}, // (23) kUriLeaderPetition + {"c/pc"}, // (24) kUriPanIdConflict + {"c/pg"}, // (25) kUriPendingGet + {"c/pq"}, // (26) kUriPanIdQuery + {"c/ps"}, // (27) kUriPendingSet + {"c/rx"}, // (28) kUriRelayRx + {"c/tx"}, // (29) kUriRelayTx + {"c/ur"}, // (30) kUriProxyRx + {"c/ut"}, // (31) kUriProxyTx + {"d/da"}, // (32) kUriDiagnosticGetAnswer + {"d/dg"}, // (33) kUriDiagnosticGetRequest + {"d/dq"}, // (34) kUriDiagnosticGetQuery + {"d/dr"}, // (35) kUriDiagnosticReset + {"n/dn"}, // (36) kUriDuaRegistrationNotify + {"n/dr"}, // (37) kUriDuaRegistrationRequest + {"n/mr"}, // (38) kUriMlr +}; + +static_assert(BinarySearch::IsSorted(kEntries), "kEntries is not sorted"); + +static_assert(0 == kUriAddressError, "kUriAddressError (`a/ae`) is invalid"); +static_assert(1 == kUriAddressNotify, "kUriAddressNotify (`a/an`) is invalid"); +static_assert(2 == kUriAddressQuery, "kUriAddressQuery (`a/aq`) is invalid"); +static_assert(3 == kUriAddressRelease, "kUriAddressRelease (`a/ar`) is invalid"); +static_assert(4 == kUriAddressSolicit, "kUriAddressSolicit (`a/as`) is invalid"); +static_assert(5 == kUriServerData, "kUriServerData (`a/sd`) is invalid"); +static_assert(6 == kUriAnycastLocate, "kUriAnycastLocate (`a/yl`) is invalid"); +static_assert(7 == kUriBackboneAnswer, "kUriBackboneAnswer (`b/ba`) is invalid"); +static_assert(8 == kUriBackboneMlr, "kUriBackboneMlr (`b/bmr`) is invalid"); +static_assert(9 == kUriBackboneQuery, "kUriBackboneQuery (`b/bq`) is invalid"); +static_assert(10 == kUriAnnounceBegin, "kUriAnnounceBegin (`c/ab`) is invalid"); +static_assert(11 == kUriActiveGet, "kUriActiveGet (`c/ag`) is invalid"); +static_assert(12 == kUriActiveSet, "kUriActiveSet (`c/as`) is invalid"); +static_assert(13 == kUriCommissionerKeepAlive, "kUriCommissionerKeepAlive (`c/ca`) is invalid"); +static_assert(14 == kUriCommissionerGet, "kUriCommissionerGet (`c/cg`) is invalid"); +static_assert(15 == kUriCommissionerPetition, "kUriCommissionerPetition (`c/cp`) is invalid"); +static_assert(16 == kUriCommissionerSet, "kUriCommissionerSet (`c/cs`) is invalid"); +static_assert(17 == kUriDatasetChanged, "kUriDatasetChanged (`c/dc`) is invalid"); +static_assert(18 == kUriEnergyReport, "kUriEnergyReport (`c/er`) is invalid"); +static_assert(19 == kUriEnergyScan, "kUriEnergyScan (`c/es`) is invalid"); +static_assert(20 == kUriJoinerEntrust, "kUriJoinerEntrust (`c/je`) is invalid"); +static_assert(21 == kUriJoinerFinalize, "kUriJoinerFinalize (`c/jf`) is invalid"); +static_assert(22 == kUriLeaderKeepAlive, "kUriLeaderKeepAlive (`c/la`) is invalid"); +static_assert(23 == kUriLeaderPetition, "kUriLeaderPetition (`c/lp`) is invalid"); +static_assert(24 == kUriPanIdConflict, "kUriPanIdConflict (`c/pc`) is invalid"); +static_assert(25 == kUriPendingGet, "kUriPendingGet (`c/pg`) is invalid"); +static_assert(26 == kUriPanIdQuery, "kUriPanIdQuery (`c/pq`) is invalid"); +static_assert(27 == kUriPendingSet, "kUriPendingSet (`c/ps`) is invalid"); +static_assert(28 == kUriRelayRx, "kUriRelayRx (`c/rx`) is invalid"); +static_assert(29 == kUriRelayTx, "kUriRelayTx (`c/tx`) is invalid"); +static_assert(30 == kUriProxyRx, "kUriProxyRx (`c/ur`) is invalid"); +static_assert(31 == kUriProxyTx, "kUriProxyTx (`c/ut`) is invalid"); +static_assert(32 == kUriDiagnosticGetAnswer, "kUriDiagnosticGetAnswer (`d/da`) is invalid"); +static_assert(33 == kUriDiagnosticGetRequest, "kUriDiagnosticGetRequest (`d/dg`) is invalid"); +static_assert(34 == kUriDiagnosticGetQuery, "kUriDiagnosticGetQuery (`d/dq`) is invalid"); +static_assert(35 == kUriDiagnosticReset, "kUriDiagnosticReset (`d/dr`) is invalid"); +static_assert(36 == kUriDuaRegistrationNotify, "kUriDuaRegistrationNotify (`n/dn`) is invalid"); +static_assert(37 == kUriDuaRegistrationRequest, "kUriDuaRegistrationRequest (`n/dr`) is invalid"); +static_assert(38 == kUriMlr, "kUriMlr (`n/mr`) is invalid"); + +} // namespace UriList + +const char *PathForUri(Uri aUri) +{ + OT_ASSERT(aUri != kUriUnknown); + + return UriList::kEntries[aUri].mPath; +} + +Uri UriFromPath(const char *aPath) +{ + Uri uri = kUriUnknown; + const UriList::Entry *entry = BinarySearch::Find(aPath, UriList::kEntries); + + VerifyOrExit(entry != nullptr); + uri = static_cast(entry - UriList::kEntries); + +exit: + return uri; +} } // namespace ot diff --git a/src/core/thread/uri_paths.hpp b/src/core/thread/uri_paths.hpp index 30c7999e2..e43928edf 100644 --- a/src/core/thread/uri_paths.hpp +++ b/src/core/thread/uri_paths.hpp @@ -36,56 +36,78 @@ #include "openthread-core-config.h" +#include "common/error.hpp" + namespace ot { /** - * - * This structure contains Thread URI Path string definitions. + * This enumeration represents Thread URIs. * */ -struct UriPath +enum Uri : uint8_t { - static const char kAddressQuery[]; ///< The URI Path for Address Query ("a/aq"). - static const char kAddressNotify[]; ///< The URI Path for Address Notify ("a/an"). - static const char kAddressError[]; ///< The URI Path for Address Error ("a/ae"). - static const char kAddressRelease[]; ///< The URI Path for Address Release ("a/ar"). - static const char kAddressSolicit[]; ///< The URI Path for Address Solicit ("a/as"). - static const char kAnycastLocate[]; ///< The URI Path for Anycast Locate ("a/yl") - static const char kActiveGet[]; ///< The URI Path for MGMT_ACTIVE_GE ("c/ag")T - static const char kActiveSet[]; ///< The URI Path for MGMT_ACTIVE_SET ("c/as"). - static const char kDatasetChanged[]; ///< The URI Path for MGMT_DATASET_CHANGED ("c/dc"). - static const char kEnergyScan[]; ///< The URI Path for Energy Scan ("c/es"). - static const char kEnergyReport[]; ///< The URI Path for Energy Report ("c/er"). - static const char kPendingGet[]; ///< The URI Path for MGMT_PENDING_GET ("c/pg"). - static const char kPendingSet[]; ///< The URI Path for MGMT_PENDING_SET ("c/ps"). - static const char kServerData[]; ///< The URI Path for Server Data Registration ("a/sd"). - static const char kAnnounceBegin[]; ///< The URI Path for Announce Begin ("c/ab"). - static const char kProxyRx[]; ///< The URI Path for Proxy RX ("c/ur"). - static const char kProxyTx[]; ///< The URI Path for Proxy TX ("c/ut"). - static const char kRelayRx[]; ///< The URI Path for Relay RX ("c/rx"). - static const char kRelayTx[]; ///< The URI Path for Relay TX ("c/tx"). - static const char kJoinerFinalize[]; ///< The URI Path for Joiner Finalize ("c/jf"). - static const char kJoinerEntrust[]; ///< The URI Path for Joiner Entrust ("c/je"). - static const char kLeaderPetition[]; ///< The URI Path for Leader Petition ("c/lp"). - static const char kLeaderKeepAlive[]; ///< The URI Path for Leader Keep Alive ("c/la"). - static const char kPanIdConflict[]; ///< The URI Path for PAN ID Conflict ("c/pc"). - static const char kPanIdQuery[]; ///< The URI Path for PAN ID Query ("c/pq"). - static const char kCommissionerGet[]; ///< The URI Path for MGMT_COMMISSIONER_GET ("c/cg"). - static const char kCommissionerKeepAlive[]; ///< The URI Path for Commissioner Keep Alive ("c/ca"). - static const char kCommissionerPetition[]; ///< The URI Path for Commissioner Petition ("c/cp"). - static const char kCommissionerSet[]; ///< The URI Path for MGMT_COMMISSIONER_SET ("c/cs"). - static const char kDiagnosticGetRequest[]; ///< The URI Path for Network Diagnostic Get Request ("d/dg"). - static const char kDiagnosticGetQuery[]; ///< The URI Path for Network Diagnostic Get Query ("d/dq"). - static const char kDiagnosticGetAnswer[]; ///< The URI Path for Network Diagnostic Get Answer ("d/da"). - static const char kDiagnosticReset[]; ///< The URI Path for Network Diagnostic Reset ("d/dr"). - static const char kMlr[]; ///< The URI Path for Multicast Listener Registration ("n/mr"). - static const char kDuaRegistrationRequest[]; ///< The URI Path for DUA Registration Request ("n/dr"). - static const char kDuaRegistrationNotify[]; ///< The URI Path for DUA Registration Notification ("n/dn"). - static const char kBackboneQuery[]; ///< The URI Path for Backbone Query ("b/bq"). - static const char kBackboneAnswer[]; ///< The URI Path for Backbone Answer / Backbone Notification ("b/ba"). - static const char kBackboneMlr[]; ///< The URI Path for Backbone Multicast Listener Report ("b/bmr"). + kUriAddressError, ///< Address Error ("a/ae") + kUriAddressNotify, ///< Address Notify ("a/an") + kUriAddressQuery, ///< Address Query ("a/aq") + kUriAddressRelease, ///< Address Release ("a/ar") + kUriAddressSolicit, ///< Address Solicit ("a/as") + kUriServerData, ///< Server Data Registration ("a/sd") + kUriAnycastLocate, ///< Anycast Locate ("a/yl") + kUriBackboneAnswer, ///< Backbone Answer / Backbone Notification ("b/ba") + kUriBackboneMlr, ///< Backbone Multicast Listener Report ("b/bmr") + kUriBackboneQuery, ///< Backbone Query ("b/bq") + kUriAnnounceBegin, ///< Announce Begin ("c/ab") + kUriActiveGet, ///< MGMT_ACTIVE_GET "c/ag" + kUriActiveSet, ///< MGMT_ACTIVE_SET ("c/as") + kUriCommissionerKeepAlive, ///< Commissioner Keep Alive ("c/ca") + kUriCommissionerGet, ///< MGMT_COMMISSIONER_GET ("c/cg") + kUriCommissionerPetition, ///< Commissioner Petition ("c/cp") + kUriCommissionerSet, ///< MGMT_COMMISSIONER_SET ("c/cs") + kUriDatasetChanged, ///< MGMT_DATASET_CHANGED ("c/dc") + kUriEnergyReport, ///< Energy Report ("c/er") + kUriEnergyScan, ///< Energy Scan ("c/es") + kUriJoinerEntrust, ///< Joiner Entrust ("c/je") + kUriJoinerFinalize, ///< Joiner Finalize ("c/jf") + kUriLeaderKeepAlive, ///< Leader Keep Alive ("c/la") + kUriLeaderPetition, ///< Leader Petition ("c/lp") + kUriPanIdConflict, ///< PAN ID Conflict ("c/pc") + kUriPendingGet, ///< MGMT_PENDING_GET ("c/pg") + kUriPanIdQuery, ///< PAN ID Query ("c/pq") + kUriPendingSet, ///< MGMT_PENDING_SET ("c/ps") + kUriRelayRx, ///< Relay RX ("c/rx") + kUriRelayTx, ///< Relay TX ("c/tx") + kUriProxyRx, ///< Proxy RX ("c/ur") + kUriProxyTx, ///< Proxy TX ("c/ut") + kUriDiagnosticGetAnswer, ///< Network Diagnostic Get Answer ("d/da") + kUriDiagnosticGetRequest, ///< Network Diagnostic Get Request ("d/dg") + kUriDiagnosticGetQuery, ///< Network Diagnostic Get Query ("d/dq") + kUriDiagnosticReset, ///< Network Diagnostic Reset ("d/dr") + kUriDuaRegistrationNotify, ///< DUA Registration Notification ("n/dn") + kUriDuaRegistrationRequest, ///< DUA Registration Request ("n/dr") + kUriMlr, ///< Multicast Listener Registration ("n/mr") + kUriUnknown, ///< Unknown URI }; +/** + * This function returns URI path string for a given URI. + * + * @param[in] aUri A URI. + * + * @returns The path string for @p aUri. + * + */ +const char *PathForUri(Uri aUri); + +/** + * This function looks up the URI from a given path string. + * + * @param[in] aPath A path string. + * + * @returns The URI associated with @p aPath or `kUriUnknown` if no match is found. + * + */ +Uri UriFromPath(const char *aPath); + } // namespace ot #endif // URI_PATHS_HPP_