tree d3ebda49651fc7b292184300b8cc8f413c006273
parent 6098ff2fa1af943c5ee91c803fe6e8e76694981b
author Meghana Vangapandu <meghanav@ami.com> 1785339633 +0000
committer ManojKiran Eda <manojkiran.eda@gmail.com> 1788416645 +0000

platform-mc: stop multipart PDR processing on TRANSFER_END

PLDM_PLATFORM_TRANSFER_END indicates that the complete PDR
record has been received. After moving the assembled record
into terminus->pdrs, continuing the multipart transfer loop is
unnecessary and can leave a potential post-move access path for
receivedPdr.

Break out of the loop immediately after handling TRANSFER_END
to make the completion condition explicit, simplify control
flow, and resolve the cppcheck accessMoved warning.

No functional change is intended for valid transfers.

Change-Id: I2f5cb57757dcc69d3d622780f17126777d4d5928
Signed-off-by: Meghana Vangapandu <meghanav@ami.com>
