[mlr] simplify multicast address state tracking (openthread#13089)

This commit simplifies the tracking of Multicast Listener Registration
(MLR) state for IPv6 addresses by removing intermediate states and
relying on the original CoAP request payload.

Previously, `Mlr::Manager` used a 3-state system (`kStateToRegister`,
`kStateRegistering`, `kStateRegistered`) which required core structures
like `Child` and `Netif` to track transient registration states.

This commit reduces the state to a single boolean (`IsMlrRegistered`)
tracked in `ChildTable` and `ThreadNetif`. When a CoAP response is
received, `Mlr::Manager` now uses `GetDispatchingRequest()` to
retrieve the original TMR MLE request message, parses the
`Ip6AddressesTlv` to determine exactly which addresses were included
in the request, and updates the registration states based purely on
this info (minus any explicitly failed addresses).

This change improves robustness, reduces RAM usage by eliminating
state-tracking arrays, and significantly cleans up the logical flow
within the MLR manager.

Author: abtink

src/core/net/ip6_address.hpp

@@ -742,6 +742,18 @@ class Address : public otIp6Address, public Equatable<Address>, public Clearable
      */
     bool MatchesPrefix(const uint8_t *aPrefix, uint8_t aPrefixLength) const;
 
+    /**
+     * Indicates whether the address matches a given other address.
+     *
+     * This method is intended to be used with `FindMatching()` in collections.
+     *
+     * @param[in] aAddress  The IPv6 address to match against.
+     *
+     * @retval TRUE   If the address matches @p aAddress.
+     * @retval FALSE  If the address does not match @p aAddress.
+     */
+    bool Matches(const Ip6::Address &aAddress) const { return (*this == aAddress); }
+
     /**
      * Sets the IPv6 address prefix.
      *

src/core/net/netif.cpp

@@ -613,11 +613,6 @@ void Netif::MulticastAddress::InitAsManualOrigin(void)
 {
     Clear();
     mAddressOrigin = kOriginManual;
-
-#if OPENTHREAD_CONFIG_MLR_ENABLE
-    // Make sure `Clear()` sets the "MlrState" to `Mlr::kStateToRegister` value.
-    static_assert(Mlr::kStateToRegister == 0, "Mlr::kStateToRegister is not correct.");
-#endif
 }
 
 #if OPENTHREAD_CONFIG_MLR_ENABLE
@@ -627,11 +622,6 @@ bool Netif::MulticastAddress::IsMlrCandidate(void) const
     return (GetOrigin() == kOriginManual) && GetAddress().IsMulticastLargerThanRealmLocal();
 }
 
-bool Netif::MulticastAddress::Matches(Mlr::State aMlrState) const
-{
-    return IsMlrCandidate() && (GetMlrState() == aMlrState);
-}
-
 #endif
 
 } // namespace Ip6

src/core/net/netif.hpp

@@ -290,28 +290,19 @@ class Netif : public InstanceLocator, private NonCopyable
         bool IsMlrCandidate(void) const;
 
         /**
-         * Returns the current Multicast Listener Registration (MLR) state.
+         * Indicates whether the multicast address is registered via Multicast Listener Registration (MLR).
          *
-         * @returns The current Multicast Listener Registration state.
+         * @retval TRUE   If the multicast address is MLR registered.
+         * @retval FALSE  If the multicast address is not MLR registered.
          */
-        Mlr::State GetMlrState(void) const { return static_cast<Mlr::State>(mData); }
+        bool IsMlrRegistered(void) const { return (mData != 0); }
 
         /**
-         * Sets the Multicast Listener Registration (MLR) state.
+         * Sets whether the multicast address is registered via Multicast Listener Registration (MLR).
          *
-         * @param[in] aState  The new Multicast Listener Registration state.
+         * @param[in] aRegistered  TRUE if MLR registered, FALSE otherwise.
          */
-        void SetMlrState(Mlr::State aState) { mData = aState; }
-
-        /**
-         * Indicates whether or not the address is an MLR candidate and matches a given MLR state.
-         *
-         * @param[in] aMlrState  The MLR state to match against.
-         *
-         * @retval TRUE  If the address is an MLR candidate and its state matches @p aMlrState.
-         * @retval FALSE If the address is not an MLR candidate or its state does not match @p aMlrState.
-         */
-        bool Matches(Mlr::State aMlrState) const;
+        void SetMlrRegistered(bool aRegistered) { mData = aRegistered ? 1 : 0; }
 #endif
 
     private:

src/core/thread/child.cpp

@@ -76,38 +76,15 @@ void Child::Info::SetFrom(const Child &aChild)
 
 #if OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
 
-Mlr::State Child::Ip6AddrEntry::GetMlrState(const Child &aChild) const
+bool Child::Ip6AddrEntry::IsMlrRegistered(const Child &aChild) const
 {
-    Mlr::State                 state = Mlr::kStateRegistering;
-    Ip6AddressArray::IndexType index;
-
-    OT_ASSERT(aChild.mIp6Addresses.IsInArrayBuffer(this));
-
-    index = aChild.mIp6Addresses.IndexOf(*this);
-
-    if (aChild.mMlrToRegisterSet.Has(index))
-    {
-        state = Mlr::kStateToRegister;
-    }
-    else if (aChild.mMlrRegisteredSet.Has(index))
-    {
-        state = Mlr::kStateRegistered;
-    }
-
-    return state;
+    return aChild.mMlrRegisteredSet.Has(aChild.mIp6Addresses.IndexOf(*this));
 }
 
 // NOLINTNEXTLINE(readability-make-member-function-const)
-void Child::Ip6AddrEntry::SetMlrState(Mlr::State aState, Child &aChild)
+void Child::Ip6AddrEntry::SetMlrRegistered(bool aRegistered, Child &aChild)
 {
-    Ip6AddressArray::IndexType index;
-
-    OT_ASSERT(aChild.mIp6Addresses.IsInArrayBuffer(this));
-
-    index = aChild.mIp6Addresses.IndexOf(*this);
-
-    aChild.mMlrToRegisterSet.Update(index, aState == Mlr::kStateToRegister);
-    aChild.mMlrRegisteredSet.Update(index, aState == Mlr::kStateRegistered);
+    aChild.mMlrRegisteredSet.Update(aChild.mIp6Addresses.IndexOf(*this), aRegistered);
 }
 
 #endif // OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
@@ -128,7 +105,6 @@ void Child::ClearIp6Addresses(void)
     mMeshLocalIid.Clear();
     mIp6Addresses.Clear();
 #if OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
-    mMlrToRegisterSet.Clear();
     mMlrRegisteredSet.Clear();
 #endif
 }
@@ -230,9 +206,6 @@ Error Child::RemoveIp6Address(const Ip6::Address &aAddress)
         uint16_t entryIndex = mIp6Addresses.IndexOf(*entry);
         uint16_t lastIndex  = mIp6Addresses.GetLength() - 1;
 
-        mMlrToRegisterSet.Update(entryIndex, mMlrToRegisterSet.Has(lastIndex));
-        mMlrToRegisterSet.Remove(lastIndex);
-
         mMlrRegisteredSet.Update(entryIndex, mMlrRegisteredSet.Has(lastIndex));
         mMlrRegisteredSet.Remove(lastIndex);
     }
@@ -292,7 +265,8 @@ bool Child::HasMlrRegisteredAddress(const Ip6::Address &aAddress) const
 
     entry = mIp6Addresses.FindMatching(aAddress);
     VerifyOrExit(entry != nullptr);
-    hasAddress = entry->GetMlrState(*this) == Mlr::kStateRegistered;
+
+    hasAddress = entry->IsMlrRegistered(*this);
 
 exit:
     return hasAddress;

src/core/thread/child.hpp

@@ -102,21 +102,22 @@ class Child : public CslNeighbor
 
 #if OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
         /**
-         * Gets the MLR state of the IPv6 address entry.
+         * Indicates whether the IPv6 address is registered via Multicast Listener Registration (MLR) on a given child.
          *
-         * @param[in] aChild  The child owning this address entry.
+         * @param[in] aChild  The child associated with the address.
          *
-         * @returns The MLR state of IPv6 address entry.
+         * @retval TRUE   If the address is MLR registered on @p aChild.
+         * @retval FALSE  If the address is not MLR registered on @p aChild.
          */
-        Mlr::State GetMlrState(const Child &aChild) const;
+        bool IsMlrRegistered(const Child &aChild) const;
 
         /**
-         * Sets the MLR state of the IPv6 address entry.
+         * Sets whether the IPv6 address is registered via Multicast Listener Registration (MLR) on a given child.
          *
-         * @param[in] aState    The MLR state.
-         * @param[in] aChild    The child owning this address entry.
+         * @param[in] aRegistered  TRUE if MLR registered, FALSE otherwise.
+         * @param[in] aChild       The child associated with the address.
          */
-        void SetMlrState(Mlr::State aState, Child &aChild);
+        void SetMlrRegistered(bool aRegistered, Child &aChild);
 #endif
     };
 
@@ -353,30 +354,27 @@ class Child : public CslNeighbor
 
 #if OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
     /**
-     * Returns if the Child has IPv6 address @p aAddress of MLR state `Mlr::kStateRegistered`.
+     * Clears the Multicast Listener Registration (MLR) registered state on all IPv6 addresses of the child.
+     */
+    void ClearMlrRegisteredStateOnAllIp6Addresses(void) { mMlrRegisteredSet.Clear(); }
+
+    /**
+     * Indicates whether the child has a given IPv6 address that is MLR registered.
      *
      * @param[in] aAddress  The IPv6 address.
      *
-     * @retval true   If the Child has IPv6 address @p aAddress of MLR state `Mlr::kStateRegistered`.
-     * @retval false  If the Child does not have IPv6 address @p aAddress of MLR state `Mlr::kStateRegistered`.
+     * @retval TRUE   If the child has the IPv6 address @p aAddress and it is MLR registered.
+     * @retval FALSE  If the child does not have the IPv6 address @p aAddress or it is not MLR registered.
      */
     bool HasMlrRegisteredAddress(const Ip6::Address &aAddress) const;
 
     /**
-     * Returns if the Child has any IPv6 address of MLR state `Mlr::kStateRegistered`.
+     * Indicates whether the child has any IPv6 address that is MLR registered.
      *
-     * @retval true   If the Child has any IPv6 address of MLR state `Mlr::kStateRegistered`.
-     * @retval false  If the Child does not have any IPv6 address of MLR state `Mlr::kStateRegistered`.
+     * @retval TRUE   If the child has any MLR registered IPv6 address.
+     * @retval FALSE  If the child does not have any MLR registered IPv6 address.
      */
     bool HasAnyMlrRegisteredAddress(void) const { return !mMlrRegisteredSet.IsEmpty(); }
-
-    /**
-     * Returns if the Child has any IPv6 address of MLR state `Mlr::kStateToRegister`.
-     *
-     * @retval true   If the Child has any IPv6 address of MLR state `Mlr::kStateToRegister`.
-     * @retval false  If the Child does not have any IPv6 address of MLR state `Mlr::kStateToRegister`.
-     */
-    bool HasAnyMlrToRegisterAddress(void) const { return !mMlrToRegisterSet.IsEmpty(); }
 #endif // OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
 
 private:
@@ -387,7 +385,6 @@ class Child : public CslNeighbor
     Ip6::InterfaceIdentifier mMeshLocalIid;
     Ip6AddressArray          mIp6Addresses;
 #if OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE
-    ChildIp6AddressSet mMlrToRegisterSet;
     ChildIp6AddressSet mMlrRegisteredSet;
 #endif
 

src/core/thread/mle_ftd.cpp

@@ -1874,12 +1874,7 @@ Error Mle::ProcessAddressRegistrationTlv(RxInfo &aRxInfo, Child &aChild)
     {
         for (const Child::Ip6AddrEntry &addrEntry : aChild.GetIp6Addresses())
         {
-            if (!addrEntry.IsMulticastLargerThanRealmLocal())
-            {
-                continue;
-            }
-
-            if (addrEntry.GetMlrState(aChild) == Mlr::kStateRegistered)
+            if (addrEntry.IsMlrRegistered(aChild))
             {
                 IgnoreError(oldMlrRegisteredAddresses.PushBack(addrEntry));
             }