From b0266bc00efef2d7f3eee7c8bbb252f245c4901c Mon Sep 17 00:00:00 2001
From: Marek Porwisz <59468987+MarekPorwisz@users.noreply.github.com>
Date: Sat, 8 Oct 2022 02:50:39 +0200
Subject: [PATCH] [ip6] fix packets not being forwarded outside of Thread
 (#8102)

Two changes made together broke fragmented packets handling: Some time
ago forwarding packets outside of thread was limited to 1280 bytes
Recently forwarding IP packet fragments was disabled.  This makes it
not forward packet fragments nor fully assembled packets.  According
to later change author this was to prevent packets from being handled
twice.

To fix this, forwarding of IP fragments was restored and instead
forwarding of reassembled frames was disabled regardless of the frame
size. This approach should save the need of fragmenting already
reassembled packets to fit into the
OPENTHREAD_CONFIG_IP6_MAX_DATAGRAM_LENGTH.

Signed-off-by: Marek Porwisz <marek.porwisz@nordicsemi.no>
---
 src/core/net/ip6.cpp | 28 ++++++++++++++++------------
 src/core/net/ip6.hpp |  5 ++++-
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/src/core/net/ip6.cpp b/src/core/net/ip6.cpp
index a0aa0ad7f..752d98d84 100644
--- a/src/core/net/ip6.cpp
+++ b/src/core/net/ip6.cpp
@@ -786,7 +786,7 @@ Error Ip6::HandleFragment(Message &aMessage, MessageOrigin aOrigin, MessageInfo
 
         mReassemblyList.Dequeue(*message);
 
-        IgnoreError(HandleDatagram(*message, aOrigin, aMessageInfo.mLinkInfo));
+        IgnoreError(HandleDatagram(*message, aOrigin, aMessageInfo.mLinkInfo, /* aIsReassembled */ true));
     }
 
 exit:
@@ -914,10 +914,8 @@ Error Ip6::HandleExtensionHeaders(Message &     aMessage,
             break;
 
         case kProtoFragment:
-#if !OPENTHREAD_CONFIG_IP6_FRAGMENTATION_ENABLE
             IgnoreError(ProcessReceiveCallback(aMessage, aOrigin, aMessageInfo, aNextHeader,
                                                /* aAllowReceiveFilter */ false, Message::kCopyToUse));
-#endif
             SuccessOrExit(error = HandleFragment(aMessage, aOrigin, aMessageInfo));
             break;
 
@@ -1026,7 +1024,7 @@ Error Ip6::ProcessReceiveCallback(Message &          aMessage,
 
     VerifyOrExit(mReceiveIp6DatagramCallback != nullptr, error = kErrorNoRoute);
 
-    // Do not forward reassembled IPv6 packets.
+    // Do not forward IPv6 packets that exceed kMinimalMtu.
     VerifyOrExit(aMessage.GetLength() <= kMinimalMtu, error = kErrorDrop);
 
     if (mIsReceiveIp6FilterEnabled && aAllowReceiveFilter)
@@ -1147,7 +1145,7 @@ exit:
     return error;
 }
 
-Error Ip6::HandleDatagram(Message &aMessage, MessageOrigin aOrigin, const void *aLinkMessageInfo)
+Error Ip6::HandleDatagram(Message &aMessage, MessageOrigin aOrigin, const void *aLinkMessageInfo, bool aIsReassembled)
 {
     Error       error;
     MessageInfo messageInfo;
@@ -1226,6 +1224,11 @@ start:
         }
     }
 
+    // never forward reassembled frames as they were already delivered as fragments
+    if (aIsReassembled)
+    {
+        forwardHost = false;
+    }
     aMessage.SetOffset(sizeof(header));
 
     // process IPv6 Extension Headers
@@ -1242,15 +1245,16 @@ start:
             Get<MeshForwarder>().LogMessage(MeshForwarder::kMessageReceive, aMessage);
             goto start;
         }
-
-        error = ProcessReceiveCallback(aMessage, aOrigin, messageInfo, nextHeader,
-                                       /* aAllowReceiveFilter */ !forwardHost, Message::kCopyToUse);
-
-        if ((error == kErrorNone || error == kErrorNoRoute) && forwardHost)
+        if (!aIsReassembled)
         {
-            forwardHost = false;
-        }
+            error = ProcessReceiveCallback(aMessage, aOrigin, messageInfo, nextHeader,
+                                           /* aAllowReceiveFilter */ !forwardHost, Message::kCopyToUse);
 
+            if ((error == kErrorNone || error == kErrorNoRoute) && forwardHost)
+            {
+                forwardHost = false;
+            }
+        }
         error             = HandlePayload(header, aMessage, messageInfo, nextHeader,
                               (forwardThread || forwardHost ? Message::kCopyToUse : Message::kTakeCustody));
         shouldFreeMessage = forwardThread || forwardHost;
diff --git a/src/core/net/ip6.hpp b/src/core/net/ip6.hpp
index 860b267c2..037f02f47 100644
--- a/src/core/net/ip6.hpp
+++ b/src/core/net/ip6.hpp
@@ -227,7 +227,10 @@ public:
      * @retval kErrorParse    Encountered a malformed header when processing the message.
      *
      */
-    Error HandleDatagram(Message &aMessage, MessageOrigin aOrigin, const void *aLinkMessageInfo = nullptr);
+    Error HandleDatagram(Message &     aMessage,
+                         MessageOrigin aOrigin,
+                         const void *  aLinkMessageInfo = nullptr,
+                         bool          aIsReassembled   = false);
 
     /**
      * This method registers a callback to provide received raw IPv6 datagrams.