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

[ip6] simplify PassToHost() to directly use Ip6::Header (#10542)

Browse Source 
This commit updates `PassToHost()` to directly use the `Ip6::Header`
and its `GetSource()` and `GetDestination()` methods when applying
filter rules. This replaces the previous model where a `MessageInfo`
was constructed from the received IPv6 header and passed to
`PassToHost()`. The previous model indirectly assumed that the
message was received, with the `MessageInfo` sock/peer addresses
mapped accordingly. However, `HandleDatagram()` can also process
messages originating from the device itself, where the notion of peer
and sock addresses would be reversed. Using `Ip6::Header` directly
makes the rules clearer and simplifies the logic of `PassToHost()`.

Additionally, this change simplifies the code by moving the
construction of `MessageInfo` to the `Receive()` method, where the
message is received.
This commit is contained in:
Abtin Keshavarzian
2024-07-30 10:53:49 -07:00
committed by GitHub
parent 0df96d8dad
commit c6da03c378
4 changed files with 46 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/net/icmp6.cpp
+5 -5
View File
@@ -153,7 +153,7 @@ exit:
return error;
}
bool Icmp::ShouldHandleEchoRequest(const MessageInfo &aMessageInfo)
bool Icmp::ShouldHandleEchoRequest(const Address &aAddress)
{
bool rval = false;
@@ -163,16 +163,16 @@ bool Icmp::ShouldHandleEchoRequest(const MessageInfo &aMessageInfo)
rval = false;
break;
case OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY:
rval = !aMessageInfo.GetSockAddr().IsMulticast();
rval = !aAddress.IsMulticast();
break;
case OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY:
rval = aMessageInfo.GetSockAddr().IsMulticast();
rval = aAddress.IsMulticast();
break;
case OT_ICMP6_ECHO_HANDLER_ALL:
rval = true;
break;
case OT_ICMP6_ECHO_HANDLER_RLOC_ALOC_ONLY:
rval = aMessageInfo.GetSockAddr().GetIid().IsLocator();
rval = aAddress.GetIid().IsLocator();
break;
}
@@ -187,7 +187,7 @@ Error Icmp::HandleEchoRequest(Message &aRequestMessage, const MessageInfo &aMess
MessageInfo replyMessageInfo;
uint16_t dataOffset;
VerifyOrExit(ShouldHandleEchoRequest(aMessageInfo));
VerifyOrExit(ShouldHandleEchoRequest(aMessageInfo.GetSockAddr()));
LogInfo("Received Echo Request");
src/core/net/icmp6.hpp
+3 -1
View File
@@ -331,11 +331,13 @@ public:
/**
* Indicates whether or not the ICMPv6 Echo Request should be handled.
*
* @param[in] aAddress The ICMPv6 destination IPv6 address.
*
* @retval TRUE if OpenThread should respond with an ICMPv6 Echo Reply.
* @retval FALSE if OpenThread should not respond with an ICMPv6 Echo Reply.
*
*/
bool ShouldHandleEchoRequest(const MessageInfo &aMessageInfo);
bool ShouldHandleEchoRequest(const Address &aAddress);
/**
* Returns the ICMPv6 Echo sequence number.
src/core/net/ip6.cpp
+31 -39
View File
@@ -526,7 +526,7 @@ exit:
return error;
}
Error Ip6::HandleOptions(Message &aMessage, Header &aHeader, bool &aReceive)
Error Ip6::HandleOptions(Message &aMessage, const Header &aHeader, bool &aReceive)
{
Error error = kErrorNone;
HopByHopHeader hbhHeader;
@@ -824,8 +824,7 @@ exit:
#endif // OPENTHREAD_CONFIG_IP6_FRAGMENTATION_ENABLE
Error Ip6::HandleExtensionHeaders(OwnedPtr<Message> &aMessagePtr,
MessageInfo &aMessageInfo,
Header &aHeader,
const Header &aHeader,
uint8_t &aNextHeader,
bool &aReceive)
{
@@ -844,7 +843,7 @@ Error Ip6::HandleExtensionHeaders(OwnedPtr<Message> &aMessagePtr,
break;
case kProtoFragment:
IgnoreError(PassToHost(aMessagePtr, aMessageInfo, aNextHeader,
IgnoreError(PassToHost(aMessagePtr, aHeader, aNextHeader,
/* aApplyFilter */ false, aReceive, Message::kCopyToUse));
SuccessOrExit(error = HandleFragment(*aMessagePtr));
break;
@@ -889,18 +888,20 @@ Error Ip6::TakeOrCopyMessagePtr(OwnedPtr<Message> &aTargetPtr,
return (aTargetPtr != nullptr) ? kErrorNone : kErrorNoBufs;
}
Error Ip6::HandlePayload(Header &aIp6Header,
OwnedPtr<Message> &aMessagePtr,
MessageInfo &aMessageInfo,
uint8_t aIpProto,
Message::Ownership aMessageOwnership)
Error Ip6::Receive(Header &aIp6Header,
OwnedPtr<Message> &aMessagePtr,
uint8_t aIpProto,
Message::Ownership aMessageOwnership)
{
#if !OPENTHREAD_CONFIG_TCP_ENABLE
OT_UNUSED_VARIABLE(aIp6Header);
#endif
Error error = kErrorNone;
OwnedPtr<Message> messagePtr;
MessageInfo messageInfo;
messageInfo.Clear();
messageInfo.SetPeerAddr(aIp6Header.GetSource());
messageInfo.SetSockAddr(aIp6Header.GetDestination());
messageInfo.SetHopLimit(aIp6Header.GetHopLimit());
messageInfo.SetEcn(aIp6Header.GetEcn());
switch (aIpProto)
{
@@ -921,15 +922,15 @@ Error Ip6::HandlePayload(Header &aIp6Header,
{
#if OPENTHREAD_CONFIG_TCP_ENABLE
case kProtoTcp:
error = mTcp.HandleMessage(aIp6Header, *messagePtr, aMessageInfo);
error = mTcp.HandleMessage(aIp6Header, *messagePtr, messageInfo);
break;
#endif
case kProtoUdp:
error = mUdp.HandleMessage(*messagePtr, aMessageInfo);
error = mUdp.HandleMessage(*messagePtr, messageInfo);
break;
case kProtoIcmp6:
error = mIcmp.HandleMessage(*messagePtr, aMessageInfo);
error = mIcmp.HandleMessage(*messagePtr, messageInfo);
break;
default:
@@ -942,7 +943,7 @@ exit:
}
Error Ip6::PassToHost(OwnedPtr<Message> &aMessagePtr,
const MessageInfo &aMessageInfo,
const Header &aHeader,
uint8_t aIpProto,
bool aApplyFilter,
bool aReceive,
@@ -965,7 +966,7 @@ Error Ip6::PassToHost(OwnedPtr<Message> &aMessagePtr,
// If the sender used mesh-local address as source, do not pass to
// host unless this message is intended for this device itself.
if (Get<Mle::Mle>().IsMeshLocalAddress(aMessageInfo.GetPeerAddr()))
if (Get<Mle::Mle>().IsMeshLocalAddress(aHeader.GetSource()))
{
VerifyOrExit(aReceive, error = kErrorDrop);
}
@@ -975,7 +976,7 @@ Error Ip6::PassToHost(OwnedPtr<Message> &aMessagePtr,
switch (aIpProto)
{
case kProtoIcmp6:
if (mIcmp.ShouldHandleEchoRequest(aMessageInfo))
if (mIcmp.ShouldHandleEchoRequest(aHeader.GetDestination()))
{
Icmp::Header icmp;
@@ -1045,9 +1046,8 @@ Error Ip6::PassToHost(OwnedPtr<Message> &aMessagePtr,
// For a multicast packet sent from link-local/mesh-local address to scope larger
// than realm-local, set the hop limit to 1 before sending to host, so this packet
// will not be forwarded by host.
if (aMessageInfo.GetSockAddr().IsMulticastLargerThanRealmLocal() &&
(aMessageInfo.GetPeerAddr().IsLinkLocalUnicast() ||
(Get<Mle::Mle>().IsMeshLocalAddress(aMessageInfo.GetPeerAddr()))))
if (aHeader.GetDestination().IsMulticastLargerThanRealmLocal() &&
(aHeader.GetSource().IsLinkLocalUnicast() || (Get<Mle::Mle>().IsMeshLocalAddress(aHeader.GetSource()))))
{
messagePtr->Write<uint8_t>(Header::kHopLimitFieldOffset, 1);
}
@@ -1099,13 +1099,12 @@ exit:
Error Ip6::HandleDatagram(OwnedPtr<Message> aMessagePtr, bool aIsReassembled)
{
Error error;
MessageInfo messageInfo;
Header header;
bool receive;
bool forwardThread;
bool forwardHost;
uint8_t nextHeader;
Error error;
Header header;
bool receive;
bool forwardThread;
bool forwardHost;
uint8_t nextHeader;
receive = false;
forwardThread = false;
@@ -1113,12 +1112,6 @@ Error Ip6::HandleDatagram(OwnedPtr<Message> aMessagePtr, bool aIsReassembled)
SuccessOrExit(error = header.ParseFrom(*aMessagePtr));
messageInfo.Clear();
messageInfo.SetPeerAddr(header.GetSource());
messageInfo.SetSockAddr(header.GetDestination());
messageInfo.SetHopLimit(header.GetHopLimit());
messageInfo.SetEcn(header.GetEcn());
// Determine `forwardThread`, `forwardHost` and `receive`
// based on the destination address.
@@ -1181,7 +1174,7 @@ Error Ip6::HandleDatagram(OwnedPtr<Message> aMessagePtr, bool aIsReassembled)
// Process IPv6 Extension Headers
nextHeader = static_cast<uint8_t>(header.GetNextHeader());
SuccessOrExit(error = HandleExtensionHeaders(aMessagePtr, messageInfo, header, nextHeader, receive));
SuccessOrExit(error = HandleExtensionHeaders(aMessagePtr, header, nextHeader, receive));
if (receive && (nextHeader == kProtoIp6))
{
@@ -1209,15 +1202,14 @@ Error Ip6::HandleDatagram(OwnedPtr<Message> aMessagePtr, bool aIsReassembled)
if ((forwardHost || receive) && !aIsReassembled)
{
error = PassToHost(aMessagePtr, messageInfo, nextHeader,
error = PassToHost(aMessagePtr, header, nextHeader,
/* aApplyFilter */ !forwardHost, receive,
(receive || forwardThread) ? Message::kCopyToUse : Message::kTakeCustody);
}
if (receive)
{
error = HandlePayload(header, aMessagePtr, messageInfo, nextHeader,
forwardThread ? Message::kCopyToUse : Message::kTakeCustody);
error = Receive(header, aMessagePtr, nextHeader, forwardThread ? Message::kCopyToUse : Message::kTakeCustody);
}
if (forwardThread)
src/core/net/ip6.hpp
+7 -9
View File
@@ -384,14 +384,13 @@ private:
void EnqueueDatagram(Message &aMessage);
void HandleSendQueue(void);
Error PassToHost(OwnedPtr<Message> &aMessagePtr,
const MessageInfo &aMessageInfo,
const Header &aHeader,
uint8_t aIpProto,
bool aApplyFilter,
bool aReceive,
Message::Ownership aMessageOwnership);
Error HandleExtensionHeaders(OwnedPtr<Message> &aMessagePtr,
MessageInfo &aMessageInfo,
Header &aHeader,
const Header &aHeader,
uint8_t &aNextHeader,
bool &aReceive);
Error FragmentDatagram(Message &aMessage, uint8_t aIpProto);
@@ -407,12 +406,11 @@ private:
Error PrepareMulticastToLargerThanRealmLocal(Message &aMessage, const Header &aHeader);
Error InsertMplOption(Message &aMessage, Header &aHeader);
Error RemoveMplOption(Message &aMessage);
Error HandleOptions(Message &aMessage, Header &aHeader, bool &aReceive);
Error HandlePayload(Header &aIp6Header,
OwnedPtr<Message> &aMessagePtr,
MessageInfo &aMessageInfo,
uint8_t aIpProto,
Message::Ownership aMessageOwnership);
Error HandleOptions(Message &aMessage, const Header &aHeader, bool &aReceive);
Error Receive(Header &aIp6Header,
OwnedPtr<Message> &aMessagePtr,
uint8_t aIpProto,
Message::Ownership aMessageOwnership);
bool IsOnLink(const Address &aAddress) const;
Error RouteLookup(const Address &aSource, const Address &aDestination) const;
#if OPENTHREAD_CONFIG_IP6_BR_COUNTERS_ENABLE