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

[coap] introduce Coap::Msg to simplify method calls (#12285)

Browse Source 
This commit introduces `Coap::Msg`, a class that encapsulates
`Coap::Message` and its associated `Ip6::MessageInfo`.

`Coap` methods and TMF resource handlers are updated to use
`Coap::Msg` when handling received messages. This change simplifies
method signatures by reducing the number of parameters and enables
future extensibility for tracking additional information related to
received CoAP messages.
This commit is contained in:
Abtin Keshavarzian
2026-01-14 10:18:17 -08:00
committed by GitHub
parent 8bdc6cf339
commit f4816375c0
49 changed files with 605 additions and 733 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/backbone_router/backbone_tmf.cpp
+7 -13
View File
@@ -62,27 +62,21 @@ exit:
return error;
}
bool BackboneTmfAgent::HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
ot::Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool BackboneTmfAgent::HandleResource(CoapBase &aCoapBase, const char *aUriPath, ot::Coap::Msg &aMsg)
{
return static_cast<BackboneTmfAgent &>(aCoapBase).HandleResource(aUriPath, aMessage, aMessageInfo);
return static_cast<BackboneTmfAgent &>(aCoapBase).HandleResource(aUriPath, aMsg);
}
bool BackboneTmfAgent::HandleResource(const char *aUriPath,
ot::Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool BackboneTmfAgent::HandleResource(const char *aUriPath, ot::Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessage);
OT_UNUSED_VARIABLE(aMessageInfo);
OT_UNUSED_VARIABLE(aMsg);
bool didHandle = true;
Uri uri = UriFromPath(aUriPath);
#define Case(kUri, Type) \
case kUri: \
Get<Type>().HandleTmf<kUri>(aMessage, aMessageInfo); \
#define Case(kUri, Type) \
case kUri: \
Get<Type>().HandleTmf<kUri>(aMsg); \
break
switch (uri)
src/core/backbone_router/backbone_tmf.hpp
+3 -6
View File
@@ -90,12 +90,9 @@ public:
void UnsubscribeMulticast(const Ip6::Address &aAddress);
private:
static bool HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
ot::Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo);
bool HandleResource(const char *aUriPath, ot::Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void LogError(const char *aText, const Ip6::Address &aAddress, Error aError) const;
static bool HandleResource(CoapBase &aCoapBase, const char *aUriPath, ot::Coap::Msg &aMsg);
bool HandleResource(const char *aUriPath, ot::Coap::Msg &aMsg);
void LogError(const char *aText, const Ip6::Address &aAddress, Error aError) const;
static Error Filter(const ot::Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext);
};
src/core/backbone_router/bbr_manager.cpp
+48 -51
View File
@@ -122,16 +122,16 @@ void Manager::HandleTimer(void)
}
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE
template <> void Manager::HandleTmf<kUriMlr>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Manager::HandleTmf<kUriMlr>(Coap::Msg &aMsg)
{
VerifyOrExit(Get<Local>().IsEnabled());
HandleMulticastListenerRegistration(aMessage, aMessageInfo);
HandleMulticastListenerRegistration(aMsg);
exit:
return;
}
void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Manager::HandleMulticastListenerRegistration(const Coap::Msg &aMsg)
{
Error error = kErrorNone;
bool isPrimary = Get<Local>().IsPrimary();
@@ -149,7 +149,7 @@ void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage,
bool hasCommissionerSessionIdTlv = false;
bool processTimeoutTlv = false;
VerifyOrExit(aMessage.IsConfirmablePostRequest(), error = kErrorParse);
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest(), error = kErrorParse);
#if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
// Required by Test Specification 5.10.22 DUA-TC-26, only for certification purpose
@@ -164,7 +164,7 @@ void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage,
// TODO: (MLR) send configured MLR response for Reference Device
if (Tlv::Find<ThreadCommissionerSessionIdTlv>(aMessage, commissionerSessionId) == kErrorNone)
if (Tlv::Find<ThreadCommissionerSessionIdTlv>(aMsg.mMessage, commissionerSessionId) == kErrorNone)
{
uint16_t localSessionId;
@@ -175,9 +175,10 @@ void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage,
hasCommissionerSessionIdTlv = true;
}
processTimeoutTlv = hasCommissionerSessionIdTlv && (Tlv::Find<ThreadTimeoutTlv>(aMessage, timeout) == kErrorNone);
processTimeoutTlv =
hasCommissionerSessionIdTlv && (Tlv::Find<ThreadTimeoutTlv>(aMsg.mMessage, timeout) == kErrorNone);
VerifyOrExit(Tlv::FindTlvValueOffsetRange(aMessage, Ip6AddressesTlv::kIp6Addresses, offsetRange) == kErrorNone,
VerifyOrExit(Tlv::FindTlvValueOffsetRange(aMsg.mMessage, Ip6AddressesTlv::kIp6Addresses, offsetRange) == kErrorNone,
error = kErrorParse);
VerifyOrExit(offsetRange.GetLength() % sizeof(Ip6::Address) == 0, status = kMlrGeneralFailure);
VerifyOrExit(offsetRange.GetLength() / sizeof(Ip6::Address) <= Ip6AddressesTlv::kMaxAddresses,
@@ -210,7 +211,7 @@ void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage,
while (!offsetRange.IsEmpty())
{
IgnoreError(aMessage.Read(offsetRange, address));
IgnoreError(aMsg.mMessage.Read(offsetRange, address));
offsetRange.AdvanceOffset(sizeof(Ip6::Address));
if (timeout == 0)
@@ -260,7 +261,7 @@ void Manager::HandleMulticastListenerRegistration(const Coap::Message &aMessage,
exit:
if (error == kErrorNone)
{
SendMulticastListenerRegistrationResponse(aMessage, aMessageInfo, status, addresses, failedAddressNum);
SendMulticastListenerRegistrationResponse(aMsg, status, addresses, failedAddressNum);
}
if (successAddressNum > 0)
@@ -270,16 +271,15 @@ exit:
}
}
void Manager::SendMulticastListenerRegistrationResponse(const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
MlrStatus aStatus,
Ip6::Address *aFailedAddresses,
uint8_t aFailedAddressNum)
void Manager::SendMulticastListenerRegistrationResponse(const Coap::Msg &aMsg,
MlrStatus aStatus,
Ip6::Address *aFailedAddresses,
uint8_t aFailedAddressNum)
{
Error error = kErrorNone;
Coap::Message *message;
message = Get<Tmf::Agent>().NewResponseMessage(aMessage);
message = Get<Tmf::Agent>().NewResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(Tlv::Append<ThreadStatusTlv>(*message, aStatus));
@@ -298,7 +298,7 @@ void Manager::SendMulticastListenerRegistrationResponse(const Coap::Message &
}
}
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
exit:
FreeMessageOnError(message, error);
@@ -343,17 +343,16 @@ exit:
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE
template <>
void Manager::HandleTmf<kUriDuaRegistrationRequest>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Manager::HandleTmf<kUriDuaRegistrationRequest>(Coap::Msg &aMsg)
{
VerifyOrExit(Get<Local>().IsEnabled());
HandleDuaRegistration(aMessage, aMessageInfo);
HandleDuaRegistration(aMsg);
exit:
return;
}
void Manager::HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void Manager::HandleDuaRegistration(const Coap::Msg &aMsg)
{
Error error = kErrorNone;
DuaStatus status = kDuaSuccess;
@@ -366,11 +365,11 @@ void Manager::HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::Me
Coap::Code duaRespCoapCode = Coap::kCodeEmpty;
#endif
VerifyOrExit(aMessageInfo.GetPeerAddr().GetIid().IsRoutingLocator(), error = kErrorDrop);
VerifyOrExit(aMessage.IsConfirmablePostRequest(), error = kErrorParse);
VerifyOrExit(aMsg.mMessageInfo.GetPeerAddr().GetIid().IsRoutingLocator(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest(), error = kErrorParse);
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMessage, target));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMessage, meshLocalIid));
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, target));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMsg.mMessage, meshLocalIid));
#if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
if (mDuaResponseIsSpecified && (mDuaResponseTargetMlIid.IsUnspecified() || mDuaResponseTargetMlIid == meshLocalIid))
@@ -392,9 +391,10 @@ void Manager::HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::Me
VerifyOrExit(Get<Leader>().HasDomainPrefix(), status = kDuaGeneralFailure);
VerifyOrExit(Get<Leader>().IsDomainUnicast(target), status = kDuaInvalid);
hasLastTransactionTime = (Tlv::Find<ThreadLastTransactionTimeTlv>(aMessage, lastTransactionTime) == kErrorNone);
hasLastTransactionTime =
(Tlv::Find<ThreadLastTransactionTimeTlv>(aMsg.mMessage, lastTransactionTime) == kErrorNone);
switch (mNdProxyTable.Register(target.GetIid(), meshLocalIid, aMessageInfo.GetPeerAddr().GetIid().GetLocator(),
switch (mNdProxyTable.Register(target.GetIid(), meshLocalIid, aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator(),
hasLastTransactionTime ? &lastTransactionTime : nullptr))
{
case kErrorNone:
@@ -420,31 +420,28 @@ exit:
#if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
if (duaRespCoapCode != Coap::kCodeEmpty)
{
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo, duaRespCoapCode));
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg, duaRespCoapCode));
}
else
#endif
{
SendDuaRegistrationResponse(aMessage, aMessageInfo, target, status);
SendDuaRegistrationResponse(aMsg, target, status);
}
}
}
void Manager::SendDuaRegistrationResponse(const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Ip6::Address &aTarget,
DuaStatus aStatus)
void Manager::SendDuaRegistrationResponse(const Coap::Msg &aMsg, const Ip6::Address &aTarget, DuaStatus aStatus)
{
Error error = kErrorNone;
Coap::Message *message;
message = Get<Tmf::Agent>().NewResponseMessage(aMessage);
message = Get<Tmf::Agent>().NewResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(Tlv::Append<ThreadStatusTlv>(*message, aStatus));
SuccessOrExit(Tlv::Append<ThreadTargetTlv>(*message, aTarget));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
exit:
FreeMessageOnError(message, error);
@@ -535,36 +532,36 @@ exit:
return error;
}
template <> void Manager::HandleTmf<kUriBackboneQuery>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Manager::HandleTmf<kUriBackboneQuery>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
Ip6::Address dua;
uint16_t rloc16 = Mle::kInvalidRloc16;
NdProxyTable::NdProxy *ndProxy;
VerifyOrExit(aMessageInfo.IsHostInterface(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessageInfo.IsHostInterface(), error = kErrorDrop);
VerifyOrExit(Get<Local>().IsPrimary(), error = kErrorInvalidState);
VerifyOrExit(aMessage.IsNonConfirmablePostRequest(), error = kErrorParse);
VerifyOrExit(aMsg.mMessage.IsNonConfirmablePostRequest(), error = kErrorParse);
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMessage, dua));
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, dua));
error = Tlv::Find<ThreadRloc16Tlv>(aMessage, rloc16);
error = Tlv::Find<ThreadRloc16Tlv>(aMsg.mMessage, rloc16);
VerifyOrExit(error == kErrorNone || error == kErrorNotFound);
LogInfo("Received BB.qry from %s for %s (rloc16=%04x)", aMessageInfo.GetPeerAddr().ToString().AsCString(),
LogInfo("Received BB.qry from %s for %s (rloc16=%04x)", aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString(),
dua.ToString().AsCString(), rloc16);
ndProxy = mNdProxyTable.ResolveDua(dua);
VerifyOrExit(ndProxy != nullptr && !ndProxy->GetDadFlag(), error = kErrorNotFound);
error = SendBackboneAnswer(aMessageInfo, dua, rloc16, *ndProxy);
error = SendBackboneAnswer(aMsg.mMessageInfo, dua, rloc16, *ndProxy);
exit:
LogInfo("HandleBackboneQuery: %s", ErrorToString(error));
}
template <> void Manager::HandleTmf<kUriBackboneAnswer>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Manager::HandleTmf<kUriBackboneAnswer>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
bool proactive;
@@ -574,19 +571,19 @@ template <> void Manager::HandleTmf<kUriBackboneAnswer>(Coap::Message &aMessage,
uint32_t timeSinceLastTransaction;
uint16_t srcRloc16 = Mle::kInvalidRloc16;
VerifyOrExit(aMessageInfo.IsHostInterface(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessageInfo.IsHostInterface(), error = kErrorDrop);
VerifyOrExit(Get<Local>().IsPrimary(), error = kErrorInvalidState);
VerifyOrExit(aMessage.IsPostRequest(), error = kErrorParse);
VerifyOrExit(aMsg.mMessage.IsPostRequest(), error = kErrorParse);
proactive = !aMessage.IsConfirmable();
proactive = !aMsg.mMessage.IsConfirmable();
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMessage, dua));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMessage, meshLocalIid));
SuccessOrExit(error = Tlv::Find<ThreadLastTransactionTimeTlv>(aMessage, timeSinceLastTransaction));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMessage, ThreadTlv::kNetworkName, offsetRange));
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, dua));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMsg.mMessage, meshLocalIid));
SuccessOrExit(error = Tlv::Find<ThreadLastTransactionTimeTlv>(aMsg.mMessage, timeSinceLastTransaction));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMsg.mMessage, ThreadTlv::kNetworkName, offsetRange));
error = Tlv::Find<ThreadRloc16Tlv>(aMessage, srcRloc16);
error = Tlv::Find<ThreadRloc16Tlv>(aMsg.mMessage, srcRloc16);
VerifyOrExit(error == kErrorNone || error == kErrorNotFound);
if (proactive)
@@ -602,7 +599,7 @@ template <> void Manager::HandleTmf<kUriBackboneAnswer>(Coap::Message &aMessage,
HandleExtendedBackboneAnswer(dua, meshLocalIid, timeSinceLastTransaction, srcRloc16);
}
SuccessOrExit(error = mBackboneTmfAgent.SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(error = mBackboneTmfAgent.SendEmptyAck(aMsg));
exit:
LogInfo("HandleBackboneAnswer: %s", ErrorToString(error));
src/core/backbone_router/bbr_manager.hpp
+8 -12
View File
@@ -166,23 +166,22 @@ private:
static constexpr uint8_t kDefaultHoplimit = 1;
static constexpr uint32_t kTimerInterval = 1000;
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE
void HandleMulticastListenerRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleMulticastListenerRegistration(const Coap::Msg &aMsg);
void SendMulticastListenerRegistrationResponse(const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
MlrStatus aStatus,
Ip6::Address *aFailedAddresses,
uint8_t aFailedAddressNum);
void SendMulticastListenerRegistrationResponse(const Coap::Msg &aMsg,
MlrStatus aStatus,
Ip6::Address *aFailedAddresses,
uint8_t aFailedAddressNum);
void SendBackboneMulticastListenerRegistration(const Ip6::Address *aAddresses,
uint8_t aAddressNum,
uint32_t aTimeout);
#endif
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE
void HandleDuaRegistration(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleDuaRegistration(const Coap::Msg &aMsg);
Error SendBackboneAnswer(const Ip6::MessageInfo &aQueryMessageInfo,
const Ip6::Address &aDua,
uint16_t aSrcRloc16,
@@ -200,10 +199,7 @@ private:
void HandleProactiveBackboneNotification(const Ip6::Address &aDua,
const Ip6::InterfaceIdentifier &aMeshLocalIid,
uint32_t aTimeSinceLastTransaction);
void SendDuaRegistrationResponse(const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Ip6::Address &aTarget,
DuaStatus aStatus);
void SendDuaRegistrationResponse(const Coap::Msg &aMsg, const Ip6::Address &aTarget, DuaStatus aStatus);
#endif
void HandleNotifierEvents(Events aEvents);
src/core/coap/coap.cpp
+182 -203
View File
@@ -75,7 +75,7 @@ void CoapBase::ClearRequests(const Ip6::Address *aAddress)
if ((aAddress == nullptr) || (metadata.mSourceAddress == *aAddress))
{
FinalizeCoapTransaction(message, metadata, nullptr, nullptr, kErrorAbort);
FinalizeCoapTransaction(message, metadata, nullptr, kErrorAbort);
}
}
}
@@ -196,6 +196,7 @@ Error CoapBase::SendMessage(Message &aMessage,
Error error;
Message *storedCopy = nullptr;
uint16_t copyLength = 0;
Msg txMsg(aMessage, aMessageInfo);
Metadata metadata;
if (aTxParameters == nullptr)
@@ -204,40 +205,40 @@ Error CoapBase::SendMessage(Message &aMessage,
}
else
{
SuccessOrExit(error = aTxParameters->ValidateFor(aMessage));
SuccessOrExit(error = aTxParameters->ValidateFor(txMsg.mMessage));
}
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
metadata.mBlockwiseReceiveHook = aReceiveHook;
metadata.mBlockwiseTransmitHook = aTransmitHook;
SuccessOrExit(error = ProcessBlockwiseSend(aMessage, aTransmitHook, aContext));
SuccessOrExit(error = ProcessBlockwiseSend(txMsg.mMessage, aTransmitHook, aContext));
#endif
switch (aMessage.GetType())
switch (txMsg.mMessage.GetType())
{
case kTypeAck:
mResponseCache.Add(aMessage, aMessageInfo, aTxParameters->CalculateExchangeLifetime());
mResponseCache.Add(txMsg, aTxParameters->CalculateExchangeLifetime());
break;
case kTypeReset:
OT_ASSERT(aMessage.GetCode() == kCodeEmpty);
OT_ASSERT(txMsg.mMessage.GetCode() == kCodeEmpty);
break;
default:
aMessage.SetMessageId(mMessageId++);
txMsg.mMessage.SetMessageId(mMessageId++);
break;
}
aMessage.Finish();
txMsg.mMessage.Finish();
if (aMessage.IsConfirmable())
if (txMsg.mMessage.IsConfirmable())
{
copyLength = aMessage.GetLength();
copyLength = txMsg.mMessage.GetLength();
}
else if (aMessage.IsNonConfirmable() && (aHandler != nullptr))
else if (txMsg.mMessage.IsNonConfirmable() && (aHandler != nullptr))
{
// As we do not retransmit non confirmable messages, create a
// copy of header only, for token information.
copyLength = aMessage.GetOptionStart();
copyLength = txMsg.mMessage.GetOptionStart();
}
if (copyLength > 0)
@@ -246,34 +247,34 @@ Error CoapBase::SendMessage(Message &aMessage,
{
bool shouldObserve = false;
SuccessOrExit(error = ProcessObserveSend(aMessage, aMessageInfo, shouldObserve));
SuccessOrExit(error = ProcessObserveSend(txMsg, shouldObserve));
metadata.mObserve = shouldObserve;
}
#endif
metadata.mSourceAddress = aMessageInfo.GetSockAddr();
metadata.mDestinationPort = aMessageInfo.GetPeerPort();
metadata.mDestinationAddress = aMessageInfo.GetPeerAddr();
metadata.mMulticastLoop = aMessageInfo.GetMulticastLoop();
metadata.mSourceAddress = txMsg.mMessageInfo.GetSockAddr();
metadata.mDestinationPort = txMsg.mMessageInfo.GetPeerPort();
metadata.mDestinationAddress = txMsg.mMessageInfo.GetPeerAddr();
metadata.mMulticastLoop = txMsg.mMessageInfo.GetMulticastLoop();
metadata.mResponseHandler = aHandler;
metadata.mResponseContext = aContext;
metadata.mRetransmissionsRemaining = aTxParameters->mMaxRetransmit;
metadata.mRetransmissionTimeout = aTxParameters->CalculateInitialRetransmissionTimeout();
metadata.mAcknowledged = false;
metadata.mConfirmable = aMessage.IsConfirmable();
metadata.mConfirmable = txMsg.mMessage.IsConfirmable();
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE
metadata.mHopLimit = aMessageInfo.GetHopLimit();
metadata.mIsHostInterface = aMessageInfo.IsHostInterface();
metadata.mHopLimit = txMsg.mMessageInfo.GetHopLimit();
metadata.mIsHostInterface = txMsg.mMessageInfo.IsHostInterface();
#endif
metadata.mNextTimerShot =
TimerMilli::GetNow() +
(metadata.mConfirmable ? metadata.mRetransmissionTimeout : aTxParameters->CalculateMaxTransmitWait());
storedCopy = CopyAndEnqueueMessage(aMessage, copyLength, metadata);
storedCopy = CopyAndEnqueueMessage(txMsg.mMessage, copyLength, metadata);
VerifyOrExit(storedCopy != nullptr, error = kErrorNoBufs);
}
SuccessOrExit(error = Send(aMessage, aMessageInfo));
SuccessOrExit(error = Send(txMsg.mMessage, txMsg.mMessageInfo));
exit:
@@ -332,64 +333,52 @@ exit:
return error;
}
Error CoapBase::SendReset(Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
Error CoapBase::SendReset(const Msg &aRxMsg) { return SendEmptyMessage(kTypeReset, aRxMsg); }
Error CoapBase::SendAck(const Msg &aRxMsg) { return SendEmptyMessage(kTypeAck, aRxMsg); }
Error CoapBase::SendEmptyAck(const Msg &aRxMsg, Code aCode)
{
return SendEmptyMessage(kTypeReset, aRequest, aMessageInfo);
return (aRxMsg.mMessage.IsConfirmable() ? SendHeaderResponse(aCode, aRxMsg) : kErrorInvalidArgs);
}
Error CoapBase::SendAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendEmptyMessage(kTypeAck, aRequest, aMessageInfo);
}
Error CoapBase::SendEmptyAck(const Msg &aRxMsg) { return SendEmptyAck(aRxMsg, kCodeChanged); }
Error CoapBase::SendEmptyAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo, Code aCode)
{
return (aRequest.IsConfirmable() ? SendHeaderResponse(aCode, aRequest, aMessageInfo) : kErrorInvalidArgs);
}
Error CoapBase::SendNotFound(const Msg &aRxMsg) { return SendHeaderResponse(kCodeNotFound, aRxMsg); }
Error CoapBase::SendEmptyAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendEmptyAck(aRequest, aMessageInfo, kCodeChanged);
}
Error CoapBase::SendNotFound(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendHeaderResponse(kCodeNotFound, aRequest, aMessageInfo);
}
Error CoapBase::SendEmptyMessage(Type aType, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
Error CoapBase::SendEmptyMessage(Type aType, const Msg &aRxMsg)
{
Error error = kErrorNone;
Message *message = nullptr;
VerifyOrExit(aRequest.IsConfirmable(), error = kErrorInvalidArgs);
VerifyOrExit(aRxMsg.mMessage.IsConfirmable(), error = kErrorInvalidArgs);
VerifyOrExit((message = NewMessage()) != nullptr, error = kErrorNoBufs);
message->Init(aType, kCodeEmpty);
message->SetMessageId(aRequest.GetMessageId());
message->SetMessageId(aRxMsg.mMessage.GetMessageId());
message->Finish();
SuccessOrExit(error = Send(*message, aMessageInfo));
SuccessOrExit(error = Send(*message, aRxMsg.mMessageInfo));
exit:
FreeMessageOnError(message, error);
return error;
}
Error CoapBase::SendHeaderResponse(Message::Code aCode, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
Error CoapBase::SendHeaderResponse(Message::Code aCode, const Msg &aRxMsg)
{
Error error = kErrorNone;
Message *message = nullptr;
VerifyOrExit(aRequest.IsRequest(), error = kErrorInvalidArgs);
VerifyOrExit(aRxMsg.mMessage.IsRequest(), error = kErrorInvalidArgs);
VerifyOrExit((message = NewMessage()) != nullptr, error = kErrorNoBufs);
switch (aRequest.GetType())
switch (aRxMsg.mMessage.GetType())
{
case kTypeConfirmable:
message->Init(kTypeAck, aCode);
message->SetMessageId(aRequest.GetMessageId());
message->SetMessageId(aRxMsg.mMessage.GetMessageId());
break;
case kTypeNonConfirmable:
@@ -400,9 +389,9 @@ Error CoapBase::SendHeaderResponse(Message::Code aCode, const Message &aRequest,
ExitNow(error = kErrorInvalidArgs);
}
SuccessOrExit(error = message->WriteTokenFromMessage(aRequest));
SuccessOrExit(error = message->WriteTokenFromMessage(aRxMsg.mMessage));
SuccessOrExit(error = SendMessage(*message, aMessageInfo));
SuccessOrExit(error = SendMessage(*message, aRxMsg.mMessageInfo));
exit:
FreeMessageOnError(message, error);
@@ -461,7 +450,7 @@ void CoapBase::HandleRetransmissionTimer(void)
if (!metadata.mConfirmable || (metadata.mRetransmissionsRemaining == 0))
{
// No expected response or acknowledgment.
FinalizeCoapTransaction(message, metadata, nullptr, nullptr, kErrorResponseTimeout);
FinalizeCoapTransaction(message, metadata, nullptr, kErrorResponseTimeout);
continue;
}
@@ -491,18 +480,11 @@ void CoapBase::HandleRetransmissionTimer(void)
ScheduleRetransmissionTimer();
}
void CoapBase::FinalizeCoapTransaction(Message &aRequest,
const Metadata &aMetadata,
Message *aResponse,
const Ip6::MessageInfo *aMessageInfo,
Error aResult)
void CoapBase::FinalizeCoapTransaction(Message &aRequest, const Metadata &aMetadata, Msg *aResponse, Error aResult)
{
DequeueMessage(aRequest);
if (aMetadata.mResponseHandler != nullptr)
{
aMetadata.mResponseHandler(aMetadata.mResponseContext, aResponse, aMessageInfo, aResult);
}
aMetadata.InvokeResponseHandler(aResponse, aResult);
}
Error CoapBase::AbortTransaction(ResponseHandler aHandler, void *aContext)
@@ -516,7 +498,7 @@ Error CoapBase::AbortTransaction(ResponseHandler aHandler, void *aContext)
if (metadata.mResponseHandler == aHandler && metadata.mResponseContext == aContext)
{
FinalizeCoapTransaction(message, metadata, nullptr, nullptr, kErrorAbort);
FinalizeCoapTransaction(message, metadata, nullptr, kErrorAbort);
error = kErrorNone;
}
}
@@ -576,9 +558,7 @@ exit:
}
}
Message *CoapBase::FindRelatedRequest(const Message &aResponse,
const Ip6::MessageInfo &aMessageInfo,
Metadata &aMetadata)
Message *CoapBase::FindRelatedRequest(const Msg &aMsg, Metadata &aMetadata)
{
Message *request = nullptr;
@@ -586,15 +566,15 @@ Message *CoapBase::FindRelatedRequest(const Message &aResponse,
{
aMetadata.ReadFrom(message);
if (((aMetadata.mDestinationAddress == aMessageInfo.GetPeerAddr() &&
aMetadata.mDestinationPort == aMessageInfo.GetPeerPort()) ||
if (((aMetadata.mDestinationAddress == aMsg.mMessageInfo.GetPeerAddr() &&
aMetadata.mDestinationPort == aMsg.mMessageInfo.GetPeerPort()) ||
aMetadata.mDestinationAddress.IsMulticast() || aMetadata.mDestinationAddress.GetIid().IsAnycastLocator()))
{
switch (aResponse.GetType())
switch (aMsg.mMessage.GetType())
{
case kTypeReset:
case kTypeAck:
if (aResponse.GetMessageId() == message.GetMessageId())
if (aMsg.mMessage.GetMessageId() == message.GetMessageId())
{
request = &message;
ExitNow();
@@ -604,7 +584,7 @@ Message *CoapBase::FindRelatedRequest(const Message &aResponse,
case kTypeConfirmable:
case kTypeNonConfirmable:
if (aResponse.HasSameTokenAs(message))
if (aMsg.mMessage.HasSameTokenAs(message))
{
request = &message;
ExitNow();
@@ -621,32 +601,32 @@ exit:
void CoapBase::Receive(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
Message &message = AsCoapMessage(&aMessage);
Msg rxMsg(AsCoapMessage(&aMessage), aMessageInfo);
if (message.ParseHeader() != kErrorNone)
if (rxMsg.mMessage.ParseHeader() != kErrorNone)
{
LogDebg("Failed to parse CoAP header");
if (!aMessageInfo.GetSockAddr().IsMulticast() && message.IsConfirmable())
if (!aMessageInfo.GetSockAddr().IsMulticast() && rxMsg.mMessage.IsConfirmable())
{
IgnoreError(SendReset(message, aMessageInfo));
IgnoreError(SendReset(rxMsg));
}
}
else if (message.IsRequest())
else if (rxMsg.mMessage.IsRequest())
{
ProcessReceivedRequest(message, aMessageInfo);
ProcessReceivedRequest(rxMsg);
}
else
{
ProcessReceivedResponse(message, aMessageInfo);
ProcessReceivedResponse(rxMsg);
}
#if OPENTHREAD_CONFIG_OTNS_ENABLE
Get<Utils::Otns>().EmitCoapReceive(message, aMessageInfo);
Get<Utils::Otns>().EmitCoapReceive(rxMsg.mMessage, aMessageInfo);
#endif
}
void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void CoapBase::ProcessReceivedResponse(Msg &aRxMsg)
{
Metadata metadata;
Message *request = nullptr;
@@ -655,7 +635,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
bool shouldObserve = false;
#endif
request = FindRelatedRequest(aMessage, aMessageInfo, metadata);
request = FindRelatedRequest(aRxMsg, metadata);
VerifyOrExit(request != nullptr);
#if OPENTHREAD_CONFIG_COAP_OBSERVE_API_ENABLE
@@ -667,24 +647,24 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
{
Option::Iterator iterator;
SuccessOrExit(error = iterator.Init(aMessage, kOptionObserve));
SuccessOrExit(error = iterator.Init(aRxMsg.mMessage, kOptionObserve));
shouldObserve = !iterator.IsDone();
}
#endif
switch (aMessage.GetType())
switch (aRxMsg.mMessage.GetType())
{
case kTypeReset:
if (aMessage.IsEmpty())
if (aRxMsg.mMessage.IsEmpty())
{
FinalizeCoapTransaction(*request, metadata, nullptr, nullptr, kErrorAbort);
FinalizeCoapTransaction(*request, metadata, nullptr, kErrorAbort);
}
// Silently ignore non-empty reset messages (RFC 7252, Section 4.2).
break;
case kTypeAck:
if (aMessage.IsEmpty())
if (aRxMsg.mMessage.IsEmpty())
{
// Empty acknowledgment.
@@ -696,7 +676,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
// as if it were a piggy-backed response so we can stop
// re-sending and the application can move on.
FinalizeCoapTransaction(*request, metadata, &aMessage, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(*request, metadata, &aRxMsg, kErrorNone);
}
else
#endif
@@ -717,7 +697,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
}
}
}
else if (aMessage.IsResponse() && aMessage.HasSameTokenAs(*request))
else if (aRxMsg.mMessage.IsResponse() && aRxMsg.mMessage.HasSameTokenAs(*request))
{
// Piggybacked response.
@@ -725,7 +705,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
if (shouldObserve)
{
// This is a RFC7641 notification. The request is *not* done!
metadata.mResponseHandler(metadata.mResponseContext, &aMessage, &aMessageInfo, kErrorNone);
metadata.InvokeResponseHandler(&aRxMsg, kErrorNone);
// Consider the message acknowledged at this point.
metadata.mAcknowledged = true;
@@ -735,9 +715,9 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
#endif
{
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
SuccessOrExit(error = ProcessBlockwiseResponse(aMessage, aMessageInfo, *request, metadata));
SuccessOrExit(error = ProcessBlockwiseResponse(aRxMsg, *request, metadata));
#else
FinalizeCoapTransaction(*request, metadata, &aMessage, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(*request, metadata, &aRxMsg, kErrorNone);
#endif
}
}
@@ -748,7 +728,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
case kTypeConfirmable:
// Send empty ACK if it is a CON message.
IgnoreError(SendAck(aMessage, aMessageInfo));
IgnoreError(SendAck(aRxMsg));
// Handling of RFC7641 and multicast is below.
@@ -759,7 +739,7 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
#if OPENTHREAD_CONFIG_COAP_OBSERVE_API_ENABLE
if (shouldObserve)
{
metadata.mResponseHandler(metadata.mResponseContext, &aMessage, &aMessageInfo, kErrorNone);
metadata.InvokeResponseHandler(&aRxMsg, kErrorNone);
// When any Observe response is seen, consider a NON observe
// request "acknowledged" at this point. This will keep the
@@ -781,11 +761,11 @@ void CoapBase::ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo
if ((metadata.mResponseHandler != nullptr) && metadata.mDestinationAddress.IsMulticast())
{
metadata.mResponseHandler(metadata.mResponseContext, &aMessage, &aMessageInfo, kErrorNone);
metadata.InvokeResponseHandler(&aRxMsg, kErrorNone);
}
else
{
FinalizeCoapTransaction(*request, metadata, &aMessage, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(*request, metadata, &aRxMsg, kErrorNone);
}
break;
@@ -795,43 +775,43 @@ exit:
if (error == kErrorNone && request == nullptr)
{
bool didHandle = InvokeResponseFallback(aMessage, aMessageInfo);
bool didHandle = InvokeResponseFallback(aRxMsg);
if (!didHandle && aMessage.RequireResetOnError())
if (!didHandle && aRxMsg.mMessage.RequireResetOnError())
{
// Successfully parsed a header but no matching request was
// found - reject the message by sending reset.
IgnoreError(SendReset(aMessage, aMessageInfo));
IgnoreError(SendReset(aRxMsg));
}
}
}
bool CoapBase::InvokeResponseFallback(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
bool CoapBase::InvokeResponseFallback(Msg &aRxMsg) const
{
bool didHandle = false;
VerifyOrExit(mResponseFallback.IsSet());
didHandle = mResponseFallback.Invoke(&aMessage, &aMessageInfo);
didHandle = mResponseFallback.Invoke(&aRxMsg.mMessage, &aRxMsg.mMessageInfo);
exit:
return didHandle;
}
void CoapBase::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
void CoapBase::ProcessReceivedRequest(Msg &aRxMsg)
{
Message::UriPathStringBuffer uriPath;
Error error = kErrorNone;
if (mInterceptor.IsSet())
{
SuccessOrExit(error = mInterceptor.Invoke(aMessage, aMessageInfo));
SuccessOrExit(error = mInterceptor.Invoke(aRxMsg.mMessage, aRxMsg.mMessageInfo));
}
// Check if `mResponseCache` has a matching cached response for this
// request and send it. Only if not found (`kErrorNotFound`), we
// continue to process the `aMessage` further.
// continue to process the `aRxMsg.mMessage` further.
error = mResponseCache.SendCachedResponse(aMessage, aMessageInfo, *this);
error = mResponseCache.SendCachedResponse(aRxMsg, *this);
switch (error)
{
@@ -846,14 +826,14 @@ void CoapBase::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo
{
bool didHandle = false;
SuccessOrExit(error = ProcessBlockwiseRequest(aMessage, aMessageInfo, uriPath, didHandle));
SuccessOrExit(error = ProcessBlockwiseRequest(aRxMsg, uriPath, didHandle));
VerifyOrExit(!didHandle);
}
#else
SuccessOrExit(error = aMessage.ReadUriPathOptions(uriPath));
SuccessOrExit(error = aRxMsg.mMessage.ReadUriPathOptions(uriPath));
#endif
if ((mResourceHandler != nullptr) && mResourceHandler(*this, uriPath, aMessage, aMessageInfo))
if ((mResourceHandler != nullptr) && mResourceHandler(*this, uriPath, aRxMsg))
{
error = kErrorNone;
ExitNow();
@@ -863,7 +843,7 @@ void CoapBase::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo
{
if (StringMatch(resource.mUriPath, uriPath))
{
resource.HandleRequest(aMessage, aMessageInfo);
resource.HandleRequest(aRxMsg);
error = kErrorNone;
ExitNow();
}
@@ -871,7 +851,7 @@ void CoapBase::ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo
if (mDefaultHandler.IsSet())
{
mDefaultHandler.Invoke(&aMessage, &aMessageInfo);
mDefaultHandler.Invoke(&aRxMsg.mMessage, &aRxMsg.mMessageInfo);
error = kErrorNone;
ExitNow();
}
@@ -884,9 +864,9 @@ exit:
{
LogInfo("Failed to process request: %s", ErrorToString(error));
if (error == kErrorNotFound && !aMessageInfo.GetSockAddr().IsMulticast())
if (error == kErrorNotFound && !aRxMsg.mMessageInfo.GetSockAddr().IsMulticast())
{
IgnoreError(SendNotFound(aMessage, aMessageInfo));
IgnoreError(SendNotFound(aRxMsg));
}
}
}
@@ -955,10 +935,7 @@ exit:
return error;
}
Error CoapBase::ProcessBlockwiseResponse(Message &aResponse,
const Ip6::MessageInfo &aMessageInfo,
Message &aRequest,
const Metadata &aMetadata)
Error CoapBase::ProcessBlockwiseResponse(Msg &aRxMsg, Message &aRequest, const Metadata &aMetadata)
{
Error error = kErrorNone;
uint8_t blockOptionType = 0;
@@ -969,7 +946,7 @@ Error CoapBase::ProcessBlockwiseResponse(Message &aResponse,
// Search for CoAP Block-Wise Option [RFC7959]
Option::Iterator iterator;
SuccessOrExit(error = iterator.Init(aResponse));
SuccessOrExit(error = iterator.Init(aRxMsg.mMessage));
while (!iterator.IsDone())
{
@@ -1000,41 +977,43 @@ Error CoapBase::ProcessBlockwiseResponse(Message &aResponse,
{
case 0:
// Piggybacked response.
FinalizeCoapTransaction(aRequest, aMetadata, &aResponse, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, kErrorNone);
break;
case 1: // Block1 option
if (aResponse.GetCode() == kCodeContinue && aMetadata.mBlockwiseTransmitHook != nullptr)
if (aRxMsg.mMessage.GetCode() == kCodeContinue && aMetadata.mBlockwiseTransmitHook != nullptr)
{
error = SendNextBlock1Request(aRequest, aResponse, aMessageInfo, aMetadata);
error = SendNextBlock1Request(aRequest, aRxMsg, aMetadata);
}
if (aResponse.GetCode() != kCodeContinue || aMetadata.mBlockwiseTransmitHook == nullptr || error != kErrorNone)
if (aRxMsg.mMessage.GetCode() != kCodeContinue || aMetadata.mBlockwiseTransmitHook == nullptr ||
error != kErrorNone)
{
FinalizeCoapTransaction(aRequest, aMetadata, &aResponse, &aMessageInfo, error);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, error);
}
break;
case 2: // Block2 option
if (aResponse.GetCode() < kCodeBadRequest && aMetadata.mBlockwiseReceiveHook != nullptr)
if (aRxMsg.mMessage.GetCode() < kCodeBadRequest && aMetadata.mBlockwiseReceiveHook != nullptr)
{
error = SendNextBlock2Request(aRequest, aResponse, aMessageInfo, aMetadata, totalTransferSize, false);
error = SendNextBlock2Request(aRequest, aRxMsg, aMetadata, totalTransferSize, false);
}
if (aResponse.GetCode() >= kCodeBadRequest || aMetadata.mBlockwiseReceiveHook == nullptr || error != kErrorNone)
if (aRxMsg.mMessage.GetCode() >= kCodeBadRequest || aMetadata.mBlockwiseReceiveHook == nullptr ||
error != kErrorNone)
{
FinalizeCoapTransaction(aRequest, aMetadata, &aResponse, &aMessageInfo, error);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, error);
}
break;
case 3: // Block1 & Block2 option
if (aResponse.GetCode() < kCodeBadRequest && aMetadata.mBlockwiseReceiveHook != nullptr)
if (aRxMsg.mMessage.GetCode() < kCodeBadRequest && aMetadata.mBlockwiseReceiveHook != nullptr)
{
error = SendNextBlock2Request(aRequest, aResponse, aMessageInfo, aMetadata, totalTransferSize, true);
error = SendNextBlock2Request(aRequest, aRxMsg, aMetadata, totalTransferSize, true);
}
FinalizeCoapTransaction(aRequest, aMetadata, &aResponse, &aMessageInfo, error);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, error);
break;
default:
error = kErrorAbort;
FinalizeCoapTransaction(aRequest, aMetadata, &aResponse, &aMessageInfo, error);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, error);
break;
}
@@ -1042,10 +1021,7 @@ exit:
return error;
}
Error CoapBase::ProcessBlockwiseRequest(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
Message::UriPathStringBuffer &aUriPath,
bool &aDidHandle)
Error CoapBase::ProcessBlockwiseRequest(Msg &aRxMsg, Message::UriPathStringBuffer &aUriPath, bool &aDidHandle)
{
Error error = kErrorNone;
Option::Iterator iterator;
@@ -1053,7 +1029,7 @@ Error CoapBase::ProcessBlockwiseRequest(Message &aMessage,
uint8_t blockOptionType = 0;
uint32_t totalTransferSize = 0;
SuccessOrExit(error = iterator.Init(aMessage));
SuccessOrExit(error = iterator.Init(aRxMsg.mMessage));
while (!iterator.IsDone())
{
@@ -1107,24 +1083,24 @@ Error CoapBase::ProcessBlockwiseRequest(Message &aMessage,
case 1:
if (resource.mReceiveHook != nullptr)
{
switch (ProcessBlock1Request(aMessage, aMessageInfo, resource, totalTransferSize))
switch (ProcessBlock1Request(aRxMsg, resource, totalTransferSize))
{
case kErrorNone:
resource.HandleRequest(aMessage, aMessageInfo);
resource.HandleRequest(aRxMsg);
OT_FALL_THROUGH;
case kErrorBusy:
error = kErrorNone;
break;
case kErrorNoBufs:
IgnoreError(SendHeaderResponse(kCodeRequestTooLarge, aMessage, aMessageInfo));
IgnoreError(SendHeaderResponse(kCodeRequestTooLarge, aRxMsg));
error = kErrorDrop;
break;
case kErrorNoFrameReceived:
IgnoreError(SendHeaderResponse(kCodeRequestIncomplete, aMessage, aMessageInfo));
IgnoreError(SendHeaderResponse(kCodeRequestIncomplete, aRxMsg));
error = kErrorDrop;
break;
default:
IgnoreError(SendHeaderResponse(kCodeInternalError, aMessage, aMessageInfo));
IgnoreError(SendHeaderResponse(kCodeInternalError, aRxMsg));
error = kErrorDrop;
break;
}
@@ -1133,9 +1109,9 @@ Error CoapBase::ProcessBlockwiseRequest(Message &aMessage,
case 2:
if (resource.mTransmitHook != nullptr)
{
if ((error = ProcessBlock2Request(aMessage, aMessageInfo, resource)) != kErrorNone)
if ((error = ProcessBlock2Request(aRxMsg, resource)) != kErrorNone)
{
IgnoreError(SendHeaderResponse(kCodeInternalError, aMessage, aMessageInfo));
IgnoreError(SendHeaderResponse(kCodeInternalError, aRxMsg));
error = kErrorDrop;
}
}
@@ -1147,7 +1123,7 @@ Error CoapBase::ProcessBlockwiseRequest(Message &aMessage,
}
else
{
resource.HandleRequest(aMessage, aMessageInfo);
resource.HandleRequest(aRxMsg);
error = kErrorNone;
aDidHandle = true;
ExitNow();
@@ -1241,10 +1217,7 @@ exit:
return error;
}
Error CoapBase::SendNextBlock1Request(Message &aRequest,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Metadata &aMetadata)
Error CoapBase::SendNextBlock1Request(Message &aRequest, Msg &aRxMsg, const Metadata &aMetadata)
{
Error error = kErrorNone;
Message *request = nullptr;
@@ -1254,12 +1227,12 @@ Error CoapBase::SendNextBlock1Request(Message &aRequest,
BlockInfo requestBlockInfo;
SuccessOrExit(error = aRequest.ReadBlockOptionValues(kOptionBlock1, requestBlockInfo));
SuccessOrExit(error = aMessage.ReadBlockOptionValues(kOptionBlock1, msgBlockInfo));
SuccessOrExit(error = aRxMsg.mMessage.ReadBlockOptionValues(kOptionBlock1, msgBlockInfo));
// Conclude block-wise transfer if last block has been received
if (!requestBlockInfo.mMoreBlocks)
{
FinalizeCoapTransaction(aRequest, aMetadata, &aMessage, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, kErrorNone);
ExitNow();
}
@@ -1289,9 +1262,9 @@ Error CoapBase::SendNextBlock1Request(Message &aRequest,
LogInfo("Send Block1 Nr. %d, Size: %d bytes, More Blocks Flag: %d", requestBlockInfo.mBlockNumber,
requestBlockInfo.GetBlockSize(), requestBlockInfo.mMoreBlocks);
SuccessOrExit(error = SendMessage(*request, aMessageInfo, /* aTxParamters */ nullptr, aMetadata.mResponseHandler,
aMetadata.mResponseContext, aMetadata.mBlockwiseTransmitHook,
aMetadata.mBlockwiseReceiveHook));
SuccessOrExit(error = SendMessage(*request, aRxMsg.mMessageInfo, /* aTxParamters */ nullptr,
aMetadata.mResponseHandler, aMetadata.mResponseContext,
aMetadata.mBlockwiseTransmitHook, aMetadata.mBlockwiseReceiveHook));
exit:
FreeMessageOnError(request, error);
@@ -1299,12 +1272,11 @@ exit:
return error;
}
Error CoapBase::SendNextBlock2Request(Message &aRequest,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Metadata &aMetadata,
uint32_t aTotalLength,
bool aBeginBlock1Transfer)
Error CoapBase::SendNextBlock2Request(Message &aRequest,
Msg &aRxMsg,
const Metadata &aMetadata,
uint32_t aTotalLength,
bool aBeginBlock1Transfer)
{
Error error = kErrorNone;
Message *request = nullptr;
@@ -1313,14 +1285,14 @@ Error CoapBase::SendNextBlock2Request(Message &aRequest,
BlockInfo msgBlockInfo;
BlockInfo requestBlockInfo;
SuccessOrExit(error = aMessage.ReadBlockOptionValues(kOptionBlock2, msgBlockInfo));
SuccessOrExit(error = aRxMsg.mMessage.ReadBlockOptionValues(kOptionBlock2, msgBlockInfo));
VerifyOrExit(msgBlockInfo.GetBlockSize() <= kMaxBlockSize, error = kErrorNoBufs);
offsetRange.InitFromMessageOffsetToEnd(aMessage);
offsetRange.InitFromMessageOffsetToEnd(aRxMsg.mMessage);
VerifyOrExit(offsetRange.GetLength() <= msgBlockInfo.GetBlockSize(), error = kErrorNoBufs);
aMessage.ReadBytes(offsetRange, buf);
aRxMsg.mMessage.ReadBytes(offsetRange, buf);
SuccessOrExit(
error = aMetadata.mBlockwiseReceiveHook(aMetadata.mResponseContext, buf, msgBlockInfo.GetBlockOffsetPosition(),
offsetRange.GetLength(), msgBlockInfo.mMoreBlocks, aTotalLength));
@@ -1330,7 +1302,7 @@ Error CoapBase::SendNextBlock2Request(Message &aRequest,
if (!msgBlockInfo.mMoreBlocks)
{
FinalizeCoapTransaction(aRequest, aMetadata, &aMessage, &aMessageInfo, kErrorNone);
FinalizeCoapTransaction(aRequest, aMetadata, &aRxMsg, kErrorNone);
ExitNow();
}
@@ -1348,8 +1320,9 @@ Error CoapBase::SendNextBlock2Request(Message &aRequest,
LogInfo("Request Block2 Nr. %d, Size: %d bytes", requestBlockInfo.mBlockNumber, requestBlockInfo.GetBlockSize());
SuccessOrExit(error = SendMessage(*request, aMessageInfo, /* aTxParameters */ nullptr, aMetadata.mResponseHandler,
aMetadata.mResponseContext, nullptr, aMetadata.mBlockwiseReceiveHook));
SuccessOrExit(error = SendMessage(*request, aRxMsg.mMessageInfo, /* aTxParameters */ nullptr,
aMetadata.mResponseHandler, aMetadata.mResponseContext, nullptr,
aMetadata.mBlockwiseReceiveHook));
exit:
FreeMessageOnError(request, error);
@@ -1357,10 +1330,7 @@ exit:
return error;
}
Error CoapBase::ProcessBlock1Request(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const ResourceBlockWise &aResource,
uint32_t aTotalLength)
Error CoapBase::ProcessBlock1Request(Msg &aRxMsg, const ResourceBlockWise &aResource, uint32_t aTotalLength)
{
Error error = kErrorNone;
Message *response = nullptr;
@@ -1368,12 +1338,12 @@ Error CoapBase::ProcessBlock1Request(Message &aMessage,
OffsetRange offsetRange;
BlockInfo msgBlockInfo;
SuccessOrExit(error = aMessage.ReadBlockOptionValues(kOptionBlock1, msgBlockInfo));
SuccessOrExit(error = aRxMsg.mMessage.ReadBlockOptionValues(kOptionBlock1, msgBlockInfo));
offsetRange.InitFromMessageOffsetToEnd(aMessage);
offsetRange.InitFromMessageOffsetToEnd(aRxMsg.mMessage);
VerifyOrExit(offsetRange.GetLength() <= kMaxBlockSize, error = kErrorNoBufs);
aMessage.ReadBytes(offsetRange, buf);
aRxMsg.mMessage.ReadBytes(offsetRange, buf);
SuccessOrExit(error =
aResource.HandleBlockReceive(buf, msgBlockInfo.GetBlockOffsetPosition(), offsetRange.GetLength(),
msgBlockInfo.mMoreBlocks, aTotalLength));
@@ -1383,8 +1353,8 @@ Error CoapBase::ProcessBlock1Request(Message &aMessage,
// Set up next response
VerifyOrExit((response = NewMessage()) != nullptr, error = kErrorFailed);
response->Init(kTypeAck, kCodeContinue);
response->SetMessageId(aMessage.GetMessageId());
SuccessOrExit(error = response->WriteTokenFromMessage(aMessage));
response->SetMessageId(aRxMsg.mMessage.GetMessageId());
SuccessOrExit(error = response->WriteTokenFromMessage(aRxMsg.mMessage));
SuccessOrExit(error = response->AppendBlockOption(kOptionBlock1, msgBlockInfo));
@@ -1392,7 +1362,7 @@ Error CoapBase::ProcessBlock1Request(Message &aMessage,
LogInfo("Acknowledge Block1 Nr. %d, Size: %d bytes", msgBlockInfo.mBlockNumber, msgBlockInfo.GetBlockSize());
SuccessOrExit(error = SendMessage(*response, aMessageInfo));
SuccessOrExit(error = SendMessage(*response, aRxMsg.mMessageInfo));
error = kErrorBusy;
}
@@ -1412,9 +1382,7 @@ exit:
return error;
}
Error CoapBase::ProcessBlock2Request(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const ResourceBlockWise &aResource)
Error CoapBase::ProcessBlock2Request(Msg &aRxMsg, const ResourceBlockWise &aResource)
{
Error error = kErrorNone;
Message *response = nullptr;
@@ -1425,22 +1393,22 @@ Error CoapBase::ProcessBlock2Request(Message &aMessage,
BlockInfo msgBlockInfo;
BlockInfo responseBlockInfo;
SuccessOrExit(error = aMessage.ReadBlockOptionValues(kOptionBlock2, msgBlockInfo));
SuccessOrExit(error = aRxMsg.mMessage.ReadBlockOptionValues(kOptionBlock2, msgBlockInfo));
LogInfo("Request for Block2 Nr. %d, Size: %d bytes received", msgBlockInfo.mBlockNumber,
msgBlockInfo.GetBlockSize());
if (msgBlockInfo.mBlockNumber == 0)
{
aResource.HandleRequest(aMessage, aMessageInfo);
aResource.HandleRequest(aRxMsg);
ExitNow();
}
VerifyOrExit((response = NewMessage()) != nullptr, error = kErrorNoBufs);
response->Init(kTypeAck, kCodeContent);
response->SetMessageId(aMessage.GetMessageId());
response->SetMessageId(aRxMsg.mMessage.GetMessageId());
SuccessOrExit(error = response->WriteTokenFromMessage(aMessage));
SuccessOrExit(error = response->WriteTokenFromMessage(aRxMsg.mMessage));
responseBlockInfo.mMoreBlocks = false;
@@ -1496,7 +1464,7 @@ Error CoapBase::ProcessBlock2Request(Message &aMessage,
LogInfo("Send Block2 Nr. %d, Size: %d bytes, More Blocks Flag %d", responseBlockInfo.mBlockNumber,
responseBlockInfo.GetBlockSize(), responseBlockInfo.mMoreBlocks);
SuccessOrExit(error = SendMessage(*response, aMessageInfo));
SuccessOrExit(error = SendMessage(*response, aRxMsg.mMessageInfo));
exit:
FreeMessageOnError(response, error);
@@ -1531,20 +1499,20 @@ exit:
#if OPENTHREAD_CONFIG_COAP_OBSERVE_API_ENABLE
Error CoapBase::ProcessObserveSend(Message &aMessage, const Ip6::MessageInfo &aMessageInfo, bool &aShouldObserve)
Error CoapBase::ProcessObserveSend(Msg &aTxMsg, bool &aShouldObserve)
{
Error error;
Option::Iterator iterator;
aShouldObserve = false;
SuccessOrExit(error = iterator.Init(aMessage, kOptionObserve));
SuccessOrExit(error = iterator.Init(aTxMsg.mMessage, kOptionObserve));
aShouldObserve = !iterator.IsDone();
// Special case, if we're sending a GET with Observe=1, that is a
// cancellation.
if (aShouldObserve && aMessage.IsGetRequest())
if (aShouldObserve && aTxMsg.mMessage.IsGetRequest())
{
uint64_t value = 0;
@@ -1559,11 +1527,11 @@ Error CoapBase::ProcessObserveSend(Message &aMessage, const Ip6::MessageInfo &aM
// If we can find the previous matching request, cancel that too.
request = FindRelatedRequest(aMessage, aMessageInfo, metadata);
request = FindRelatedRequest(aTxMsg, metadata);
if (request != nullptr)
{
FinalizeCoapTransaction(*request, metadata, nullptr, nullptr, kErrorNone);
FinalizeCoapTransaction(*request, metadata, nullptr, kErrorNone);
}
}
}
@@ -1582,6 +1550,20 @@ bool CoapBase::IsObserveSubscription(const Message &aMessage, const Metadata &aM
#endif // OPENTHREAD_CONFIG_COAP_OBSERVE_API_ENABLE
//---------------------------------------------------------------------------------------------------------------------
// CoapBase::Metadata
void CoapBase::Metadata::InvokeResponseHandler(Msg *aMsg, Error aResult) const
{
if (mResponseHandler != nullptr)
{
Message *message = (aMsg != nullptr) ? &aMsg->mMessage : nullptr;
const Ip6::MessageInfo *messageInfo = (aMsg != nullptr) ? &aMsg->mMessageInfo : nullptr;
mResponseHandler(mResponseContext, message, messageInfo, aResult);
}
}
//---------------------------------------------------------------------------------------------------------------------
// CoapBase::ResponseCache
@@ -1590,17 +1572,15 @@ CoapBase::ResponseCache::ResponseCache(Instance &aInstance)
{
}
Error CoapBase::ResponseCache::SendCachedResponse(const Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
CoapBase &aCoapBase)
Error CoapBase::ResponseCache::SendCachedResponse(const Msg &aRxMsg, CoapBase &aCoapBase)
{
// Search `ResponseCache` for a cached response matching the given
// `aRequest`. If found, clone the response and send it. Returns
// request `aRxMsg`. If found, clone the response and send it. Returns
// `kErrorNotFound` if no match is found, `kErrorNone` on success,
// or other errors if send fails.
Error error = kErrorNone;
const Message *match = FindMatching(aRequest.GetMessageId(), aMessageInfo);
const Message *match = FindMatching(aRxMsg);
Message *response = nullptr;
VerifyOrExit(match != nullptr, error = kErrorNotFound);
@@ -1610,26 +1590,27 @@ Error CoapBase::ResponseCache::SendCachedResponse(const Message &aReque
response->Finish();
error = aCoapBase.Send(*response, aMessageInfo);
error = aCoapBase.Send(*response, aRxMsg.mMessageInfo);
exit:
FreeMessageOnError(response, error);
return error;
}
const Message *CoapBase::ResponseCache::FindMatching(uint16_t aMessageId, const Ip6::MessageInfo &aMessageInfo) const
const Message *CoapBase::ResponseCache::FindMatching(const Msg &aRxMsg) const
{
const Message *match = nullptr;
const Message *match = nullptr;
uint16_t requestMsgId = aRxMsg.mMessage.GetMessageId();
for (const Message &response : mResponses)
{
if (response.GetMessageId() == aMessageId)
if (response.GetMessageId() == requestMsgId)
{
ResponseMetadata metadata;
metadata.ReadFrom(response);
if (metadata.mMessageInfo.HasSamePeerAddrAndPort(aMessageInfo))
if (metadata.mMessageInfo.HasSamePeerAddrAndPort(aRxMsg.mMessageInfo))
{
match = &response;
break;
@@ -1640,25 +1621,23 @@ const Message *CoapBase::ResponseCache::FindMatching(uint16_t aMessageId, const
return match;
}
void CoapBase::ResponseCache::Add(const Message &aResponse,
const Ip6::MessageInfo &aMessageInfo,
uint32_t aExchangeLifetime)
void CoapBase::ResponseCache::Add(const Msg &aTxMsg, uint32_t aExchangeLifetime)
{
// Adds a clone of the `aResponse` to the cache if a matching
// Adds a clone of the `aTxMsg` to the cache if a matching
// entry does not already exist.
Message *responseClone = nullptr;
ResponseMetadata metadata;
VerifyOrExit(FindMatching(aResponse.GetMessageId(), aMessageInfo) == nullptr);
VerifyOrExit(FindMatching(aTxMsg) == nullptr);
MaintainCacheSize();
responseClone = aResponse.Clone();
responseClone = aTxMsg.mMessage.Clone();
VerifyOrExit(responseClone != nullptr);
metadata.mExpireTime = TimerMilli::GetNow() + aExchangeLifetime;
metadata.mMessageInfo = aMessageInfo;
metadata.mMessageInfo = aTxMsg.mMessageInfo;
SuccessOrExit(metadata.AppendTo(*responseClone));
src/core/coap/coap.hpp
+65 -81
View File
@@ -63,6 +63,8 @@ namespace Coap {
* @{
*/
class CoapBase;
/**
* Represents a function pointer which is called when a CoAP response is received or on the request timeout.
*
@@ -119,6 +121,25 @@ private:
static const otCoapTxParameters kDefaultTxParameters;
};
/**
* Represents a CoAP message and its associated `Ip6::MessageInfo`.
*/
class Msg
{
friend class CoapBase;
public:
Message &mMessage; ///< The CoAP message.
const Ip6::MessageInfo &mMessageInfo; ///< The `Ip6::MessageInfo` associated with the message.
private:
Msg(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
: mMessage(aMessage)
, mMessageInfo(aMessageInfo)
{
}
};
/**
* Implements CoAP resource handling.
*/
@@ -153,10 +174,7 @@ public:
const char *GetUriPath(void) const { return mUriPath; }
protected:
void HandleRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
mHandler(mContext, &aMessage, &aMessageInfo);
}
void HandleRequest(Msg &aRxMsg) const { mHandler(mContext, &aRxMsg.mMessage, &aRxMsg.mMessageInfo); }
};
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
@@ -216,10 +234,7 @@ public:
const char *GetUriPath(void) const { return mUriPath; }
protected:
void HandleRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
{
mHandler(mContext, &aMessage, &aMessageInfo);
}
void HandleRequest(Msg &aMsg) const { mHandler(mContext, &aMsg.mMessage, &aMsg.mMessageInfo); }
Error HandleBlockReceive(const uint8_t *aBlock,
uint32_t aPosition,
@@ -513,75 +528,69 @@ public:
/**
* Sends a CoAP reset message.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received CoAP request message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
* @retval kErrorInvalidArgs The @p aRequest is not of confirmable type.
* @retval kErrorInvalidArgs The @p aRxMsg is not of confirmable type.
*/
Error SendReset(Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendReset(const Msg &aRxMsg);
/**
* Sends header-only CoAP response message.
*
* @param[in] aCode The CoAP code of this response.
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received request message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
* @retval kErrorInvalidArgs The @p aRequest header is not of confirmable type.
*/
Error SendHeaderResponse(Message::Code aCode, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendHeaderResponse(Message::Code aCode, const Msg &aRxMsg);
/**
* Sends a CoAP ACK empty message which is used in Separate Response for confirmable requests.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg `Msg` for the received CoAP request message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
* @retval kErrorInvalidArgs The @p aRequest header is not of confirmable type.
* @retval kErrorInvalidArgs The @p aRxMsg header is not of confirmable type.
*/
Error SendAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendAck(const Msg &aRxMsg);
/**
* Sends a CoAP ACK message on which a dummy CoAP response is piggybacked.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received CoAP request Message.
* @param[in] aCode The CoAP code of the dummy CoAP response.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
* @retval kErrorInvalidArgs The @p aRequest header is not of confirmable type.
* @retval kErrorInvalidArgs The @p aRxMsg header is not of confirmable type.
*/
Error SendEmptyAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo, Code aCode);
Error SendEmptyAck(const Msg &aRxMsg, Code aCode);
/**
* Sends a CoAP ACK message on which a dummy CoAP response is piggybacked.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received CoAP request Message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
* @retval kErrorInvalidArgs The @p aRequest header is not of confirmable type.
* @retval kErrorInvalidArgs The @p aRxMsg header is not of confirmable type.
*/
Error SendEmptyAck(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendEmptyAck(const Msg &aRxMsg);
/**
* Sends a header-only CoAP message to indicate no resource matched for the request.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received request CoAP Message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
*/
Error SendNotFound(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendNotFound(const Msg &aRxMsg);
/**
* Aborts CoAP transactions associated with given handler and context.
@@ -659,16 +668,12 @@ public:
* Sends a header-only CoAP message to indicate not all blocks have been sent or
* were sent out of order.
*
* @param[in] aRequest A reference to the CoAP Message that was used in CoAP request.
* @param[in] aMessageInfo The message info corresponding to the CoAP request.
* @param[in] aRxMsg The received CoAP request message.
*
* @retval kErrorNone Successfully enqueued the CoAP response message.
* @retval kErrorNoBufs Insufficient buffers available to send the CoAP response.
*/
Error SendRequestEntityIncomplete(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo)
{
return SendHeaderResponse(kCodeRequestIncomplete, aRequest, aMessageInfo);
}
Error SendRequestEntityIncomplete(const Msg &aRxMsg) { return SendHeaderResponse(kCodeRequestIncomplete, aRxMsg); }
#endif // OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
protected:
@@ -680,16 +685,12 @@ protected:
*
* @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.
* @param[in] aRxMsg The received message
*
* @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);
typedef bool (*ResourceHandler)(CoapBase &aCoapBase, const char *aUriPath, Msg &aRxMsg);
/**
* Pointer is called to send a CoAP message.
@@ -732,6 +733,8 @@ private:
struct Metadata : public Message::FooterData<Metadata>
{
void InvokeResponseHandler(Msg *aMsg, Error aResult) const;
Ip6::Address mSourceAddress; // IPv6 address of the message source.
Ip6::Address mDestinationAddress; // IPv6 address of the message destination.
uint16_t mDestinationPort; // UDP port of the message destination.
@@ -763,9 +766,9 @@ private:
public:
explicit ResponseCache(Instance &aInstance);
void Add(const Message &aResponse, const Ip6::MessageInfo &aMessageInfo, uint32_t aExchangeLifetime);
void Add(const Msg &aTxMsg, uint32_t aExchangeLifetime);
void RemoveAll(void);
Error SendCachedResponse(const Message &aRequest, const Ip6::MessageInfo &aMessageInfo, CoapBase &aCoapBase);
Error SendCachedResponse(const Msg &aRxMsg, CoapBase &aCoapBase);
void GetInfo(MessageQueue::Info &aInfo) const { return mResponses.GetInfo(aInfo); }
private:
@@ -779,7 +782,7 @@ private:
Ip6::MessageInfo mMessageInfo;
};
const Message *FindMatching(uint16_t aMessageId, const Ip6::MessageInfo &aMessageInfo) const;
const Message *FindMatching(const Msg &aRxMsg) const;
void MaintainCacheSize(void);
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
@@ -796,60 +799,41 @@ private:
void ClearRequests(const Ip6::Address *aAddress);
Message *CopyAndEnqueueMessage(const Message &aMessage, uint16_t aCopyLength, const Metadata &aMetadata);
void DequeueMessage(Message &aMessage);
Message *FindRelatedRequest(const Message &aResponse, const Ip6::MessageInfo &aMessageInfo, Metadata &aMetadata);
void FinalizeCoapTransaction(Message &aRequest,
const Metadata &aMetadata,
Message *aResponse,
const Ip6::MessageInfo *aMessageInfo,
Error aResult);
bool InvokeResponseFallback(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
void ProcessReceivedRequest(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void ProcessReceivedResponse(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Message *FindRelatedRequest(const Msg &aMsg, Metadata &aMetadata);
void FinalizeCoapTransaction(Message &aRequest, const Metadata &aMetadata, Msg *aResponse, Error aResult);
bool InvokeResponseFallback(Msg &aRxMsg) const;
void ProcessReceivedRequest(Msg &aRxMsg);
void ProcessReceivedResponse(Msg &aRxMsg);
void SendCopy(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Error SendEmptyMessage(Type aType, const Message &aRequest, const Ip6::MessageInfo &aMessageInfo);
Error SendEmptyMessage(Type aType, const Msg &aRxMsg);
Error Send(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
Error ProcessBlockwiseSend(Message &aMessage, BlockwiseTransmitHook aTransmitHook, void *aContext);
Error ProcessBlockwiseResponse(Message &aResponse,
const Ip6::MessageInfo &aMessageInfo,
Message &aRequest,
const Metadata &aMetadata);
Error ProcessBlockwiseRequest(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
Message::UriPathStringBuffer &aUriPath,
bool &aDidHandle);
Error ProcessBlockwiseResponse(Msg &aRxMsg, Message &aRequest, const Metadata &aMetadata);
Error ProcessBlockwiseRequest(Msg &aRxMsg, Message::UriPathStringBuffer &aUriPath, bool &aDidHandle);
void FreeLastBlockResponse(void);
Error CacheLastBlockResponse(Message *aResponse);
Error PrepareNextBlockRequest(uint16_t aBlockOptionNumber,
Message &aRequestOld,
Message &aRequest,
const BlockInfo &aBlockInfo);
Error ProcessBlock1Request(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const ResourceBlockWise &aResource,
uint32_t aTotalLength);
Error ProcessBlock2Request(Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const ResourceBlockWise &aResource);
Error SendNextBlock1Request(Message &aRequest,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Metadata &aMetadata);
Error SendNextBlock2Request(Message &aRequest,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
const Metadata &aMetadata,
uint32_t aTotalLength,
bool aBeginBlock1Transfer);
Error ProcessBlock1Request(Msg &aRxMsg, const ResourceBlockWise &aResource, uint32_t aTotalLength);
Error ProcessBlock2Request(Msg &aRxMsg, const ResourceBlockWise &aResource);
Error SendNextBlock1Request(Message &aRequest, Msg &aRxMsg, const Metadata &aMetadata);
Error SendNextBlock2Request(Message &aRequest,
Msg &aRxMsg,
const Metadata &aMetadata,
uint32_t aTotalLength,
bool aBeginBlock1Transfer);
static Error DetermineBlockSzxFromSize(uint16_t aSize, BlockSzx &aBlockSzx);
#endif // OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
#if OPENTHREAD_CONFIG_COAP_OBSERVE_API_ENABLE
Error ProcessObserveSend(Message &aMessage, const Ip6::MessageInfo &aMessageInfo, bool &aShouldObserve);
Error ProcessObserveSend(Msg &aTxMsg, bool &aShouldObserve);
static bool IsObserveSubscription(const Message &aMessage, const Metadata &aMetadata);
#endif
src/core/meshcop/border_agent.cpp
+21 -30
View File
@@ -354,20 +354,18 @@ exit:
return didHandle;
}
template <> void Manager::HandleTmf<kUriRelayRx>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Manager::HandleTmf<kUriRelayRx>(Coap::Msg &aMsg)
{
// This is from TMF agent.
OT_UNUSED_VARIABLE(aMessageInfo);
VerifyOrExit(mIsRunning);
VerifyOrExit(aMessage.IsNonConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsNonConfirmablePostRequest());
LogInfo("Received %s from %s", UriToString<kUriRelayRx>(), aMessageInfo.GetPeerAddr().ToString().AsCString());
LogInfo("Received %s from %s", UriToString<kUriRelayRx>(), aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
VerifyOrExit(mCommissionerSession != nullptr);
mCommissionerSession->ForwardUdpRelayToCommissioner(aMessage);
mCommissionerSession->ForwardUdpRelayToCommissioner(aMsg.mMessage);
exit:
return;
@@ -578,17 +576,13 @@ void Manager::CoapDtlsSession::Cleanup(void)
Coap::SecureSession::Cleanup();
}
bool Manager::CoapDtlsSession::HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool Manager::CoapDtlsSession::HandleResource(CoapBase &aCoapBase, const char *aUriPath, Coap::Msg &aMsg)
{
return static_cast<CoapDtlsSession &>(aCoapBase).HandleResource(aUriPath, aMessage, aMessageInfo);
return static_cast<CoapDtlsSession &>(aCoapBase).HandleResource(aUriPath, aMsg);
}
bool Manager::CoapDtlsSession::HandleResource(const char *aUriPath,
Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool Manager::CoapDtlsSession::HandleResource(const char *aUriPath, Coap::Msg &aMsg)
{
bool didHandle = true;
Uri uri = UriFromPath(aUriPath);
@@ -597,21 +591,21 @@ bool Manager::CoapDtlsSession::HandleResource(const char *aUriPath,
{
case kUriCommissionerPetition:
Log<kUriCommissionerPetition>(kReceive);
IgnoreError(ForwardToLeader(aMessage, aMessageInfo, kUriLeaderPetition));
IgnoreError(ForwardToLeader(aMsg, kUriLeaderPetition));
break;
case kUriCommissionerKeepAlive:
HandleTmfCommissionerKeepAlive(aMessage, aMessageInfo);
HandleTmfCommissionerKeepAlive(aMsg);
break;
case kUriRelayTx:
HandleTmfRelayTx(aMessage);
HandleTmfRelayTx(aMsg.mMessage);
break;
case kUriCommissionerGet:
case kUriActiveGet:
case kUriPendingGet:
HandleTmfDatasetGet(aMessage, uri);
HandleTmfDatasetGet(aMsg.mMessage, uri);
break;
case kUriProxyTx:
HandleTmfProxyTx(aMessage);
HandleTmfProxyTx(aMsg.mMessage);
break;
default:
didHandle = false;
@@ -641,14 +635,13 @@ void Manager::CoapDtlsSession::HandleConnected(ConnectEvent aEvent)
}
}
void Manager::CoapDtlsSession::HandleTmfCommissionerKeepAlive(Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
void Manager::CoapDtlsSession::HandleTmfCommissionerKeepAlive(Coap::Msg &aMsg)
{
VerifyOrExit(IsActiveCommissioner());
Log<kUriCommissionerKeepAlive>(kReceive);
SuccessOrExit(ForwardToLeader(aMessage, aMessageInfo, kUriLeaderKeepAlive));
SuccessOrExit(ForwardToLeader(aMsg, kUriLeaderKeepAlive));
mTimer.Start(kKeepAliveTimeout);
#if OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE && OPENTHREAD_CONFIG_HISTORY_TRACKER_ENABLE
if (Get<EphemeralKeyManager>().OwnsSession(*this))
@@ -661,9 +654,7 @@ exit:
return;
}
Error Manager::CoapDtlsSession::ForwardToLeader(const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo,
Uri aUri)
Error Manager::CoapDtlsSession::ForwardToLeader(const Coap::Msg &aMsg, Uri aUri)
{
Error error = kErrorNone;
OwnedPtr<ForwardContext> forwardContext;
@@ -681,16 +672,16 @@ Error Manager::CoapDtlsSession::ForwardToLeader(const Coap::Message &aMessage
OT_ASSERT(false);
}
SuccessOrExit(error = SendAck(aMessage, aMessageInfo));
SuccessOrExit(error = SendAck(aMsg));
forwardContext.Reset(ForwardContext::Allocate(*this, aMessage, aUri));
forwardContext.Reset(ForwardContext::Allocate(*this, aMsg.mMessage, aUri));
VerifyOrExit(!forwardContext.IsNull(), error = kErrorNoBufs);
message.Reset(Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(aUri));
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
offsetRange.InitFromMessageOffsetToEnd(aMessage);
SuccessOrExit(error = message->AppendBytesFromMessage(aMessage, offsetRange));
offsetRange.InitFromMessageOffsetToEnd(aMsg.mMessage);
SuccessOrExit(error = message->AppendBytesFromMessage(aMsg.mMessage, offsetRange));
messageInfo.SetSockAddrToRlocPeerAddrToLeaderAloc();
messageInfo.SetSockPortToTmf();
@@ -719,7 +710,7 @@ Error Manager::CoapDtlsSession::ForwardToLeader(const Coap::Message &aMessage
exit:
LogWarnOnError(error, "forward to leader");
if ((error != kErrorNone) && (aMessage.ReadToken(token) == kErrorNone))
if ((error != kErrorNone) && (aMsg.mMessage.ReadToken(token) == kErrorNone))
{
SendErrorMessage(error, token);
}
src/core/meshcop/border_agent.hpp
+5 -8
View File
@@ -303,11 +303,11 @@ private:
CoapDtlsSession(Instance &aInstance, Dtls::Transport &aDtlsTransport);
Error ForwardToCommissioner(OwnedPtr<Coap::Message> aForwardMessage, const Message &aMessage);
void HandleTmfCommissionerKeepAlive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
void HandleTmfCommissionerKeepAlive(Coap::Msg &aMsg);
void HandleTmfRelayTx(Coap::Message &aMessage);
void HandleTmfProxyTx(Coap::Message &aMessage);
void HandleTmfDatasetGet(Coap::Message &aMessage, Uri aUri);
Error ForwardToLeader(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo, Uri aUri);
Error ForwardToLeader(const Coap::Msg &aMsg, Uri aUri);
void SendErrorMessage(Error aError, const Coap::Token &aToken);
static void HandleConnected(ConnectEvent aEvent, void *aContext);
@@ -319,11 +319,8 @@ private:
void HandleLeaderResponseToFwdTmf(const ForwardContext &aForwardContext,
const Coap::Message *aResponse,
Error aResult);
static bool HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo);
bool HandleResource(const char *aUriPath, Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
static bool HandleResource(CoapBase &aCoapBase, const char *aUriPath, Coap::Msg &aMsg);
bool HandleResource(const char *aUriPath, Coap::Msg &aMsg);
static void HandleTimer(Timer &aTimer);
void HandleTimer(void);
@@ -350,7 +347,7 @@ private:
// Callback from Notifier
void HandleNotifierEvents(Events aEvents);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
// Callbacks used with `Dtls::Transport`.
static SecureSession *HandleAcceptSession(void *aContext, const Ip6::MessageInfo &aMessageInfo);
src/core/meshcop/commissioner.cpp
+16 -22
View File
@@ -813,10 +813,8 @@ exit:
return;
}
template <> void Commissioner::HandleTmf<kUriRelayRx>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Commissioner::HandleTmf<kUriRelayRx>(Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessageInfo);
Error error;
uint16_t joinerPort;
Ip6::InterfaceIdentifier joinerIid;
@@ -826,13 +824,13 @@ template <> void Commissioner::HandleTmf<kUriRelayRx>(Coap::Message &aMessage, c
VerifyOrExit(mState == kStateActive, error = kErrorInvalidState);
VerifyOrExit(aMessage.IsNonConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsNonConfirmablePostRequest());
SuccessOrExit(error = Tlv::Find<JoinerUdpPortTlv>(aMessage, joinerPort));
SuccessOrExit(error = Tlv::Find<JoinerIidTlv>(aMessage, joinerIid));
SuccessOrExit(error = Tlv::Find<JoinerRouterLocatorTlv>(aMessage, joinerRloc));
SuccessOrExit(error = Tlv::Find<JoinerUdpPortTlv>(aMsg.mMessage, joinerPort));
SuccessOrExit(error = Tlv::Find<JoinerIidTlv>(aMsg.mMessage, joinerIid));
SuccessOrExit(error = Tlv::Find<JoinerRouterLocatorTlv>(aMsg.mMessage, joinerRloc));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMessage, Tlv::kJoinerDtlsEncapsulation, offsetRange));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMsg.mMessage, Tlv::kJoinerDtlsEncapsulation, offsetRange));
if (!Get<Tmf::SecureAgent>().IsConnectionActive())
{
@@ -869,14 +867,14 @@ template <> void Commissioner::HandleTmf<kUriRelayRx>(Coap::Message &aMessage, c
LogInfo("Received %s (%s, 0x%04x)", UriToString<kUriRelayRx>(), mJoinerIid.ToString().AsCString(), mJoinerRloc);
aMessage.SetOffset(offsetRange.GetOffset());
SuccessOrExit(error = aMessage.SetLength(offsetRange.GetEndOffset()));
aMsg.mMessage.SetOffset(offsetRange.GetOffset());
SuccessOrExit(error = aMsg.mMessage.SetLength(offsetRange.GetEndOffset()));
joinerMessageInfo.SetPeerAddr(Get<Mle::Mle>().GetMeshLocalEid());
joinerMessageInfo.GetPeerAddr().SetIid(mJoinerIid);
joinerMessageInfo.SetPeerPort(mJoinerPort);
Get<Tmf::SecureAgent>().HandleReceive(aMessage, joinerMessageInfo);
Get<Tmf::SecureAgent>().HandleReceive(aMsg.mMessage, joinerMessageInfo);
exit:
return;
@@ -892,15 +890,14 @@ void Commissioner::HandleJoinerSessionTimer(void)
Get<Tmf::SecureAgent>().Disconnect();
}
template <>
void Commissioner::HandleTmf<kUriDatasetChanged>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Commissioner::HandleTmf<kUriDatasetChanged>(Coap::Msg &aMsg)
{
VerifyOrExit(mState == kStateActive);
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s", UriToString<kUriDatasetChanged>());
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s ack", UriToString<kUriDatasetChanged>());
@@ -908,11 +905,8 @@ exit:
return;
}
template <>
void Commissioner::HandleTmf<kUriJoinerFinalize>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Commissioner::HandleTmf<kUriJoinerFinalize>(Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessageInfo);
StateTlv::State state = StateTlv::kAccept;
ProvisioningUrlTlv::StringType provisioningUrl;
@@ -920,7 +914,7 @@ void Commissioner::HandleTmf<kUriJoinerFinalize>(Coap::Message &aMessage, const
LogInfo("Received %s", UriToString<kUriJoinerFinalize>());
switch (Tlv::Find<ProvisioningUrlTlv>(aMessage, provisioningUrl))
switch (Tlv::Find<ProvisioningUrlTlv>(aMsg.mMessage, provisioningUrl))
{
case kErrorNone:
if (!StringMatch(provisioningUrl, mProvisioningUrl))
@@ -937,10 +931,10 @@ void Commissioner::HandleTmf<kUriJoinerFinalize>(Coap::Message &aMessage, const
}
#if OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE
LogCertMessage("[THCI] direction=recv | type=JOIN_FIN.req |", aMessage);
LogCertMessage("[THCI] direction=recv | type=JOIN_FIN.req |", aMsg.mMessage);
#endif
SendJoinFinalizeResponse(aMessage, state);
SendJoinFinalizeResponse(aMsg.mMessage, state);
exit:
return;
src/core/meshcop/commissioner.hpp
+1 -1
View File
@@ -401,7 +401,7 @@ private:
static void HandleSecureAgentConnectEvent(Dtls::Session::ConnectEvent aEvent, void *aContext);
void HandleSecureAgentConnectEvent(Dtls::Session::ConnectEvent aEvent);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
void HandleRelayReceive(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
src/core/meshcop/dataset_manager.cpp
+6 -14
View File
@@ -530,16 +530,16 @@ exit:
mTimer.Start(kSendSetDelay);
}
void DatasetManager::HandleGet(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const
void DatasetManager::HandleGet(const Coap::Msg &aMsg) const
{
Error error = kErrorNone;
Coap::Message *response = ProcessGetRequest(aMessage, kCheckSecurityPolicyFlags);
Coap::Message *response = ProcessGetRequest(aMsg.mMessage, kCheckSecurityPolicyFlags);
VerifyOrExit(response != nullptr);
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMsg.mMessageInfo));
LogInfo("sent %s dataset get response to %s", IsActiveDataset() ? "active" : "pending",
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
exit:
FreeMessageOnError(response, error);
@@ -878,11 +878,7 @@ exit:
return isValid;
}
template <>
void ActiveDatasetManager::HandleTmf<kUriActiveGet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
DatasetManager::HandleGet(aMessage, aMessageInfo);
}
template <> void ActiveDatasetManager::HandleTmf<kUriActiveGet>(Coap::Msg &aMsg) { DatasetManager::HandleGet(aMsg); }
void ActiveDatasetManager::HandleTimer(Timer &aTimer) { aTimer.Get<ActiveDatasetManager>().HandleTimer(); }
@@ -1002,11 +998,7 @@ exit:
Clear();
}
template <>
void PendingDatasetManager::HandleTmf<kUriPendingGet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
DatasetManager::HandleGet(aMessage, aMessageInfo);
}
template <> void PendingDatasetManager::HandleTmf<kUriPendingGet>(Coap::Msg &aMsg) { DatasetManager::HandleGet(aMsg); }
void PendingDatasetManager::HandleTimer(Timer &aTimer) { aTimer.Get<PendingDatasetManager>().HandleTimer(); }
src/core/meshcop/dataset_manager.hpp
+5 -7
View File
@@ -279,7 +279,7 @@ private:
bool IsPendingDataset(void) const { return (mType == Dataset::kPending); }
void Restore(const Dataset &aDataset);
Error ApplyConfiguration(const Dataset &aDataset) const;
void HandleGet(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) const;
void HandleGet(const Coap::Msg &aMsg) const;
void HandleTimer(void);
Error Save(const Dataset &aDataset, bool aAllowOlderTimestamp);
void LocalSave(const Dataset &aDataset);
@@ -302,11 +302,9 @@ private:
#endif
#if OPENTHREAD_FTD
Error HandleSetOrReplace(MgmtCommand aCommand, const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Error HandleSetOrReplace(MgmtCommand aCommand, const Coap::Msg &aMsg);
Error ProcessSetOrReplaceRequest(MgmtCommand aCommand, const Coap::Message &aMessage, RequestInfo &aInfo) const;
void SendSetOrReplaceResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
void SendSetOrReplaceResponse(const Coap::Msg &aMsg, StateTlv::State aState);
#endif
Type mType;
@@ -390,7 +388,7 @@ public:
#endif
private:
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
static void HandleTimer(Timer &aTimer);
void HandleTimer(void) { DatasetManager::HandleTimer(); }
@@ -477,7 +475,7 @@ private:
void HandleTimer(void) { DatasetManager::HandleTimer(); }
void HandleDelayTimer(void);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
using DelayTimer = TimerMilliIn<PendingDatasetManager, &PendingDatasetManager::HandleDelayTimer>;
src/core/meshcop/dataset_manager_ftd.cpp
+12 -19
View File
@@ -188,16 +188,14 @@ exit:
return error;
}
Error DatasetManager::HandleSetOrReplace(MgmtCommand aCommand,
const Coap::Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
Error DatasetManager::HandleSetOrReplace(MgmtCommand aCommand, const Coap::Msg &aMsg)
{
StateTlv::State state = StateTlv::kReject;
RequestInfo info;
VerifyOrExit(Get<Mle::Mle>().IsLeader());
SuccessOrExit(ProcessSetOrReplaceRequest(aCommand, aMessage, info));
SuccessOrExit(ProcessSetOrReplaceRequest(aCommand, aMsg.mMessage, info));
if (IsActiveDataset() && info.mAffectsConnectivity)
{
@@ -228,24 +226,22 @@ Error DatasetManager::HandleSetOrReplace(MgmtCommand aCommand,
}
exit:
SendSetOrReplaceResponse(aMessage, aMessageInfo, state);
SendSetOrReplaceResponse(aMsg, state);
return (state == StateTlv::kAccept) ? kErrorNone : kErrorDrop;
}
void DatasetManager::SendSetOrReplaceResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
void DatasetManager::SendSetOrReplaceResponse(const Coap::Msg &aMsg, StateTlv::State aState)
{
Error error = kErrorNone;
Coap::Message *message;
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aRequest);
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<StateTlv>(*message, aState));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
LogInfo("sent dataset set/replace response");
@@ -368,20 +364,18 @@ void ActiveDatasetManager::StartLeader(void) { IgnoreError(GenerateLocal()); }
void ActiveDatasetManager::StartLeader(void) {}
#endif // OPENTHREAD_CONFIG_OPERATIONAL_DATASET_AUTO_INIT
template <>
void ActiveDatasetManager::HandleTmf<kUriActiveSet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void ActiveDatasetManager::HandleTmf<kUriActiveSet>(Coap::Msg &aMsg)
{
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtSet, aMessage, aMessageInfo));
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtSet, aMsg));
IgnoreError(ApplyConfiguration());
exit:
return;
}
template <>
void ActiveDatasetManager::HandleTmf<kUriActiveReplace>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void ActiveDatasetManager::HandleTmf<kUriActiveReplace>(Coap::Msg &aMsg)
{
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtReplace, aMessage, aMessageInfo));
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtReplace, aMsg));
IgnoreError(ApplyConfiguration());
exit:
@@ -404,10 +398,9 @@ exit:
return error;
}
template <>
void PendingDatasetManager::HandleTmf<kUriPendingSet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void PendingDatasetManager::HandleTmf<kUriPendingSet>(Coap::Msg &aMsg)
{
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtSet, aMessage, aMessageInfo));
SuccessOrExit(DatasetManager::HandleSetOrReplace(kMgmtSet, aMsg));
StartDelayTimer();
exit:
src/core/meshcop/energy_scan_client.cpp
+6 -6
View File
@@ -85,23 +85,23 @@ exit:
return error;
}
template <>
void EnergyScanClient::HandleTmf<kUriEnergyReport>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void EnergyScanClient::HandleTmf<kUriEnergyReport>(Coap::Msg &aMsg)
{
uint32_t mask;
MeshCoP::EnergyListTlv energyListTlv;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s", UriToString<kUriEnergyReport>());
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMessage, mask));
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMsg.mMessage, mask));
SuccessOrExit(MeshCoP::Tlv::FindTlv(aMessage, MeshCoP::Tlv::kEnergyList, sizeof(energyListTlv), energyListTlv));
SuccessOrExit(
MeshCoP::Tlv::FindTlv(aMsg.mMessage, MeshCoP::Tlv::kEnergyList, sizeof(energyListTlv), energyListTlv));
mCallback.InvokeIfSet(mask, energyListTlv.GetEnergyList(), energyListTlv.GetEnergyListLength());
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s ack", UriToString<kUriEnergyReport>());
src/core/meshcop/energy_scan_client.hpp
+1 -1
View File
@@ -85,7 +85,7 @@ public:
void *aContext);
private:
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
Callback<otCommissionerEnergyReportCallback> mCallback;
};
src/core/meshcop/joiner.cpp
+7 -7
View File
@@ -494,19 +494,19 @@ exit:
IgnoreError(Get<Ip6::Filter>().RemoveUnsecurePort(kJoinerUdpPort));
}
template <> void Joiner::HandleTmf<kUriJoinerEntrust>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Joiner::HandleTmf<kUriJoinerEntrust>(Coap::Msg &aMsg)
{
Error error;
Dataset::Info datasetInfo;
VerifyOrExit(mState == kStateEntrust && aMessage.IsConfirmablePostRequest(), error = kErrorDrop);
VerifyOrExit(mState == kStateEntrust && aMsg.mMessage.IsConfirmablePostRequest(), error = kErrorDrop);
LogInfo("Received %s", UriToString<kUriJoinerEntrust>());
LogCert("[THCI] direction=recv | type=JOIN_ENT.ntf");
datasetInfo.Clear();
SuccessOrExit(error = Tlv::Find<NetworkKeyTlv>(aMessage, datasetInfo.Update<Dataset::kNetworkKey>()));
SuccessOrExit(error = Tlv::Find<NetworkKeyTlv>(aMsg.mMessage, datasetInfo.Update<Dataset::kNetworkKey>()));
datasetInfo.Set<Dataset::kChannel>(Get<Mac::Mac>().GetPanChannel());
datasetInfo.Set<Dataset::kPanId>(Get<Mac::Mac>().GetPanId());
@@ -515,7 +515,7 @@ template <> void Joiner::HandleTmf<kUriJoinerEntrust>(Coap::Message &aMessage, c
LogInfo("Joiner successful!");
SendJoinerEntrustResponse(aMessage, aMessageInfo);
SendJoinerEntrustResponse(aMsg);
// Delay extended address configuration to allow DTLS wrap up.
mTimer.Start(kConfigExtAddressDelay);
@@ -524,13 +524,13 @@ exit:
LogWarnOnError(error, "process joiner entrust");
}
void Joiner::SendJoinerEntrustResponse(const Coap::Message &aRequest, const Ip6::MessageInfo &aRequestInfo)
void Joiner::SendJoinerEntrustResponse(const Coap::Msg &aMsg)
{
Error error = kErrorNone;
Coap::Message *message;
Ip6::MessageInfo responseInfo(aRequestInfo);
Ip6::MessageInfo responseInfo(aMsg.mMessageInfo);
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aRequest);
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
message->SetSubType(Message::kSubTypeJoinerEntrust);
src/core/meshcop/joiner.hpp
+2 -2
View File
@@ -207,7 +207,7 @@ private:
const char *aVendorData);
void FreeJoinerFinalizeMessage(void);
void SendJoinerFinalize(void);
void SendJoinerEntrustResponse(const Coap::Message &aRequest, const Ip6::MessageInfo &aRequestInfo);
void SendJoinerEntrustResponse(const Coap::Msg &aMsg);
static void HandleDiscoverResult(Mle::DiscoverScanner::ScanResult *aResult, void *aContext);
void HandleDiscoverResult(Mle::DiscoverScanner::ScanResult *aResult);
static void HandleSecureCoapClientConnect(Dtls::Session::ConnectEvent aEvent, void *aContext);
@@ -215,7 +215,7 @@ private:
DeclareTmfResponseHandlerIn(Joiner, HandleJoinerFinalizeResponse);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
using JoinerTimer = TimerMilliIn<Joiner, &Joiner::HandleTimer>;
src/core/meshcop/joiner_router.cpp
+7 -9
View File
@@ -151,10 +151,8 @@ exit:
FreeMessageOnError(message, error);
}
template <> void JoinerRouter::HandleTmf<kUriRelayTx>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void JoinerRouter::HandleTmf<kUriRelayTx>(Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessageInfo);
Error error;
uint16_t joinerPort;
Ip6::InterfaceIdentifier joinerIid;
@@ -164,25 +162,25 @@ template <> void JoinerRouter::HandleTmf<kUriRelayTx>(Coap::Message &aMessage, c
Message::Settings settings(kNoLinkSecurity, Message::kPriorityNet);
Ip6::MessageInfo messageInfo;
VerifyOrExit(aMessage.IsNonConfirmablePostRequest(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessage.IsNonConfirmablePostRequest(), error = kErrorDrop);
LogInfo("Received %s", UriToString<kUriRelayTx>());
SuccessOrExit(error = Tlv::Find<JoinerUdpPortTlv>(aMessage, joinerPort));
SuccessOrExit(error = Tlv::Find<JoinerIidTlv>(aMessage, joinerIid));
SuccessOrExit(error = Tlv::Find<JoinerUdpPortTlv>(aMsg.mMessage, joinerPort));
SuccessOrExit(error = Tlv::Find<JoinerIidTlv>(aMsg.mMessage, joinerIid));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMessage, Tlv::kJoinerDtlsEncapsulation, offsetRange));
SuccessOrExit(error = Tlv::FindTlvValueOffsetRange(aMsg.mMessage, Tlv::kJoinerDtlsEncapsulation, offsetRange));
VerifyOrExit((message = mSocket.NewMessage(0, settings)) != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = message->AppendBytesFromMessage(aMessage, offsetRange));
SuccessOrExit(error = message->AppendBytesFromMessage(aMsg.mMessage, offsetRange));
messageInfo.GetPeerAddr().SetToLinkLocalAddress(joinerIid);
messageInfo.SetPeerPort(joinerPort);
SuccessOrExit(error = mSocket.SendTo(*message, messageInfo));
if (Tlv::Find<JoinerRouterKekTlv>(aMessage, kek) == kErrorNone)
if (Tlv::Find<JoinerRouterKekTlv>(aMsg.mMessage, kek) == kErrorNone)
{
LogInfo("Received kek");
src/core/meshcop/joiner_router.hpp
+1 -1
View File
@@ -96,7 +96,7 @@ private:
void HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
DeclareTmfResponseHandlerIn(JoinerRouter, HandleJoinerEntrustResponse);
src/core/meshcop/meshcop_leader.cpp
+16 -22
View File
@@ -49,10 +49,8 @@ Leader::Leader(Instance &aInstance)
{
}
template <> void Leader::HandleTmf<kUriLeaderPetition>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriLeaderPetition>(Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessageInfo);
CommissioningData data;
CommissionerIdTlv::StringType commissionerId;
StateTlv::State state = StateTlv::kReject;
@@ -61,9 +59,9 @@ template <> void Leader::HandleTmf<kUriLeaderPetition>(Coap::Message &aMessage,
VerifyOrExit(Get<Mle::Mle>().IsLeader());
VerifyOrExit(Get<Mle::Mle>().IsRoutingLocator(aMessageInfo.GetPeerAddr()));
VerifyOrExit(Get<Mle::Mle>().IsRoutingLocator(aMsg.mMessageInfo.GetPeerAddr()));
SuccessOrExit(Tlv::Find<CommissionerIdTlv>(aMessage, commissionerId));
SuccessOrExit(Tlv::Find<CommissionerIdTlv>(aMsg.mMessage, commissionerId));
if (mTimer.IsRunning())
{
@@ -71,7 +69,7 @@ template <> void Leader::HandleTmf<kUriLeaderPetition>(Coap::Message &aMessage,
ResignCommissioner();
}
data.Init(aMessageInfo.GetPeerAddr().GetIid().GetLocator(), ++mSessionId);
data.Init(aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator(), ++mSessionId);
SuccessOrExit(Get<NetworkData::Leader>().SetCommissioningData(&data, data.GetLength()));
IgnoreError(StringCopy(mCommissionerId, commissionerId));
@@ -80,17 +78,15 @@ template <> void Leader::HandleTmf<kUriLeaderPetition>(Coap::Message &aMessage,
mTimer.Start(kLeaderPetitionTimeout);
exit:
SendPetitionResponse(aMessage, aMessageInfo, state);
SendPetitionResponse(aMsg, state);
}
void Leader::SendPetitionResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
void Leader::SendPetitionResponse(const Coap::Msg &aMsg, StateTlv::State aState)
{
Error error = kErrorNone;
Coap::Message *message;
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aRequest);
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<StateTlv>(*message, aState));
@@ -105,7 +101,7 @@ void Leader::SendPetitionResponse(const Coap::Message &aRequest,
SuccessOrExit(error = Tlv::Append<CommissionerSessionIdTlv>(*message, mSessionId));
}
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
LogInfo("Sent %s response", UriToString<kUriLeaderPetition>());
@@ -114,7 +110,7 @@ exit:
LogWarnOnError(error, "send petition response");
}
template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(Coap::Msg &aMsg)
{
uint8_t state;
uint16_t sessionId;
@@ -125,9 +121,9 @@ template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(Coap::Message &aMessage,
VerifyOrExit(Get<Mle::Mle>().IsLeader());
SuccessOrExit(Tlv::Find<StateTlv>(aMessage, state));
SuccessOrExit(Tlv::Find<StateTlv>(aMsg.mMessage, state));
SuccessOrExit(Tlv::Find<CommissionerSessionIdTlv>(aMessage, sessionId));
SuccessOrExit(Tlv::Find<CommissionerSessionIdTlv>(aMsg.mMessage, sessionId));
borderAgentLocator = Get<NetworkData::Leader>().FindInCommissioningData<BorderAgentLocatorTlv>();
@@ -142,7 +138,7 @@ template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(Coap::Message &aMessage,
}
else
{
uint16_t rloc = aMessageInfo.GetPeerAddr().GetIid().GetLocator();
uint16_t rloc = aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator();
if (borderAgentLocator->GetBorderAgentLocator() != rloc)
{
@@ -154,25 +150,23 @@ template <> void Leader::HandleTmf<kUriLeaderKeepAlive>(Coap::Message &aMessage,
mTimer.Start(kLeaderPetitionTimeout);
}
SendKeepAliveResponse(aMessage, aMessageInfo, responseState);
SendKeepAliveResponse(aMsg, responseState);
exit:
return;
}
void Leader::SendKeepAliveResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
void Leader::SendKeepAliveResponse(const Coap::Msg &aMsg, StateTlv::State aState)
{
Error error = kErrorNone;
Coap::Message *message;
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aRequest);
message = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Append<StateTlv>(*message, aState));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
LogInfo("Sent %s response", UriToString<kUriLeaderKeepAlive>());
src/core/meshcop/meshcop_leader.hpp
+3 -7
View File
@@ -98,15 +98,11 @@ private:
void HandleTimer(void);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
void SendPetitionResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
void SendPetitionResponse(const Coap::Msg &aMsg, StateTlv::State aState);
void SendKeepAliveResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState);
void SendKeepAliveResponse(const Coap::Msg &aMsg, StateTlv::State aState);
static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
src/core/meshcop/panid_query_client.cpp
+5 -6
View File
@@ -81,23 +81,22 @@ exit:
return error;
}
template <>
void PanIdQueryClient::HandleTmf<kUriPanIdConflict>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void PanIdQueryClient::HandleTmf<kUriPanIdConflict>(Coap::Msg &aMsg)
{
uint16_t panId;
uint32_t mask;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s", UriToString<kUriPanIdConflict>());
SuccessOrExit(Tlv::Find<MeshCoP::PanIdTlv>(aMessage, panId));
SuccessOrExit(Tlv::Find<MeshCoP::PanIdTlv>(aMsg.mMessage, panId));
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMessage, mask));
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMsg.mMessage, mask));
mCallback.InvokeIfSet(panId, mask);
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s response", UriToString<kUriPanIdConflict>());
src/core/meshcop/panid_query_client.hpp
+1 -1
View File
@@ -80,7 +80,7 @@ public:
void *aContext);
private:
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
Callback<otCommissionerPanIdConflictCallback> mCallback;
};
src/core/meshcop/tcat_agent.cpp
+8 -7
View File
@@ -1111,7 +1111,7 @@ void TcatAgent::NotifyStateChange(void)
mState == kStateConnected);
}
template <> void TcatAgent::HandleTmf<kUriTcatEnable>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void TcatAgent::HandleTmf<kUriTcatEnable>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
Coap::Message *message = nullptr;
@@ -1119,13 +1119,14 @@ template <> void TcatAgent::HandleTmf<kUriTcatEnable>(Coap::Message &aMessage, c
uint16_t durationSec = 0;
uint32_t durationMs;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
LogInfo("Received %s from %s", UriToString<kUriTcatEnable>(), aMessageInfo.GetPeerAddr().ToString().AsCString());
message = Get<Tmf::Agent>().NewResponseMessage(aMessage);
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s from %s", UriToString<kUriTcatEnable>(),
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
message = Get<Tmf::Agent>().NewResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr, error = kErrorNoBufs);
SuccessOrExit(error = Tlv::Find<DelayTimerTlv>(aMessage, delayTimerMs));
switch (Tlv::Find<DurationTlv>(aMessage, durationSec))
SuccessOrExit(error = Tlv::Find<DelayTimerTlv>(aMsg.mMessage, delayTimerMs));
switch (Tlv::Find<DurationTlv>(aMsg.mMessage, durationSec))
{
case kErrorNone:
break;
@@ -1149,7 +1150,7 @@ exit:
Tlv::Append<StateTlv>(*message, error == kErrorNone ? StateTlv::State::kAccept : StateTlv::State::kReject);
if (error == kErrorNone)
{
error = Get<Tmf::Agent>().SendMessage(*message, aMessageInfo);
error = Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo);
}
FreeMessageOnError(message, error);
}
src/core/meshcop/tcat_agent.hpp
+1 -1
View File
@@ -414,7 +414,7 @@ public:
*/
bool GetApplicationResponsePending(void) const { return mApplicationResponsePending; }
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
private:
void NotifyApplicationResponseSent(void) { mApplicationResponsePending = false; }
src/core/thread/address_resolver.cpp
+22 -24
View File
@@ -645,8 +645,7 @@ exit:
return error;
}
template <>
void AddressResolver::HandleTmf<kUriAddressNotify>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void AddressResolver::HandleTmf<kUriAddressNotify>(Coap::Msg &aMsg)
{
Ip6::Address target;
Ip6::InterfaceIdentifier meshLocalIid;
@@ -656,13 +655,13 @@ void AddressResolver::HandleTmf<kUriAddressNotify>(Coap::Message &aMessage, cons
CacheEntry *entry;
CacheEntry *prev;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
SuccessOrExit(Tlv::Find<ThreadTargetTlv>(aMessage, target));
SuccessOrExit(Tlv::Find<ThreadMeshLocalEidTlv>(aMessage, meshLocalIid));
SuccessOrExit(Tlv::Find<ThreadRloc16Tlv>(aMessage, rloc16));
SuccessOrExit(Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, target));
SuccessOrExit(Tlv::Find<ThreadMeshLocalEidTlv>(aMsg.mMessage, meshLocalIid));
SuccessOrExit(Tlv::Find<ThreadRloc16Tlv>(aMsg.mMessage, rloc16));
switch (Tlv::Find<ThreadLastTransactionTimeTlv>(aMessage, lastTransactionTime))
switch (Tlv::Find<ThreadLastTransactionTimeTlv>(aMsg.mMessage, lastTransactionTime))
{
case kErrorNone:
break;
@@ -674,7 +673,7 @@ void AddressResolver::HandleTmf<kUriAddressNotify>(Coap::Message &aMessage, cons
}
LogInfo("Received %s from 0x%04x for %s to 0x%04x", UriToString<kUriAddressNotify>(),
aMessageInfo.GetPeerAddr().GetIid().GetLocator(), target.ToString().AsCString(), rloc16);
aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator(), target.ToString().AsCString(), rloc16);
entry = FindCacheEntry(target, list, prev);
VerifyOrExit(entry != nullptr);
@@ -705,7 +704,7 @@ void AddressResolver::HandleTmf<kUriAddressNotify>(Coap::Message &aMessage, cons
LogCacheEntryChange(kEntryUpdated, kReasonReceivedNotification, *entry);
if (Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo) == kErrorNone)
if (Get<Tmf::Agent>().SendEmptyAck(aMsg) == kErrorNone)
{
LogInfo("Sent %s ack", UriToString<kUriAddressNotify>());
}
@@ -757,8 +756,7 @@ exit:
#endif // OPENTHREAD_FTD
template <>
void AddressResolver::HandleTmf<kUriAddressError>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void AddressResolver::HandleTmf<kUriAddressError>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
Ip6::Address target;
@@ -768,20 +766,20 @@ void AddressResolver::HandleTmf<kUriAddressError>(Coap::Message &aMessage, const
Ip6::Address destination;
#endif
VerifyOrExit(aMessage.IsPostRequest(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessage.IsPostRequest(), error = kErrorDrop);
LogInfo("Received %s", UriToString<kUriAddressError>());
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMsg.mMessage.IsConfirmable() && !aMsg.mMessageInfo.GetSockAddr().IsMulticast())
{
if (Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo) == kErrorNone)
if (Get<Tmf::Agent>().SendEmptyAck(aMsg) == kErrorNone)
{
LogInfo("Sent %s ack", UriToString<kUriAddressError>());
}
}
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMessage, target));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMessage, meshLocalIid));
SuccessOrExit(error = Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, target));
SuccessOrExit(error = Tlv::Find<ThreadMeshLocalEidTlv>(aMsg.mMessage, meshLocalIid));
for (Ip6::Netif::UnicastAddress &address : Get<ThreadNetif>().GetUnicastAddresses())
{
@@ -839,23 +837,22 @@ exit:
#if OPENTHREAD_FTD
template <>
void AddressResolver::HandleTmf<kUriAddressQuery>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void AddressResolver::HandleTmf<kUriAddressQuery>(Coap::Msg &aMsg)
{
Ip6::Address target;
uint32_t lastTransactionTime;
VerifyOrExit(aMessage.IsNonConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsNonConfirmablePostRequest());
SuccessOrExit(Tlv::Find<ThreadTargetTlv>(aMessage, target));
SuccessOrExit(Tlv::Find<ThreadTargetTlv>(aMsg.mMessage, target));
LogInfo("Received %s from 0x%04x for target %s", UriToString<kUriAddressQuery>(),
aMessageInfo.GetPeerAddr().GetIid().GetLocator(), target.ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator(), target.ToString().AsCString());
if (Get<ThreadNetif>().HasUnicastAddress(target))
{
SendAddressQueryResponse(target, Get<Mle::Mle>().GetMeshLocalEid().GetIid(), nullptr,
aMessageInfo.GetPeerAddr());
aMsg.mMessageInfo.GetPeerAddr());
ExitNow();
}
@@ -869,7 +866,8 @@ void AddressResolver::HandleTmf<kUriAddressQuery>(Coap::Message &aMessage, const
if (child.HasIp6Address(target))
{
lastTransactionTime = Time::MsecToSec(TimerMilli::GetNow() - child.GetLastHeard());
SendAddressQueryResponse(target, child.GetMeshLocalIid(), &lastTransactionTime, aMessageInfo.GetPeerAddr());
SendAddressQueryResponse(target, child.GetMeshLocalIid(), &lastTransactionTime,
aMsg.mMessageInfo.GetPeerAddr());
ExitNow();
}
}
@@ -877,7 +875,7 @@ void AddressResolver::HandleTmf<kUriAddressQuery>(Coap::Message &aMessage, const
#if OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE
if (Get<BackboneRouter::Local>().IsPrimary() && Get<BackboneRouter::Leader>().IsDomainUnicast(target))
{
uint16_t srcRloc16 = aMessageInfo.GetPeerAddr().GetIid().GetLocator();
uint16_t srcRloc16 = aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator();
LogInfo("Extending %s to %s for target %s rloc16=%04x", UriToString<kUriAddressQuery>(),
UriToString<kUriBackboneQuery>(), target.ToString().AsCString(), srcRloc16);
src/core/thread/address_resolver.hpp
+1 -1
View File
@@ -358,7 +358,7 @@ private:
#endif // OPENTHREAD_FTD
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
#if OPENTHREAD_FTD
src/core/thread/announce_begin_server.cpp
+7 -8
View File
@@ -52,24 +52,23 @@ void AnnounceBeginServer::SendAnnounce(uint32_t aChannelMask, uint8_t aCount, ui
AnnounceSenderBase::SendAnnounce(aCount);
}
template <>
void AnnounceBeginServer::HandleTmf<kUriAnnounceBegin>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void AnnounceBeginServer::HandleTmf<kUriAnnounceBegin>(Coap::Msg &aMsg)
{
uint32_t mask;
uint8_t count;
uint16_t period;
VerifyOrExit(aMessage.IsPostRequest());
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMessage, mask));
VerifyOrExit(aMsg.mMessage.IsPostRequest());
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMsg.mMessage, mask));
SuccessOrExit(Tlv::Find<MeshCoP::CountTlv>(aMessage, count));
SuccessOrExit(Tlv::Find<MeshCoP::PeriodTlv>(aMessage, period));
SuccessOrExit(Tlv::Find<MeshCoP::CountTlv>(aMsg.mMessage, count));
SuccessOrExit(Tlv::Find<MeshCoP::PeriodTlv>(aMsg.mMessage, period));
SendAnnounce(mask, count, period);
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMsg.mMessage.IsConfirmable() && !aMsg.mMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s response", UriToString<kUriAnnounceBegin>());
}
src/core/thread/announce_begin_server.hpp
+1 -1
View File
@@ -71,7 +71,7 @@ private:
static constexpr uint16_t kDefaultPeriod = 1000;
static constexpr uint16_t kDefaultJitter = 0;
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
static void HandleTimer(Timer &aTimer);
};
src/core/thread/anycast_locator.cpp
+4 -5
View File
@@ -109,20 +109,19 @@ exit:
#if OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_SEND_RESPONSE
template <>
void AnycastLocator::HandleTmf<kUriAnycastLocate>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void AnycastLocator::HandleTmf<kUriAnycastLocate>(Coap::Msg &aMsg)
{
Coap::Message *message = nullptr;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
message = Get<Tmf::Agent>().NewResponseMessage(aMessage);
message = Get<Tmf::Agent>().NewResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr);
SuccessOrExit(Tlv::Append<ThreadMeshLocalEidTlv>(*message, Get<Mle::Mle>().GetMeshLocalEid().GetIid()));
SuccessOrExit(Tlv::Append<ThreadRloc16Tlv>(*message, Get<Mle::Mle>().GetRloc16()));
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
message = nullptr;
exit:
src/core/thread/anycast_locator.hpp
+1 -1
View File
@@ -97,7 +97,7 @@ private:
void HandleResponse(Coap::Message *aMessage, const Ip6::MessageInfo *aMessageInfo, Error aError);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
Callback<LocatorCallback> mCallback;
};
src/core/thread/dua_manager.cpp
+4 -7
View File
@@ -571,21 +571,18 @@ exit:
LogInfo("Received %s response: %s", UriToString<kUriDuaRegistrationRequest>(), ErrorToString(error));
}
template <>
void DuaManager::HandleTmf<kUriDuaRegistrationNotify>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void DuaManager::HandleTmf<kUriDuaRegistrationNotify>(Coap::Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessageInfo);
Error error;
VerifyOrExit(aMessage.IsPostRequest(), error = kErrorParse);
VerifyOrExit(aMsg.mMessage.IsPostRequest(), error = kErrorParse);
if (aMessage.IsConfirmable() && Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo) == kErrorNone)
if (aMsg.mMessage.IsConfirmable() && Get<Tmf::Agent>().SendEmptyAck(aMsg) == kErrorNone)
{
LogInfo("Sent %s ack", UriToString<kUriDuaRegistrationNotify>());
}
error = ProcessDuaResponse(aMessage);
error = ProcessDuaResponse(aMsg.mMessage);
exit:
OT_UNUSED_VARIABLE(error);
src/core/thread/dua_manager.hpp
+1 -1
View File
@@ -221,7 +221,7 @@ private:
DeclareTmfResponseHandlerIn(DuaManager, HandleDuaResponse);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
Error ProcessDuaResponse(Coap::Message &aMessage);
src/core/thread/energy_scan_server.cpp
+9 -10
View File
@@ -50,8 +50,7 @@ EnergyScanServer::EnergyScanServer(Instance &aInstance)
{
}
template <>
void EnergyScanServer::HandleTmf<kUriEnergyScan>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void EnergyScanServer::HandleTmf<kUriEnergyScan>(Coap::Msg &aMsg)
{
uint8_t count;
uint16_t period;
@@ -59,15 +58,15 @@ void EnergyScanServer::HandleTmf<kUriEnergyScan>(Coap::Message &aMessage, const
uint32_t mask;
MeshCoP::Tlv tlv;
VerifyOrExit(aMessage.IsPostRequest());
VerifyOrExit(aMsg.mMessage.IsPostRequest());
SuccessOrExit(Tlv::Find<MeshCoP::CountTlv>(aMessage, count));
SuccessOrExit(Tlv::Find<MeshCoP::CountTlv>(aMsg.mMessage, count));
count = Clamp(count, kMinCount, kMaxCount);
SuccessOrExit(Tlv::Find<MeshCoP::PeriodTlv>(aMessage, period));
SuccessOrExit(Tlv::Find<MeshCoP::ScanDurationTlv>(aMessage, scanDuration));
SuccessOrExit(Tlv::Find<MeshCoP::PeriodTlv>(aMsg.mMessage, period));
SuccessOrExit(Tlv::Find<MeshCoP::ScanDurationTlv>(aMsg.mMessage, scanDuration));
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMessage, mask));
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMsg.mMessage, mask));
VerifyOrExit(mask != 0);
mReportMessage.Reset(Get<Tmf::Agent>().NewPriorityConfirmablePostMessage(kUriEnergyReport));
@@ -86,11 +85,11 @@ void EnergyScanServer::HandleTmf<kUriEnergyScan>(Coap::Message &aMessage, const
mScanDuration = scanDuration;
mTimer.Start(kScanDelay);
mCommissioner = aMessageInfo.GetPeerAddr();
mCommissioner = aMsg.mMessageInfo.GetPeerAddr();
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMsg.mMessage.IsConfirmable() && !aMsg.mMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s ack", UriToString<kUriEnergyScan>());
}
src/core/thread/energy_scan_server.hpp
+1 -1
View File
@@ -69,7 +69,7 @@ private:
static constexpr uint8_t kMinCount = 1;
static constexpr uint8_t kMaxCount = 3;
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
static void HandleScanResult(Mac::EnergyScanResult *aResult, void *aContext);
void HandleScanResult(Mac::EnergyScanResult *aResult);
src/core/thread/mle.hpp
+1 -1
View File
@@ -2416,7 +2416,7 @@ private:
void HandleAdvertiseTrickleTimer(void);
void HandleTimeTick(void);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
DeclareTmfResponseHandlerFullParamIn(Mle, HandleAddressSolicitResponse);
src/core/thread/mle_ftd.cpp
+15 -15
View File
@@ -3568,22 +3568,22 @@ exit:
return;
}
template <> void Mle::HandleTmf<kUriAddressSolicit>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Mle::HandleTmf<kUriAddressSolicit>(Coap::Msg &aMsg)
{
Coap::Message *response = nullptr;
AddrSolicitInfo info;
VerifyOrExit(IsLeader() && !IsAttaching());
Log(kMessageReceive, kTypeAddressSolicit, aMessageInfo.GetPeerAddr());
Log(kMessageReceive, kTypeAddressSolicit, aMsg.mMessageInfo.GetPeerAddr());
SuccessOrExit(info.ParseFrom(aMessage));
SuccessOrExit(info.ParseFrom(aMsg.mMessage));
ProcessAddressSolicit(info);
// Prepare and send response
response = Get<Tmf::Agent>().NewPriorityResponseMessage(aMessage);
response = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(response != nullptr);
SuccessOrExit(Tlv::Append<ThreadStatusTlv>(*response, info.mResponse));
@@ -3601,10 +3601,10 @@ template <> void Mle::HandleTmf<kUriAddressSolicit>(Coap::Message &aMessage, con
SuccessOrExit(routerMaskTlv.AppendTo(*response));
}
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*response, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*response, aMsg.mMessageInfo));
response = nullptr;
Log(kMessageSend, kTypeAddressReply, aMessageInfo.GetPeerAddr());
Log(kMessageSend, kTypeAddressReply, aMsg.mMessageInfo.GetPeerAddr());
// If assigning a new RLOC16 (e.g., on promotion of a child to
// router role) we clear any address cache entries associated
@@ -3617,8 +3617,8 @@ template <> void Mle::HandleTmf<kUriAddressSolicit>(Coap::Message &aMessage, con
{
uint16_t oldRloc16;
VerifyOrExit(IsRoutingLocator(aMessageInfo.GetPeerAddr()));
oldRloc16 = aMessageInfo.GetPeerAddr().GetIid().GetLocator();
VerifyOrExit(IsRoutingLocator(aMsg.mMessageInfo.GetPeerAddr()));
oldRloc16 = aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator();
VerifyOrExit(oldRloc16 != info.mRouter->GetRloc16());
VerifyOrExit(!RouterIdMatch(oldRloc16, GetRloc16()));
@@ -3629,7 +3629,7 @@ exit:
FreeMessage(response);
}
template <> void Mle::HandleTmf<kUriAddressRelease>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Mle::HandleTmf<kUriAddressRelease>(Coap::Msg &aMsg)
{
uint16_t rloc16;
Mac::ExtAddress extAddress;
@@ -3638,12 +3638,12 @@ template <> void Mle::HandleTmf<kUriAddressRelease>(Coap::Message &aMessage, con
VerifyOrExit(mRole == kRoleLeader);
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
Log(kMessageReceive, kTypeAddressRelease, aMessageInfo.GetPeerAddr());
Log(kMessageReceive, kTypeAddressRelease, aMsg.mMessageInfo.GetPeerAddr());
SuccessOrExit(Tlv::Find<ThreadRloc16Tlv>(aMessage, rloc16));
SuccessOrExit(Tlv::Find<ThreadExtMacAddressTlv>(aMessage, extAddress));
SuccessOrExit(Tlv::Find<ThreadRloc16Tlv>(aMsg.mMessage, rloc16));
SuccessOrExit(Tlv::Find<ThreadExtMacAddressTlv>(aMsg.mMessage, extAddress));
routerId = RouterIdFromRloc16(rloc16);
router = mRouterTable.FindRouterById(routerId);
@@ -3652,9 +3652,9 @@ template <> void Mle::HandleTmf<kUriAddressRelease>(Coap::Message &aMessage, con
IgnoreError(mRouterTable.Release(routerId));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
Log(kMessageSend, kTypeAddressReleaseReply, aMessageInfo.GetPeerAddr());
Log(kMessageSend, kTypeAddressReleaseReply, aMsg.mMessageInfo.GetPeerAddr());
exit:
return;
src/core/thread/network_data_leader.hpp
+2 -4
View File
@@ -544,7 +544,7 @@ private:
#endif
};
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
void HandleTimer(void);
@@ -617,9 +617,7 @@ private:
Error UpdateCommissioningData(uint16_t aDataLength, CommissioningDataTlv *&aDataTlv);
Error SetCommissioningData(const Message &aMessage);
void SendCommissioningSetResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
MeshCoP::StateTlv::State aState);
void SendCommissioningSetResponse(const Coap::Msg &aMsg, MeshCoP::StateTlv::State aState);
void IncrementVersions(bool aIncludeStable);
void IncrementVersions(const ChangedFlags &aFlags);
src/core/thread/network_data_leader_ftd.cpp
+19 -21
View File
@@ -219,7 +219,7 @@ void Leader::RemoveBorderRouter(uint16_t aRloc16, MatchMode aMatchMode)
IncrementVersions(flags);
}
template <> void Leader::HandleTmf<kUriServerData>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriServerData>(Coap::Msg &aMsg)
{
ThreadNetworkDataTlv networkDataTlv;
uint16_t rloc16;
@@ -228,9 +228,9 @@ template <> void Leader::HandleTmf<kUriServerData>(Coap::Message &aMessage, cons
LogInfo("Received %s", UriToString<kUriServerData>());
VerifyOrExit(aMessageInfo.GetPeerAddr().GetIid().IsRoutingLocator());
VerifyOrExit(aMsg.mMessageInfo.GetPeerAddr().GetIid().IsRoutingLocator());
switch (Tlv::Find<ThreadRloc16Tlv>(aMessage, rloc16))
switch (Tlv::Find<ThreadRloc16Tlv>(aMsg.mMessage, rloc16))
{
case kErrorNone:
RemoveBorderRouter(rloc16, kMatchModeRloc16);
@@ -241,18 +241,18 @@ template <> void Leader::HandleTmf<kUriServerData>(Coap::Message &aMessage, cons
ExitNow();
}
if (Tlv::FindTlv(aMessage, networkDataTlv) == kErrorNone)
if (Tlv::FindTlv(aMsg.mMessage, networkDataTlv) == kErrorNone)
{
VerifyOrExit(networkDataTlv.IsValid());
{
NetworkData networkData(GetInstance(), networkDataTlv.GetTlvs(), networkDataTlv.GetLength());
RegisterNetworkData(aMessageInfo.GetPeerAddr().GetIid().GetLocator(), networkData);
RegisterNetworkData(aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator(), networkData);
}
}
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s ack", UriToString<kUriServerData>());
@@ -260,7 +260,7 @@ exit:
return;
}
template <> void Leader::HandleTmf<kUriCommissionerSet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriCommissionerSet>(Coap::Msg &aMsg)
{
MeshCoP::StateTlv::State state = MeshCoP::StateTlv::kReject;
uint16_t borderAgentRloc;
@@ -272,9 +272,9 @@ template <> void Leader::HandleTmf<kUriCommissionerSet>(Coap::Message &aMessage,
// Validate that there is no Border Agent Locator TLV. This also
// validates that all included TLVs are properly formatted.
VerifyOrExit(Tlv::Find<MeshCoP::BorderAgentLocatorTlv>(aMessage, borderAgentRloc) == kErrorNotFound);
VerifyOrExit(Tlv::Find<MeshCoP::BorderAgentLocatorTlv>(aMsg.mMessage, borderAgentRloc) == kErrorNotFound);
SuccessOrExit(Tlv::Find<MeshCoP::CommissionerSessionIdTlv>(aMessage, sessionId));
SuccessOrExit(Tlv::Find<MeshCoP::CommissionerSessionIdTlv>(aMsg.mMessage, sessionId));
if (FindCommissioningSessionId(localSessionId) == kErrorNone)
{
@@ -285,49 +285,47 @@ template <> void Leader::HandleTmf<kUriCommissionerSet>(Coap::Message &aMessage,
if (FindBorderAgentRloc(borderAgentRloc) == kErrorNone)
{
SuccessOrExit(Tlv::Append<MeshCoP::BorderAgentLocatorTlv>(aMessage, borderAgentRloc));
SuccessOrExit(Tlv::Append<MeshCoP::BorderAgentLocatorTlv>(aMsg.mMessage, borderAgentRloc));
}
SuccessOrExit(SetCommissioningData(aMessage));
SuccessOrExit(SetCommissioningData(aMsg.mMessage));
state = MeshCoP::StateTlv::kAccept;
exit:
if (Get<Mle::Mle>().IsLeader())
{
SendCommissioningSetResponse(aMessage, aMessageInfo, state);
SendCommissioningSetResponse(aMsg, state);
}
}
template <> void Leader::HandleTmf<kUriCommissionerGet>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Leader::HandleTmf<kUriCommissionerGet>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
Coap::Message *response = nullptr;
VerifyOrExit(Get<Mle::Mle>().IsLeader() && !mWaitingForNetDataSync, error = kErrorInvalidState);
response = ProcessCommissionerGetRequest(aMessage);
response = ProcessCommissionerGetRequest(aMsg.mMessage);
VerifyOrExit(response != nullptr, error = kErrorParse);
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMessageInfo));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMsg.mMessageInfo));
LogInfo("Sent %s response to %s", UriToString<kUriCommissionerGet>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
exit:
LogWarnOnError(error, "send CommissionerGet response");
FreeMessageOnError(response, error);
}
void Leader::SendCommissioningSetResponse(const Coap::Message &aRequest,
const Ip6::MessageInfo &aMessageInfo,
MeshCoP::StateTlv::State aState)
void Leader::SendCommissioningSetResponse(const Coap::Msg &aMsg, MeshCoP::StateTlv::State aState)
{
Coap::Message *message = Get<Tmf::Agent>().NewPriorityResponseMessage(aRequest);
Coap::Message *message = Get<Tmf::Agent>().NewPriorityResponseMessage(aMsg.mMessage);
VerifyOrExit(message != nullptr);
SuccessOrExit(Tlv::Append<MeshCoP::StateTlv>(*message, aState));
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*message, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendMessage(*message, aMsg.mMessageInfo));
message = nullptr; // `SendMessage` takes ownership on success
LogInfo("Sent %s response", UriToString<kUriCommissionerSet>());
src/core/thread/network_diagnostic.cpp
+27 -30
View File
@@ -613,24 +613,23 @@ exit:
return error;
}
template <>
void Server::HandleTmf<kUriDiagnosticGetQuery>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Server::HandleTmf<kUriDiagnosticGetQuery>(Coap::Msg &aMsg)
{
VerifyOrExit(aMessage.IsPostRequest());
VerifyOrExit(aMsg.mMessage.IsPostRequest());
LogInfo("Received %s from %s", UriToString<kUriDiagnosticGetQuery>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
// DIAG_GET.qry may be sent as a confirmable request.
if (aMessage.IsConfirmable())
if (aMsg.mMessage.IsConfirmable())
{
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg));
}
#if OPENTHREAD_MTD
SendAnswer(aMessageInfo.GetPeerAddr(), aMessage);
SendAnswer(aMsg.mMessageInfo.GetPeerAddr(), aMsg.mMessage);
#elif OPENTHREAD_FTD
PrepareAndSendAnswers(aMessageInfo.GetPeerAddr(), aMessage);
PrepareAndSendAnswers(aMsg.mMessageInfo.GetPeerAddr(), aMsg.mMessage);
#endif
exit:
@@ -980,48 +979,47 @@ exit:
#endif // OPENTHREAD_FTD
template <>
void Server::HandleTmf<kUriDiagnosticGetRequest>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Server::HandleTmf<kUriDiagnosticGetRequest>(Coap::Msg &aMsg)
{
Error error = kErrorNone;
Coap::Message *response = nullptr;
VerifyOrExit(aMessage.IsConfirmablePostRequest(), error = kErrorDrop);
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest(), error = kErrorDrop);
LogInfo("Received %s from %s", UriToString<kUriDiagnosticGetRequest>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
response = Get<Tmf::Agent>().NewResponseMessage(aMessage);
response = Get<Tmf::Agent>().NewResponseMessage(aMsg.mMessage);
VerifyOrExit(response != nullptr, error = kErrorNoBufs);
IgnoreError(response->SetPriority(aMessage.GetPriority()));
SuccessOrExit(error = AppendRequestedTlvs(aMessage, *response));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMessageInfo));
IgnoreError(response->SetPriority(aMsg.mMessage.GetPriority()));
SuccessOrExit(error = AppendRequestedTlvs(aMsg.mMessage, *response));
SuccessOrExit(error = Get<Tmf::Agent>().SendMessage(*response, aMsg.mMessageInfo));
exit:
FreeMessageOnError(response, error);
}
template <> void Server::HandleTmf<kUriDiagnosticReset>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Server::HandleTmf<kUriDiagnosticReset>(Coap::Msg &aMsg)
{
uint16_t offset = 0;
uint8_t type;
Tlv tlv;
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s from %s", UriToString<kUriDiagnosticReset>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
SuccessOrExit(aMessage.Read(aMessage.GetOffset(), tlv));
SuccessOrExit(aMsg.mMessage.Read(aMsg.mMessage.GetOffset(), tlv));
VerifyOrExit(tlv.GetType() == Tlv::kTypeList);
offset = aMessage.GetOffset() + sizeof(Tlv);
offset = aMsg.mMessage.GetOffset() + sizeof(Tlv);
for (uint8_t i = 0; i < tlv.GetLength(); i++)
{
SuccessOrExit(aMessage.Read(offset + i, type));
SuccessOrExit(aMsg.mMessage.Read(offset + i, type));
switch (type)
{
@@ -1042,7 +1040,7 @@ template <> void Server::HandleTmf<kUriDiagnosticReset>(Coap::Message &aMessage,
}
}
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg));
exit:
return;
@@ -1145,23 +1143,22 @@ exit:
mGetCallback.InvokeIfSet(aResult, aMessage, aMessageInfo);
}
template <>
void Client::HandleTmf<kUriDiagnosticGetAnswer>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Client::HandleTmf<kUriDiagnosticGetAnswer>(Coap::Msg &aMsg)
{
VerifyOrExit(aMessage.IsConfirmablePostRequest());
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
LogInfo("Received %s from %s", ot::UriToString<kUriDiagnosticGetAnswer>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
#if OPENTHREAD_CONFIG_MESH_DIAG_ENABLE && OPENTHREAD_FTD
// Let the `MeshDiag` process the message first.
if (!Get<Utils::MeshDiag>().HandleDiagnosticGetAnswer(aMessage, aMessageInfo))
if (!Get<Utils::MeshDiag>().HandleDiagnosticGetAnswer(aMsg.mMessage, aMsg.mMessageInfo))
#endif
{
mGetCallback.InvokeIfSet(kErrorNone, &aMessage, &aMessageInfo);
mGetCallback.InvokeIfSet(kErrorNone, &aMsg.mMessage, &aMsg.mMessageInfo);
}
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg));
exit:
return;
src/core/thread/network_diagnostic.hpp
+2 -2
View File
@@ -270,7 +270,7 @@ private:
Error AppendBrPrefixTlv(uint8_t aTlvType, Message &aMessage);
#endif
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
#if OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE
VendorNameTlv::StringType mVendorName;
@@ -374,7 +374,7 @@ private:
DeclareTmfResponseHandlerFullParamIn(Client, HandleGetResponse);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
static void ParseIp6AddrList(Ip6AddrList &aIp6Addrs, const Message &aMessage, OffsetRange aOffsetRange);
static void ParseMacCounters(const MacCountersTlv &aMacCountersTlv, MacCounters &aMacCounters);
src/core/thread/panid_query_server.cpp
+7 -8
View File
@@ -47,25 +47,24 @@ PanIdQueryServer::PanIdQueryServer(Instance &aInstance)
{
}
template <>
void PanIdQueryServer::HandleTmf<kUriPanIdQuery>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void PanIdQueryServer::HandleTmf<kUriPanIdQuery>(Coap::Msg &aMsg)
{
uint16_t panId;
uint32_t mask;
VerifyOrExit(aMessage.IsPostRequest());
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMessage, mask));
VerifyOrExit(aMsg.mMessage.IsPostRequest());
SuccessOrExit(MeshCoP::ChannelMaskTlv::FindIn(aMsg.mMessage, mask));
SuccessOrExit(Tlv::Find<MeshCoP::PanIdTlv>(aMessage, panId));
SuccessOrExit(Tlv::Find<MeshCoP::PanIdTlv>(aMsg.mMessage, panId));
mChannelMask = mask;
mCommissioner = aMessageInfo.GetPeerAddr();
mCommissioner = aMsg.mMessageInfo.GetPeerAddr();
mPanId = panId;
mTimer.Start(kScanDelay);
if (aMessage.IsConfirmable() && !aMessageInfo.GetSockAddr().IsMulticast())
if (aMsg.mMessage.IsConfirmable() && !aMsg.mMessageInfo.GetSockAddr().IsMulticast())
{
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
SuccessOrExit(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Sent %s ack", UriToString<kUriPanIdQuery>());
}
src/core/thread/panid_query_server.hpp
+1 -1
View File
@@ -62,7 +62,7 @@ public:
private:
static constexpr uint32_t kScanDelay = 1000; ///< SCAN_DELAY (in msec)
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
static void HandleScanResult(Mac::ActiveScanResult *aScanResult, void *aContext);
void HandleScanResult(Mac::ActiveScanResult *aScanResult);
src/core/thread/tmf.cpp
+14 -21
View File
@@ -85,35 +85,31 @@ Agent::Agent(Instance &aInstance)
Error Agent::Start(void) { return Coap::Start(kUdpPort, Ip6::kNetifThreadInternal); }
template <> void Agent::HandleTmf<kUriRelayRx>(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Agent::HandleTmf<kUriRelayRx>(Msg &aMsg)
{
OT_UNUSED_VARIABLE(aMessage);
OT_UNUSED_VARIABLE(aMessageInfo);
OT_UNUSED_VARIABLE(aMsg);
#if (OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE)
Get<MeshCoP::Commissioner>().HandleTmf<kUriRelayRx>(aMessage, aMessageInfo);
Get<MeshCoP::Commissioner>().HandleTmf<kUriRelayRx>(aMsg);
#endif
#if OPENTHREAD_CONFIG_BORDER_AGENT_ENABLE
Get<MeshCoP::BorderAgent::Manager>().HandleTmf<kUriRelayRx>(aMessage, aMessageInfo);
Get<MeshCoP::BorderAgent::Manager>().HandleTmf<kUriRelayRx>(aMsg);
#endif
}
bool Agent::HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool Agent::HandleResource(CoapBase &aCoapBase, const char *aUriPath, Msg &aMsg)
{
return static_cast<Agent &>(aCoapBase).HandleResource(aUriPath, aMessage, aMessageInfo);
return static_cast<Agent &>(aCoapBase).HandleResource(aUriPath, aMsg);
}
bool Agent::HandleResource(const char *aUriPath, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
bool Agent::HandleResource(const char *aUriPath, Msg &aMsg)
{
bool didHandle = true;
Uri uri = UriFromPath(aUriPath);
#define Case(kUri, Type) \
case kUri: \
Get<Type>().HandleTmf<kUri>(aMessage, aMessageInfo); \
#define Case(kUri, Type) \
case kUri: \
Get<Type>().HandleTmf<kUri>(aMsg); \
break
switch (uri)
@@ -307,22 +303,19 @@ Coap::SecureSession *SecureAgent::HandleDtlsAccept(void)
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
bool SecureAgent::HandleResource(CoapBase &aCoapBase,
const char *aUriPath,
Message &aMessage,
const Ip6::MessageInfo &aMessageInfo)
bool SecureAgent::HandleResource(CoapBase &aCoapBase, const char *aUriPath, Msg &aMsg)
{
return static_cast<SecureAgent &>(aCoapBase).HandleResource(aUriPath, aMessage, aMessageInfo);
return static_cast<SecureAgent &>(aCoapBase).HandleResource(aUriPath, aMsg);
}
bool SecureAgent::HandleResource(const char *aUriPath, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
bool SecureAgent::HandleResource(const char *aUriPath, Msg &aMsg)
{
bool didHandle = false;
Uri uri = UriFromPath(aUriPath);
if (uri == kUriJoinerFinalize)
{
Get<MeshCoP::Commissioner>().HandleTmf<kUriJoinerFinalize>(aMessage, aMessageInfo);
Get<MeshCoP::Commissioner>().HandleTmf<kUriJoinerFinalize>(aMsg);
didHandle = true;
}
src/core/thread/tmf.hpp
+8 -14
View File
@@ -49,13 +49,12 @@ namespace Tmf {
*
* The class `Type` MUST declare a template method of the following format:
*
* template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
* template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
*
* @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)
#define DeclareTmfHandler(Type, kUri) template <> void Type::HandleTmf<kUri>(Coap::Msg & aMsg)
/**
* Declares a TMF/CoAP response handler method in a given class `Type`.
@@ -106,6 +105,7 @@ namespace Tmf {
constexpr uint16_t kUdpPort = 61631; ///< TMF UDP Port
typedef Coap::Message Message; ///< A TMF message.
typedef Coap::Msg Msg; ///< A TMF message along with its `Ip6::MessageInfo`.
/**
* Represents message information for a TMF message.
@@ -228,13 +228,10 @@ public:
static Message::Priority DscpToPriority(uint8_t aDscp);
private:
template <Uri kUri> void HandleTmf(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Msg &aMsg);
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 bool HandleResource(CoapBase &aCoapBase, const char *aUriPath, Msg &aMsg);
bool HandleResource(const char *aUriPath, Msg &aMsg);
static Error Filter(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, void *aContext);
};
@@ -259,11 +256,8 @@ private:
Coap::SecureSession *HandleDtlsAccept(void);
#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
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 bool HandleResource(CoapBase &aCoapBase, const char *aUriPath, Msg &aMsg);
bool HandleResource(const char *aUriPath, Msg &aMsg);
#endif
};
src/core/utils/history_tracker_client.cpp
+11 -11
View File
@@ -112,20 +112,20 @@ exit:
return error;
}
template <> void Client::HandleTmf<kUriHistoryAnswer>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Client::HandleTmf<kUriHistoryAnswer>(Coap::Msg &aMsg)
{
VerifyOrExit(aMessage.IsConfirmablePostRequest());
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
VerifyOrExit(aMsg.mMessage.IsConfirmablePostRequest());
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg));
LogInfo("Received %s from %s", ot::UriToString<kUriHistoryAnswer>(),
aMessageInfo.GetPeerAddr().ToString().AsCString());
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
SuccessOrExit(ProcessAnswer(aMessage, aMessageInfo));
SuccessOrExit(ProcessAnswer(aMsg));
switch (mTlvType)
{
case Tlv::kNetworkInfo:
ProcessNetInfoAnswer(aMessage);
ProcessNetInfoAnswer(aMsg.mMessage);
break;
default:
ExitNow();
@@ -135,20 +135,20 @@ exit:
return;
}
Error Client::ProcessAnswer(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
Error Client::ProcessAnswer(const Coap::Msg &aMsg)
{
Error error = kErrorFailed;
AnswerTlv answerTlv;
uint16_t queryId;
VerifyOrExit(mActive);
VerifyOrExit(Get<Mle::Mle>().IsRoutingLocator(aMessageInfo.GetPeerAddr()));
VerifyOrExit(aMessageInfo.GetPeerAddr().GetIid().GetLocator() == mQueryRloc16);
VerifyOrExit(Get<Mle::Mle>().IsRoutingLocator(aMsg.mMessageInfo.GetPeerAddr()));
VerifyOrExit(aMsg.mMessageInfo.GetPeerAddr().GetIid().GetLocator() == mQueryRloc16);
SuccessOrExit(Tlv::Find<QueryIdTlv>(aMessage, queryId));
SuccessOrExit(Tlv::Find<QueryIdTlv>(aMsg.mMessage, queryId));
VerifyOrExit(queryId == mQueryId);
SuccessOrExit(Tlv::FindTlv(aMessage, answerTlv));
SuccessOrExit(Tlv::FindTlv(aMsg.mMessage, answerTlv));
if (answerTlv.GetIndex() != mAnswerIndex)
{
src/core/utils/history_tracker_client.hpp
+2 -2
View File
@@ -102,12 +102,12 @@ private:
static constexpr uint16_t kResponseTimeout = 5000;
Error SendQuery(Tlv::Type aTlvType, uint16_t aMaxEntries, uint32_t aMaxEntryAge, uint16_t aRloc16);
Error ProcessAnswer(const Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
Error ProcessAnswer(const Coap::Msg &aMsg);
void ProcessNetInfoAnswer(const Coap::Message &aMessage);
void Finalize(Error aError);
void HandleTimer(void);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
union Callbacks
{
src/core/utils/history_tracker_server.cpp
+7 -6
View File
@@ -47,18 +47,19 @@ Server::Server(Instance &aInstance)
{
}
template <> void Server::HandleTmf<kUriHistoryQuery>(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
template <> void Server::HandleTmf<kUriHistoryQuery>(Coap::Msg &aMsg)
{
VerifyOrExit(aMessage.IsPostRequest());
VerifyOrExit(aMsg.mMessage.IsPostRequest());
LogInfo("Received %s from %s", UriToString<kUriHistoryQuery>(), aMessageInfo.GetPeerAddr().ToString().AsCString());
LogInfo("Received %s from %s", UriToString<kUriHistoryQuery>(),
aMsg.mMessageInfo.GetPeerAddr().ToString().AsCString());
if (aMessage.IsConfirmable())
if (aMsg.mMessage.IsConfirmable())
{
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMessage, aMessageInfo));
IgnoreError(Get<Tmf::Agent>().SendEmptyAck(aMsg));
}
PrepareAndSendAnswers(aMessageInfo.GetPeerAddr(), aMessage);
PrepareAndSendAnswers(aMsg.mMessageInfo.GetPeerAddr(), aMsg.mMessage);
exit:
return;
src/core/utils/history_tracker_server.hpp
+1 -1
View File
@@ -100,7 +100,7 @@ private:
const Ip6::MessageInfo *aMessageInfo,
Error aResult);
template <Uri kUri> void HandleTmf(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
template <Uri kUri> void HandleTmf(Coap::Msg &aMsg);
Coap::MessageQueue mAnswerQueue;
};