Batch #8 nodiscard errors: crypto, data-model, include (project-chip#41866)

Author: gmarcosb

src/crypto/CHIPCryptoPAL.cpp

@@ -1177,7 +1177,7 @@ CHIP_ERROR GenerateCertificateSigningRequest(const P256Keypair * keypair, Mutabl
          *        attributes    [0] Attributes{{ CRIAttributes }}
          *     }
          */
-        GenerateCertificationRequestInformation(writer, keypair->Pubkey());
+        ReturnErrorOnFailure(GenerateCertificationRequestInformation(writer, keypair->Pubkey()));
 
         // algorithm  AlgorithmIdentifier
         ASN1_START_SEQUENCE

src/crypto/CHIPCryptoPAL.h

@@ -313,7 +313,7 @@ class SensitiveDataBuffer
             return *this;
 
         ClearSecretData(mBytes);
-        SetLength(other.Length());
+        TEMPORARY_RETURN_IGNORED SetLength(other.Length());
         ::memcpy(Bytes(), other.ConstBytes(), other.Length());
         return *this;
     }

src/crypto/CHIPCryptoPALmbedTLS.cpp

@@ -722,7 +722,7 @@ CHIP_ERROR P256Keypair::Serialize(P256SerializedKeypair & output) const
     bbuf.Put(privkey, sizeof(privkey));
     VerifyOrExit(bbuf.Fit(), error = CHIP_ERROR_BUFFER_TOO_SMALL);
 
-    output.SetLength(bbuf.Needed());
+    TEMPORARY_RETURN_IGNORED output.SetLength(bbuf.Needed());
 
 exit:
     ClearSecretData(privkey, sizeof(privkey));

src/crypto/CHIPCryptoPALmbedTLSCert.cpp

@@ -83,7 +83,7 @@ CHIP_ERROR VerifyCertificateSigningRequest(const uint8_t * csr_buf, size_t csr_l
 
     VerifyOrExit(error == CHIP_NO_ERROR, error = CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(out_raw_sig_span.size() == (kP256_FE_Length * 2), error = CHIP_ERROR_INTERNAL);
-    signature.SetLength(out_raw_sig_span.size());
+    TEMPORARY_RETURN_IGNORED signature.SetLength(out_raw_sig_span.size());
 
     // Verify the signature using the public key
     error = pubkey.ECDSA_validate_msg_signature(csr.CHIP_CRYPTO_PAL_PRIVATE_X509(cri).CHIP_CRYPTO_PAL_PRIVATE_X509(p),

src/crypto/P256KeyPairOpenSSL.cpp

@@ -308,7 +308,7 @@ CHIP_ERROR P256Keypair::Serialize(P256SerializedKeypair & output) const
         bbuf.Put(mPublicKey, mPublicKey.Length());
         bbuf.Put(privkey, sizeof(privkey));
         VerifyOrExit(bbuf.Fit(), error = CHIP_ERROR_NO_MEMORY);
-        output.SetLength(bbuf.Needed());
+        TEMPORARY_RETURN_IGNORED output.SetLength(bbuf.Needed());
     }
 
 exit:

src/crypto/PersistentStorageOperationalKeystore.cpp

@@ -100,7 +100,7 @@ CHIP_ERROR ExportStoredOpKey(FabricIndex fabricIndex, PersistentStorageDelegate
     ReturnErrorOnFailure(
         storage->SyncGetKeyValue(DefaultStorageKeyAllocator::FabricOpKey(fabricIndex).KeyName(), buf.Bytes(), size));
 
-    buf.SetLength(static_cast<size_t>(size));
+    TEMPORARY_RETURN_IGNORED buf.SetLength(static_cast<size_t>(size));
 
     // Read-out the operational key TLV entry.
     TLV::ContiguousBufferTLVReader reader;
@@ -126,10 +126,8 @@ CHIP_ERROR ExportStoredOpKey(FabricIndex fabricIndex, PersistentStorageDelegate
         ReturnErrorOnFailure(reader.ExitContainer(containerType));
 
         memcpy(serializedOpKey.Bytes(), keyData.data(), keyData.size());
-        serializedOpKey.SetLength(keyData.size());
+        return serializedOpKey.SetLength(keyData.size());
     }
-
-    return CHIP_NO_ERROR;
 }
 
 /** WARNING: This can leave the operational key on the stack somewhere, since many of the platform
@@ -212,7 +210,7 @@ CHIP_ERROR PersistentStorageOperationalKeystore::NewOpKeypairForFabric(FabricInd
     mPendingKeypair = Platform::New<Crypto::P256Keypair>();
     VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_NO_MEMORY);
 
-    mPendingKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA);
+    TEMPORARY_RETURN_IGNORED mPendingKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA);
     size_t csrLength = outCertificateSigningRequest.size();
     CHIP_ERROR err   = mPendingKeypair->NewCertificateSigningRequest(outCertificateSigningRequest.data(), csrLength);
     if (err != CHIP_NO_ERROR)

src/data-model-providers/codegen/CodegenDataModelProvider.cpp

@@ -538,7 +538,7 @@ CHIP_ERROR CodegenDataModelProvider::EndpointUniqueID(EndpointId endpointId, Mut
 {
     char buffer[Clusters::Descriptor::Attributes::EndpointUniqueID::TypeInfo::MaxLength()] = { 0 };
     MutableCharSpan epUniqueIdSpan(buffer);
-    emberAfGetEndpointUniqueIdForEndPoint(endpointId, epUniqueIdSpan);
+    ReturnErrorOnFailure(emberAfGetEndpointUniqueIdForEndPoint(endpointId, epUniqueIdSpan));
 
     memcpy(epUniqueId.data(), epUniqueIdSpan.data(), epUniqueIdSpan.size());
     return CHIP_NO_ERROR;

src/include/platform/internal/GenericConfigurationManagerImpl.ipp

@@ -245,7 +245,7 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::Init()
     CHIP_ERROR err = CHIP_NO_ERROR;
 
 #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
-    mLifetimePersistedCounter.Init(CHIP_CONFIG_LIFETIIME_PERSISTED_COUNTER_KEY);
+    err = mLifetimePersistedCounter.Init(CHIP_CONFIG_LIFETIIME_PERSISTED_COUNTER_KEY);
 #endif
 
 #if CHIP_USE_TRANSITIONAL_DEVICE_INSTANCE_INFO_PROVIDER
@@ -443,7 +443,7 @@ void GenericConfigurationManagerImpl<ImplClass>::NotifyOfAdvertisementStart()
 {
 #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
     // Increment life time counter to protect against long-term tracking of rotating device ID.
-    IncrementLifetimeCounter();
+    TEMPORARY_RETURN_IGNORED IncrementLifetimeCounter();
     // Inheriting classes should call this method so the lifetime counter is updated if necessary.
 #endif
 }

src/include/platform/internal/GenericPlatformManagerImpl.ipp

@@ -165,8 +165,9 @@ void GenericPlatformManagerImpl<ImplClass>::_Shutdown()
 
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     ChipLogProgress(DeviceLayer, "WiFi-PAF Layer shutdown");
-    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(
-        [](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });
+    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown([](uint32_t id, WiFiPAF::WiFiPafRole role) {
+        TEMPORARY_RETURN_IGNORED DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role);
+    });
 #endif
 
 #if CHIP_DEVICE_CONFIG_ENABLE_NFC_BASED_COMMISSIONING