[24178] Fix failure setting default locator in empty multicast locator list

include/fastdds/rtps/transport/TransportInterface.hpp

@@ -262,7 +262,11 @@ class FASTDDS_EXPORTED_API TransportInterface
             uint32_t domainId,
             LocatorList& list) const = 0;
 
-    //! Assign port to the given unicast locator if not already defined
+    /**
+     *  Assign only the port to the given unicast locator if not already defined
+     *  Note: As the default address is usually valid for unicast, this method
+     *  does not assign a new value
+     */
     virtual bool fillUnicastLocator(
             Locator& locator,
             uint32_t well_known_port) const = 0;

src/cpp/rtps/network/NetworkFactory.cpp

@@ -25,6 +25,7 @@
 #include <fastdds/utils/IPLocator.hpp>
 
 #include <rtps/network/NetworkConfiguration.hpp>
+#include <rtps/transport/MulticastTransportInterface.hpp>
 #include <rtps/transport/TCPTransportInterface.h>
 
 using namespace std;
@@ -488,6 +489,23 @@ bool NetworkFactory::getDefaultUnicastLocators(
     return result;
 }
 
+bool NetworkFactory::getDefaultMulticastLocators(
+        LocatorList_t& locators,
+        uint32_t port) const
+{
+    bool result = false;
+    for (auto& transport : mRegisteredTransports)
+    {
+        const MulticastTransportInterface* multicast_transport =
+                dynamic_cast<const MulticastTransportInterface*>(transport.get());
+        if (multicast_transport)
+        {
+            result |= multicast_transport->getDefaultMulticastLocators(locators, port);
+        }
+    }
+    return result;
+}
+
 bool NetworkFactory::fill_default_locator_port(
         Locator_t& locator,
         uint32_t port) const
@@ -503,6 +521,26 @@ bool NetworkFactory::fill_default_locator_port(
     return result;
 }
 
+bool NetworkFactory::fill_default_multicast_locator(
+        Locator_t& locator,
+        uint32_t port) const
+{
+    bool result = false;
+    for (auto& transport : mRegisteredTransports)
+    {
+        if (transport->IsLocatorSupported(locator))
+        {
+            const MulticastTransportInterface* multicast_transport =
+                    dynamic_cast<const MulticastTransportInterface*>(transport.get());
+            if (multicast_transport)
+            {
+                result |= multicast_transport->fillMulticastLocator(locator, port);
+            }
+        }
+    }
+    return result;
+}
+
 void NetworkFactory::Shutdown()
 {
     for (auto& transport : mRegisteredTransports)

src/cpp/rtps/network/NetworkFactory.hpp

@@ -297,13 +297,30 @@ class NetworkFactory
             LocatorList_t& locators,
             uint32_t port) const;
 
+    /**
+     * Add the default multicast locator to the given locator list.
+     *
+     * @param locators List to be filled with the default multicast locator.
+     * @param port Port to be used in the default multicast locator.
+     * */
+    bool getDefaultMulticastLocators(
+            LocatorList_t& locators,
+            uint32_t port) const;
+
     /**
      * Fill the locator with the default unicast configuration.
      * */
     bool fill_default_locator_port(
             Locator_t& locator,
             uint32_t port) const;
 
+    /**
+     * Fill the locator with the default multicast configuration.
+     * */
+    bool fill_default_multicast_locator(
+            Locator_t& locator,
+            uint32_t port) const;
+
     /**
      * Shutdown method to close the connections of the transports.
      */

src/cpp/rtps/participant/RTPSParticipantImpl.cpp

@@ -678,6 +678,7 @@ void RTPSParticipantImpl::setup_user_traffic()
         std::for_each(m_att.defaultUnicastLocatorList.begin(), m_att.defaultUnicastLocatorList.end(),
                 [&](Locator_t& loc)
                 {
+                    // This methods always leaves the address unchanged
                     m_network_Factory.fill_default_locator_port(loc, default_unicast_port_);
                 });
         m_network_Factory.NormalizeLocators(m_att.defaultUnicastLocatorList);
@@ -687,7 +688,8 @@ void RTPSParticipantImpl::setup_user_traffic()
         std::for_each(m_att.defaultMulticastLocatorList.begin(), m_att.defaultMulticastLocatorList.end(),
                 [&](Locator_t& loc)
                 {
-                    m_network_Factory.fill_default_locator_port(loc, multicast_port);
+                    // This methods leaves the address unchanged if it was already set
+                    m_network_Factory.fill_default_multicast_locator(loc, multicast_port);
                 });
     }
 
@@ -2332,7 +2334,7 @@ void RTPSParticipantImpl::normalize_endpoint_locators(
     uint32_t multicast_port = m_network_Factory.calculate_well_known_port(domain_id_, m_att, true);
     for (Locator_t& loc : endpoint_att.multicastLocatorList)
     {
-        m_network_Factory.fill_default_locator_port(loc, multicast_port);
+        m_network_Factory.fill_default_multicast_locator(loc, multicast_port);
     }
 
     // Normalize unicast locators

src/cpp/rtps/transport/MulticastTransportInterface.cpp

@@ -0,0 +1,47 @@
+// Copyright 2026 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <rtps/transport/MulticastTransportInterface.hpp>
+
+#include <fastdds/utils/IPLocator.hpp>
+
+namespace eprosima {
+namespace fastdds {
+namespace rtps {
+
+bool MulticastTransportInterface::fillMulticastLocator(
+        Locator& locator,
+        uint32_t well_known_port) const
+{
+    LocatorList defaults;
+    getDefaultMulticastLocators(defaults, well_known_port);
+    if (!defaults.empty())
+    {
+        const Locator& default_loc = *defaults.begin();
+        if (locator.port == 0)
+        {
+            locator.port = default_loc.port;
+        }
+        if (!IsAddressDefined(locator))
+        {
+            IPLocator::copy_address(default_loc, locator);
+        }
+    }
+
+    return true;
+}
+
+} // namespace rtps
+} // namespace fastdds
+} // namespace eprosima

src/cpp/rtps/transport/MulticastTransportInterface.hpp

@@ -0,0 +1,46 @@
+// Copyright 2026 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _FASTDDS_MULTICAST_TRANSPORT_INTERFACE_HPP_
+#define _FASTDDS_MULTICAST_TRANSPORT_INTERFACE_HPP_
+
+#include <cstdint>
+
+#include <fastdds/rtps/common/Locator.hpp>
+#include <fastdds/rtps/common/LocatorList.hpp>
+
+namespace eprosima {
+namespace fastdds {
+namespace rtps {
+
+class MulticastTransportInterface
+{
+public:
+
+    virtual ~MulticastTransportInterface() = default;
+
+    virtual bool getDefaultMulticastLocators(
+            LocatorList& locators,
+            uint32_t multicast_port) const = 0;
+
+    virtual bool fillMulticastLocator(
+            Locator& locator,
+            uint32_t well_known_port) const;
+};
+
+} // namespace rtps
+} // namespace fastdds
+} // namespace eprosima
+
+#endif // _FASTDDS_MULTICAST_TRANSPORT_INTERFACE_HPP_

src/cpp/rtps/transport/TCPTransportInterface.cpp

@@ -1690,7 +1690,7 @@ bool TCPTransportInterface::getDefaultMetatrafficMulticastLocators(
         uint32_t ) const
 {
     // TCP doesn't have multicast support
-    return true;
+    return false;
 }
 
 bool TCPTransportInterface::getDefaultMetatrafficUnicastLocators(
@@ -1722,7 +1722,7 @@ bool TCPTransportInterface::fillMetatrafficMulticastLocator(
         uint32_t) const
 {
     // TCP doesn't have multicast support
-    return true;
+    return false;
 }
 
 bool TCPTransportInterface::fillMetatrafficUnicastLocator(

src/cpp/rtps/transport/TCPTransportInterface.h

@@ -452,6 +452,10 @@ class TCPTransportInterface : public TransportInterface
      */
     virtual std::vector<std::string> get_binding_interfaces_list() = 0;
 
+    /**
+     * This method should never be called because TCP interfaces do not support
+     * multicast locators. It always returns false
+     */
     bool getDefaultMetatrafficMulticastLocators(
             LocatorList& locators,
             uint32_t metatraffic_multicast_port) const override;
@@ -464,6 +468,10 @@ class TCPTransportInterface : public TransportInterface
             LocatorList& locators,
             uint32_t unicast_port) const override;
 
+    /**
+     * This method should never be called because TCP interfaces do not support
+     * multicast locators. It always returns false
+     */
     bool fillMetatrafficMulticastLocator(
             Locator& locator,
             uint32_t metatraffic_multicast_port) const override;

src/cpp/rtps/transport/UDPTransportInterface.cpp

@@ -724,9 +724,19 @@ bool UDPTransportInterface::fillMetatrafficMulticastLocator(
         Locator& locator,
         uint32_t metatraffic_multicast_port) const
 {
-    if (locator.port == 0)
+    LocatorList defaults;
+    getDefaultMetatrafficMulticastLocators(defaults, metatraffic_multicast_port);
+    if (!defaults.empty())
     {
-        locator.port = metatraffic_multicast_port;
+        const Locator& default_loc = *defaults.begin();
+        if (locator.port == 0)
+        {
+            locator.port = default_loc.port;
+        }
+        if (!IsAddressDefined(locator))
+        {
+            IPLocator::copy_address(default_loc, locator);
+        }
     }
     return true;
 }

src/cpp/rtps/transport/UDPTransportInterface.h

@@ -29,14 +29,17 @@
 #include <fastdds/rtps/transport/UDPTransportDescriptor.hpp>
 #include <fastdds/utils/IPFinder.hpp>
 
+#include <rtps/transport/MulticastTransportInterface.hpp>
 #include <rtps/transport/UDPChannelResource.h>
 #include <statistics/rtps/messages/OutputTrafficManager.hpp>
 
 namespace eprosima {
 namespace fastdds {
 namespace rtps {
 
-class UDPTransportInterface : public TransportInterface
+class UDPTransportInterface
+    : public TransportInterface
+    , public MulticastTransportInterface
 {
     friend class UDPSenderResource;
     friend struct TSN_UDPSender;

src/cpp/rtps/transport/UDPv4Transport.cpp

@@ -261,6 +261,18 @@ bool UDPv4Transport::getDefaultMetatrafficMulticastLocators(
     return true;
 }
 
+bool UDPv4Transport::getDefaultMulticastLocators(
+        LocatorList& locators,
+        uint32_t multicast_port) const
+{
+    Locator locator;
+    locator.kind = LOCATOR_KIND_UDPv4;
+    locator.port = static_cast<uint16_t>(multicast_port);
+    IPLocator::setIPv4(locator, DEFAULT_MULTICAST_ADDRESS);
+    locators.push_back(locator);
+    return true;
+}
+
 bool UDPv4Transport::getDefaultMetatrafficUnicastLocators(
         LocatorList& locators,
         uint32_t metatraffic_unicast_port) const

src/cpp/rtps/transport/UDPv4Transport.h

@@ -81,6 +81,10 @@ class UDPv4Transport : public UDPTransportInterface
             LocatorList& locators,
             uint32_t metatraffic_unicast_port) const override;
 
+    bool getDefaultMulticastLocators(
+            LocatorList& locators,
+            uint32_t multicast_port) const override;
+
     bool getDefaultUnicastLocators(
             LocatorList& locators,
             uint32_t unicast_port) const override;
@@ -169,6 +173,9 @@ class UDPv4Transport : public UDPTransportInterface
 };
 
 const char* const DEFAULT_METATRAFFIC_MULTICAST_ADDRESS = "239.255.0.1";
+// Metatraffic multicast address is the same as default multicast address,
+// but we keep this definition in case we want to differentiate them in the future
+const char* const DEFAULT_MULTICAST_ADDRESS = DEFAULT_METATRAFFIC_MULTICAST_ADDRESS;
 
 } // namespace rtps
 } // namespace fastdds

src/cpp/rtps/transport/UDPv6Transport.cpp

@@ -257,7 +257,7 @@ bool UDPv6Transport::getDefaultMetatrafficMulticastLocators(
     Locator locator;
     locator.kind = LOCATOR_KIND_UDPv6;
     locator.port = static_cast<uint16_t>(metatraffic_multicast_port);
-    IPLocator::setIPv6(locator, "ff1e::ffff:efff:1");
+    IPLocator::setIPv6(locator, DEFAULT_METATRAFFIC_MULTICAST_ADDRESS_v6);
     locators.push_back(locator);
     return true;
 }
@@ -275,6 +275,18 @@ bool UDPv6Transport::getDefaultMetatrafficUnicastLocators(
     return true;
 }
 
+bool UDPv6Transport::getDefaultMulticastLocators(
+        LocatorList& locators,
+        uint32_t multicast_port) const
+{
+    Locator locator;
+    locator.kind = LOCATOR_KIND_UDPv6;
+    locator.port = static_cast<uint16_t>(multicast_port);
+    IPLocator::setIPv6(locator, DEFAULT_MULTICAST_ADDRESS_v6);
+    locators.push_back(locator);
+    return true;
+}
+
 bool UDPv6Transport::getDefaultUnicastLocators(
         LocatorList& locators,
         uint32_t unicast_port) const
@@ -293,7 +305,7 @@ void UDPv6Transport::AddDefaultOutputLocator(
 {
     // TODO What is the default IPv6 address?
     Locator temp;
-    IPLocator::createLocator(LOCATOR_KIND_UDPv6, "ff1e::ffff:efff:1", 0, temp);
+    IPLocator::createLocator(LOCATOR_KIND_UDPv6, DEFAULT_MULTICAST_ADDRESS_v6, 0, temp);
     defaultList.push_back(temp);
 }