Make on_xxx_matched thread-safe (#6371) (#6380)

mergify[bot] · MiguelCompany · web-flow · commit 449d7efb31bf · 2026-06-01T07:52:50.000+02:00
* Refs #21355. Added regression test.



* Refs #21355. Improve readability in EDP.cpp.



* Refs #21355. Protect `InnerDataWriterListener::on_writer_matched`.



* Refs #21355. Protect `InnerDataReaderListener::on_reader_matched`.



---------

Signed-off-by: Miguel Company &lt;miguelcompany@eprosima.com&gt;
Co-authored-by: Miguel Company &lt;miguelcompany@eprosima.com&gt;
diff --git a/src/cpp/fastdds/publisher/DataWriterImpl.cpp b/src/cpp/fastdds/publisher/DataWriterImpl.cpp
@@ -1341,6 +1341,8 @@ void DataWriterImpl::InnerDataWriterListener::on_writer_matched(
         RTPSWriter* /*writer*/,
         const MatchingInfo& info)
 {
+    std::lock_guard<std::mutex> scoped_lock(matching_info_mutex_);
+
     data_writer_->update_publication_matched_status(info);
 
     StatusMask notify_status = StatusMask::publication_matched();
diff --git a/src/cpp/fastdds/publisher/DataWriterImpl.hpp b/src/cpp/fastdds/publisher/DataWriterImpl.hpp
@@ -520,7 +520,10 @@ class DataWriterImpl : protected rtps::IReaderDataFilter
                 const uint32_t& status_id);
 #endif //FASTDDS_STATISTICS
 
+    private:
+
         DataWriterImpl* data_writer_;
+        std::mutex matching_info_mutex_;
     }
     writer_listener_;
 
diff --git a/src/cpp/fastdds/subscriber/DataReaderImpl.cpp b/src/cpp/fastdds/subscriber/DataReaderImpl.cpp
@@ -941,6 +941,8 @@ void DataReaderImpl::InnerDataReaderListener::on_reader_matched(
         RTPSReader* /*reader*/,
         const MatchingInfo& info)
 {
+    std::lock_guard<std::mutex> scoped_lock(matching_info_mutex_);
+
     data_reader_->update_subscription_matched_status(info);
 
     StatusMask notify_status = StatusMask::subscription_matched();
diff --git a/src/cpp/fastdds/subscriber/DataReaderImpl.hpp b/src/cpp/fastdds/subscriber/DataReaderImpl.hpp
@@ -500,7 +500,10 @@ class DataReaderImpl
                 const uint32_t& status_id);
 #endif //FASTDDS_STATISTICS
 
+    private:
+
         DataReaderImpl* data_reader_;
+        std::mutex matching_info_mutex_;
 
     }
     reader_listener_;
diff --git a/src/cpp/rtps/builtin/discovery/endpoint/EDP.cpp b/src/cpp/rtps/builtin/discovery/endpoint/EDP.cpp
@@ -799,8 +799,8 @@ bool EDP::unpairWriterProxy(
 #endif // if HAVE_SECURITY
 
                     //MATCHED AND ADDED CORRECTLY:
-                    ReaderListener* listener = nullptr;
-                    if (nullptr != (listener = r.get_listener()))
+                    ReaderListener* listener = r.get_listener();
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = REMOVED_MATCHING;
@@ -834,8 +834,8 @@ bool EDP::unpairReaderProxy(
                     participant_guid, reader_guid);
 #endif // if HAVE_SECURITY
                     //MATCHED AND ADDED CORRECTLY:
-                    WriterListener* listener = nullptr;
-                    if (nullptr != (listener = w.get_listener()))
+                    WriterListener* listener = w.get_listener();
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = REMOVED_MATCHING;
@@ -1144,40 +1144,39 @@ bool EDP::pairingReader(
                             "WP:" << wdatait->guid << " match R:" << reader_guid << ". RLoc:" <<
                             wdatait->remote_locators);
                     //MATCHED AND ADDED CORRECTLY:
-                    if (reader->get_listener() != nullptr)
+                    ReaderListener* listener = reader->get_listener();
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = MATCHED_MATCHING;
                         info.remoteEndpointGuid = writer_guid;
-                        reader->get_listener()->on_reader_matched(reader, info);
+                        listener->on_reader_matched(reader, info);
                     }
                 }
 #endif // if HAVE_SECURITY
             }
             else
             {
-                if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && reader->get_listener() != nullptr)
+                ReaderListener* listener = reader->get_listener();
+                if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                 {
-                    reader->get_listener()->on_requested_incompatible_qos(reader, incompatible_qos);
+                    listener->on_requested_incompatible_qos(reader, incompatible_qos);
                     mp_PDP->notify_incompatible_qos_matching(R->getGuid(), wdatait->guid, incompatible_qos);
                 }
 
-                //EPROSIMA_LOG_INFO(RTPS_EDP,RTPS_CYAN<<"Valid Matching to writerProxy: "<<wdatait->guid<<RTPS_DEF<<endl);
-                if (reader->matched_writer_is_matched(wdatait->guid)
-                        && reader->matched_writer_remove(wdatait->guid))
+                if (reader->matched_writer_is_matched(wdatait->guid) && reader->matched_writer_remove(wdatait->guid))
                 {
 #if HAVE_SECURITY
-                    mp_RTPSParticipant->security_manager().remove_writer(reader_guid, participant_guid,
-                            wdatait->guid);
+                    mp_RTPSParticipant->security_manager().remove_writer(reader_guid, participant_guid, wdatait->guid);
 #endif // if HAVE_SECURITY
 
                     //MATCHED AND ADDED CORRECTLY:
-                    if (reader->get_listener() != nullptr)
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = REMOVED_MATCHING;
                         info.remoteEndpointGuid = writer_guid;
-                        reader->get_listener()->on_reader_matched(reader, info);
+                        listener->on_reader_matched(reader, info);
                     }
                 }
             }
@@ -1237,21 +1236,23 @@ bool EDP::pairingWriter(
                             "RP:" << rdatait->guid << " match W:" << writer_guid << ". WLoc:" <<
                             rdatait->remote_locators);
                     //MATCHED AND ADDED CORRECTLY:
-                    if (writer->get_listener() != nullptr)
+                    WriterListener* listener = writer->get_listener();
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = MATCHED_MATCHING;
                         info.remoteEndpointGuid = reader_guid;
-                        writer->get_listener()->on_writer_matched(writer, info);
+                        listener->on_writer_matched(writer, info);
                     }
                 }
 #endif // if HAVE_SECURITY
             }
             else
             {
-                if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && writer->get_listener() != nullptr)
+                WriterListener* listener = writer->get_listener();
+                if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                 {
-                    writer->get_listener()->on_offered_incompatible_qos(writer, incompatible_qos);
+                    listener->on_offered_incompatible_qos(writer, incompatible_qos);
                     mp_PDP->notify_incompatible_qos_matching(W->getGuid(), rdatait->guid, incompatible_qos);
                 }
 
@@ -1262,12 +1263,12 @@ bool EDP::pairingWriter(
                     mp_RTPSParticipant->security_manager().remove_reader(writer_guid, participant_guid, reader_guid);
 #endif // if HAVE_SECURITY
                     //MATCHED AND ADDED CORRECTLY:
-                    if (writer->get_listener() != nullptr)
+                    if (nullptr != listener)
                     {
                         MatchingInfo info;
                         info.status = REMOVED_MATCHING;
                         info.remoteEndpointGuid = reader_guid;
-                        writer->get_listener()->on_writer_matched(writer, info);
+                        listener->on_writer_matched(writer, info);
                     }
                 }
             }
@@ -1313,38 +1314,39 @@ bool EDP::pairing_reader_proxy_with_any_local_writer(
                             "RP:" << rdata->guid << " match W:" << w.getGuid() << ". RLoc:" <<
                                 rdata->remote_locators);
                             //MATCHED AND ADDED CORRECTLY:
-                            if (w.get_listener() != nullptr)
+                            WriterListener* listener = w.get_listener();
+                            if (nullptr != listener)
                             {
                                 MatchingInfo info;
                                 info.status = MATCHED_MATCHING;
                                 info.remoteEndpointGuid = reader_guid;
-                                w.get_listener()->on_writer_matched(&w, info);
+                                listener->on_writer_matched(&w, info);
                             }
                         }
 #endif // if HAVE_SECURITY
                     }
                     else
                     {
-                        if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && w.get_listener() != nullptr)
+                        WriterListener* listener = w.get_listener();
+                        if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                         {
-                            w.get_listener()->on_offered_incompatible_qos(&w, incompatible_qos);
+                            listener->on_offered_incompatible_qos(&w, incompatible_qos);
                             mp_PDP->notify_incompatible_qos_matching(w.getGuid(), rdata->guid, incompatible_qos);
                         }
 
-                        if (w.matched_reader_is_matched(reader_guid)
-                        && w.matched_reader_remove(reader_guid))
+                        if (w.matched_reader_is_matched(reader_guid) && w.matched_reader_remove(reader_guid))
                         {
 #if HAVE_SECURITY
                             mp_RTPSParticipant->security_manager().remove_reader(
                                 w.getGuid(), participant_guid, reader_guid);
 #endif // if HAVE_SECURITY
                             //MATCHED AND ADDED CORRECTLY:
-                            if (w.get_listener() != nullptr)
+                            if (nullptr != listener)
                             {
                                 MatchingInfo info;
                                 info.status = REMOVED_MATCHING;
                                 info.remoteEndpointGuid = reader_guid;
-                                w.get_listener()->on_writer_matched(&w, info);
+                                listener->on_writer_matched(&w, info);
                             }
                         }
                     }
@@ -1393,25 +1395,24 @@ bool EDP::pairing_reader_proxy_with_local_writer(
                         }
                         else
                         {
-                            if (no_match_reason.test(MatchingFailureMask::incompatible_qos) &&
-                            w.get_listener() != nullptr)
+                            WriterListener* listener = w.get_listener();
+                            if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                             {
-                                w.get_listener()->on_offered_incompatible_qos(&w, incompatible_qos);
+                                listener->on_offered_incompatible_qos(&w, incompatible_qos);
                                 mp_PDP->notify_incompatible_qos_matching(local_writer, rdata.guid, incompatible_qos);
                             }
 
-                            if (w.matched_reader_is_matched(reader_guid)
-                            && w.matched_reader_remove(reader_guid))
+                            if (w.matched_reader_is_matched(reader_guid) && w.matched_reader_remove(reader_guid))
                             {
                                 mp_RTPSParticipant->security_manager().remove_reader(w.getGuid(),
                                 remote_participant_guid, reader_guid);
                                 //MATCHED AND ADDED CORRECTLY:
-                                if (w.get_listener() != nullptr)
+                                if (nullptr != listener)
                                 {
                                     MatchingInfo info;
                                     info.status = REMOVED_MATCHING;
                                     info.remoteEndpointGuid = reader_guid;
-                                    w.get_listener()->on_writer_matched(&w, info);
+                                    listener->on_writer_matched(&w, info);
                                 }
                             }
                         }
@@ -1448,12 +1449,13 @@ bool EDP::pairing_remote_reader_with_local_writer_after_security(
                         matched = true;
 
                         //MATCHED AND ADDED CORRECTLY:
-                        if (w.get_listener() != nullptr)
+                        WriterListener* listener = w.get_listener();
+                        if (nullptr != listener)
                         {
                             MatchingInfo info;
                             info.status = MATCHED_MATCHING;
                             info.remoteEndpointGuid = reader_guid;
-                            w.get_listener()->on_writer_matched(&w, info);
+                            listener->on_writer_matched(&w, info);
                         }
                     }
                     // don't look anymore
@@ -1506,38 +1508,39 @@ bool EDP::pairing_writer_proxy_with_any_local_reader(
                             "WP:" << wdata->guid << " match R:" << r.getGuid() << ". WLoc:" <<
                                 wdata->remote_locators);
                             //MATCHED AND ADDED CORRECTLY:
-                            if (r.get_listener() != nullptr)
+                            ReaderListener* listener = r.get_listener();
+                            if (nullptr != listener)
                             {
                                 MatchingInfo info;
                                 info.status = MATCHED_MATCHING;
                                 info.remoteEndpointGuid = writer_guid;
-                                r.get_listener()->on_reader_matched(&r, info);
+                                listener->on_reader_matched(&r, info);
                             }
                         }
 #endif // if HAVE_SECURITY
                     }
                     else
                     {
-                        if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && r.get_listener() != nullptr)
+                        ReaderListener* listener = r.get_listener();
+                        if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                         {
-                            r.get_listener()->on_requested_incompatible_qos(&r, incompatible_qos);
+                            listener->on_requested_incompatible_qos(&r, incompatible_qos);
                             mp_PDP->notify_incompatible_qos_matching(r.getGuid(), wdata->guid, incompatible_qos);
                         }
 
-                        if (r.matched_writer_is_matched(writer_guid)
-                        && r.matched_writer_remove(writer_guid))
+                        if (r.matched_writer_is_matched(writer_guid) && r.matched_writer_remove(writer_guid))
                         {
 #if HAVE_SECURITY
                             mp_RTPSParticipant->security_manager().remove_writer(readerGUID, participant_guid,
                             writer_guid);
 #endif // if HAVE_SECURITY
                             //MATCHED AND ADDED CORRECTLY:
-                            if (r.get_listener() != nullptr)
+                            if (nullptr != listener)
                             {
                                 MatchingInfo info;
                                 info.status = REMOVED_MATCHING;
                                 info.remoteEndpointGuid = writer_guid;
-                                r.get_listener()->on_reader_matched(&r, info);
+                                listener->on_reader_matched(&r, info);
                             }
                         }
                     }
@@ -1586,25 +1589,24 @@ bool EDP::pairing_writer_proxy_with_local_reader(
                         }
                         else
                         {
-                            if (no_match_reason.test(MatchingFailureMask::incompatible_qos) &&
-                            r.get_listener() != nullptr)
+                            ReaderListener* listener = r.get_listener();
+                            if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))
                             {
-                                r.get_listener()->on_requested_incompatible_qos(&r, incompatible_qos);
+                                listener->on_requested_incompatible_qos(&r, incompatible_qos);
                                 mp_PDP->notify_incompatible_qos_matching(local_reader, wdata.guid, incompatible_qos);
                             }
 
-                            if (r.matched_writer_is_matched(writer_guid)
-                            && r.matched_writer_remove(writer_guid))
+                            if (r.matched_writer_is_matched(writer_guid) && r.matched_writer_remove(writer_guid))
                             {
                                 mp_RTPSParticipant->security_manager().remove_writer(readerGUID,
                                 remote_participant_guid, writer_guid);
                                 //MATCHED AND ADDED CORRECTLY:
-                                if (r.get_listener() != nullptr)
+                                if (nullptr != listener)
                                 {
                                     MatchingInfo info;
                                     info.status = REMOVED_MATCHING;
                                     info.remoteEndpointGuid = writer_guid;
-                                    r.get_listener()->on_reader_matched(&r, info);
+                                    listener->on_reader_matched(&r, info);
                                 }
                             }
                         }
@@ -1643,13 +1645,13 @@ bool EDP::pairing_remote_writer_with_local_reader_after_security(
                         matched = true;
 
                         //MATCHED AND ADDED CORRECTLY:
-                        if (r.get_listener() != nullptr)
+                        ReaderListener* listener = r.get_listener();
+                        if (nullptr != listener)
                         {
                             MatchingInfo info;
                             info.status = MATCHED_MATCHING;
                             info.remoteEndpointGuid = writer_guid;
-                            r.get_listener()->on_reader_matched(&r, info);
-
+                            listener->on_reader_matched(&r, info);
                         }
                     }
                     // dont' look anymore
diff --git a/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp b/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp

Original file line number	Diff line number	Diff line change
`@@ -1341,6 +1341,8 @@ void DataWriterImpl::InnerDataWriterListener::on_writer_matched(`
`1341`	`1341`	`RTPSWriter* /writer/,`
`1342`	`1342`	`const MatchingInfo& info)`
`1343`	`1343`	`{`
	`1344`	`+ std::lock_guard<std::mutex> scoped_lock(matching_info_mutex_);`
	`1345`	`+`
`1344`	`1346`	`data_writer_->update_publication_matched_status(info);`
`1345`	`1347`
`1346`	`1348`	`StatusMask notify_status = StatusMask::publication_matched();`
Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,10 @@ class DataWriterImpl : protected rtps::IReaderDataFilter`
`520`	`520`	`const uint32_t& status_id);`
`521`	`521`	`#endif //FASTDDS_STATISTICS`
`522`	`522`
	`523`	`+ private:`
	`524`	`+`
`523`	`525`	`DataWriterImpl* data_writer_;`
	`526`	`+ std::mutex matching_info_mutex_;`
`524`	`527`	`}`
`525`	`528`	`writer_listener_;`
`526`	`529`
Original file line number	Diff line number	Diff line change
`@@ -941,6 +941,8 @@ void DataReaderImpl::InnerDataReaderListener::on_reader_matched(`
`941`	`941`	`RTPSReader* /reader/,`
`942`	`942`	`const MatchingInfo& info)`
`943`	`943`	`{`
	`944`	`+ std::lock_guard<std::mutex> scoped_lock(matching_info_mutex_);`
	`945`	`+`
`944`	`946`	`data_reader_->update_subscription_matched_status(info);`
`945`	`947`
`946`	`948`	`StatusMask notify_status = StatusMask::subscription_matched();`
Original file line number	Diff line number	Diff line change
`@@ -500,7 +500,10 @@ class DataReaderImpl`
`500`	`500`	`const uint32_t& status_id);`
`501`	`501`	`#endif //FASTDDS_STATISTICS`
`502`	`502`
	`503`	`+ private:`
	`504`	`+`
`503`	`505`	`DataReaderImpl* data_reader_;`
	`506`	`+ std::mutex matching_info_mutex_;`
`504`	`507`
`505`	`508`	`}`
`506`	`509`	`reader_listener_;`
Original file line number	Diff line number	Diff line change
`@@ -799,8 +799,8 @@ bool EDP::unpairWriterProxy(`
`799`	`799`	`#endif // if HAVE_SECURITY`
`800`	`800`
`801`	`801`	`//MATCHED AND ADDED CORRECTLY:`
`802`		`- ReaderListener* listener = nullptr;`
`803`		`- if (nullptr != (listener = r.get_listener()))`
	`802`	`+ ReaderListener* listener = r.get_listener();`
	`803`	`+ if (nullptr != listener)`
`804`	`804`	`{`
`805`	`805`	`MatchingInfo info;`
`806`	`806`	`info.status = REMOVED_MATCHING;`
`@@ -834,8 +834,8 @@ bool EDP::unpairReaderProxy(`
`834`	`834`	`participant_guid, reader_guid);`
`835`	`835`	`#endif // if HAVE_SECURITY`
`836`	`836`	`//MATCHED AND ADDED CORRECTLY:`
`837`		`- WriterListener* listener = nullptr;`
`838`		`- if (nullptr != (listener = w.get_listener()))`
	`837`	`+ WriterListener* listener = w.get_listener();`
	`838`	`+ if (nullptr != listener)`
`839`	`839`	`{`
`840`	`840`	`MatchingInfo info;`
`841`	`841`	`info.status = REMOVED_MATCHING;`
`@@ -1144,40 +1144,39 @@ bool EDP::pairingReader(`
`1144`	`1144`	`"WP:" << wdatait->guid << " match R:" << reader_guid << ". RLoc:" <<`
`1145`	`1145`	`wdatait->remote_locators);`
`1146`	`1146`	`//MATCHED AND ADDED CORRECTLY:`
`1147`		`- if (reader->get_listener() != nullptr)`
	`1147`	`+ ReaderListener* listener = reader->get_listener();`
	`1148`	`+ if (nullptr != listener)`
`1148`	`1149`	`{`
`1149`	`1150`	`MatchingInfo info;`
`1150`	`1151`	`info.status = MATCHED_MATCHING;`
`1151`	`1152`	`info.remoteEndpointGuid = writer_guid;`
`1152`		`- reader->get_listener()->on_reader_matched(reader, info);`
	`1153`	`+ listener->on_reader_matched(reader, info);`
`1153`	`1154`	`}`
`1154`	`1155`	`}`
`1155`	`1156`	`#endif // if HAVE_SECURITY`
`1156`	`1157`	`}`
`1157`	`1158`	`else`
`1158`	`1159`	`{`
`1159`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && reader->get_listener() != nullptr)`
	`1160`	`+ ReaderListener* listener = reader->get_listener();`
	`1161`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1160`	`1162`	`{`
`1161`		`- reader->get_listener()->on_requested_incompatible_qos(reader, incompatible_qos);`
	`1163`	`+ listener->on_requested_incompatible_qos(reader, incompatible_qos);`
`1162`	`1164`	`mp_PDP->notify_incompatible_qos_matching(R->getGuid(), wdatait->guid, incompatible_qos);`
`1163`	`1165`	`}`
`1164`	`1166`
`1165`		`- //EPROSIMA_LOG_INFO(RTPS_EDP,RTPS_CYAN<<"Valid Matching to writerProxy: "<<wdatait->guid<<RTPS_DEF<<endl);`
`1166`		`- if (reader->matched_writer_is_matched(wdatait->guid)`
`1167`		`- && reader->matched_writer_remove(wdatait->guid))`
	`1167`	`+ if (reader->matched_writer_is_matched(wdatait->guid) && reader->matched_writer_remove(wdatait->guid))`
`1168`	`1168`	`{`
`1169`	`1169`	`#if HAVE_SECURITY`
`1170`		`- mp_RTPSParticipant->security_manager().remove_writer(reader_guid, participant_guid,`
`1171`		`- wdatait->guid);`
	`1170`	`+ mp_RTPSParticipant->security_manager().remove_writer(reader_guid, participant_guid, wdatait->guid);`
`1172`	`1171`	`#endif // if HAVE_SECURITY`
`1173`	`1172`
`1174`	`1173`	`//MATCHED AND ADDED CORRECTLY:`
`1175`		`- if (reader->get_listener() != nullptr)`
	`1174`	`+ if (nullptr != listener)`
`1176`	`1175`	`{`
`1177`	`1176`	`MatchingInfo info;`
`1178`	`1177`	`info.status = REMOVED_MATCHING;`
`1179`	`1178`	`info.remoteEndpointGuid = writer_guid;`
`1180`		`- reader->get_listener()->on_reader_matched(reader, info);`
	`1179`	`+ listener->on_reader_matched(reader, info);`
`1181`	`1180`	`}`
`1182`	`1181`	`}`
`1183`	`1182`	`}`
`@@ -1237,21 +1236,23 @@ bool EDP::pairingWriter(`
`1237`	`1236`	`"RP:" << rdatait->guid << " match W:" << writer_guid << ". WLoc:" <<`
`1238`	`1237`	`rdatait->remote_locators);`
`1239`	`1238`	`//MATCHED AND ADDED CORRECTLY:`
`1240`		`- if (writer->get_listener() != nullptr)`
	`1239`	`+ WriterListener* listener = writer->get_listener();`
	`1240`	`+ if (nullptr != listener)`
`1241`	`1241`	`{`
`1242`	`1242`	`MatchingInfo info;`
`1243`	`1243`	`info.status = MATCHED_MATCHING;`
`1244`	`1244`	`info.remoteEndpointGuid = reader_guid;`
`1245`		`- writer->get_listener()->on_writer_matched(writer, info);`
	`1245`	`+ listener->on_writer_matched(writer, info);`
`1246`	`1246`	`}`
`1247`	`1247`	`}`
`1248`	`1248`	`#endif // if HAVE_SECURITY`
`1249`	`1249`	`}`
`1250`	`1250`	`else`
`1251`	`1251`	`{`
`1252`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && writer->get_listener() != nullptr)`
	`1252`	`+ WriterListener* listener = writer->get_listener();`
	`1253`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1253`	`1254`	`{`
`1254`		`- writer->get_listener()->on_offered_incompatible_qos(writer, incompatible_qos);`
	`1255`	`+ listener->on_offered_incompatible_qos(writer, incompatible_qos);`
`1255`	`1256`	`mp_PDP->notify_incompatible_qos_matching(W->getGuid(), rdatait->guid, incompatible_qos);`
`1256`	`1257`	`}`
`1257`	`1258`
`@@ -1262,12 +1263,12 @@ bool EDP::pairingWriter(`
`1262`	`1263`	`mp_RTPSParticipant->security_manager().remove_reader(writer_guid, participant_guid, reader_guid);`
`1263`	`1264`	`#endif // if HAVE_SECURITY`
`1264`	`1265`	`//MATCHED AND ADDED CORRECTLY:`
`1265`		`- if (writer->get_listener() != nullptr)`
	`1266`	`+ if (nullptr != listener)`
`1266`	`1267`	`{`
`1267`	`1268`	`MatchingInfo info;`
`1268`	`1269`	`info.status = REMOVED_MATCHING;`
`1269`	`1270`	`info.remoteEndpointGuid = reader_guid;`
`1270`		`- writer->get_listener()->on_writer_matched(writer, info);`
	`1271`	`+ listener->on_writer_matched(writer, info);`
`1271`	`1272`	`}`
`1272`	`1273`	`}`
`1273`	`1274`	`}`
`@@ -1313,38 +1314,39 @@ bool EDP::pairing_reader_proxy_with_any_local_writer(`
`1313`	`1314`	`"RP:" << rdata->guid << " match W:" << w.getGuid() << ". RLoc:" <<`
`1314`	`1315`	`rdata->remote_locators);`
`1315`	`1316`	`//MATCHED AND ADDED CORRECTLY:`
`1316`		`- if (w.get_listener() != nullptr)`
	`1317`	`+ WriterListener* listener = w.get_listener();`
	`1318`	`+ if (nullptr != listener)`
`1317`	`1319`	`{`
`1318`	`1320`	`MatchingInfo info;`
`1319`	`1321`	`info.status = MATCHED_MATCHING;`
`1320`	`1322`	`info.remoteEndpointGuid = reader_guid;`
`1321`		`- w.get_listener()->on_writer_matched(&w, info);`
	`1323`	`+ listener->on_writer_matched(&w, info);`
`1322`	`1324`	`}`
`1323`	`1325`	`}`
`1324`	`1326`	`#endif // if HAVE_SECURITY`
`1325`	`1327`	`}`
`1326`	`1328`	`else`
`1327`	`1329`	`{`
`1328`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && w.get_listener() != nullptr)`
	`1330`	`+ WriterListener* listener = w.get_listener();`
	`1331`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1329`	`1332`	`{`
`1330`		`- w.get_listener()->on_offered_incompatible_qos(&w, incompatible_qos);`
	`1333`	`+ listener->on_offered_incompatible_qos(&w, incompatible_qos);`
`1331`	`1334`	`mp_PDP->notify_incompatible_qos_matching(w.getGuid(), rdata->guid, incompatible_qos);`
`1332`	`1335`	`}`
`1333`	`1336`
`1334`		`- if (w.matched_reader_is_matched(reader_guid)`
`1335`		`- && w.matched_reader_remove(reader_guid))`
	`1337`	`+ if (w.matched_reader_is_matched(reader_guid) && w.matched_reader_remove(reader_guid))`
`1336`	`1338`	`{`
`1337`	`1339`	`#if HAVE_SECURITY`
`1338`	`1340`	`mp_RTPSParticipant->security_manager().remove_reader(`
`1339`	`1341`	`w.getGuid(), participant_guid, reader_guid);`
`1340`	`1342`	`#endif // if HAVE_SECURITY`
`1341`	`1343`	`//MATCHED AND ADDED CORRECTLY:`
`1342`		`- if (w.get_listener() != nullptr)`
	`1344`	`+ if (nullptr != listener)`
`1343`	`1345`	`{`
`1344`	`1346`	`MatchingInfo info;`
`1345`	`1347`	`info.status = REMOVED_MATCHING;`
`1346`	`1348`	`info.remoteEndpointGuid = reader_guid;`
`1347`		`- w.get_listener()->on_writer_matched(&w, info);`
	`1349`	`+ listener->on_writer_matched(&w, info);`
`1348`	`1350`	`}`
`1349`	`1351`	`}`
`1350`	`1352`	`}`
`@@ -1393,25 +1395,24 @@ bool EDP::pairing_reader_proxy_with_local_writer(`
`1393`	`1395`	`}`
`1394`	`1396`	`else`
`1395`	`1397`	`{`
`1396`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) &&`
`1397`		`- w.get_listener() != nullptr)`
	`1398`	`+ WriterListener* listener = w.get_listener();`
	`1399`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1398`	`1400`	`{`
`1399`		`- w.get_listener()->on_offered_incompatible_qos(&w, incompatible_qos);`
	`1401`	`+ listener->on_offered_incompatible_qos(&w, incompatible_qos);`
`1400`	`1402`	`mp_PDP->notify_incompatible_qos_matching(local_writer, rdata.guid, incompatible_qos);`
`1401`	`1403`	`}`
`1402`	`1404`
`1403`		`- if (w.matched_reader_is_matched(reader_guid)`
`1404`		`- && w.matched_reader_remove(reader_guid))`
	`1405`	`+ if (w.matched_reader_is_matched(reader_guid) && w.matched_reader_remove(reader_guid))`
`1405`	`1406`	`{`
`1406`	`1407`	`mp_RTPSParticipant->security_manager().remove_reader(w.getGuid(),`
`1407`	`1408`	`remote_participant_guid, reader_guid);`
`1408`	`1409`	`//MATCHED AND ADDED CORRECTLY:`
`1409`		`- if (w.get_listener() != nullptr)`
	`1410`	`+ if (nullptr != listener)`
`1410`	`1411`	`{`
`1411`	`1412`	`MatchingInfo info;`
`1412`	`1413`	`info.status = REMOVED_MATCHING;`
`1413`	`1414`	`info.remoteEndpointGuid = reader_guid;`
`1414`		`- w.get_listener()->on_writer_matched(&w, info);`
	`1415`	`+ listener->on_writer_matched(&w, info);`
`1415`	`1416`	`}`
`1416`	`1417`	`}`
`1417`	`1418`	`}`
`@@ -1448,12 +1449,13 @@ bool EDP::pairing_remote_reader_with_local_writer_after_security(`
`1448`	`1449`	`matched = true;`
`1449`	`1450`
`1450`	`1451`	`//MATCHED AND ADDED CORRECTLY:`
`1451`		`- if (w.get_listener() != nullptr)`
	`1452`	`+ WriterListener* listener = w.get_listener();`
	`1453`	`+ if (nullptr != listener)`
`1452`	`1454`	`{`
`1453`	`1455`	`MatchingInfo info;`
`1454`	`1456`	`info.status = MATCHED_MATCHING;`
`1455`	`1457`	`info.remoteEndpointGuid = reader_guid;`
`1456`		`- w.get_listener()->on_writer_matched(&w, info);`
	`1458`	`+ listener->on_writer_matched(&w, info);`
`1457`	`1459`	`}`
`1458`	`1460`	`}`
`1459`	`1461`	`// don't look anymore`
`@@ -1506,38 +1508,39 @@ bool EDP::pairing_writer_proxy_with_any_local_reader(`
`1506`	`1508`	`"WP:" << wdata->guid << " match R:" << r.getGuid() << ". WLoc:" <<`
`1507`	`1509`	`wdata->remote_locators);`
`1508`	`1510`	`//MATCHED AND ADDED CORRECTLY:`
`1509`		`- if (r.get_listener() != nullptr)`
	`1511`	`+ ReaderListener* listener = r.get_listener();`
	`1512`	`+ if (nullptr != listener)`
`1510`	`1513`	`{`
`1511`	`1514`	`MatchingInfo info;`
`1512`	`1515`	`info.status = MATCHED_MATCHING;`
`1513`	`1516`	`info.remoteEndpointGuid = writer_guid;`
`1514`		`- r.get_listener()->on_reader_matched(&r, info);`
	`1517`	`+ listener->on_reader_matched(&r, info);`
`1515`	`1518`	`}`
`1516`	`1519`	`}`
`1517`	`1520`	`#endif // if HAVE_SECURITY`
`1518`	`1521`	`}`
`1519`	`1522`	`else`
`1520`	`1523`	`{`
`1521`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && r.get_listener() != nullptr)`
	`1524`	`+ ReaderListener* listener = r.get_listener();`
	`1525`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1522`	`1526`	`{`
`1523`		`- r.get_listener()->on_requested_incompatible_qos(&r, incompatible_qos);`
	`1527`	`+ listener->on_requested_incompatible_qos(&r, incompatible_qos);`
`1524`	`1528`	`mp_PDP->notify_incompatible_qos_matching(r.getGuid(), wdata->guid, incompatible_qos);`
`1525`	`1529`	`}`
`1526`	`1530`
`1527`		`- if (r.matched_writer_is_matched(writer_guid)`
`1528`		`- && r.matched_writer_remove(writer_guid))`
	`1531`	`+ if (r.matched_writer_is_matched(writer_guid) && r.matched_writer_remove(writer_guid))`
`1529`	`1532`	`{`
`1530`	`1533`	`#if HAVE_SECURITY`
`1531`	`1534`	`mp_RTPSParticipant->security_manager().remove_writer(readerGUID, participant_guid,`
`1532`	`1535`	`writer_guid);`
`1533`	`1536`	`#endif // if HAVE_SECURITY`
`1534`	`1537`	`//MATCHED AND ADDED CORRECTLY:`
`1535`		`- if (r.get_listener() != nullptr)`
	`1538`	`+ if (nullptr != listener)`
`1536`	`1539`	`{`
`1537`	`1540`	`MatchingInfo info;`
`1538`	`1541`	`info.status = REMOVED_MATCHING;`
`1539`	`1542`	`info.remoteEndpointGuid = writer_guid;`
`1540`		`- r.get_listener()->on_reader_matched(&r, info);`
	`1543`	`+ listener->on_reader_matched(&r, info);`
`1541`	`1544`	`}`
`1542`	`1545`	`}`
`1543`	`1546`	`}`
`@@ -1586,25 +1589,24 @@ bool EDP::pairing_writer_proxy_with_local_reader(`
`1586`	`1589`	`}`
`1587`	`1590`	`else`
`1588`	`1591`	`{`
`1589`		`- if (no_match_reason.test(MatchingFailureMask::incompatible_qos) &&`
`1590`		`- r.get_listener() != nullptr)`
	`1592`	`+ ReaderListener* listener = r.get_listener();`
	`1593`	`+ if (no_match_reason.test(MatchingFailureMask::incompatible_qos) && (nullptr != listener))`
`1591`	`1594`	`{`
`1592`		`- r.get_listener()->on_requested_incompatible_qos(&r, incompatible_qos);`
	`1595`	`+ listener->on_requested_incompatible_qos(&r, incompatible_qos);`
`1593`	`1596`	`mp_PDP->notify_incompatible_qos_matching(local_reader, wdata.guid, incompatible_qos);`
`1594`	`1597`	`}`
`1595`	`1598`
`1596`		`- if (r.matched_writer_is_matched(writer_guid)`
`1597`		`- && r.matched_writer_remove(writer_guid))`
	`1599`	`+ if (r.matched_writer_is_matched(writer_guid) && r.matched_writer_remove(writer_guid))`
`1598`	`1600`	`{`
`1599`	`1601`	`mp_RTPSParticipant->security_manager().remove_writer(readerGUID,`
`1600`	`1602`	`remote_participant_guid, writer_guid);`
`1601`	`1603`	`//MATCHED AND ADDED CORRECTLY:`
`1602`		`- if (r.get_listener() != nullptr)`
	`1604`	`+ if (nullptr != listener)`
`1603`	`1605`	`{`
`1604`	`1606`	`MatchingInfo info;`
`1605`	`1607`	`info.status = REMOVED_MATCHING;`
`1606`	`1608`	`info.remoteEndpointGuid = writer_guid;`
`1607`		`- r.get_listener()->on_reader_matched(&r, info);`
	`1609`	`+ listener->on_reader_matched(&r, info);`
`1608`	`1610`	`}`
`1609`	`1611`	`}`
`1610`	`1612`	`}`
`@@ -1643,13 +1645,13 @@ bool EDP::pairing_remote_writer_with_local_reader_after_security(`
`1643`	`1645`	`matched = true;`
`1644`	`1646`
`1645`	`1647`	`//MATCHED AND ADDED CORRECTLY:`
`1646`		`- if (r.get_listener() != nullptr)`
	`1648`	`+ ReaderListener* listener = r.get_listener();`
	`1649`	`+ if (nullptr != listener)`
`1647`	`1650`	`{`
`1648`	`1651`	`MatchingInfo info;`
`1649`	`1652`	`info.status = MATCHED_MATCHING;`
`1650`	`1653`	`info.remoteEndpointGuid = writer_guid;`
`1651`		`- r.get_listener()->on_reader_matched(&r, info);`
`1652`		`-`
	`1654`	`+ listener->on_reader_matched(&r, info);`
`1653`	`1655`	`}`
`1654`	`1656`	`}`
`1655`	`1657`	`// dont' look anymore`