[21358] Fix null-dereference error on Ubuntu

.github/workflows/reusable-ubuntu-ci.yml

@@ -856,6 +856,22 @@ jobs:
           cd ${{ github.workspace }}
           rm -rf build install log
 
+      - name: Null dereference colcon build
+        uses: eProsima/eProsima-CI/multiplatform/colcon_build@v0
+        with:
+          colcon_meta_file: ${{ github.workspace }}/src/fastdds/.github/workflows/config/fastdds_build.meta
+          colcon_build_args: '${{ inputs.colcon-args }} --packages-up-to fastdds'
+          cmake_args: '-DEPROSIMA_BUILD_TESTS=OFF -DCMAKE_CXX_FLAGS="-Wnull-dereference" -DSECURITY=ON -DFASTDDS_STATISTICS=ON ${{ inputs.cmake-args }}'
+          cmake_args_default: ${{ env.colcon-build-default-cmake-args }}
+          # Force to build with maximum compiler optimization to catch all 'null-dereference' errors
+          cmake_build_type: Release
+          workspace: ${{ github.workspace }}
+
+      - name: Clean workspace - No shared libs
+        run: |
+          cd ${{ github.workspace }}
+          rm -rf build install log
+
       - name: Vanilla colcon build
         uses: eProsima/eProsima-CI/multiplatform/colcon_build@v0
         with:

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()

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.

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();
@@ -4274,6 +4302,72 @@ ReturnCode_t DynamicDataImpl::set_primitive_value<TK_STRING16>(
     return ret_value;
 }
 
+template<typename T, typename std::enable_if<std::is_integral<T>::value, bool>::type>
+bool DynamicDataImpl::check_new_discriminator_value(
+        const T& value)
+{
+    bool ret_value = false;
+
+    if (MEMBER_ID_INVALID != selected_union_member_) // There is a member selected by current discriminator.
+    {
+        traits<DynamicTypeMember>::ref_type selected_member;
+        enclosing_type_->get_member(selected_member, selected_union_member_);
+        auto sm_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(selected_member);
+
+        if (!sm_impl)
+        {
+            EPROSIMA_LOG_ERROR(DYNAMIC_DATA,
+                    "Null DynamicTypeMemberImpl pointer");
+            return false;
+        }
+
+        for (auto label : sm_impl->get_descriptor().label())
+        {
+            if (static_cast<int32_t>(value) == label)
+            {
+                ret_value = true;
+                break;
+            }
+        }
+    }
+
+    if (MEMBER_ID_INVALID == selected_union_member_ ||
+            (MEMBER_ID_INVALID == enclosing_type_->default_union_member() && !ret_value)) // It is selected the implicit default member.
+    {
+        ret_value = true;
+
+        if (enclosing_type_->default_value() != static_cast<int32_t>(value))
+        {
+            for (auto member : enclosing_type_->get_all_members_by_index())
+            {
+                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)
+                    {
+                        ret_value = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (ret_value)
+        {
+            selected_union_member_ = MEMBER_ID_INVALID;
+        }
+    }
+
+    return ret_value;
+}
+
 template<TypeKind TK>
 ReturnCode_t DynamicDataImpl::set_sequence_values(
         MemberId id,
@@ -6406,6 +6500,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 +6565,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)

src/cpp/fastdds/xtypes/dynamic_types/DynamicDataImpl.hpp

@@ -481,56 +481,7 @@ class DynamicDataImpl : public traits<DynamicData>::base_type
      */
     template<typename T, typename std::enable_if<std::is_integral<T>::value, bool>::type = true>
     bool check_new_discriminator_value(
-            const T& value)
-    {
-        bool ret_value = false;
-
-        if (MEMBER_ID_INVALID != selected_union_member_) // There is a member selected by current discriminator.
-        {
-            traits<DynamicTypeMember>::ref_type selected_member;
-            enclosing_type_->get_member(selected_member, selected_union_member_);
-            auto sm_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(selected_member);
-
-            for (auto label : sm_impl->get_descriptor().label())
-            {
-                if (static_cast<int32_t>(value) == label)
-                {
-                    ret_value = true;
-                    break;
-                }
-            }
-        }
-
-        if (MEMBER_ID_INVALID == selected_union_member_ ||
-                (MEMBER_ID_INVALID == enclosing_type_->default_union_member() && !ret_value)) // It is selected the implicit default member.
-        {
-            ret_value = true;
-
-            if (enclosing_type_->default_value() != static_cast<int32_t>(value))
-            {
-                for (auto member : enclosing_type_->get_all_members_by_index())
-                {
-                    auto m_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member);
-
-                    for (auto label : m_impl->get_descriptor().label())
-                    {
-                        if (static_cast<int32_t>(value) == label)
-                        {
-                            ret_value = false;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            if (ret_value)
-            {
-                selected_union_member_ = MEMBER_ID_INVALID;
-            }
-        }
-
-        return ret_value;
-    }
+            const T& value);
 
     template<typename T, typename std::enable_if<!std::is_integral<T>::value, bool>::type = true>
     bool check_new_discriminator_value(

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;

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);

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_;

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;