[20701] Enforce SHM ports open mode exclusions (backport #4635)

src/cpp/rtps/transport/shared_mem/SharedMemGlobal.hpp

@@ -898,12 +898,22 @@ class SharedMemGlobal
 
  void lock_read_exclusive()
  {
+ if (OpenMode::ReadShared == open_mode())
+ {
+ throw std::runtime_error("port is opened ReadShared");
+ }
+
  std::string lock_name = std::string(node_->domain_name) + "_port" + std::to_string(node_->port_id) + "_el";
  read_exclusive_lock_ = std::unique_ptr<RobustExclusiveLock>(new RobustExclusiveLock(lock_name));
  }
 
  void lock_read_shared()
  {
+ if (OpenMode::ReadExclusive == open_mode())
+ {
+ throw std::runtime_error("port is opened ReadExclusive");
+ }
+
  std::string lock_name = std::string(node_->domain_name) + "_port" + std::to_string(node_->port_id) + "_sl";
  read_shared_lock_ = std::unique_ptr<RobustSharedLock>(new RobustSharedLock(lock_name));
  }
@@ -1124,7 +1134,24 @@ class SharedMemGlobal
  std::stringstream ss;
 
  ss << port_node->port_id << " (" << port_node->uuid.to_string() <<
- ") because is ReadExclusive locked";
+ ") because it was already locked";
+
+ err_reason = ss.str();
+ port.reset();
+ }
+ }
+ else if (open_mode == Port::OpenMode::ReadShared)
+ {
+ try
+ {
+ port->lock_read_shared();
+ }
+ catch (const std::exception&)
+ {
+ std::stringstream ss;
+
+ ss << port_node->port_id << " (" << port_node->uuid.to_string() <<
+ ") because it had a ReadExclusive lock";
 
  err_reason = ss.str();
  port.reset();

test/blackbox/common/BlackboxTestsTransportSHM.cpp

@@ -16,6 +16,7 @@
 
 #include "BlackboxTests.hpp"
 
+#include "PubSubParticipant.hpp"
 #include "PubSubReader.hpp"
 #include "PubSubWriter.hpp"
 
@@ -28,6 +29,8 @@ using namespace eprosima::fastrtps;
 
 using SharedMemTransportDescriptor = eprosima::fastdds::rtps::SharedMemTransportDescriptor;
 using test_SharedMemTransportDescriptor = eprosima::fastdds::rtps::test_SharedMemTransportDescriptor;
+using Locator = eprosima::fastdds::rtps::Locator;
+using LocatorList = eprosima::fastdds::rtps::LocatorList;
 
 TEST(SHM, TransportPubSub)
 {
@@ -70,6 +73,58 @@ TEST(SHM, TransportPubSub)
  reader.wait_participant_undiscovery();
 }
 
+/* Regression test for redmine issue #20701
+ *
+ * This test checks that the SHM transport will not listen on the same port
+ * in unicast and multicast at the same time.
+ * It does so by specifying custom default locators on a DataReader and then
+ * checking that the port mutation took place, thus producing a different port.
+ */
+TEST(SHM, SamePortUnicastMulticast)
+{
+ PubSubReader<HelloWorldPubSubType> participant(TEST_TOPIC_NAME);
+
+ Locator locator;
+ locator.kind = LOCATOR_KIND_SHM;
+ locator.port = global_port;
+
+ LocatorList unicast_list;
+ LocatorList multicast_list;
+
+ // Note: this is using knowledge of the SHM locator address format since
+ // SHMLocator is not exposed to the user.
+ locator.address[0] = 'U';
+ unicast_list.push_back(locator);
+
+ // Note: this is using knowledge of the SHM locator address format since
+ // SHMLocator is not exposed to the user.
+ locator.address[0] = 'M';
+ multicast_list.push_back(locator);
+
+ // Create the reader with the custom transport and locators
+ auto testTransport = std::make_shared<SharedMemTransportDescriptor>();
+ participant
+ .disable_builtin_transport()
+ .add_user_transport_to_pparams(testTransport)
+ .set_default_unicast_locators(unicast_list)
+ .set_default_multicast_locators(multicast_list)
+ .init();
+
+ ASSERT_TRUE(participant.isInitialized());
+
+ // Retrieve the listening locators and check that one port is different
+ LocatorList reader_locators;
+ participant.get_native_reader().get_listening_locators(reader_locators);
+
+ ASSERT_EQ(reader_locators.size(), 2u);
+ auto it = reader_locators.begin();
+ auto first_port = it->port;
+ ++it;
+ auto second_port = it->port;
+ EXPECT_NE(first_port, second_port);
+ EXPECT_TRUE(first_port == global_port || second_port == global_port);
+}
+
 TEST(SHM, Test300KFragmentation)
 {
  PubSubReader<Data1mbPubSubType> reader(TEST_TOPIC_NAME);

test/unittest/transport/SharedMemTests.cpp

@@ -1013,6 +1013,40 @@ TEST_F(SHMTransportTests, port_lock_read_exclusive)
  port = shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadExclusive);
 }
 
+// Regression test for redmine issue #20701
+TEST_F(SHMTransportTests, port_lock_read_shared_then_exclusive)
+{
+ const std::string domain_name("SHMTests");
+
+ auto shared_mem_manager = SharedMemManager::create(domain_name);
+
+ shared_mem_manager->remove_port(0);
+
+ auto port = shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadShared);
+ ASSERT_THROW(shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadExclusive),
+ std::exception);
+
+ port.reset();
+ port = shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadExclusive);
+}
+
+// Regression test for redmine issue #20701
+TEST_F(SHMTransportTests, port_lock_read_exclusive_then_shared)
+{
+ const std::string domain_name("SHMTests");
+
+ auto shared_mem_manager = SharedMemManager::create(domain_name);
+
+ shared_mem_manager->remove_port(0);
+
+ auto port = shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadExclusive);
+ ASSERT_THROW(shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadShared),
+ std::exception);
+
+ port.reset();
+ port = shared_mem_manager->open_port(0, 1, 1000, SharedMemGlobal::Port::OpenMode::ReadShared);
+}
+
 TEST_F(SHMTransportTests, robust_exclusive_lock)
 {
  const std::string lock_name = "robust_exclusive_lock_test1_el";