Refs #21358: Fix null-deprecated error

Javier Gil Aviles · Javier Gil Aviles · commit d979d8f8eb65 · 2025-06-20T15:20:07.000+02:00
Signed-off-by: Javier Gil Aviles &lt;javiergil@eprosima.com&gt;
diff --git a/.github/workflows/reusable-ubuntu-ci.yml b/.github/workflows/reusable-ubuntu-ci.yml
@@ -60,7 +60,6 @@ on:
 
 env:
   security-cmake-flag: ${{ inputs.security == true && '-DSECURITY=ON' || '-DSECURITY=OFF' }}
-  colcon-build-default-cmake-args: '-DCMAKE_CXX_FLAGS="-Werror -Wall -Wextra -Wpedantic -Wunused-value -Woverloaded-virtual -Wsign-compare -Wcast-align -Wlogical-op -Wduplicated-cond -Wrestrict -Wpointer-arith -Wwrite-strings -Wunreachable-code"'
 defaults:
   run:
     shell: bash
@@ -74,6 +73,8 @@ jobs:
       matrix:
         cmake-build-type:
           - 'RelWithDebInfo'
+    env:
+        colcon-build-default-cmake-args: '-DCMAKE_CXX_FLAGS="-Werror -Wall -Wextra -Wpedantic -Wunused-value -Woverloaded-virtual -Wsign-compare -Wcast-align -Wlogical-op -Wduplicated-cond -Wrestrict -Wnull-dereference -Wpointer-arith -Wwrite-strings -Wunreachable-code"'
     steps:
       - name: Add ci-pending label if PR
         if: ${{ github.event_name == 'pull_request' && inputs.add-label == true }}
diff --git a/include/fastdds/rtps/common/Guid.hpp b/include/fastdds/rtps/common/Guid.hpp
@@ -34,6 +34,11 @@ namespace rtps {
 
 struct InstanceHandle_t;
 
+#ifndef _MSC_VER
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wnull-dereference"
+#endif
+
 //!@brief Structure GUID_t, entity identifier, unique in DDS-RTPS Domain.
 //!@ingroup COMMON_MODULE
 struct FASTDDS_EXPORTED_API GUID_t
@@ -147,6 +152,10 @@ struct FASTDDS_EXPORTED_API GUID_t
     }
 };
 
+#ifndef _MSC_VER
+    #pragma GCC diagnostic pop
+#endif
+
 #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
 /**
diff --git a/src/cpp/fastdds/publisher/DataWriter.cpp b/src/cpp/fastdds/publisher/DataWriter.cpp
@@ -40,8 +40,24 @@ DataWriter::DataWriter(
         DataWriterListener* listener,
         const StatusMask& mask)
     : DomainEntity(mask)
-    , impl_(pub->create_datawriter(topic, qos, listener, mask)->impl_)
+    , impl_(nullptr)
 {
+    if (nullptr == pub)
+    {
+        EPROSIMA_LOG_ERROR(DATA_WRITER, "Publisher pointer is null");
+    }
+    else
+    {
+        DataWriter* dw = pub->create_datawriter(topic, qos, listener, mask);
+        if (nullptr == dw)
+        {
+            EPROSIMA_LOG_ERROR(DATA_WRITER, "Publisher::create_datawriter returned null");
+        }
+        else
+        {
+            impl_ = dw->impl_;
+        }
+    }
 }
 
 DataWriter::~DataWriter()
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/AnnotationDescriptorImpl.cpp b/src/cpp/fastdds/xtypes/dynamic_types/AnnotationDescriptorImpl.cpp
@@ -137,6 +137,11 @@ bool AnnotationDescriptorImpl::is_consistent() noexcept
         {
             return false;
         }
+
+        if (!ann_param_type)
+        {
+            return false;
+        }
         //}}}
 
         //{{{ Check the parameter value is convertible to its type.
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/DynamicDataImpl.cpp b/src/cpp/fastdds/xtypes/dynamic_types/DynamicDataImpl.cpp
@@ -1585,6 +1585,10 @@ size_t DynamicDataImpl::calculate_key_serialized_size(
             for (auto& member : enclosing_type_->get_all_members())
             {
                 auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
+                if (!member_impl)
+                {
+                    continue;
+                }
                 if (member_impl->get_descriptor().is_key())
                 {
                     there_is_keyed_member = true;
@@ -1610,6 +1614,10 @@ size_t DynamicDataImpl::calculate_key_serialized_size(
                 for (auto& member : enclosing_type_->get_all_members())
                 {
                     auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
+                    if (!member_impl)
+                    {
+                        continue;
+                    }
                     auto member_type {traits<DynamicType>::narrow<DynamicTypeImpl>(member_impl->get_descriptor().type())};
 
                     //TODO(richiware) For the future support of optionals. Optional member cannot be a keyed member.
@@ -1978,6 +1986,10 @@ void DynamicDataImpl::serialize_key(
             for (auto& member : enclosing_type_->get_all_members())
             {
                 auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
+                if (!member_impl)
+                {
+                    continue;
+                }
                 if (member_impl->get_descriptor().is_key())
                 {
                     there_is_keyed_member = true;
@@ -2002,6 +2014,10 @@ void DynamicDataImpl::serialize_key(
                 for (auto& member : enclosing_type_->get_all_members())
                 {
                     auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
+                    if (!member_impl)
+                    {
+                        continue;
+                    }
                     auto member_type {traits<DynamicType>::narrow<DynamicTypeImpl>(member_impl->get_descriptor().type())};
 
                     if (TK_MAP != member_type->resolve_alias_enclosed_type()->get_kind())
@@ -2050,6 +2066,11 @@ void DynamicDataImpl::apply_bitset_mask(
     assert(enclosing_type_->get_all_members().end() != enclosing_type_->get_all_members().find(member_id));
     const auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(
                                 enclosing_type_->get_all_members().at(member_id))};
+    if (!member_impl)
+    {
+        EPROSIMA_LOG_ERROR(DYN_TYPES, "Error applying bitset mask. MemberId not found.");
+        return;
+    }
     const auto member_index {member_impl->get_descriptor().index()};
     const auto bound {enclosing_type_->get_descriptor().bound().at(member_index)};
     uint64_t mask {64 == bound ? 0x0llu : 0XFFFFFFFFFFFFFFFFllu << bound};
@@ -4008,6 +4029,13 @@ void DynamicDataImpl::set_discriminator_value(
     auto m_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member);
     int32_t label {0};
 
+    if (!m_impl)
+    {
+        EPROSIMA_LOG_ERROR(DYN_TYPES, "MemberId " << id << " not found in enclosing type "
+                                                  << enclosing_type_->get_descriptor().name());
+        return;
+    }
+
     if (m_impl->get_descriptor().is_default_label())
     {
         label = enclosing_type_->default_value();
@@ -6406,6 +6434,11 @@ bool DynamicDataImpl::deserialize(
                         {
                             auto member_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member);
                             traits<DynamicDataImpl>::ref_type member_data;
+                            if (!member_impl)
+                            {
+                                throw fastcdr::exception::BadParamException(
+                                    "Member not found in DynamicTypeImpl");
+                            }
                             auto it = value_.find(member_impl->get_id());
 
                             if (it != value_.end())
@@ -6466,6 +6499,12 @@ bool DynamicDataImpl::deserialize(
                                             auto m_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(
                                                              member)};
 
+                                            if (!m_impl)
+                                            {
+                                                ret_value = false;
+                                                continue;
+                                            }
+
                                             for (auto label : m_impl->get_descriptor().label())
                                             {
                                                 if (static_cast<int32_t>(discriminator) == label)
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/DynamicDataImpl.hpp b/src/cpp/fastdds/xtypes/dynamic_types/DynamicDataImpl.hpp
@@ -491,6 +491,11 @@ class DynamicDataImpl : public traits<DynamicData>::base_type
             enclosing_type_->get_member(selected_member, selected_union_member_);
             auto sm_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(selected_member);
 
+            if (!sm_impl)
+            {
+                return false;
+            }
+
             for (auto label : sm_impl->get_descriptor().label())
             {
                 if (static_cast<int32_t>(value) == label)
@@ -512,6 +517,12 @@ class DynamicDataImpl : public traits<DynamicData>::base_type
                 {
                     auto m_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member);
 
+                    if (!m_impl)
+                    {
+                        ret_value = false;
+                        continue;
+                    }
+
                     for (auto label : m_impl->get_descriptor().label())
                     {
                         if (static_cast<int32_t>(value) == label)
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/DynamicPubSubType.cpp b/src/cpp/fastdds/xtypes/dynamic_types/DynamicPubSubType.cpp
@@ -232,6 +232,11 @@ bool DynamicPubSubType::serialize(
     payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
 
     auto type_impl = traits<DynamicType>::narrow<DynamicTypeImpl>(dynamic_type_);
+    if (!type_impl)
+    {
+        EPROSIMA_LOG_ERROR(DYN_TYPES, "DynamicPubSubType cannot serialize data. Unspecified type.");
+        return false;
+    }
     ser.set_encoding_flag(get_fastcdr_encoding_flag(type_impl->get_descriptor().extensibility_kind(),
             fastdds::dds::DataRepresentationId_t::XCDR_DATA_REPRESENTATION == data_representation?
             eprosima::fastcdr::CdrVersion:: XCDRv1 :
@@ -317,6 +322,10 @@ void DynamicPubSubType::update_dynamic_type()
         for (auto& member : type_impl->get_all_members_by_index())
         {
             auto member_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member);
+            if (!member_impl)
+            {
+                continue;
+            }
             if (member_impl->get_descriptor().is_key())
             {
                 is_compute_key_provided = true;
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/DynamicTypeBuilderFactoryImpl.cpp b/src/cpp/fastdds/xtypes/dynamic_types/DynamicTypeBuilderFactoryImpl.cpp
@@ -56,6 +56,12 @@ traits<DynamicTypeBuilder>::ref_type DynamicTypeBuilderFactoryImpl::create_type(
 {
     auto descriptor_impl = traits<TypeDescriptor>::narrow<TypeDescriptorImpl>(descriptor);
 
+    if (!descriptor_impl)
+    {
+        EPROSIMA_LOG_ERROR(DYN_TYPES, "Invalid TypeDescriptor provided to create_type.");
+        return {};
+    }
+
     if (descriptor_impl->is_consistent())
     {
         return std::make_shared<DynamicTypeBuilderImpl>(*descriptor_impl);
diff --git a/src/cpp/fastdds/xtypes/dynamic_types/DynamicTypeBuilderImpl.cpp b/src/cpp/fastdds/xtypes/dynamic_types/DynamicTypeBuilderImpl.cpp
@@ -59,8 +59,16 @@ DynamicTypeBuilderImpl::DynamicTypeBuilderImpl(
         {
             traits<DynamicTypeMemberImpl>::ref_type member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(
                                                                      members_.back())};
-            assert(MEMBER_ID_INVALID != member_impl->get_descriptor().id());
-            next_id_ = member_impl->get_descriptor().id() + 1;
+            if (!member_impl)
+            {
+                EPROSIMA_LOG_ERROR(DYN_TYPES,
+                        "Internal error: last member is not a DynamicTypeMemberImpl");
+            }
+            else
+            {
+                assert(MEMBER_ID_INVALID != member_impl->get_descriptor().id());
+                next_id_ = member_impl->get_descriptor().id() + 1;
+            }
         }
 
         next_index_ = static_cast<uint32_t>(members_.size());
@@ -453,6 +461,11 @@ ReturnCode_t DynamicTypeBuilderImpl::add_member(
         {
             const MemberId mid {member.first};
             const auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
+            if (!member_impl)
+            {
+                EPROSIMA_LOG_ERROR(DYN_TYPES, "Member with id " << mid << " is not a DynamicTypeMemberImpl");
+                return RETCODE_BAD_PARAMETER;
+            }
             const auto member_index {member_impl->get_descriptor().index()};
 
             if (mid == new_member_id)
@@ -499,6 +512,12 @@ ReturnCode_t DynamicTypeBuilderImpl::add_member(
         {
             const auto member_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(members_.at(0));
 
+            if (!member_impl)
+            {
+                EPROSIMA_LOG_ERROR(DYN_TYPES, "Member is not a DynamicTypeMemberImpl");
+                return RETCODE_BAD_PARAMETER;
+            }
+
             if (member_impl->get_descriptor().type()->get_kind() != descriptor->type()->get_kind())
             {
                 EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor type kind differs from the current member types.");
@@ -554,6 +573,11 @@ ReturnCode_t DynamicTypeBuilderImpl::add_member(
         for (++it; it != members_.end(); ++it)
         {
             auto next_member = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(*it);
+            if (!next_member)
+            {
+                EPROSIMA_LOG_ERROR(DYN_TYPES, "Member is not a DynamicTypeMemberImpl");
+                return RETCODE_BAD_PARAMETER;
+            }
             next_member->get_descriptor().index(next_member->get_descriptor().index() + 1);
         }
         ++next_index_;
diff --git a/src/cpp/rtps/builtin/discovery/endpoint/EDPSimple.cpp b/src/cpp/rtps/builtin/discovery/endpoint/EDPSimple.cpp
@@ -157,8 +157,19 @@ void EDPSimple::processPersistentData(
     std::lock_guard<RecursiveTimedMutex> guardW(writer.first->getMutex());
     std::lock_guard<std::recursive_mutex> guardP(*mp_PDP->getMutex());
 
+    if (nullptr == mp_PDP)
+    {
+        EPROSIMA_LOG_ERROR(RTPS_EDP, "Cannot processPersistentData: mp_PDP is null");
+        return;
+    }
+    ParticipantProxyData* local_ppd = mp_PDP->getLocalParticipantProxyData();
+    if (nullptr == local_ppd)
+    {
+        EPROSIMA_LOG_ERROR(RTPS_EDP, "Cannot processPersistentData: LocalParticipantProxyData is null");
+        return;
+    }
     // own server instance
-    InstanceHandle_t server_key = mp_PDP->getLocalParticipantProxyData()->m_key;
+    InstanceHandle_t server_key = local_ppd->m_key;
 
     // reference own references from writer history
     std::forward_list<CacheChange_t*> removal;
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDP.cpp b/src/cpp/rtps/builtin/discovery/participant/PDP.cpp
@@ -597,7 +597,14 @@ void PDP::announceParticipantState(
             if (m_hasChangedLocalPDP.exchange(false) || new_change)
             {
                 mp_mutex->lock();
-                ParticipantProxyData* local_participant_data = getLocalParticipantProxyData();
+                auto* local_participant_data = getLocalParticipantProxyData();
+                if (!local_participant_data)
+                {
+                    EPROSIMA_LOG_ERROR(RTPS_PDP,
+                            "announceParticipantState(): local participant data is null");
+                    mp_mutex->unlock();
+                    return;
+                }
                 InstanceHandle_t key = local_participant_data->m_key;
                 ParticipantProxyData proxy_data_copy(*local_participant_data);
                 mp_mutex->unlock();
@@ -638,7 +645,14 @@ void PDP::announceParticipantState(
         else
         {
             mp_mutex->lock();
-            ParticipantProxyData* local_participant_data = getLocalParticipantProxyData();
+            auto* local_participant_data = getLocalParticipantProxyData();
+            if (!local_participant_data)
+            {
+                EPROSIMA_LOG_ERROR(RTPS_PDP,
+                        "announceParticipantState(): local participant data is null");
+                mp_mutex->unlock();
+                return;
+            }
             InstanceHandle_t key = local_participant_data->m_key;
             ParticipantProxyData proxy_data_copy(*local_participant_data);
             mp_mutex->unlock();
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDP.h b/src/cpp/rtps/builtin/discovery/participant/PDP.h
@@ -342,7 +342,13 @@ class PDP : public fastdds::statistics::rtps::IProxyQueryable
      */
     ParticipantProxyData* getLocalParticipantProxyData() const
     {
-        return participant_proxies_.empty() ? nullptr : participant_proxies_.front();
+        if (participant_proxies_.empty())
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP,
+                    "getLocalParticipantProxyData(): no local ParticipantProxyData available – returning dummy instance");
+            assert(false && "No ParticipantProxyData available in pool");
+        }
+        return participant_proxies_.front();
     }
 
     /**
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp b/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
@@ -575,12 +575,27 @@ void PDPSimple::unmatch_pdp_remote_endpoints(
 
     {
         auto endpoints = dynamic_cast<fastdds::rtps::SimplePDPEndpoints*>(builtin_endpoints_.get());
-        assert(nullptr != endpoints);
+        if (nullptr == endpoints)
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP,
+                    "unmatch_pdp_remote_endpoints(): builtin_endpoints_ is null or wrong type");
+            return;
+        }
 
         guid.entityId = c_EntityId_SPDPWriter;
+        if (!endpoints->reader.reader_)
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP, "SPDPReader is null, cannot unmatch remote endpoints for " << guid);
+            return;
+        }
         endpoints->reader.reader_->matched_writer_remove(guid);
 
         guid.entityId = c_EntityId_SPDPReader;
+        if (!endpoints->writer.writer_)
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP, "SPDPWriter is null, cannot unmatch remote endpoints for " << guid);
+            return;
+        }
         endpoints->writer.writer_->matched_reader_remove(guid);
     }
 
diff --git a/src/cpp/rtps/flowcontrol/FlowControllerImpl.hpp b/src/cpp/rtps/flowcontrol/FlowControllerImpl.hpp
diff --git a/test/unittest/rtps/network/mock/MockTransport.cpp b/test/unittest/rtps/network/mock/MockTransport.cpp
diff --git a/thirdparty/optionparser/optionparser/optionparser.h b/thirdparty/optionparser/optionparser/optionparser.h

Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,11 @@ bool AnnotationDescriptorImpl::is_consistent() noexcept`
`137`	`137`	`{`
`138`	`138`	`return false;`
`139`	`139`	`}`
	`140`	`+`
	`141`	`+ if (!ann_param_type)`
	`142`	`+ {`
	`143`	`+ return false;`
	`144`	`+ }`
`140`	`145`	`//}}}`
`141`	`146`
`142`	`147`	`//{{{ Check the parameter value is convertible to its type.`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,12 @@ traits<DynamicTypeBuilder>::ref_type DynamicTypeBuilderFactoryImpl::create_type(`
`56`	`56`	`{`
`57`	`57`	`auto descriptor_impl = traits<TypeDescriptor>::narrow<TypeDescriptorImpl>(descriptor);`
`58`	`58`
	`59`	`+ if (!descriptor_impl)`
	`60`	`+ {`
	`61`	`+ EPROSIMA_LOG_ERROR(DYN_TYPES, "Invalid TypeDescriptor provided to create_type.");`
	`62`	`+ return {};`
	`63`	`+ }`
	`64`	`+`
`59`	`65`	`if (descriptor_impl->is_consistent())`
`60`	`66`	`{`
`61`	`67`	`return std::make_shared<DynamicTypeBuilderImpl>(*descriptor_impl);`