espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-11 05:07:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[tmf] new model for handling TMF URI resources (#8233)

Browse Source 
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<Uri>()` 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.
This commit is contained in:
Abtin Keshavarzian
2022-10-06 18:32:22 -07:00
committed by GitHub
parent c4b6206f16
commit 812c36f658
49 changed files with 746 additions and 698 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/backbone_router/bbr_manager.cpp
+25 -19
View File
@@ -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<Local>().GetState() == OT_BACKBONE_ROUTER_STATE_DISABLED)
{
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE
Get<Tmf::Agent>().RemoveResource(mMulticastListenerRegistration);
mMulticastListenersTable.Clear();
#endif
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE
Get<Tmf::Agent>().RemoveResource(mDuaRegistration);
#endif
mTimer.Stop();
@@ -120,12 +112,6 @@ void Manager::HandleNotifierEvents(Events aEvents)
}
else
{
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE
Get<Tmf::Agent>().AddResource(mMulticastListenerRegistration);
#endif
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE
Get<Tmf::Agent>().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<kUriMlr>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
VerifyOrExit(Get<Local>().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<kUriDuaRegistrationRequest>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
VerifyOrExit(Get<Local>().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<Local>().IsPrimary(), error = kErrorInvalidState);
message = mBackboneTmfAgent.NewPriorityNonConfirmablePostMessage(UriPath::kBackboneQuery);
message = mBackboneTmfAgent.NewPriorityNonConfirmablePostMessage(kUriBackboneQuery);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadTargetTlv>(*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<ThreadTargetTlv>(*message, aDua));
src/core/backbone_router/bbr_manager.hpp
+4 -16
View File
@@ -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 <Uri kUri> 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<Manager *>(aContext)->HandleMulticastListenerRegistration(
*static_cast<const Coap::Message *>(aMessage), *static_cast<const Ip6::MessageInfo *>(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<Manager *>(aContext)->HandleDuaRegistration(*static_cast<const Coap::Message *>(aMessage),
*static_cast<const Ip6::MessageInfo *>(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<Manager, &Manager::HandleTimer>;
#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;
src/core/coap/coap.cpp
+34 -10
View File
@@ -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)
src/core/coap/coap.hpp
+55 -19
View File
@@ -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
src/core/coap/coap_message.cpp
+4 -4
View File
@@ -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
src/core/coap/coap_message.hpp
+5 -4
View File
@@ -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.
src/core/common/instance.hpp
+15
View File
@@ -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
src/core/meshcop/announce_begin_client.cpp
+1 -1
View File
@@ -68,7 +68,7 @@ Error AnnounceBeginClient::SendRequest(uint32_t aChannelMask,
VerifyOrExit(Get<MeshCoP::Commissioner>().IsActive(), error = kErrorInvalidState);
VerifyOrExit((message = Get<Tmf::Agent>().NewPriorityMessage()) != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = message->InitAsPost(aAddress, UriPath::kAnnounceBegin));
SuccessOrExit(error = message->InitAsPost(aAddress, kUriAnnounceBegin));
SuccessOrExit(error = message->SetPayloadMarker());
SuccessOrExit(
src/core/meshcop/border_agent.cpp
+30 -38
View File
@@ -226,7 +226,7 @@ void BorderAgent::HandleRequest(void *aContext, otMessage *aMessage, const otMes
{
IgnoreError(static_cast<BorderAgent *>(aContext)->ForwardToLeader(
AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
(static_cast<BorderAgent *>(aContext)->*aResource).GetUriPath(), false, false));
UriFromPath((static_cast<BorderAgent *>(aContext)->*aResource).GetUriPath()), false, false));
}
template <>
@@ -235,7 +235,7 @@ void BorderAgent::HandleRequest<&BorderAgent::mCommissionerPetition>(void *
const otMessageInfo *aMessageInfo)
{
IgnoreError(static_cast<BorderAgent *>(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<BorderAgent *>(aContext)->HandleRelayTransmit(AsCoapMessage(aMessage));
}
template <>
void BorderAgent::HandleRequest<&BorderAgent::mRelayReceive>(void * aContext,
otMessage * aMessage,
const otMessageInfo *aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
static_cast<BorderAgent *>(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<Coap::CoapSecure>().NewPriorityNonConfirmablePostMessage(UriPath::kProxyRx);
message = Get<Coap::CoapSecure>().NewPriorityNonConfirmablePostMessage(kUriProxyRx);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
{
@@ -390,7 +380,7 @@ bool BorderAgent::HandleUdpReceive(const Message &aMessage, const Ip6::MessageIn
SuccessOrExit(error = Get<Coap::CoapSecure>().SendMessage(*message, Get<Coap::CoapSecure>().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<kUriRelayRx>(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<Coap::CoapSecure>().NewPriorityNonConfirmablePostMessage(UriPath::kRelayRx);
message = Get<Coap::CoapSecure>().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<JoinerRouterLocatorTlv>(aMessage, joinerRouterRloc));
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(UriPath::kRelayTx);
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(kUriRelayTx);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
offset = message->GetLength();
@@ -474,7 +468,7 @@ void BorderAgent::HandleRelayTransmit(const Coap::Message &aMessage)
SuccessOrExit(error = Get<Tmf::Agent>().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<Coap::CoapSecure>().SendAck(aMessage, aMessageInfo));
@@ -503,7 +499,7 @@ Error BorderAgent::ForwardToLeader(const Coap::Message & aMessage,
forwardContext->Init(GetInstance(), aMessage, aPetition, aSeparate);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(aPath);
message = Get<Tmf::Agent>().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<Tmf::Agent>().AddResource(mRelayReceive);
mState = kStateStarted;
mUdpProxyPort = 0;
@@ -633,8 +627,6 @@ void BorderAgent::Stop(void)
coaps.RemoveResource(mProxyTransmit);
coaps.RemoveResource(mRelayTransmit);
Get<Tmf::Agent>().RemoveResource(mRelayReceive);
coaps.Stop();
mState = kStateStopped;
src/core/meshcop/border_agent.hpp
+9 -6
View File
@@ -40,12 +40,13 @@
#include <openthread/border_agent.h>
#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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Coap::Resource BorderAgent::*aResource>
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);
src/core/meshcop/commissioner.cpp
+10 -24
View File
@@ -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<Tmf::Agent>().AddResource(mRelayReceive);
Get<Tmf::Agent>().AddResource(mDatasetChanged);
Get<Coap::CoapSecure>().AddResource(mJoinerFinalize);
}
void Commissioner::RemoveCoapResources(void)
{
Get<Tmf::Agent>().RemoveResource(mRelayReceive);
Get<Tmf::Agent>().RemoveResource(mDatasetChanged);
Get<Coap::CoapSecure>().RemoveResource(mJoinerFinalize);
}
@@ -705,7 +699,7 @@ Error Commissioner::SendMgmtCommissionerGetRequest(const uint8_t *aTlvs, uint8_t
Tmf::MessageInfo messageInfo(GetInstance());
Tlv tlv;
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kCommissionerGet);
message = Get<Tmf::Agent>().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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kCommissionerSet);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriCommissionerSet);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
if (aDataset.IsLocatorSet())
@@ -827,7 +821,7 @@ Error Commissioner::SendPetition(void)
mTransmitAttempts++;
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kLeaderPetition);
message = Get<Tmf::Agent>().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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kLeaderKeepAlive);
message = Get<Tmf::Agent>().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<Commissioner *>(aContext)->HandleRelayReceive(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Commissioner::HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Commissioner::HandleTmf<kUriRelayRx>(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<Commissioner *>(aContext)->HandleDatasetChanged(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Commissioner::HandleDatasetChanged(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void Commissioner::HandleTmf<kUriDatasetChanged>(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<KeyManager>().ExtractKek(kek);
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(UriPath::kRelayTx);
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(kUriRelayTx);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<JoinerUdpPortTlv>(*message, mJoinerPort));
src/core/meshcop/commissioner.hpp
+8 -7
View File
@@ -40,7 +40,6 @@
#include <openthread/commissioner.h>
#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 <Uri kUri> 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);
src/core/meshcop/dataset_manager.cpp
+7 -28
View File
@@ -278,8 +278,7 @@ void DatasetManager::SendSet(void)
}
}
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveSet
: UriPath::kPendingSet);
message = Get<Tmf::Agent>().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<Tmf::Agent>().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveSet
: UriPath::kPendingSet);
message = Get<Tmf::Agent>().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<Tmf::Agent>().NewPriorityConfirmablePostMessage(IsActiveDataset() ? UriPath::kActiveGet
: UriPath::kPendingGet);
message = Get<Tmf::Agent>().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<Tmf::Agent>().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<ActiveDatasetManager *>(aContext)->HandleGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void ActiveDatasetManager::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
template <>
void ActiveDatasetManager::HandleTmf<kUriActiveGet>(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<Tmf::Agent>().AddResource(mResourceGet);
}
void PendingDatasetManager::Clear(void)
@@ -837,12 +820,8 @@ exit:
return;
}
void PendingDatasetManager::HandleGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PendingDatasetManager *>(aContext)->HandleGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void PendingDatasetManager::HandleGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
template <>
void PendingDatasetManager::HandleTmf<kUriPendingGet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
DatasetManager::HandleGet(aMessage, aMessageInfo);
}
src/core/meshcop/dataset_manager.hpp
+19 -42
View File
@@ -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 <Uri kUri> 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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
using DelayTimer = TimerMilliIn<PendingDatasetManager, &PendingDatasetManager::HandleDelayTimer>;
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
src/core/meshcop/dataset_manager_ftd.cpp
+6 -24
View File
@@ -397,21 +397,12 @@ exit:
void ActiveDatasetManager::StartLeader(void)
{
IgnoreError(GenerateLocal());
Get<Tmf::Agent>().AddResource(mResourceSet);
}
void ActiveDatasetManager::StopLeader(void)
{
Get<Tmf::Agent>().RemoveResource(mResourceSet);
}
void ActiveDatasetManager::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<ActiveDatasetManager *>(aContext)->HandleSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void ActiveDatasetManager::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void ActiveDatasetManager::HandleTmf<kUriActiveSet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
VerifyOrExit(Get<Mle::Mle>().IsLeader());
SuccessOrExit(DatasetManager::HandleSet(aMessage, aMessageInfo));
IgnoreError(ApplyConfiguration());
@@ -422,21 +413,12 @@ exit:
void PendingDatasetManager::StartLeader(void)
{
StartDelayTimer();
Get<Tmf::Agent>().AddResource(mResourceSet);
}
void PendingDatasetManager::StopLeader(void)
{
Get<Tmf::Agent>().RemoveResource(mResourceSet);
}
void PendingDatasetManager::HandleSet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PendingDatasetManager *>(aContext)->HandleSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void PendingDatasetManager::HandleSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void PendingDatasetManager::HandleTmf<kUriPendingSet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
VerifyOrExit(Get<Mle::Mle>().IsLeader());
SuccessOrExit(DatasetManager::HandleSet(aMessage, aMessageInfo));
StartDelayTimer();
src/core/meshcop/energy_scan_client.cpp
+3 -9
View File
@@ -57,9 +57,7 @@ EnergyScanClient::EnergyScanClient(Instance &aInstance)
: InstanceLocator(aInstance)
, mCallback(nullptr)
, mContext(nullptr)
, mEnergyScan(UriPath::kEnergyReport, &EnergyScanClient::HandleReport, this)
{
Get<Tmf::Agent>().AddResource(mEnergyScan);
}
Error EnergyScanClient::SendQuery(uint32_t aChannelMask,
@@ -78,7 +76,7 @@ Error EnergyScanClient::SendQuery(uint32_t aChannelMas
VerifyOrExit(Get<MeshCoP::Commissioner>().IsActive(), error = kErrorInvalidState);
VerifyOrExit((message = Get<Tmf::Agent>().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<EnergyScanClient *>(aContext)->HandleReport(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void EnergyScanClient::HandleReport(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void EnergyScanClient::HandleTmf<kUriEnergyReport>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint32_t mask;
MeshCoP::EnergyListTlv energyListTlv;
src/core/meshcop/energy_scan_client.hpp
+6 -4
View File
@@ -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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otCommissionerEnergyReportCallback mCallback;
void * mContext;
Coap::Resource mEnergyScan;
};
DeclareTmfHandler(EnergyScanClient, kUriEnergyReport);
/**
* @}
*/
src/core/meshcop/joiner.cpp
+2 -9
View File
@@ -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<Tmf::Agent>().AddResource(mJoinerEntrust);
}
void Joiner::SetIdFromIeeeEui64(void)
@@ -442,7 +440,7 @@ Error Joiner::PrepareJoinerFinalizeMessage(const char *aProvisioningUrl,
VendorStackVersionTlv vendorStackVersionTlv;
ProvisioningUrlTlv provisioningUrlTlv;
mFinalizeMessage = Get<Coap::CoapSecure>().NewPriorityConfirmablePostMessage(UriPath::kJoinerFinalize);
mFinalizeMessage = Get<Coap::CoapSecure>().NewPriorityConfirmablePostMessage(kUriJoinerFinalize);
VerifyOrExit(mFinalizeMessage != nullptr, error = kErrorNoBufs);
mFinalizeMessage->SetOffset(mFinalizeMessage->GetLength());
@@ -557,12 +555,7 @@ exit:
IgnoreError(Get<Ip6::Filter>().RemoveUnsecurePort(kJoinerUdpPort));
}
void Joiner::HandleJoinerEntrust(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Joiner *>(aContext)->HandleJoinerEntrust(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Joiner::HandleJoinerEntrust(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Joiner::HandleTmf<kUriJoinerEntrust>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Error error;
Dataset::Info datasetInfo;
src/core/meshcop/joiner.hpp
+7 -5
View File
@@ -40,7 +40,6 @@
#include <openthread/joiner.h>
#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 <Uri kUri> 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);
src/core/meshcop/joiner_router.cpp
+3 -10
View File
@@ -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<Tmf::Agent>().AddResource(mRelayTransmit);
}
void JoinerRouter::HandleNotifierEvents(Events aEvents)
@@ -142,7 +140,7 @@ void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &a
SuccessOrExit(error = GetBorderAgentRloc(Get<ThreadNetif>(), borderAgentRloc));
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(UriPath::kRelayRx);
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(kUriRelayRx);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<JoinerUdpPortTlv>(*message, aMessageInfo.GetPeerPort()));
@@ -166,12 +164,7 @@ exit:
FreeMessageOnError(message, error);
}
void JoinerRouter::HandleRelayTransmit(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<JoinerRouter *>(aContext)->HandleRelayTransmit(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void JoinerRouter::HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void JoinerRouter::HandleTmf<kUriRelayTx>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kJoinerEntrust);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriJoinerEntrust);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
message->SetSubType(Message::kSubTypeJoinerEntrust);
src/core/meshcop/joiner_router.hpp
+5 -4
View File
@@ -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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleJoinerEntrustResponse(void * aContext,
otMessage * aMessage,
@@ -121,7 +121,6 @@ private:
using JoinerRouterTimer = TimerMilliIn<JoinerRouter, &JoinerRouter::HandleTimer>;
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
src/core/meshcop/meshcop_leader.cpp
+3 -17
View File
@@ -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<Tmf::Agent>().AddResource(mPetition);
Get<Tmf::Agent>().AddResource(mKeepAlive);
}
void Leader::HandlePetition(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandlePetition(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Leader::HandlePetition(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriLeaderPetition>(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<Leader *>(aContext)->HandleKeepAlive(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Leader::HandleKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kDatasetChanged);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriDatasetChanged);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
messageInfo.SetSockAddrToRlocPeerAddrTo(aAddress);
src/core/meshcop/meshcop_leader.hpp
+15 -14
View File
@@ -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 <Uri kUri> 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<Leader, &Leader::HandleTimer>;
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
src/core/meshcop/panid_query_client.cpp
+3 -9
View File
@@ -55,9 +55,7 @@ PanIdQueryClient::PanIdQueryClient(Instance &aInstance)
: InstanceLocator(aInstance)
, mCallback(nullptr)
, mContext(nullptr)
, mPanIdQuery(UriPath::kPanIdConflict, &PanIdQueryClient::HandleConflict, this)
{
Get<Tmf::Agent>().AddResource(mPanIdQuery);
}
Error PanIdQueryClient::SendQuery(uint16_t aPanId,
@@ -74,7 +72,7 @@ Error PanIdQueryClient::SendQuery(uint16_t aPanId,
VerifyOrExit(Get<MeshCoP::Commissioner>().IsActive(), error = kErrorInvalidState);
VerifyOrExit((message = Get<Tmf::Agent>().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<PanIdQueryClient *>(aContext)->HandleConflict(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void PanIdQueryClient::HandleConflict(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void PanIdQueryClient::HandleTmf<kUriPanIdConflict>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint16_t panId;
Ip6::MessageInfo responseInfo(aMessageInfo);
src/core/meshcop/panid_query_client.hpp
+6 -5
View File
@@ -40,10 +40,10 @@
#include <openthread/commissioner.h>
#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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
otCommissionerPanIdConflictCallback mCallback;
void * mContext;
Coap::Resource mPanIdQuery;
};
DeclareTmfHandler(PanIdQueryClient, kUriPanIdConflict);
/**
* @}
*/
src/core/thread/address_resolver.cpp
+9 -29
View File
@@ -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<Tmf::Agent>().AddResource(mAddressError);
#if OPENTHREAD_FTD
Get<Tmf::Agent>().AddResource(mAddressQuery);
Get<Tmf::Agent>().AddResource(mAddressNotification);
IgnoreError(Get<Ip6::Icmp>().RegisterHandler(mIcmpHandler));
#endif
}
@@ -561,7 +554,7 @@ Error AddressResolver::SendAddressQuery(const Ip6::Address &aEid)
Coap::Message * message;
Tmf::MessageInfo messageInfo(GetInstance());
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(UriPath::kAddressQuery);
message = Get<Tmf::Agent>().NewPriorityNonConfirmablePostMessage(kUriAddressQuery);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadTargetTlv>(*message, aEid));
@@ -591,13 +584,8 @@ exit:
return error;
}
void AddressResolver::HandleAddressNotification(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AddressResolver *>(aContext)->HandleAddressNotification(AsCoapMessage(aMessage),
AsCoreType(aMessageInfo));
}
void AddressResolver::HandleAddressNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void AddressResolver::HandleTmf<kUriAddressNotify>(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<Tmf::Agent>().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<ThreadTargetTlv>(*message, aTarget));
@@ -706,12 +694,8 @@ exit:
#endif // OPENTHREAD_FTD
void AddressResolver::HandleAddressError(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<AddressResolver *>(aContext)->HandleAddressError(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void AddressResolver::HandleAddressError(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void AddressResolver::HandleTmf<kUriAddressError>(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<AddressResolver *>(aContext)->HandleAddressQuery(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void AddressResolver::HandleAddressQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void AddressResolver::HandleTmf<kUriAddressQuery>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kAddressNotify);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriAddressNotify);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadTargetTlv>(*message, aTarget));
src/core/thread/address_resolver.hpp
+21 -27
View File
@@ -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 <Uri kUri> 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
/**
* @}
*/
src/core/thread/announce_begin_server.cpp
+2 -8
View File
@@ -52,9 +52,7 @@ RegisterLogModule("MeshCoP");
AnnounceBeginServer::AnnounceBeginServer(Instance &aInstance)
: AnnounceSenderBase(aInstance, AnnounceBeginServer::HandleTimer)
, mAnnounceBegin(UriPath::kAnnounceBegin, &AnnounceBeginServer::HandleRequest, this)
{
Get<Tmf::Agent>().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<AnnounceBeginServer *>(aContext)->HandleRequest(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void AnnounceBeginServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void AnnounceBeginServer::HandleTmf<kUriAnnounceBegin>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint32_t mask;
uint8_t count;
src/core/thread/announce_begin_server.hpp
+6 -5
View File
@@ -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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static void HandleTimer(Timer &aTimer);
Coap::Resource mAnnounceBegin;
};
DeclareTmfHandler(AnnounceBeginServer, kUriAnnounceBegin);
/**
* @}
*/
src/core/thread/anycast_locator.cpp
+5 -15
View File
@@ -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<Tmf::Agent>().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<Mle::Mle>().IsAnycastLocator(aAnycastAddress),
error = kErrorInvalidArgs);
message = Get<Tmf::Agent>().NewConfirmablePostMessage(UriPath::kAnycastLocate);
message = Get<Tmf::Agent>().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<AnycastLocator *>(aContext)->HandleAnycastLocate(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void AnycastLocator::HandleAnycastLocate(const Coap::Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
template <>
void AnycastLocator::HandleTmf<kUriAnycastLocate>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Coap::Message *message = nullptr;
VerifyOrExit(aRequest.IsConfirmablePostRequest());
VerifyOrExit(aMessage.IsConfirmablePostRequest());
message = Get<Tmf::Agent>().NewResponseMessage(aRequest);
message = Get<Tmf::Agent>().NewResponseMessage(aMessage);
VerifyOrExit(message != nullptr);
SuccessOrExit(Tlv::Append<ThreadMeshLocalEidTlv>(*message, Get<Mle::Mle>().GetMeshLocal64().GetIid()));
src/core/thread/anycast_locator.hpp
+8 -8
View File
@@ -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 <Uri kUri> 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
src/core/thread/dua_manager.cpp
+4 -10
View File
@@ -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<Tmf::Agent>().AddResource(mDuaNotification);
}
void DuaManager::HandleDomainPrefixUpdate(BackboneRouter::Leader::DomainPrefixState aState)
@@ -450,7 +447,7 @@ void DuaManager::PerformNextRegistration(void)
}
// Prepare DUA.req
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kDuaRegistrationRequest);
message = Get<Tmf::Agent>().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<DuaManager *>(aContext)->HandleDuaNotification(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void DuaManager::HandleDuaNotification(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void DuaManager::HandleTmf<kUriDuaRegistrationNotify>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kDuaRegistrationNotify);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriDuaRegistrationNotify);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadStatusTlv>(*message, aStatus));
src/core/thread/dua_manager.hpp
+5 -4
View File
@@ -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 <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Error ProcessDuaResponse(Coap::Message &aMessage);
@@ -215,7 +215,6 @@ private:
using RegistrationTask = TaskletIn<DuaManager, &DuaManager::PerformNextRegistration>;
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)
src/core/thread/energy_scan_server.cpp
+3 -10
View File
@@ -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<Tmf::Agent>().AddResource(mEnergyScan);
}
void EnergyScanServer::HandleRequest(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<EnergyScanServer *>(aContext)->HandleRequest(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void EnergyScanServer::HandleRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void EnergyScanServer::HandleTmf<kUriEnergyScan>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kEnergyReport);
mReportMessage = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriEnergyReport);
VerifyOrExit(mReportMessage != nullptr);
channelMaskTlv.Init();
src/core/thread/energy_scan_server.hpp
+5 -5
View File
@@ -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 <Uri kUri> 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);
/**
* @}
*/
src/core/thread/mle_router.cpp
+8 -24
View File
@@ -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<Tmf::Agent>().RemoveResource(mAddressSolicit);
Get<Tmf::Agent>().RemoveResource(mAddressRelease);
Get<MeshCoP::ActiveDatasetManager>().StopLeader();
Get<MeshCoP::PendingDatasetManager>().StopLeader();
StopAdvertiseTrickleTimer();
Get<NetworkData::Leader>().Stop();
Get<ThreadNetif>().UnsubscribeAllRoutersMulticast();
}
@@ -388,7 +381,6 @@ void MleRouter::SetStateRouter(uint16_t aRloc16)
Get<ThreadNetif>().SubscribeAllRoutersMulticast();
mPreviousPartitionIdRouter = mLeaderData.GetPartitionId();
Get<NetworkData::Leader>().Stop();
Get<Ip6::Ip6>().SetForwardingEnabled(true);
Get<Ip6::Mpl>().SetTimerExpirations(kMplRouterDataMessageTimerExpirations);
Get<Mac::Mac>().SetBeaconEnabled(true);
@@ -430,8 +422,6 @@ void MleRouter::SetStateLeader(uint16_t aRloc16, LeaderStartMode aStartMode)
Get<NetworkData::Leader>().Start(aStartMode);
Get<MeshCoP::ActiveDatasetManager>().StartLeader();
Get<MeshCoP::PendingDatasetManager>().StartLeader();
Get<Tmf::Agent>().AddResource(mAddressSolicit);
Get<Tmf::Agent>().AddResource(mAddressRelease);
Get<Ip6::Ip6>().SetForwardingEnabled(true);
Get<Ip6::Mpl>().SetTimerExpirations(kMplRouterDataMessageTimerExpirations);
Get<Mac::Mac>().SetBeaconEnabled(true);
@@ -3719,7 +3709,7 @@ Error MleRouter::SendAddressSolicit(ThreadStatusTlv::Status aStatus)
VerifyOrExit(!mAddressSolicitPending);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kAddressSolicit);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriAddressSolicit);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadExtMacAddressTlv>(*message, Get<Mac::Mac>().GetExtAddress()));
@@ -3753,7 +3743,7 @@ void MleRouter::SendAddressRelease(void)
Tmf::MessageInfo messageInfo(GetInstance());
Coap::Message * message;
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kAddressRelease);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriAddressRelease);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<ThreadRloc16Tlv>(*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<MleRouter *>(aContext)->HandleAddressSolicit(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void MleRouter::HandleAddressSolicit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void MleRouter::HandleTmf<kUriAddressSolicit>(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<MleRouter *>(aContext)->HandleAddressRelease(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void MleRouter::HandleAddressRelease(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void MleRouter::HandleTmf<kUriAddressRelease>(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());
src/core/thread/mle_router.hpp
+7 -8
View File
@@ -38,7 +38,6 @@
#include <openthread/thread_ftd.h>
#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 <Uri kUri> 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
src/core/thread/mlr_manager.cpp
+1 -1
View File
@@ -404,7 +404,7 @@ Error MlrManager::SendMulticastListenerRegistrationMessage(const otIp6Address *
VerifyOrExit(Get<BackboneRouter::Leader>().HasPrimary(), error = kErrorInvalidState);
message = Get<Tmf::Agent>().NewConfirmablePostMessage(UriPath::kMlr);
message = Get<Tmf::Agent>().NewConfirmablePostMessage(kUriMlr);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
addressesTlv.Init();
src/core/thread/network_data.cpp
+1 -1
View File
@@ -644,7 +644,7 @@ Error NetworkData::SendServerDataNotification(uint16_t aRloc16,
Coap::Message * message;
Tmf::MessageInfo messageInfo(GetInstance());
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kServerData);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriServerData);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
if (aAppendNetDataTlv)
src/core/thread/network_data_leader_ftd.cpp
+13 -33
View File
@@ -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<Tmf::Agent>().AddResource(mServerData);
Get<Tmf::Agent>().AddResource(mCommissioningDataGet);
Get<Tmf::Agent>().AddResource(mCommissioningDataSet);
}
void Leader::Stop(void)
{
Get<Tmf::Agent>().RemoveResource(mServerData);
Get<Tmf::Agent>().RemoveResource(mCommissioningDataGet);
Get<Tmf::Agent>().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<Leader *>(aContext)->HandleServerData(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Leader::HandleServerData(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriServerData>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
ThreadNetworkDataTlv networkDataTlv;
uint16_t rloc16;
VerifyOrExit(Get<Mle::Mle>().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<Leader *>(aContext)->HandleCommissioningSet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Leader::HandleCommissioningSet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriCommissionerSet>(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<Mle::Mle>().IsLeader());
VerifyOrExit(length <= sizeof(tlvs));
VerifyOrExit(Get<Mle::MleRouter>().IsLeader());
@@ -290,21 +270,21 @@ exit:
}
}
void Leader::HandleCommissioningGet(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<Leader *>(aContext)->HandleCommissioningGet(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void Leader::HandleCommissioningGet(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriCommissionerGet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint16_t length = 0;
uint16_t offset;
VerifyOrExit(Get<Mle::Mle>().IsLeader());
SuccessOrExit(Tlv::FindTlvValueOffset(aMessage, MeshCoP::Tlv::kGet, offset, length));
aMessage.SetOffset(offset);
exit:
SendCommissioningGetResponse(aMessage, length, aMessageInfo);
if (Get<Mle::MleRouter>().IsLeader())
{
SendCommissioningGetResponse(aMessage, length, aMessageInfo);
}
}
void Leader::SendCommissioningGetResponse(const Coap::Message & aRequest,
src/core/thread/network_data_leader_ftd.hpp
+8 -20
View File
@@ -40,12 +40,12 @@
#include <stdint.h>
#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 <Uri kUri> 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);
/**
* @}
*/
src/core/thread/network_diagnostic.cpp
+14 -45
View File
@@ -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<Tmf::Agent>().AddResource(mDiagnosticGetRequest);
Get<Tmf::Agent>().AddResource(mDiagnosticGetQuery);
Get<Tmf::Agent>().AddResource(mDiagnosticGetAnswer);
Get<Tmf::Agent>().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<Tmf::Agent>().NewNonConfirmablePostMessage(UriPath::kDiagnosticGetQuery);
message = Get<Tmf::Agent>().NewNonConfirmablePostMessage(kUriDiagnosticGetQuery);
messageInfo.SetMulticastLoop(true);
}
else
{
handler = &NetworkDiagnostic::HandleDiagnosticGetResponse;
message = Get<Tmf::Agent>().NewConfirmablePostMessage(UriPath::kDiagnosticGetRequest);
message = Get<Tmf::Agent>().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<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetAnswer(AsCoapMessage(aMessage),
AsCoreType(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetAnswer(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void NetworkDiagnostic::HandleTmf<kUriDiagnosticGetAnswer>(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<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetQuery(AsCoapMessage(aMessage),
AsCoreType(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void NetworkDiagnostic::HandleTmf<kUriDiagnosticGetQuery>(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<Tmf::Agent>().NewConfirmablePostMessage(UriPath::kDiagnosticGetAnswer);
message = Get<Tmf::Agent>().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<NetworkDiagnostic *>(aContext)->HandleDiagnosticGetRequest(AsCoapMessage(aMessage),
AsCoreType(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticGetRequest(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void NetworkDiagnostic::HandleTmf<kUriDiagnosticGetRequest>(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<Tmf::Agent>().NewConfirmablePostMessage(UriPath::kDiagnosticReset);
message = Get<Tmf::Agent>().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<NetworkDiagnostic *>(aContext)->HandleDiagnosticReset(AsCoapMessage(aMessage),
AsCoreType(aMessageInfo));
}
void NetworkDiagnostic::HandleDiagnosticReset(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void NetworkDiagnostic::HandleTmf<kUriDiagnosticReset>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
uint16_t offset = 0;
uint8_t type;
src/core/thread/network_diagnostic.hpp
+9 -17
View File
@@ -40,11 +40,11 @@
#include <openthread/netdiag.h>
#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 <Uri kUri> 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);
/**
* @}
*/
src/core/thread/panid_query_server.cpp
+3 -9
View File
@@ -54,17 +54,11 @@ PanIdQueryServer::PanIdQueryServer(Instance &aInstance)
, mChannelMask(0)
, mPanId(Mac::kPanIdBroadcast)
, mTimer(aInstance)
, mPanIdQuery(UriPath::kPanIdQuery, &PanIdQueryServer::HandleQuery, this)
{
Get<Tmf::Agent>().AddResource(mPanIdQuery);
}
void PanIdQueryServer::HandleQuery(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
static_cast<PanIdQueryServer *>(aContext)->HandleQuery(AsCoapMessage(aMessage), AsCoreType(aMessageInfo));
}
void PanIdQueryServer::HandleQuery(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <>
void PanIdQueryServer::HandleTmf<kUriPanIdQuery>(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<Tmf::Agent>().NewPriorityConfirmablePostMessage(UriPath::kPanIdConflict);
message = Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriPanIdConflict);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
channelMask.Init();
src/core/thread/panid_query_server.hpp
+6 -5
View File
@@ -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 <Uri kUri> 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);
/**
* @}
*/
src/core/thread/tmf.cpp
+111
View File
@@ -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<kUriRelayRx>(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessage);
OT_UNUSED_VARIABLE(aMessageInfo);
#if (OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE)
Get<MeshCoP::Commissioner>().HandleTmf<kUriRelayRx>(aMessage, aMessageInfo);
#endif
#if OPENTHREAD_CONFIG_BORDER_AGENT_ENABLE
Get<MeshCoP::BorderAgent>().HandleTmf<kUriRelayRx>(aMessage, aMessageInfo);
#endif
}
bool Agent::HandleResource(CoapBase & aCoapBase,
const char * aUriPath,
Message & aMessage,
const Ip6::MessageInfo &aMessageInfo)
{
return static_cast<Agent &>(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<Type>().HandleTmf<kUri>(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);
src/core/thread/tmf.hpp
+23 -5
View File
@@ -42,6 +42,20 @@
namespace ot {
namespace Tmf {
/**
* This macro declares a TMF handler (a full template specialization of `HandleTmf<Uri>` method) in a given `Type`.
*
* The class `Type` MUST declare a template method of the following format:
*
* template <Uri kUri> 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<kUri>(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 <Uri kUri> 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);
};
src/core/thread/uri_paths.cpp
+125 -39
View File
@@ -33,46 +33,132 @@
#include "uri_paths.hpp"
#include "common/binary_search.hpp"
#include "common/debug.hpp"
#include "common/string.hpp"
#include <string.h>
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<Uri>(entry - UriList::kEntries);
exit:
return uri;
}
} // namespace ot
src/core/thread/uri_paths.hpp
+64 -42
View File
@@ -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_