Batch project-chip#14 nodiscard errors: transport, wifipaf (project-chip#41872)

Author: gmarcosb

src/transport/CryptoContext.cpp

@@ -273,7 +273,7 @@ CHIP_ERROR CryptoContext::PrivacyEncrypt(const uint8_t * input, size_t input_len
     ByteSpan plaintext(input, input_length);
     MutableByteSpan privacytext(output, input_length);
     CryptoContext::NonceStorage privacyNonce;
-    CryptoContext::BuildPrivacyNonce(privacyNonce, header.GetSessionId(), mac);
+    ReturnErrorOnFailure(CryptoContext::BuildPrivacyNonce(privacyNonce, header.GetSessionId(), mac));
 
     return mKeyContext->PrivacyEncrypt(plaintext, privacyNonce, privacytext);
 }
@@ -291,7 +291,7 @@ CHIP_ERROR CryptoContext::PrivacyDecrypt(const uint8_t * input, size_t input_len
     const ByteSpan privacytext(input, input_length);
     MutableByteSpan plaintext(output, input_length);
     CryptoContext::NonceStorage privacyNonce;
-    CryptoContext::BuildPrivacyNonce(privacyNonce, header.GetSessionId(), mac);
+    ReturnErrorOnFailure(CryptoContext::BuildPrivacyNonce(privacyNonce, header.GetSessionId(), mac));
 
     return mKeyContext->PrivacyDecrypt(privacytext, privacyNonce, plaintext);
 }

src/transport/GroupPeerMessageCounter.cpp

@@ -259,7 +259,7 @@ void GroupPeerTable::RemoveAndCompactFabric(uint32_t tableIndex)
 
 GroupOutgoingCounters::GroupOutgoingCounters(chip::PersistentStorageDelegate * storage_delegate)
 {
-    Init(storage_delegate);
+    TEMPORARY_RETURN_IGNORED Init(storage_delegate);
 }
 
 CHIP_ERROR GroupOutgoingCounters::Init(chip::PersistentStorageDelegate * storage_delegate)

src/transport/SessionManager.cpp

@@ -167,7 +167,7 @@ void SessionManager::Shutdown()
  */
 void SessionManager::FabricRemoved(FabricIndex fabricIndex)
 {
-    gGroupPeerTable->FabricRemoved(fabricIndex);
+    TEMPORARY_RETURN_IGNORED gGroupPeerTable->FabricRemoved(fabricIndex);
 }
 
 CHIP_ERROR SessionManager::PrepareMessage(const SessionHandle & sessionHandle, PayloadHeader & payloadHeader,
@@ -211,7 +211,7 @@ CHIP_ERROR SessionManager::PrepareMessage(const SessionHandle & sessionHandle, P
 
         packetHeader.SetDestinationGroupId(groupSession->GetGroupId());
         packetHeader.SetMessageCounter(mGroupClientCounter.GetCounter(isControlMsg));
-        mGroupClientCounter.IncrementCounter(isControlMsg);
+        TEMPORARY_RETURN_IGNORED mGroupClientCounter.IncrementCounter(isControlMsg);
         packetHeader.SetSessionType(Header::SessionType::kGroupSession);
         sourceNodeId = fabric->GetNodeId();
         packetHeader.SetSourceNodeId(sourceNodeId);
@@ -238,7 +238,8 @@ CHIP_ERROR SessionManager::PrepareMessage(const SessionHandle & sessionHandle, P
         CHIP_TRACE_MESSAGE_SENT(payloadHeader, packetHeader, destination_address, message->Start(), message->TotalLength());
 
         CryptoContext::NonceStorage nonce;
-        CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), sourceNodeId);
+        ReturnErrorOnFailure(
+            CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), sourceNodeId));
         CHIP_ERROR err = SecureMessageCodec::Encrypt(cryptoContext, nonce, payloadHeader, packetHeader, message);
         keyContext->Release();
         ReturnErrorOnFailure(err);
@@ -277,7 +278,7 @@ CHIP_ERROR SessionManager::PrepareMessage(const SessionHandle & sessionHandle, P
 
         CryptoContext::NonceStorage nonce;
         sourceNodeId = session->GetLocalScopedNodeId().GetNodeId();
-        CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), messageCounter, sourceNodeId);
+        ReturnErrorOnFailure(CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), messageCounter, sourceNodeId));
 
         ReturnErrorOnFailure(SecureMessageCodec::Encrypt(cryptoContext, nonce, payloadHeader, packetHeader, message));
 
@@ -454,10 +455,10 @@ CHIP_ERROR SessionManager::SendPreparedMessage(const SessionHandle & sessionHand
 
         while (interfaceIt.Next())
         {
-            char name[Inet::InterfaceId::kMaxIfNameLength];
-            interfaceIt.GetInterfaceName(name, Inet::InterfaceId::kMaxIfNameLength);
             if (interfaceIt.SupportsMulticast() && interfaceIt.IsUp())
             {
+                char name[Inet::InterfaceId::kMaxIfNameLength];
+                TEMPORARY_RETURN_IGNORED interfaceIt.GetInterfaceName(name, Inet::InterfaceId::kMaxIfNameLength);
                 interfaceId = interfaceIt.GetInterfaceId();
                 if (CHIP_NO_ERROR == interfaceId.GetLinkLocalAddr(&addr))
                 {
@@ -946,10 +947,11 @@ void SessionManager::SecureUnicastMessageDispatch(const PacketHeader & partialPa
     CryptoContext::NonceStorage nonce;
     // PASE Sessions use the undefined node ID of all zeroes, since there is no node ID to use
     // and the key is short-lived and always different for each PASE session.
-    CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(),
-                              secureSession->GetSecureSessionType() == SecureSession::Type::kCASE ? secureSession->GetPeerNodeId()
-                                                                                                  : kUndefinedNodeId);
-    if (SecureMessageCodec::Decrypt(secureSession->GetCryptoContext(), nonce, payloadHeader, packetHeader, msg) != CHIP_NO_ERROR)
+    CHIP_ERROR nonceResult = CryptoContext::BuildNonce(
+        nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(),
+        secureSession->GetSecureSessionType() == SecureSession::Type::kCASE ? secureSession->GetPeerNodeId() : kUndefinedNodeId);
+    if ((nonceResult != CHIP_NO_ERROR) ||
+        SecureMessageCodec::Decrypt(secureSession->GetCryptoContext(), nonce, payloadHeader, packetHeader, msg) != CHIP_NO_ERROR)
     {
         ChipLogError(Inet, "Secure transport received message, but failed to decode/authenticate it, discarding");
         return;
@@ -1056,9 +1058,11 @@ static bool GroupKeyDecryptAttempt(const PacketHeader & partialPacketHeader, Pac
     }
 
     CryptoContext::NonceStorage nonce;
-    CryptoContext::BuildNonce(nonce, packetHeaderCopy.GetSecurityFlags(), packetHeaderCopy.GetMessageCounter(),
-                              packetHeaderCopy.GetSourceNodeId().Value());
-    decrypted = (CHIP_NO_ERROR == SecureMessageCodec::Decrypt(context, nonce, payloadHeader, packetHeaderCopy, msgCopy));
+    CHIP_ERROR nonceResult =
+        CryptoContext::BuildNonce(nonce, packetHeaderCopy.GetSecurityFlags(), packetHeaderCopy.GetMessageCounter(),
+                                  packetHeaderCopy.GetSourceNodeId().Value());
+    decrypted = (nonceResult == CHIP_NO_ERROR) &&
+        (CHIP_NO_ERROR == SecureMessageCodec::Decrypt(context, nonce, payloadHeader, packetHeaderCopy, msgCopy));
 
     return decrypted;
 }

src/transport/SessionManager.h

@@ -312,8 +312,7 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate, public FabricTabl
         auto * targetFabric = mFabricTable->FindFabricWithIndex(fabricIndex);
         VerifyOrReturnError(targetFabric != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
 
-        auto err = targetFabric->FetchRootPubkey(targetPubKey);
-        VerifyOrDie(err == CHIP_NO_ERROR);
+        SuccessOrDie(targetFabric->FetchRootPubkey(targetPubKey));
 
         mSecureSessions.ForEachSession([&](auto * session) {
             Crypto::P256PublicKey comparePubKey;
@@ -331,8 +330,7 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate, public FabricTabl
             auto * compareFabric = mFabricTable->FindFabricWithIndex(session->GetFabricIndex());
             VerifyOrDie(compareFabric != nullptr);
 
-            err = compareFabric->FetchRootPubkey(comparePubKey);
-            VerifyOrDie(err == CHIP_NO_ERROR);
+            SuccessOrDie(compareFabric->FetchRootPubkey(comparePubKey));
 
             if (comparePubKey.Matches(targetPubKey) && targetFabric->GetFabricId() == compareFabric->GetFabricId())
             {

src/transport/raw/BLE.cpp

@@ -45,7 +45,7 @@ void BLEBase::ClearState()
 {
     if (mBleLayer)
     {
-        mBleLayer->CancelBleIncompleteConnection();
+        TEMPORARY_RETURN_IGNORED mBleLayer->CancelBleIncompleteConnection();
         mBleLayer->mBleTransport = nullptr;
         mBleLayer                = nullptr;
     }

src/transport/raw/NFC.cpp

@@ -101,9 +101,7 @@ CHIP_ERROR NFCBase::SendMessage(const Transport::PeerAddress & address, System::
     VerifyOrReturnError(address.GetTransportType() == Type::kNfc, CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrReturnError(mState == State::kConnected, CHIP_ERROR_INCORRECT_STATE);
 
-    DeviceLayer::Internal::NFCCommissioningMgrImpl().SendToNfcTag(address, std::move(msgBuf));
-
-    return CHIP_NO_ERROR;
+    return DeviceLayer::Internal::NFCCommissioningMgrImpl().SendToNfcTag(address, std::move(msgBuf));
 }
 
 } // namespace Transport

src/transport/raw/TCP.cpp

@@ -591,7 +591,8 @@ void TCPBase::HandleTCPEndPointConnectComplete(const Inet::TCPEndPointHandle & e
     });
 
     // Set the TCPKeepalive configurations on the established connection
-    endPoint->EnableKeepAlive(activeConnection->mTCPKeepAliveIntervalSecs, activeConnection->mTCPMaxNumKeepAliveProbes);
+    TEMPORARY_RETURN_IGNORED endPoint->EnableKeepAlive(activeConnection->mTCPKeepAliveIntervalSecs,
+                                                       activeConnection->mTCPMaxNumKeepAliveProbes);
 
     ChipLogProgress(Inet, "Connection established successfully with %s.", addrStr);
 
@@ -655,13 +656,16 @@ CHIP_ERROR TCPBase::DoHandleIncomingConnection(const Inet::TCPEndPointHandle & l
     endPoint->OnConnectionClosed = HandleTCPEndPointConnectionClosed;
 
     // By default, disable TCP Nagle buffering by setting TCP_NODELAY socket option to true
-    endPoint->EnableNoDelay();
+    // If it fails, we can still use the connection
+    RETURN_SAFELY_IGNORED endPoint->EnableNoDelay();
 
     mUsedEndPointCount++;
     activeConnection->mConnectionState = TCPState::kConnected;
 
     // Set the TCPKeepalive configurations on the received connection
-    endPoint->EnableKeepAlive(activeConnection->mTCPKeepAliveIntervalSecs, activeConnection->mTCPMaxNumKeepAliveProbes);
+    // If it fails, we can still use the connection until it dies
+    RETURN_SAFELY_IGNORED endPoint->EnableKeepAlive(activeConnection->mTCPKeepAliveIntervalSecs,
+                                                    activeConnection->mTCPMaxNumKeepAliveProbes);
 
     char addrStr[Transport::PeerAddress::kMaxToStringSize];
     peerAddress.ToString(addrStr);

src/transport/raw/WiFiPAF.cpp

@@ -58,9 +58,7 @@ CHIP_ERROR WiFiPAFBase::SendMessage(const Transport::PeerAddress & address, Pack
         ChipLogError(Inet, "WiFi-PAF: No valid session whose nodeId: %lu", address.GetRemoteId());
         return CHIP_ERROR_INCORRECT_STATE;
     }
-    mWiFiPAFLayer->SendMessage(*pTxInfo, std::move(msgBuf));
-
-    return CHIP_NO_ERROR;
+    return mWiFiPAFLayer->SendMessage(*pTxInfo, std::move(msgBuf));
 }
 
 bool WiFiPAFBase::CanSendToPeer(const Transport::PeerAddress & address)
@@ -106,15 +104,13 @@ CHIP_ERROR WiFiPAFBase::WiFiPAFMessageReceived(WiFiPAFSession & RxInfo, PacketBu
 CHIP_ERROR WiFiPAFBase::WiFiPAFMessageSend(WiFiPAFSession & TxInfo, PacketBufferHandle && msgBuf)
 {
     VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);
-    DeviceLayer::ConnectivityMgr().WiFiPAFSend(TxInfo, std::move(msgBuf));
-
-    return CHIP_NO_ERROR;
+    return DeviceLayer::ConnectivityMgr().WiFiPAFSend(TxInfo, std::move(msgBuf));
 }
 
 CHIP_ERROR WiFiPAFBase::WiFiPAFCloseSession(WiFiPAFSession & SessionInfo)
 {
     VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);
-    DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(SessionInfo.id, SessionInfo.role);
+    TEMPORARY_RETURN_IGNORED DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(SessionInfo.id, SessionInfo.role);
     mWiFiPAFLayer->SetWiFiPAFState(State::kInitialized);
 
     return CHIP_NO_ERROR;

src/wifipaf/WiFiPAFEndPoint.cpp

@@ -228,7 +228,7 @@ void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR
     mSendQueue = nullptr;
     // Clear the session information
     ChipLogProgress(WiFiPAF, "Shutdown PAF session (%u, %u)", mSessionInfo.id, mSessionInfo.role);
-    mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo);
+    TEMPORARY_RETURN_IGNORED mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo);
     memset(&mSessionInfo, 0, sizeof(mSessionInfo));
     // Fire application's close callback if we haven't already, and it's not suppressed.
     if (oldState != kState_Closing && (flags & kWiFiPAFCloseFlag_SuppressCallback) == 0)
@@ -562,7 +562,7 @@ CHIP_ERROR WiFiPAFEndPoint::DoSendStandAloneAck()
     ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "sending stand-alone ack");
 
     // Encode and transmit stand-alone ack.
-    mPafTP.EncodeStandAloneAck(mAckToSend);
+    ReturnErrorOnFailure(mPafTP.EncodeStandAloneAck(mAckToSend));
     ReturnErrorOnFailure(SendCharacteristic(mAckToSend.Retain()));
 
     // Reset local receive window counter.
@@ -605,8 +605,7 @@ CHIP_ERROR WiFiPAFEndPoint::DriveSending()
     if (!mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFResourceAvailable() && (!mAckToSend.IsNull() || !mSendQueue.IsNull()))
     {
         // Resource is currently unavailable, send packets later
-        StartWaitResourceTimer();
-        return CHIP_NO_ERROR;
+        return StartWaitResourceTimer();
     }
     mResourceWaitCount = 0;
 
@@ -974,7 +973,7 @@ CHIP_ERROR WiFiPAFEndPoint::RxPacketProcess(PacketBufferHandle && data)
     bool didReceiveAck           = false;
     BitFlags<WiFiPAFTP::HeaderFlags> rx_flags;
     Encoding::LittleEndian::Reader reader(data->Start(), data->DataLength());
-    DebugPktAckSn(PktDirect_t::kRx, reader, data->Start());
+    TEMPORARY_RETURN_IGNORED DebugPktAckSn(PktDirect_t::kRx, reader, data->Start());
 
     { // This is a special handling on the first CHIPoPAF data packet, the CapabilitiesRequest.
         // If we're receiving the first inbound packet of a PAF transport connection handshake...
@@ -1133,10 +1132,8 @@ CHIP_ERROR WiFiPAFEndPoint::SendWrite(PacketBufferHandle && buf)
 
     ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, buf);
     Encoding::LittleEndian::Reader reader(buf->Start(), buf->DataLength());
-    DebugPktAckSn(PktDirect_t::kTx, reader, buf->Start());
-    mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFMessageSend(mSessionInfo, std::move(buf));
-
-    return CHIP_NO_ERROR;
+    TEMPORARY_RETURN_IGNORED DebugPktAckSn(PktDirect_t::kTx, reader, buf->Start());
+    return mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFMessageSend(mSessionInfo, std::move(buf));
 }
 
 CHIP_ERROR WiFiPAFEndPoint::StartConnectTimer()

src/wifipaf/WiFiPAFLayer.cpp

@@ -328,9 +328,7 @@ CHIP_ERROR WiFiPAFLayer::NewEndPoint(WiFiPAFEndPoint ** retEndPoint, WiFiPAFSess
         ChipLogError(WiFiPAF, "endpoint pool FULL");
         return CHIP_ERROR_ENDPOINT_POOL_FULL;
     }
-    (*retEndPoint)->Init(this, SessionInfo);
-
-    return CHIP_NO_ERROR;
+    return (*retEndPoint)->Init(this, SessionInfo);
 }
 
 CHIP_ERROR WiFiPAFLayer::HandleTransportConnectionInitiated(WiFiPAF::WiFiPAFSession & SessionInfo,