Adjust storage and processing in SystemPacketBuffer

and associated code for large payloads.

Extend uint16_t type variables to uint32_t at applicable
places.

src/app/server/EchoHandler.cpp

@@ -40,7 +40,7 @@ chip::Protocols::Echo::EchoServer gEchoServer;
  */
 void HandleEchoRequestReceived(chip::Messaging::ExchangeContext * ec, chip::System::PacketBufferHandle && payload)
 {
-    ChipLogProgress(AppServer, "Echo Request, len=%u ... sending response.\n", payload->DataLength());
+    ChipLogProgress(AppServer, "Echo Request, len=%u ... sending response.\n", static_cast<uint16_t>(payload->DataLength()));
 }
 
 } // namespace

src/ble/BtpEngine.cpp

@@ -310,7 +310,7 @@ CHIP_ERROR BtpEngine::HandleCharacteristicReceived(System::PacketBufferHandle &&
         // mRxFragnentSize may be smaller than the characteristic size.  Make sure
         // we're not truncating to a data length smaller than what we have already consumed.
         VerifyOrExit(reader.OctetsRead() <= mRxFragmentSize, err = BLE_ERROR_REASSEMBLER_INCORRECT_STATE);
-        data->SetDataLength(chip::min(data->DataLength(), mRxFragmentSize));
+        data->SetDataLength(chip::min(data->DataLength(), static_cast<uint32_t>(mRxFragmentSize)));
 
         // Now mark the bytes we consumed as consumed.
         data->ConsumeHead(static_cast<uint16_t>(reader.OctetsRead()));
@@ -374,7 +374,7 @@ CHIP_ERROR BtpEngine::HandleCharacteristicReceived(System::PacketBufferHandle &&
     if (rx_flags.Has(HeaderFlags::kEndMessage))
     {
         // Trim remainder, if any, of the received packet buffer based on sender-specified length of reassembled message.
-        int padding = mRxBuf->DataLength() - mRxLength;
+        uint32_t padding = mRxBuf->DataLength() - mRxLength;
 
         if (padding > 0)
         {
@@ -403,7 +403,7 @@ CHIP_ERROR BtpEngine::HandleCharacteristicReceived(System::PacketBufferHandle &&
         }
         if (!mRxBuf.IsNull())
         {
-            ChipLogError(Ble, "With rx buf data length = %u", mRxBuf->DataLength());
+            ChipLogError(Ble, "With rx buf data length = %u", static_cast<uint16_t>(mRxBuf->DataLength()));
         }
         LogState();
 
@@ -456,7 +456,7 @@ bool BtpEngine::HandleCharacteristicSend(System::PacketBufferHandle data, bool s
 
         mTxBuf    = std::move(data);
         mTxState  = kState_InProgress;
-        mTxLength = mTxBuf->DataLength();
+        mTxLength = static_cast<uint16_t>(mTxBuf->DataLength());
 
         ChipLogDebugBtpEngine(Ble, ">>> CHIPoBle preparing to send whole message:");
         PrintBufDebug(mTxBuf);

src/inet/TCPEndPoint.cpp

@@ -333,7 +333,7 @@ void TCPEndPoint::DriveReceiving()
     {
         // Acknowledgement is done after handling the buffers to allow the
         // application processing to throttle flow.
-        uint16_t ackLength = mRcvQueue->TotalLength();
+        uint32_t ackLength = mRcvQueue->TotalLength();
         CHIP_ERROR err     = OnDataReceived(this, std::move(mRcvQueue));
         if (err != CHIP_NO_ERROR)
         {

src/inet/TCPEndPoint.h

@@ -274,7 +274,7 @@ class DLL_EXPORT TCPEndPoint : public EndPointBasis<TCPEndPoint>
      *  received. The operational semantics are undefined if \c len is larger
      *  than the total outstanding unacknowledged received data.
      */
-    virtual CHIP_ERROR AckReceive(uint16_t len) = 0;
+    virtual CHIP_ERROR AckReceive(uint32_t len) = 0;
 
     /**
      * @brief   Set the receive queue, for testing.
@@ -301,7 +301,7 @@ class DLL_EXPORT TCPEndPoint : public EndPointBasis<TCPEndPoint>
      * @brief   Extract the length of the unacknowledged receive data.
      *
      * @return  Number of bytes in the receive queue that have not yet been
-     *      acknowledged with <tt>AckReceive(uint16_t len)</tt>.
+     *      acknowledged with <tt>AckReceive(uint32_t len)</tt>.
      */
     uint32_t PendingReceiveLength();
 
@@ -447,7 +447,7 @@ class DLL_EXPORT TCPEndPoint : public EndPointBasis<TCPEndPoint>
      *  is the length of the message text added to the TCP transmit window,
      *  which are eligible for sending by the underlying network stack.
      */
-    typedef void (*OnDataSentFunct)(TCPEndPoint * endPoint, uint16_t len);
+    typedef void (*OnDataSentFunct)(TCPEndPoint * endPoint, uint32_t len);
 
     /**
      * The endpoint's message text transmission event handling function

src/inet/TCPEndPointImplLwIP.cpp

@@ -351,7 +351,7 @@ CHIP_ERROR TCPEndPointImplLwIP::DriveSendingImpl()
             {
                 VerifyOrDie(!startOfUnsent.buffer.IsNull());
 
-                uint16_t bufDataLen = startOfUnsent.buffer->DataLength();
+                uint16_t bufDataLen = static_cast<uint16_t>(startOfUnsent.buffer->DataLength());
 
                 // Get a pointer to the start of unsent data within the first buffer on the unsent queue.
                 const uint8_t * sendData = startOfUnsent.buffer->Start() + startOfUnsent.offset;
@@ -503,7 +503,7 @@ void TCPEndPointImplLwIP::DoCloseImpl(CHIP_ERROR err, State oldState)
     }
 }
 
-CHIP_ERROR TCPEndPointImplLwIP::AckReceive(uint16_t len)
+CHIP_ERROR TCPEndPointImplLwIP::AckReceive(uint32_t len)
 {
     VerifyOrReturnError(IsConnected(), CHIP_ERROR_INCORRECT_STATE);
     CHIP_ERROR res = CHIP_NO_ERROR;
@@ -512,7 +512,7 @@ CHIP_ERROR TCPEndPointImplLwIP::AckReceive(uint16_t len)
     LOCK_TCPIP_CORE();
 
     if (mTCP != nullptr)
-        tcp_recved(mTCP, len);
+        tcp_recved(mTCP, static_cast<uint16_t>(len));
     else
         res = CHIP_ERROR_CONNECTION_ABORTED;
 
@@ -570,7 +570,7 @@ TCPEndPointImplLwIP::BufferOffset TCPEndPointImplLwIP::FindStartOfUnsent()
     while (leftToSkip > 0)
     {
         VerifyOrDie(!startOfUnsent.buffer.IsNull());
-        uint16_t bufDataLen = startOfUnsent.buffer->DataLength();
+        uint16_t bufDataLen = static_cast<uint16_t>(startOfUnsent.buffer->DataLength());
         if (leftToSkip >= bufDataLen)
         {
             // We have more to skip than current packet buffer size.

src/inet/TCPEndPointImplLwIP.h

@@ -51,7 +51,7 @@ class TCPEndPointImplLwIP : public TCPEndPoint, public EndPointStateLwIP
     CHIP_ERROR EnableNoDelay() override;
     CHIP_ERROR EnableKeepAlive(uint16_t interval, uint16_t timeoutCount) override;
     CHIP_ERROR DisableKeepAlive() override;
-    CHIP_ERROR AckReceive(uint16_t len) override;
+    CHIP_ERROR AckReceive(uint32_t len) override;
 #if INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
     void TCPUserTimeoutHandler() override;
 #endif // INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT

src/inet/TCPEndPointImplOpenThread.cpp

@@ -54,7 +54,7 @@ CHIP_ERROR TCPEndPointImplOT::DisableKeepAlive()
 {
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
-CHIP_ERROR TCPEndPointImplOT::AckReceive(uint16_t len)
+CHIP_ERROR TCPEndPointImplOT::AckReceive(uint32_t len)
 {
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }

src/inet/TCPEndPointImplOpenThread.h

@@ -46,7 +46,7 @@ class TCPEndPointImplOT : public TCPEndPoint, public EndPointStateOpenThread
     CHIP_ERROR EnableNoDelay() override;
     CHIP_ERROR EnableKeepAlive(uint16_t interval, uint16_t timeoutCount) override;
     CHIP_ERROR DisableKeepAlive() override;
-    CHIP_ERROR AckReceive(uint16_t len) override;
+    CHIP_ERROR AckReceive(uint32_t len) override;
 #if INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
     void TCPUserTimeoutHandler() override;
 #endif // INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT

src/inet/TCPEndPointImplSockets.cpp

@@ -441,7 +441,7 @@ CHIP_ERROR TCPEndPointImplSockets::DisableKeepAlive()
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR TCPEndPointImplSockets::AckReceive(uint16_t len)
+CHIP_ERROR TCPEndPointImplSockets::AckReceive(uint32_t len)
 {
     VerifyOrReturnError(IsConnected(), CHIP_ERROR_INCORRECT_STATE);
 
@@ -483,7 +483,7 @@ CHIP_ERROR TCPEndPointImplSockets::DriveSendingImpl()
 
     while (!mSendQueue.IsNull())
     {
-        uint16_t bufLen = mSendQueue->DataLength();
+        uint32_t bufLen = mSendQueue->DataLength();
 
         ssize_t lenSentRaw = send(mSocket, mSendQueue->Start(), bufLen, sendFlags);
 
@@ -502,8 +502,8 @@ CHIP_ERROR TCPEndPointImplSockets::DriveSendingImpl()
             break;
         }
 
-        // Cast is safe because bufLen is uint16_t.
-        uint16_t lenSent = static_cast<uint16_t>(lenSentRaw);
+        // Cast is safe because bufLen is uint32_t.
+        uint32_t lenSent = static_cast<uint32_t>(lenSentRaw);
 
         // Mark the connection as being active.
         MarkActive();
@@ -948,10 +948,10 @@ void TCPEndPointImplSockets::ReceiveData()
         {
             VerifyOrDie(rcvLen > 0);
             size_t newDataLength = rcvBuf->DataLength() + static_cast<size_t>(rcvLen);
-            VerifyOrDie(CanCastTo<uint16_t>(newDataLength));
+            VerifyOrDie(CanCastTo<uint32_t>(newDataLength));
             if (isNewBuf)
             {
-                rcvBuf->SetDataLength(static_cast<uint16_t>(newDataLength));
+                rcvBuf->SetDataLength(static_cast<uint32_t>(newDataLength));
                 rcvBuf.RightSize();
                 if (mRcvQueue.IsNull())
                 {
@@ -964,7 +964,7 @@ void TCPEndPointImplSockets::ReceiveData()
             }
             else
             {
-                rcvBuf->SetDataLength(static_cast<uint16_t>(newDataLength), mRcvQueue);
+                rcvBuf->SetDataLength(static_cast<uint32_t>(newDataLength), mRcvQueue);
             }
         }
     }

src/inet/TCPEndPointImplSockets.h

@@ -46,7 +46,7 @@ class TCPEndPointImplSockets : public TCPEndPoint, public EndPointStateSockets
     CHIP_ERROR EnableNoDelay() override;
     CHIP_ERROR EnableKeepAlive(uint16_t interval, uint16_t timeoutCount) override;
     CHIP_ERROR DisableKeepAlive() override;
-    CHIP_ERROR AckReceive(uint16_t len) override;
+    CHIP_ERROR AckReceive(uint32_t len) override;
 #if INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
     void TCPUserTimeoutHandler() override;
 #endif // INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT

src/inet/UDPEndPointImplLwIP.cpp

@@ -352,11 +352,11 @@ void UDPEndPointImplLwIP::LwIPReceiveUDPMessage(void * arg, struct udp_pcb * pcb
     if (buf->HasChainedBuffer())
     {
         // Have to allocate a new big-enough buffer and copy.
-        uint16_t messageSize            = buf->TotalLength();
+        uint16_t messageSize            = static_cast<uint16_t>(buf->TotalLength());
         System::PacketBufferHandle copy = System::PacketBufferHandle::New(messageSize, 0);
         if (copy.IsNull() || buf->Read(copy->Start(), messageSize) != CHIP_NO_ERROR)
         {
-            ChipLogError(Inet, "No memory to flatten incoming packet buffer chain of size %u", buf->TotalLength());
+            ChipLogError(Inet, "No memory to flatten incoming packet buffer chain of size %lu", buf->TotalLength());
             return;
         }
         buf = std::move(copy);

src/inet/UDPEndPointImplSockets.cpp

@@ -416,7 +416,7 @@ CHIP_ERROR UDPEndPointImplSockets::SendMsgImpl(const IPPacketInfo * aPktInfo, Sy
     {
         return CHIP_ERROR_POSIX(errno);
     }
-    if (lenSent != msg->DataLength())
+    if (msg->DataLength() != static_cast<uint32_t>(lenSent))
     {
         return CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG;
     }
@@ -612,7 +612,7 @@ void UDPEndPointImplSockets::HandlePendingIO(System::SocketEvents events)
         {
             lStatus = CHIP_ERROR_POSIX(errno);
         }
-        else if (rcvLen > lBuffer->AvailableDataLength())
+        else if (lBuffer->AvailableDataLength() < static_cast<uint32_t>(rcvLen))
         {
             lStatus = CHIP_ERROR_INBOUND_MESSAGE_TOO_BIG;
         }

src/inet/tests/TestInetLayer.cpp

@@ -569,7 +569,7 @@ static void HandleTCPConnectionClosed(TCPEndPoint * aEndPoint, CHIP_ERROR aError
     }
 }
 
-static void HandleTCPDataSent(TCPEndPoint * aEndPoint, uint16_t len) {}
+static void HandleTCPDataSent(TCPEndPoint * aEndPoint, uint32_t len) {}
 
 static CHIP_ERROR HandleTCPDataReceived(TCPEndPoint * aEndPoint, PacketBufferHandle && aBuffer)
 {

src/inet/tests/TestInetLayerCommon.cpp

@@ -123,9 +123,9 @@ bool WasSuccessful(const TestStatus & aTestStatus)
     return (lStatus);
 }
 
-static void FillDataBufferPattern(uint8_t * aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
+static void FillDataBufferPattern(uint8_t * aBuffer, uint32_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
-    for (uint16_t i = aPatternStartOffset; i < aLength; i++)
+    for (uint32_t i = aPatternStartOffset; i < aLength; i++)
     {
         const uint8_t lValue = static_cast<uint8_t>(aFirstValue & 0xFF);
 
@@ -135,9 +135,9 @@ static void FillDataBufferPattern(uint8_t * aBuffer, uint16_t aLength, uint16_t
     }
 }
 
-static bool CheckDataBufferPattern(const uint8_t * aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
+static bool CheckDataBufferPattern(const uint8_t * aBuffer, uint32_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
-    for (uint16_t i = aPatternStartOffset; i < aLength; i++)
+    for (uint32_t i = aPatternStartOffset; i < aLength; i++)
     {
         const uint8_t lValue = aBuffer[i];
 
@@ -156,7 +156,7 @@ static bool CheckDataBufferPattern(const uint8_t * aBuffer, uint16_t aLength, ui
     return true;
 }
 
-static PacketBufferHandle MakeDataBuffer(uint16_t aDesiredLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
+static PacketBufferHandle MakeDataBuffer(uint32_t aDesiredLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
     VerifyOrReturnError(aPatternStartOffset <= aDesiredLength, PacketBufferHandle());
 
@@ -244,7 +244,7 @@ static bool HandleDataReceived(const PacketBufferHandle & aBuffer, TransferStats
 
     for (PacketBufferHandle lBuffer = aBuffer.Retain(); !lBuffer.IsNull(); lBuffer.Advance())
     {
-        const uint16_t lDataLength = lBuffer->DataLength();
+        const uint32_t lDataLength = lBuffer->DataLength();
         const uint8_t * const p    = lBuffer->Start();
 
         if (aCheckBuffer && !CheckDataBufferPattern(p, lDataLength, aPatternStartOffset, aFirstValue))

src/lib/core/tests/TestTLV.cpp

@@ -277,7 +277,7 @@ void TestBufferContents(nlTestSuite * inSuite, const System::PacketBufferHandle
     System::PacketBufferHandle buf = buffer.Retain();
     while (!buf.IsNull())
     {
-        uint16_t len = buf->DataLength();
+        uint32_t len = buf->DataLength();
         NL_TEST_ASSERT(inSuite, len <= expectedLen);
 
         NL_TEST_ASSERT(inSuite, memcmp(buf->Start(), expectedVal, len) == 0);
@@ -2990,7 +2990,7 @@ void CheckBufferOverflow(nlTestSuite * inSuite, void * inContext)
     System::PacketBufferTLVReader reader;
 
     System::PacketBufferHandle buf = System::PacketBufferHandle::New(sizeof(Encoding1), 0);
-    uint16_t maxDataLen            = buf->MaxDataLength();
+    uint32_t maxDataLen            = buf->MaxDataLength();
     uint16_t reserve = static_cast<uint16_t>((sizeof(Encoding1) < maxDataLen) ? (maxDataLen - sizeof(Encoding1)) + 2 : 0);
 
     // Repeatedly write and read a TLV encoding to a chain of PacketBuffers. Use progressively larger

src/protocols/secure_channel/CASESession.cpp

@@ -1571,7 +1571,7 @@ CHIP_ERROR CASESession::HandleSigma3a(System::PacketBufferHandle && msg)
     TLV::TLVType containerType = TLV::kTLVType_Structure;
 
     const uint8_t * buf   = msg->Start();
-    const uint16_t bufLen = msg->DataLength();
+    const uint32_t bufLen = msg->DataLength();
 
     constexpr size_t kCaseOverheadForFutureTbeData = 128;