Release change while authentication fails (#5935) (#6020)

* Release change while authentication fails



* Fix uncrustify error



* Refs #23431: Refactor PubSubReader/Writer (un)authorized() methods



* Refs #23431: Add regression test



* Refs #23431: Apply Miguel's suggestions



* Refs #23431: Fix windows compilation



* Refs #23431: Uncrustify



* Fix a memory leak on handshake handle



* Fix an Uncrustify error



---------




(cherry picked from commit db64a12)

Signed-off-by: Barry Xu <[email protected]>
Signed-off-by: Mario Dominguez <[email protected]>
Co-authored-by: Barry Xu <[email protected]>
Co-authored-by: Mario Dominguez <[email protected]>

Author: 3 people

src/cpp/rtps/security/SecurityManager.cpp

@@ -4255,6 +4255,19 @@ void SecurityManager::resend_handshake_message_token(
                     remote_participant_info->event_->cancel_timer();
                     remote_participant_info->auth_status_ = AUTHENTICATION_FAILED;
                     on_validation_failed(dp_it->second->participant_data(), exception);
+                    if (remote_participant_info->change_sequence_number_ != SequenceNumber_t::unknown())
+                    {
+                        participant_stateless_message_writer_history_->remove_change(
+                            remote_participant_info->change_sequence_number_);
+                        remote_participant_info->change_sequence_number_ = SequenceNumber_t::unknown();
+                        // Return the handshake handle
+                        if (remote_participant_info->handshake_handle_ != nullptr)
+                        {
+                            authentication_plugin_->return_handshake_handle(
+                                remote_participant_info->handshake_handle_, exception);
+                            remote_participant_info->handshake_handle_ = nullptr;
+                        }
+                    }
                 }
             }
             else

test/blackbox/api/dds-pim/PubSubReader.hpp

@@ -865,7 +865,7 @@ class PubSubReader
     }
 
 #if HAVE_SECURITY
-    void waitAuthorized(
+    void wait_authorized(
             std::chrono::seconds timeout = std::chrono::seconds::zero(),
             unsigned int expected = 1)
     {
@@ -891,16 +891,28 @@ class PubSubReader
         std::cout << "Reader authorization finished..." << std::endl;
     }
 
-    void waitUnauthorized()
+    void wait_unauthorized(
+            std::chrono::seconds timeout = std::chrono::seconds::zero(),
+            unsigned int expected = 1)
     {
         std::unique_lock<std::mutex> lock(mutexAuthentication_);
 
         std::cout << "Reader is waiting unauthorization..." << std::endl;
 
-        cvAuthentication_.wait(lock, [&]() -> bool
-                {
-                    return unauthorized_ > 0;
-                });
+        if (timeout == std::chrono::seconds::zero())
+        {
+            cvAuthentication_.wait(lock, [&]()
+                    {
+                        return unauthorized_ >= expected;
+                    });
+        }
+        else
+        {
+            cvAuthentication_.wait_for(lock, timeout, [&]()
+                    {
+                        return unauthorized_ >= expected;
+                    });
+        }
 
         std::cout << "Reader unauthorization finished..." << std::endl;
     }

test/blackbox/api/dds-pim/PubSubWriter.hpp

@@ -768,7 +768,7 @@ class PubSubWriter
     }
 
 #if HAVE_SECURITY
-    void waitAuthorized(
+    void wait_authorized(
             std::chrono::seconds timeout = std::chrono::seconds::zero(),
             unsigned int expected = 1)
     {
@@ -794,16 +794,28 @@ class PubSubWriter
         std::cout << "Writer authorization finished..." << std::endl;
     }
 
-    void waitUnauthorized()
+    void wait_unauthorized(
+            std::chrono::seconds timeout = std::chrono::seconds::zero(),
+            unsigned int expected = 1)
     {
         std::unique_lock<std::mutex> lock(mutexAuthentication_);
 
         std::cout << "Writer is waiting unauthorization..." << std::endl;
 
-        cvAuthentication_.wait(lock, [&]() -> bool
-                {
-                    return unauthorized_ > 0;
-                });
+        if (timeout == std::chrono::seconds::zero())
+        {
+            cvAuthentication_.wait(lock, [&]()
+                    {
+                        return unauthorized_ >= expected;
+                    });
+        }
+        else
+        {
+            cvAuthentication_.wait_for(lock, timeout, [&]()
+                    {
+                        return unauthorized_ >= expected;
+                    });
+        }
 
         std::cout << "Writer unauthorization finished..." << std::endl;
     }

test/blackbox/api/dds-pim/PubSubWriterReader.hpp

@@ -685,7 +685,7 @@ class PubSubWriterReader
     }
 
 #if HAVE_SECURITY
-    void waitAuthorized(
+    void wait_authorized(
             unsigned int how_many = 1)
     {
         std::unique_lock<std::mutex> lock(mutexAuthentication_);
@@ -701,7 +701,7 @@ class PubSubWriterReader
         std::cout << "WReader authorization finished..." << std::endl;
     }
 
-    void waitUnauthorized(
+    void wait_unauthorized(
             unsigned int how_many = 1)
     {
         std::unique_lock<std::mutex> lock(mutexAuthentication_);