From eeb163d3bae0aa7bfe13aa3596974591a23043a5 Mon Sep 17 00:00:00 2001 From: Carol Yang Date: Mon, 8 Nov 2021 17:30:19 -0800 Subject: [PATCH] Log BDX messages (#11510) * Log BDX messages * Create a new macro ChipLogAutomation - This macro is to be used only for test validation purpose * Remove private struct members from BdxMessage types - Pass in the message type directly during logging --- src/lib/core/BUILD.gn | 1 + src/lib/core/CHIPConfig.h | 12 +++ src/lib/core/core.gni | 3 + src/lib/support/logging/CHIPLogging.cpp | 1 + src/lib/support/logging/CHIPLogging.h | 27 +++++- src/lib/support/logging/Constants.h | 12 ++- src/platform/qpg/args.gni | 1 + src/protocols/bdx/BdxMessages.cpp | 117 ++++++++++++++++++++--- src/protocols/bdx/BdxMessages.h | 29 ++++++ src/protocols/bdx/BdxTransferSession.cpp | 66 +++++++++++++ 10 files changed, 253 insertions(+), 16 deletions(-) diff --git a/src/lib/core/BUILD.gn b/src/lib/core/BUILD.gn index f8eec50de42863..3c046222cdc25a 100644 --- a/src/lib/core/BUILD.gn +++ b/src/lib/core/BUILD.gn @@ -46,6 +46,7 @@ buildconfig_header("chip_buildconfig") { "CHIP_ERROR_LOGGING=${chip_error_logging}", "CHIP_PROGRESS_LOGGING=${chip_progress_logging}", "CHIP_DETAIL_LOGGING=${chip_detail_logging}", + "CHIP_AUTOMATION_LOGGING=${chip_automation_logging}", "CHIP_CONFIG_SHORT_ERROR_STR=${chip_config_short_error_str}", "CHIP_CONFIG_ENABLE_ARG_PARSER=${chip_config_enable_arg_parser}", "CHIP_TARGET_STYLE_UNIX=${chip_target_style_unix}", diff --git a/src/lib/core/CHIPConfig.h b/src/lib/core/CHIPConfig.h index 279e1cf49e5f59..d8137496b30e2b 100644 --- a/src/lib/core/CHIPConfig.h +++ b/src/lib/core/CHIPConfig.h @@ -1832,6 +1832,18 @@ #define CHIP_DETAIL_LOGGING 1 #endif // CHIP_DETAIL_LOGGING +/** + * @def CHIP_AUTOMATION_LOGGING + * + * @brief + * If asserted (1), enable logging of all messages in the + * chip::Logging::kLogCategory_Automation category. + * + */ +#ifndef CHIP_AUTOMATION_LOGGING +#define CHIP_AUTOMATION_LOGGING 1 +#endif // CHIP_AUTOMATION_LOGGING + /** * CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE * diff --git a/src/lib/core/core.gni b/src/lib/core/core.gni index fdd43dabb6a90c..c33fd2af2b7b21 100644 --- a/src/lib/core/core.gni +++ b/src/lib/core/core.gni @@ -30,6 +30,9 @@ declare_args() { # Enable detail logging. chip_detail_logging = chip_logging + # Enable automation logging. + chip_automation_logging = chip_logging + # Enable short error strings. chip_config_short_error_str = false diff --git a/src/lib/support/logging/CHIPLogging.cpp b/src/lib/support/logging/CHIPLogging.cpp index df5439bd952697..57dacbe3f1b9f0 100644 --- a/src/lib/support/logging/CHIPLogging.cpp +++ b/src/lib/support/logging/CHIPLogging.cpp @@ -95,6 +95,7 @@ static const char ModuleNames[] = "-\0\0" // None "IM\0" // InteractionModel "TST" // Test "ODP" // OperationalDeviceProxy + "ATM" // Automation ; #define ModuleNamesCount ((sizeof(ModuleNames) - 1) / chip::Logging::kMaxModuleNameLen) diff --git a/src/lib/support/logging/CHIPLogging.h b/src/lib/support/logging/CHIPLogging.h index ac8f6820b2701f..8dfffd21288d1e 100644 --- a/src/lib/support/logging/CHIPLogging.h +++ b/src/lib/support/logging/CHIPLogging.h @@ -29,6 +29,7 @@ * - #CHIP_ERROR_LOGGING * - #CHIP_PROGRESS_LOGGING * - #CHIP_DETAIL_LOGGING + * - #CHIP_AUTOMATION_LOGGING * */ @@ -62,6 +63,7 @@ * - #CHIP_ERROR_LOGGING * - #CHIP_PROGRESS_LOGGING * - #CHIP_DETAIL_LOGGING + * - #CHIP_AUTOMATION_LOGGING * */ @@ -174,11 +176,32 @@ void SetLogFilter(uint8_t category); #define ChipLogByteSpan(MOD, DATA) ((void) 0) #endif -#if CHIP_ERROR_LOGGING || CHIP_PROGRESS_LOGGING || CHIP_DETAIL_LOGGING +#ifndef CHIP_AUTOMATION_LOGGING +#define CHIP_AUTOMATION_LOGGING 1 +#endif + +#if CHIP_AUTOMATION_LOGGING +/** + * @def ChipLogAutomation(MSG, ...) + * + * @brief + * Log a chip message for the specified module in the 'Automation' + * category. + * + */ +#ifndef ChipLogAutomation +#define ChipLogAutomation(MSG, ...) \ + chip::Logging::Log(chip::Logging::kLogModule_Automation, chip::Logging::kLogCategory_Automation, MSG, ##__VA_ARGS__) +#endif +#else +#define ChipLogAutomation(MOD, MSG, ...) ((void) 0) +#endif + +#if CHIP_ERROR_LOGGING || CHIP_PROGRESS_LOGGING || CHIP_DETAIL_LOGGING || CHIP_AUTOMATION_LOGGING #define _CHIP_USE_LOGGING 1 #else #define _CHIP_USE_LOGGING 0 -#endif /* CHIP_ERROR_LOGGING || CHIP_PROGRESS_LOGGING || CHIP_DETAIL_LOGGING */ +#endif /* CHIP_ERROR_LOGGING || CHIP_PROGRESS_LOGGING || CHIP_DETAIL_LOGGING || CHIP_AUTOMATION_LOGGING */ #if _CHIP_USE_LOGGING diff --git a/src/lib/support/logging/Constants.h b/src/lib/support/logging/Constants.h index ddc6beacbbf28e..0214fcaa2dbab8 100644 --- a/src/lib/support/logging/Constants.h +++ b/src/lib/support/logging/Constants.h @@ -57,6 +57,7 @@ enum LogModule kLogModule_InteractionModel, kLogModule_Test, kLogModule_OperationalDeviceProxy, + kLogModule_Automation, kLogModule_Max }; @@ -125,7 +126,16 @@ enum LogCategory */ kLogCategory_Detail = 3, - kLogCategory_Max = kLogCategory_Detail + /*!< + * Indicates a category of log message that describes automation + * information about an event or the state of the system. + * + * Such messages can be used by automation for test validation. + * + */ + kLogCategory_Automation = 4, + + kLogCategory_Max = kLogCategory_Automation }; } // namespace Logging diff --git a/src/platform/qpg/args.gni b/src/platform/qpg/args.gni index 28525a023d8256..a051e30b87bbbc 100644 --- a/src/platform/qpg/args.gni +++ b/src/platform/qpg/args.gni @@ -31,6 +31,7 @@ chip_inet_config_enable_tcp_endpoint = false # Size opt's #chip_progress_logging = false chip_detail_logging = false +chip_automation_logging = false # Use -Os is_debug = false diff --git a/src/protocols/bdx/BdxMessages.cpp b/src/protocols/bdx/BdxMessages.cpp index b9770a0bbad2f6..9c0e24c273f07e 100644 --- a/src/protocols/bdx/BdxMessages.cpp +++ b/src/protocols/bdx/BdxMessages.cpp @@ -31,7 +31,8 @@ #include namespace { -constexpr uint8_t kVersionMask = 0x0F; +constexpr uint8_t kVersionMask = 0x0F; +constexpr uint8_t kMaxFileDesignatorLen = 32; } // namespace using namespace chip; @@ -99,17 +100,16 @@ CHIP_ERROR TransferInit::Parse(System::PacketBufferHandle aBuffer) uint32_t tmpUint32Value = 0; // Used for reading non-wide length and offset fields uint8_t * bufStart = aBuffer->Start(); Reader bufReader(bufStart, aBuffer->DataLength()); - BitFlags rangeCtlFlags; - SuccessOrExit(bufReader.Read8(&proposedTransferCtl).Read8(rangeCtlFlags.RawStorage()).Read16(&MaxBlockSize).StatusCode()); + SuccessOrExit(bufReader.Read8(&proposedTransferCtl).Read8(mRangeCtlFlags.RawStorage()).Read16(&MaxBlockSize).StatusCode()); Version = proposedTransferCtl & kVersionMask; TransferCtlOptions.SetRaw(static_cast(proposedTransferCtl & ~kVersionMask)); StartOffset = 0; - if (rangeCtlFlags.Has(RangeControlFlags::kStartOffset)) + if (mRangeCtlFlags.Has(RangeControlFlags::kStartOffset)) { - if (rangeCtlFlags.Has(RangeControlFlags::kWiderange)) + if (mRangeCtlFlags.Has(RangeControlFlags::kWiderange)) { SuccessOrExit(bufReader.Read64(&StartOffset).StatusCode()); } @@ -121,9 +121,9 @@ CHIP_ERROR TransferInit::Parse(System::PacketBufferHandle aBuffer) } MaxLength = 0; - if (rangeCtlFlags.Has(RangeControlFlags::kDefLen)) + if (mRangeCtlFlags.Has(RangeControlFlags::kDefLen)) { - if (rangeCtlFlags.Has(RangeControlFlags::kWiderange)) + if (mRangeCtlFlags.Has(RangeControlFlags::kWiderange)) { SuccessOrExit(bufReader.Read64(&MaxLength).StatusCode()); } @@ -166,6 +166,34 @@ size_t TransferInit::MessageSize() const return WriteToBuffer(emptyBuf).Needed(); } +#if CHIP_AUTOMATION_LOGGING +void TransferInit::LogMessage(bdx::MessageType messageType) const +{ + char fd[kMaxFileDesignatorLen]; + snprintf(fd, sizeof(fd), "%s", FileDesignator); + + switch (messageType) + { + case MessageType::SendInit: + ChipLogAutomation("SendInit"); + break; + case MessageType::ReceiveInit: + ChipLogAutomation("ReceiveInit"); + break; + default: + break; + } + + ChipLogAutomation(" Proposed Transfer Control: 0x%X", static_cast(TransferCtlOptions.Raw() | Version)); + ChipLogAutomation(" Range Control: 0x%X", static_cast(mRangeCtlFlags.Raw())); + ChipLogAutomation(" Proposed Max Block Size: %" PRIu16, MaxBlockSize); + ChipLogAutomation(" Start Offset: 0x" ChipLogFormatX64, ChipLogValueX64(StartOffset)); + ChipLogAutomation(" Proposed Max Length: 0x" ChipLogFormatX64, ChipLogValueX64(MaxLength)); + ChipLogAutomation(" File Designator Length: %" PRIu16, FileDesLength); + ChipLogAutomation(" File Designator: %s", fd); +} +#endif // CHIP_AUTOMATION_LOGGING + bool TransferInit::operator==(const TransferInit & another) const { if ((MetadataLength != another.MetadataLength) || (FileDesLength != another.FileDesLength)) @@ -246,6 +274,16 @@ size_t SendAccept::MessageSize() const return WriteToBuffer(emptyBuf).Needed(); } +#if CHIP_AUTOMATION_LOGGING +void SendAccept::LogMessage(bdx::MessageType messageType) const +{ + (void) messageType; + ChipLogAutomation("SendAccept"); + ChipLogAutomation(" Transfer Control: 0x%X", static_cast(TransferCtlFlags.Raw() | Version)); + ChipLogAutomation(" Max Block Size: %" PRIu16, MaxBlockSize); +} +#endif // CHIP_AUTOMATION_LOGGING + bool SendAccept::operator==(const SendAccept & another) const { if (MetadataLength != another.MetadataLength) @@ -317,9 +355,8 @@ CHIP_ERROR ReceiveAccept::Parse(System::PacketBufferHandle aBuffer) uint32_t tmpUint32Value = 0; // Used for reading non-wide length and offset fields uint8_t * bufStart = aBuffer->Start(); Reader bufReader(bufStart, aBuffer->DataLength()); - BitFlags rangeCtlFlags; - SuccessOrExit(bufReader.Read8(&transferCtl).Read8(rangeCtlFlags.RawStorage()).Read16(&MaxBlockSize).StatusCode()); + SuccessOrExit(bufReader.Read8(&transferCtl).Read8(mRangeCtlFlags.RawStorage()).Read16(&MaxBlockSize).StatusCode()); Version = transferCtl & kVersionMask; @@ -327,9 +364,9 @@ CHIP_ERROR ReceiveAccept::Parse(System::PacketBufferHandle aBuffer) TransferCtlFlags.SetRaw(static_cast(transferCtl & ~kVersionMask)); StartOffset = 0; - if (rangeCtlFlags.Has(RangeControlFlags::kStartOffset)) + if (mRangeCtlFlags.Has(RangeControlFlags::kStartOffset)) { - if (rangeCtlFlags.Has(RangeControlFlags::kWiderange)) + if (mRangeCtlFlags.Has(RangeControlFlags::kWiderange)) { SuccessOrExit(bufReader.Read64(&StartOffset).StatusCode()); } @@ -341,9 +378,9 @@ CHIP_ERROR ReceiveAccept::Parse(System::PacketBufferHandle aBuffer) } Length = 0; - if (rangeCtlFlags.Has(RangeControlFlags::kDefLen)) + if (mRangeCtlFlags.Has(RangeControlFlags::kDefLen)) { - if (rangeCtlFlags.Has(RangeControlFlags::kWiderange)) + if (mRangeCtlFlags.Has(RangeControlFlags::kWiderange)) { SuccessOrExit(bufReader.Read64(&Length).StatusCode()); } @@ -380,6 +417,18 @@ size_t ReceiveAccept::MessageSize() const return WriteToBuffer(emptyBuf).Needed(); } +#if CHIP_AUTOMATION_LOGGING +void ReceiveAccept::LogMessage(bdx::MessageType messageType) const +{ + (void) messageType; + ChipLogAutomation("ReceiveAccept"); + ChipLogAutomation(" Transfer Control: 0x%X", TransferCtlFlags.Raw() | Version); + ChipLogAutomation(" Range Control: 0x%X", mRangeCtlFlags.Raw()); + ChipLogAutomation(" Max Block Size: %" PRIu16, MaxBlockSize); + ChipLogAutomation(" Length: 0x" ChipLogFormatX64, ChipLogValueX64(Length)); +} +#endif // CHIP_AUTOMATION_LOGGING + bool ReceiveAccept::operator==(const ReceiveAccept & another) const { if (MetadataLength != another.MetadataLength) @@ -423,6 +472,28 @@ bool CounterMessage::operator==(const CounterMessage & another) const return (BlockCounter == another.BlockCounter); } +#if CHIP_AUTOMATION_LOGGING +void CounterMessage::LogMessage(bdx::MessageType messageType) const +{ + switch (messageType) + { + case MessageType::BlockQuery: + ChipLogAutomation("BlockQuery"); + break; + case MessageType::BlockAck: + ChipLogAutomation("BlockAck"); + break; + case MessageType::BlockAckEOF: + ChipLogAutomation("BlockAckEOF"); + break; + default: + break; + } + + ChipLogAutomation(" Block Counter: %" PRIu32, BlockCounter); +} +#endif // CHIP_AUTOMATION_LOGGING + // WARNING: this function should never return early, since MessageSize() relies on it to calculate // the size of the message (even if the message is incomplete or filled out incorrectly). Encoding::LittleEndian::BufferWriter & DataBlock::WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const @@ -469,6 +540,26 @@ size_t DataBlock::MessageSize() const return WriteToBuffer(emptyBuf).Needed(); } +#if CHIP_AUTOMATION_LOGGING +void DataBlock::LogMessage(bdx::MessageType messageType) const +{ + switch (messageType) + { + case MessageType::Block: + ChipLogAutomation("Block"); + break; + case MessageType::BlockEOF: + ChipLogAutomation("BlockEOF"); + break; + default: + break; + } + + ChipLogAutomation(" Block Counter: %" PRIu32, BlockCounter); + ChipLogAutomation(" Data Length: %zu", DataLength); +} +#endif // CHIP_AUTOMATION_LOGGING + bool DataBlock::operator==(const DataBlock & another) const { if (DataLength != another.DataLength) diff --git a/src/protocols/bdx/BdxMessages.h b/src/protocols/bdx/BdxMessages.h index ab15032a196e4e..880008b6956f24 100644 --- a/src/protocols/bdx/BdxMessages.h +++ b/src/protocols/bdx/BdxMessages.h @@ -120,6 +120,14 @@ struct BdxMessage */ virtual size_t MessageSize() const = 0; +#if CHIP_AUTOMATION_LOGGING + /** + * @brief + * Log all parameters for this message. + */ + virtual void LogMessage(bdx::MessageType messageType) const = 0; +#endif // CHIP_AUTOMATION_LOGGING + virtual ~BdxMessage() = default; }; @@ -139,6 +147,9 @@ struct TransferInit : public BdxMessage BitFlags TransferCtlOptions; uint8_t Version = 0; ///< The highest version supported by the sender + // Range Control + BitFlags mRangeCtlFlags; + // All required uint16_t MaxBlockSize = 0; ///< Proposed max block size to use in transfer uint64_t StartOffset = 0; ///< Proposed start offset of data. 0 for no offset @@ -158,6 +169,9 @@ struct TransferInit : public BdxMessage CHIP_ERROR Parse(System::PacketBufferHandle aBuffer) override; Encoding::LittleEndian::BufferWriter & WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const override; size_t MessageSize() const override; +#if CHIP_AUTOMATION_LOGGING + void LogMessage(bdx::MessageType messageType) const override; +#endif // CHIP_AUTOMATION_LOGGING }; using SendInit = TransferInit; @@ -192,6 +206,9 @@ struct SendAccept : public BdxMessage CHIP_ERROR Parse(System::PacketBufferHandle aBuffer) override; Encoding::LittleEndian::BufferWriter & WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const override; size_t MessageSize() const override; +#if CHIP_AUTOMATION_LOGGING + void LogMessage(bdx::MessageType messageType) const override; +#endif // CHIP_AUTOMATION_LOGGING }; /** @@ -208,6 +225,9 @@ struct ReceiveAccept : public BdxMessage // Transfer Control (required, only one should be set) BitFlags TransferCtlFlags; + // Range Control + BitFlags mRangeCtlFlags; + // All required uint8_t Version = 0; ///< The agreed upon version for the transfer uint16_t MaxBlockSize = 0; ///< Chosen max block size to use in transfer @@ -226,6 +246,9 @@ struct ReceiveAccept : public BdxMessage CHIP_ERROR Parse(System::PacketBufferHandle aBuffer) override; Encoding::LittleEndian::BufferWriter & WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const override; size_t MessageSize() const override; +#if CHIP_AUTOMATION_LOGGING + void LogMessage(bdx::MessageType messageType) const override; +#endif // CHIP_AUTOMATION_LOGGING }; /** @@ -245,6 +268,9 @@ struct CounterMessage : public BdxMessage CHIP_ERROR Parse(System::PacketBufferHandle aBuffer) override; Encoding::LittleEndian::BufferWriter & WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const override; size_t MessageSize() const override; +#if CHIP_AUTOMATION_LOGGING + void LogMessage(bdx::MessageType messageType) const override; +#endif // CHIP_AUTOMATION_LOGGING }; using BlockQuery = CounterMessage; @@ -275,6 +301,9 @@ struct DataBlock : public BdxMessage CHIP_ERROR Parse(System::PacketBufferHandle aBuffer) override; Encoding::LittleEndian::BufferWriter & WriteToBuffer(Encoding::LittleEndian::BufferWriter & aBuffer) const override; size_t MessageSize() const override; +#if CHIP_AUTOMATION_LOGGING + void LogMessage(bdx::MessageType messageType) const override; +#endif // CHIP_AUTOMATION_LOGGING }; using Block = DataBlock; diff --git a/src/protocols/bdx/BdxTransferSession.cpp b/src/protocols/bdx/BdxTransferSession.cpp index 24c03fc78d316f..96aa2d205b71d9 100644 --- a/src/protocols/bdx/BdxTransferSession.cpp +++ b/src/protocols/bdx/BdxTransferSession.cpp @@ -160,6 +160,11 @@ CHIP_ERROR TransferSession::StartTransfer(TransferRole role, const TransferInitD const MessageType msgType = (mRole == TransferRole::kSender) ? MessageType::SendInit : MessageType::ReceiveInit; +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + initMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING + mState = TransferState::kAwaitingAccept; mAwaitingResponse = true; @@ -216,6 +221,11 @@ CHIP_ERROR TransferSession::AcceptTransfer(const TransferAcceptData & acceptData ReturnErrorOnFailure(WriteToPacketBuffer(acceptMsg, mPendingMsgHandle)); msgType = MessageType::ReceiveAccept; + +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + acceptMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING } else { @@ -228,6 +238,11 @@ CHIP_ERROR TransferSession::AcceptTransfer(const TransferAcceptData & acceptData ReturnErrorOnFailure(WriteToPacketBuffer(acceptMsg, mPendingMsgHandle)); msgType = MessageType::SendAccept; + +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + acceptMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING } mState = TransferState::kTransferInProgress; @@ -257,6 +272,11 @@ CHIP_ERROR TransferSession::PrepareBlockQuery() ReturnErrorOnFailure(WriteToPacketBuffer(queryMsg, mPendingMsgHandle)); +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + queryMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING + mAwaitingResponse = true; mLastQueryNum = mNextQueryNum++; @@ -284,6 +304,11 @@ CHIP_ERROR TransferSession::PrepareBlock(const BlockData & inData) const MessageType msgType = inData.IsEof ? MessageType::BlockEOF : MessageType::Block; +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + blockMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING + if (msgType == MessageType::BlockEOF) { mState = TransferState::kAwaitingEOFAck; @@ -310,6 +335,11 @@ CHIP_ERROR TransferSession::PrepareBlockAck() ReturnErrorOnFailure(WriteToPacketBuffer(ackMsg, mPendingMsgHandle)); +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Sending BDX Message"); + ackMsg.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING + if (mState == TransferState::kTransferInProgress) { if (mControlMode == TransferControlFlags::kSenderDrive) @@ -398,6 +428,10 @@ CHIP_ERROR TransferSession::HandleBdxMessage(const PayloadHeader & header, Syste const MessageType msgType = static_cast(header.GetMessageType()); +#if CHIP_AUTOMATION_LOGGING + ChipLogAutomation("Handling received BDX Message"); +#endif // CHIP_AUTOMATION_LOGGING + switch (msgType) { case MessageType::SendInit: @@ -496,6 +530,10 @@ void TransferSession::HandleTransferInit(MessageType msgType, System::PacketBuff mPendingOutput = OutputEventType::kInitReceived; mState = TransferState::kNegotiateTransferParams; + +#if CHIP_AUTOMATION_LOGGING + transferInit.LogMessage(msgType); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleReceiveAccept(System::PacketBufferHandle msgData) @@ -528,6 +566,10 @@ void TransferSession::HandleReceiveAccept(System::PacketBufferHandle msgData) mAwaitingResponse = (mControlMode == TransferControlFlags::kSenderDrive); mState = TransferState::kTransferInProgress; + +#if CHIP_AUTOMATION_LOGGING + rcvAcceptMsg.LogMessage(MessageType::ReceiveAccept); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleSendAccept(System::PacketBufferHandle msgData) @@ -558,6 +600,10 @@ void TransferSession::HandleSendAccept(System::PacketBufferHandle msgData) mAwaitingResponse = (mControlMode == TransferControlFlags::kReceiverDrive); mState = TransferState::kTransferInProgress; + +#if CHIP_AUTOMATION_LOGGING + sendAcceptMsg.LogMessage(MessageType::SendAccept); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleBlockQuery(System::PacketBufferHandle msgData) @@ -576,6 +622,10 @@ void TransferSession::HandleBlockQuery(System::PacketBufferHandle msgData) mAwaitingResponse = false; mLastQueryNum = query.BlockCounter; + +#if CHIP_AUTOMATION_LOGGING + query.LogMessage(MessageType::BlockQuery); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleBlock(System::PacketBufferHandle msgData) @@ -609,6 +659,10 @@ void TransferSession::HandleBlock(System::PacketBufferHandle msgData) mLastBlockNum = blockMsg.BlockCounter; mAwaitingResponse = false; + +#if CHIP_AUTOMATION_LOGGING + blockMsg.LogMessage(MessageType::Block); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleBlockEOF(System::PacketBufferHandle msgData) @@ -636,6 +690,10 @@ void TransferSession::HandleBlockEOF(System::PacketBufferHandle msgData) mAwaitingResponse = false; mState = TransferState::kReceivedEOF; + +#if CHIP_AUTOMATION_LOGGING + blockEOFMsg.LogMessage(MessageType::BlockEOF); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleBlockAck(System::PacketBufferHandle msgData) @@ -654,6 +712,10 @@ void TransferSession::HandleBlockAck(System::PacketBufferHandle msgData) // In Receiver Drive, the Receiver can send a BlockAck to indicate receipt of the message and reset the timeout. // In this case, the Sender should wait to receive a BlockQuery next. mAwaitingResponse = (mControlMode == TransferControlFlags::kReceiverDrive); + +#if CHIP_AUTOMATION_LOGGING + ackMsg.LogMessage(MessageType::BlockAck); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::HandleBlockAckEOF(System::PacketBufferHandle msgData) @@ -672,6 +734,10 @@ void TransferSession::HandleBlockAckEOF(System::PacketBufferHandle msgData) mAwaitingResponse = false; mState = TransferState::kTransferDone; + +#if CHIP_AUTOMATION_LOGGING + ackMsg.LogMessage(MessageType::BlockAckEOF); +#endif // CHIP_AUTOMATION_LOGGING } void TransferSession::ResolveTransferControlOptions(const BitFlags & proposed)