src/app/clusters/diagnostic-logs-server/BDXDiagnosticLogsProvider.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2023 Project CHIP Authors
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #include <lib/core/CHIPConfig.h>

 #if CHIP_CONFIG_ENABLE_BDX_LOG_TRANSFER
 #include "BDXDiagnosticLogsProvider.h"
 #include <app/clusters/diagnostic-logs-server/diagnostic-logs-server.h>
 #include <messaging/ExchangeMgr.h>
 #include <platform/CHIPDeviceLayer.h>

 using namespace chip::bdx;

 namespace chip {
 namespace app {
 namespace Clusters {
 namespace DiagnosticLogs {

 // BDX transfer session polling interval.
 constexpr System::Clock::Timeout kBdxPollIntervalMs = System::Clock::Milliseconds32(50);

 // Timeout for the BDX transfer session
 constexpr System::Clock::Timeout kBdxTimeout = System::Clock::Seconds16(5 * 60);

 constexpr uint16_t kBdxMaxBlockSize = 1024;

 CHIP_ERROR BDXDiagnosticLogsProvider::InitializeTransfer(CommandHandler * commandObj, const ConcreteCommandPath & path,
                                                          DiagnosticLogsProviderDelegate * delegate, IntentEnum intent,
                                                          CharSpan fileDesignator)
 {
     auto exchangeCtx = commandObj->GetExchangeContext();
     VerifyOrReturnError(nullptr != exchangeCtx, CHIP_ERROR_INVALID_ARGUMENT);

     auto exchangeMgr = exchangeCtx->GetExchangeMgr();
     VerifyOrReturnError(nullptr != exchangeMgr, CHIP_ERROR_INVALID_ARGUMENT);

     auto sessionHandle = exchangeCtx->GetSessionHandle();
     VerifyOrReturnError(sessionHandle->IsSecureSession(), CHIP_ERROR_INVALID_ARGUMENT);

     ScopedNodeId scopedPeerNodeId = sessionHandle->AsSecureSession()->GetPeer();
     auto fabricIndex              = scopedPeerNodeId.GetFabricIndex();
     VerifyOrReturnError(kUndefinedFabricIndex != fabricIndex, CHIP_ERROR_INVALID_ARGUMENT);

     auto peerNodeId = scopedPeerNodeId.GetNodeId();
     VerifyOrReturnError(kUndefinedNodeId != peerNodeId, CHIP_ERROR_INVALID_ARGUMENT);

     LogSessionHandle logSessionHandle;
     Optional<uint64_t> timeStamp;
     Optional<uint64_t> timeSinceBoot;
     VerifyOrReturnError(delegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     ReturnErrorOnFailure(delegate->StartLogCollection(intent, logSessionHandle, timeStamp, timeSinceBoot));

     // Create a new exchange context to use for the BDX transfer session
     // and send the SendInit message over the exchange.
     auto transferExchangeCtx = exchangeMgr->NewContext(sessionHandle, this);
     VerifyOrReturnError(nullptr != transferExchangeCtx, CHIP_ERROR_NO_MEMORY);

     TransferSession::TransferInitData initOptions;
     initOptions.TransferCtlFlags = TransferControlFlags::kSenderDrive;
     initOptions.MaxBlockSize     = kBdxMaxBlockSize;
     initOptions.FileDesLength    = static_cast<uint16_t>(fileDesignator.size());
     initOptions.FileDesignator   = Uint8::from_const_char(fileDesignator.data());

     CHIP_ERROR err = Initiator::InitiateTransfer(&DeviceLayer::SystemLayer(), TransferRole::kSender, initOptions, kBdxTimeout,
                                                  kBdxPollIntervalMs);
     if (CHIP_NO_ERROR != err)
     {
         LogErrorOnFailure(err);
         transferExchangeCtx->Close();
         return err;
     }

     mBDXTransferExchangeCtx = transferExchangeCtx;
     mDelegate               = delegate;
     mFabricIndex.SetValue(fabricIndex);
     mPeerNodeId.SetValue(peerNodeId);
     mIsAcceptReceived   = false;
     mLogSessionHandle   = logSessionHandle;
     mTimeStamp          = timeStamp;
     mTimeSinceBoot      = timeSinceBoot;
     mAsyncCommandHandle = CommandHandler::Handle(commandObj);
     mRequestPath        = path;
     mInitialized        = true;

     return CHIP_NO_ERROR;
 }

 void BDXDiagnosticLogsProvider::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
 {
     if (event.EventType != TransferSession::OutputEventType::kNone)
     {
         ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
     }

     switch (event.EventType)
     {
     case TransferSession::OutputEventType::kMsgToSend:
         OnMsgToSend(event);
         break;
     case TransferSession::OutputEventType::kAcceptReceived:
         OnAcceptReceived();
         // Upon acceptance of the transfer, the OnAckReceived method initiates the process of sending logs.
         OnAckReceived();
         break;
     case TransferSession::OutputEventType::kAckReceived:
         OnAckReceived();
         break;
     case TransferSession::OutputEventType::kAckEOFReceived:
         OnAckEOFReceived();
         break;
     case TransferSession::OutputEventType::kStatusReceived:
         OnStatusReceived(event);
         break;
     case TransferSession::OutputEventType::kInternalError:
         OnInternalError();
         break;
     case TransferSession::OutputEventType::kTransferTimeout:
         OnTimeout();
         break;
     case TransferSession::OutputEventType::kNone:
     case TransferSession::OutputEventType::kInitReceived:
         break;
     case TransferSession::OutputEventType::kBlockReceived:
     case TransferSession::OutputEventType::kQueryReceived:
     case TransferSession::OutputEventType::kQueryWithSkipReceived:
         // TransferSession should prevent this case from happening.
         ChipLogError(BDX, "Unsupported event type");
         break;
     }
 }

 void BDXDiagnosticLogsProvider::OnMsgToSend(TransferSession::OutputEvent & event)
 {
     VerifyOrReturn(mBDXTransferExchangeCtx != nullptr);

     auto & msgTypeData  = event.msgTypeData;
     bool isStatusReport = msgTypeData.HasMessageType(Protocols::SecureChannel::MsgType::StatusReport);

     // All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
     // end of the transfer.
     Messaging::SendFlags sendFlags;
     if (!isStatusReport)
     {
         sendFlags.Set(Messaging::SendMessageFlags::kExpectResponse);
     }

     auto err =
         mBDXTransferExchangeCtx->SendMessage(msgTypeData.ProtocolId, msgTypeData.MessageType, std::move(event.MsgData), sendFlags);

     VerifyOrDo(CHIP_NO_ERROR == err, Reset());
 }

 void BDXDiagnosticLogsProvider::OnAcceptReceived()
 {
     mIsAcceptReceived = true;

     // On reception of a BDX SendAccept message the Node SHALL send a RetrieveLogsResponse command with a Status field set to
     // Success and proceed with the log transfer over BDX.
     SendCommandResponse(StatusEnum::kSuccess);
 }

 void BDXDiagnosticLogsProvider::OnAckReceived()
 {
     uint16_t blockSize = mTransfer.GetTransferBlockSize();

     auto blockBuf = System::PacketBufferHandle::New(blockSize);
     VerifyOrReturn(!blockBuf.IsNull(), mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(CHIP_ERROR_NO_MEMORY)));

     auto buffer     = MutableByteSpan(blockBuf->Start(), blockSize);
     bool isEndOfLog = false;

     // Get the log next chunk and see if it fits i.e. if is end of log is reported
     auto err = mDelegate->CollectLog(mLogSessionHandle, buffer, isEndOfLog);
     VerifyOrReturn(CHIP_NO_ERROR == err, mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err)));

     // If the buffer has empty space, end the log collection session.
     if (isEndOfLog)
     {
         mDelegate->EndLogCollection(mLogSessionHandle);
         mLogSessionHandle = kInvalidLogSessionHandle;
     }

     // Prepare the BDX block to send to the requestor
     TransferSession::BlockData blockData;
     blockData.Data   = blockBuf->Start();
     blockData.Length = static_cast<size_t>(buffer.size());
     blockData.IsEof  = isEndOfLog;

     err = mTransfer.PrepareBlock(blockData);
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
         mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));
     }
 }

 void BDXDiagnosticLogsProvider::OnAckEOFReceived()
 {
     ChipLogProgress(BDX, "Diagnostic logs transfer: Success");

     Reset();
 }

 void BDXDiagnosticLogsProvider::OnStatusReceived(TransferSession::OutputEvent & event)
 {
     ChipLogError(BDX, "Diagnostic logs transfer: StatusReport Error %x", to_underlying(event.statusData.statusCode));

     // If a failure StatusReport is received in response to the SendInit message, the Node SHALL send a RetrieveLogsResponse command
     // with a Status of Denied.
     VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
     Reset();
 }

 void BDXDiagnosticLogsProvider::OnInternalError()
 {
     ChipLogError(BDX, "Internal Error");
     VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
     Reset();
 }

 void BDXDiagnosticLogsProvider::OnTimeout()
 {
     ChipLogError(BDX, "Timeout");
     VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
     Reset();
 }

 void BDXDiagnosticLogsProvider::SendCommandResponse(StatusEnum status)
 {
     auto commandHandleRef = std::move(mAsyncCommandHandle);
     auto commandHandle    = commandHandleRef.Get();

     VerifyOrReturn(nullptr != commandHandle, ChipLogError(Zcl, "SendCommandResponse - commandHandler is null"));

     Commands::RetrieveLogsResponse::Type response;
     response.status = status;
     if (status == StatusEnum::kSuccess)
     {
         if (mTimeStamp.HasValue())
         {
             response.UTCTimeStamp = mTimeStamp;
         }

         if (mTimeSinceBoot.HasValue())
         {
             response.timeSinceBoot = mTimeSinceBoot;
         }
     }
     commandHandle->AddResponse(mRequestPath, response);
 }

 void BDXDiagnosticLogsProvider::Reset()
 {
     assertChipStackLockedByCurrentThread();

     Initiator::ResetTransfer();
     mExchangeCtx = nullptr;

     if (mBDXTransferExchangeCtx != nullptr)
     {
         mBDXTransferExchangeCtx->Close();
         mBDXTransferExchangeCtx = nullptr;
     }

     if (mDelegate != nullptr)
     {
         mDelegate->EndLogCollection(mLogSessionHandle);
         mDelegate = nullptr;
     }

     mFabricIndex.ClearValue();
     mPeerNodeId.ClearValue();
     mIsAcceptReceived = false;
     mLogSessionHandle = kInvalidLogSessionHandle;
     mTimeStamp.ClearValue();
     mTimeSinceBoot.ClearValue();
     mAsyncCommandHandle = nullptr;
     mRequestPath        = ConcreteCommandPath(kInvalidEndpointId, kInvalidClusterId, kInvalidCommandId);
     mInitialized        = false;
 }

 void BDXDiagnosticLogsProvider::OnExchangeClosing(Messaging::ExchangeContext * ec)
 {
     mBDXTransferExchangeCtx = nullptr;
 }

 } // namespace DiagnosticLogs
 } // namespace Clusters
 } // namespace app
 } // namespace chip

 #endif
	/*
	*
	* Copyright (c) 2023 Project CHIP Authors
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <lib/core/CHIPConfig.h>

	#if CHIP_CONFIG_ENABLE_BDX_LOG_TRANSFER
	#include "BDXDiagnosticLogsProvider.h"
	#include <app/clusters/diagnostic-logs-server/diagnostic-logs-server.h>
	#include <messaging/ExchangeMgr.h>
	#include <platform/CHIPDeviceLayer.h>

	using namespace chip::bdx;

	namespace chip {
	namespace app {
	namespace Clusters {
	namespace DiagnosticLogs {

	// BDX transfer session polling interval.
	constexpr System::Clock::Timeout kBdxPollIntervalMs = System::Clock::Milliseconds32(50);

	// Timeout for the BDX transfer session
	constexpr System::Clock::Timeout kBdxTimeout = System::Clock::Seconds16(5 * 60);

	constexpr uint16_t kBdxMaxBlockSize = 1024;

	CHIP_ERROR BDXDiagnosticLogsProvider::InitializeTransfer(CommandHandler * commandObj, const ConcreteCommandPath & path,
	DiagnosticLogsProviderDelegate * delegate, IntentEnum intent,
	CharSpan fileDesignator)
	{
	auto exchangeCtx = commandObj->GetExchangeContext();
	VerifyOrReturnError(nullptr != exchangeCtx, CHIP_ERROR_INVALID_ARGUMENT);

	auto exchangeMgr = exchangeCtx->GetExchangeMgr();
	VerifyOrReturnError(nullptr != exchangeMgr, CHIP_ERROR_INVALID_ARGUMENT);

	auto sessionHandle = exchangeCtx->GetSessionHandle();
	VerifyOrReturnError(sessionHandle->IsSecureSession(), CHIP_ERROR_INVALID_ARGUMENT);

	ScopedNodeId scopedPeerNodeId = sessionHandle->AsSecureSession()->GetPeer();
	auto fabricIndex = scopedPeerNodeId.GetFabricIndex();
	VerifyOrReturnError(kUndefinedFabricIndex != fabricIndex, CHIP_ERROR_INVALID_ARGUMENT);

	auto peerNodeId = scopedPeerNodeId.GetNodeId();
	VerifyOrReturnError(kUndefinedNodeId != peerNodeId, CHIP_ERROR_INVALID_ARGUMENT);

	LogSessionHandle logSessionHandle;
	Optional<uint64_t> timeStamp;
	Optional<uint64_t> timeSinceBoot;
	VerifyOrReturnError(delegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
	ReturnErrorOnFailure(delegate->StartLogCollection(intent, logSessionHandle, timeStamp, timeSinceBoot));

	// Create a new exchange context to use for the BDX transfer session
	// and send the SendInit message over the exchange.
	auto transferExchangeCtx = exchangeMgr->NewContext(sessionHandle, this);
	VerifyOrReturnError(nullptr != transferExchangeCtx, CHIP_ERROR_NO_MEMORY);

	TransferSession::TransferInitData initOptions;
	initOptions.TransferCtlFlags = TransferControlFlags::kSenderDrive;
	initOptions.MaxBlockSize = kBdxMaxBlockSize;
	initOptions.FileDesLength = static_cast<uint16_t>(fileDesignator.size());
	initOptions.FileDesignator = Uint8::from_const_char(fileDesignator.data());

	CHIP_ERROR err = Initiator::InitiateTransfer(&DeviceLayer::SystemLayer(), TransferRole::kSender, initOptions, kBdxTimeout,
	kBdxPollIntervalMs);
	if (CHIP_NO_ERROR != err)
	{
	LogErrorOnFailure(err);
	transferExchangeCtx->Close();
	return err;
	}

	mBDXTransferExchangeCtx = transferExchangeCtx;
	mDelegate = delegate;
	mFabricIndex.SetValue(fabricIndex);
	mPeerNodeId.SetValue(peerNodeId);
	mIsAcceptReceived = false;
	mLogSessionHandle = logSessionHandle;
	mTimeStamp = timeStamp;
	mTimeSinceBoot = timeSinceBoot;
	mAsyncCommandHandle = CommandHandler::Handle(commandObj);
	mRequestPath = path;
	mInitialized = true;

	return CHIP_NO_ERROR;
	}

	void BDXDiagnosticLogsProvider::HandleTransferSessionOutput(TransferSession::OutputEvent & event)
	{
	if (event.EventType != TransferSession::OutputEventType::kNone)
	{
	ChipLogDetail(BDX, "OutputEvent type: %s", event.ToString(event.EventType));
	}

	switch (event.EventType)
	{
	case TransferSession::OutputEventType::kMsgToSend:
	OnMsgToSend(event);
	break;
	case TransferSession::OutputEventType::kAcceptReceived:
	OnAcceptReceived();
	// Upon acceptance of the transfer, the OnAckReceived method initiates the process of sending logs.
	OnAckReceived();
	break;
	case TransferSession::OutputEventType::kAckReceived:
	OnAckReceived();
	break;
	case TransferSession::OutputEventType::kAckEOFReceived:
	OnAckEOFReceived();
	break;
	case TransferSession::OutputEventType::kStatusReceived:
	OnStatusReceived(event);
	break;
	case TransferSession::OutputEventType::kInternalError:
	OnInternalError();
	break;
	case TransferSession::OutputEventType::kTransferTimeout:
	OnTimeout();
	break;
	case TransferSession::OutputEventType::kNone:
	case TransferSession::OutputEventType::kInitReceived:
	break;
	case TransferSession::OutputEventType::kBlockReceived:
	case TransferSession::OutputEventType::kQueryReceived:
	case TransferSession::OutputEventType::kQueryWithSkipReceived:
	// TransferSession should prevent this case from happening.
	ChipLogError(BDX, "Unsupported event type");
	break;
	}
	}

	void BDXDiagnosticLogsProvider::OnMsgToSend(TransferSession::OutputEvent & event)
	{
	VerifyOrReturn(mBDXTransferExchangeCtx != nullptr);

	auto & msgTypeData = event.msgTypeData;
	bool isStatusReport = msgTypeData.HasMessageType(Protocols::SecureChannel::MsgType::StatusReport);

	// All messages sent from the Sender expect a response, except for a StatusReport which would indicate an error and the
	// end of the transfer.
	Messaging::SendFlags sendFlags;
	if (!isStatusReport)
	{
	sendFlags.Set(Messaging::SendMessageFlags::kExpectResponse);
	}

	auto err =
	mBDXTransferExchangeCtx->SendMessage(msgTypeData.ProtocolId, msgTypeData.MessageType, std::move(event.MsgData), sendFlags);

	VerifyOrDo(CHIP_NO_ERROR == err, Reset());
	}

	void BDXDiagnosticLogsProvider::OnAcceptReceived()
	{
	mIsAcceptReceived = true;

	// On reception of a BDX SendAccept message the Node SHALL send a RetrieveLogsResponse command with a Status field set to
	// Success and proceed with the log transfer over BDX.
	SendCommandResponse(StatusEnum::kSuccess);
	}

	void BDXDiagnosticLogsProvider::OnAckReceived()
	{
	uint16_t blockSize = mTransfer.GetTransferBlockSize();

	auto blockBuf = System::PacketBufferHandle::New(blockSize);
	VerifyOrReturn(!blockBuf.IsNull(), mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(CHIP_ERROR_NO_MEMORY)));

	auto buffer = MutableByteSpan(blockBuf->Start(), blockSize);
	bool isEndOfLog = false;

	// Get the log next chunk and see if it fits i.e. if is end of log is reported
	auto err = mDelegate->CollectLog(mLogSessionHandle, buffer, isEndOfLog);
	VerifyOrReturn(CHIP_NO_ERROR == err, mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err)));

	// If the buffer has empty space, end the log collection session.
	if (isEndOfLog)
	{
	mDelegate->EndLogCollection(mLogSessionHandle);
	mLogSessionHandle = kInvalidLogSessionHandle;
	}

	// Prepare the BDX block to send to the requestor
	TransferSession::BlockData blockData;
	blockData.Data = blockBuf->Start();
	blockData.Length = static_cast<size_t>(buffer.size());
	blockData.IsEof = isEndOfLog;

	err = mTransfer.PrepareBlock(blockData);
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(BDX, "PrepareBlock failed: %" CHIP_ERROR_FORMAT, err.Format());
	mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));
	}
	}

	void BDXDiagnosticLogsProvider::OnAckEOFReceived()
	{
	ChipLogProgress(BDX, "Diagnostic logs transfer: Success");

	Reset();
	}

	void BDXDiagnosticLogsProvider::OnStatusReceived(TransferSession::OutputEvent & event)
	{
	ChipLogError(BDX, "Diagnostic logs transfer: StatusReport Error %x", to_underlying(event.statusData.statusCode));

	// If a failure StatusReport is received in response to the SendInit message, the Node SHALL send a RetrieveLogsResponse command
	// with a Status of Denied.
	VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
	Reset();
	}

	void BDXDiagnosticLogsProvider::OnInternalError()
	{
	ChipLogError(BDX, "Internal Error");
	VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
	Reset();
	}

	void BDXDiagnosticLogsProvider::OnTimeout()
	{
	ChipLogError(BDX, "Timeout");
	VerifyOrDo(mIsAcceptReceived, SendCommandResponse(StatusEnum::kDenied));
	Reset();
	}

	void BDXDiagnosticLogsProvider::SendCommandResponse(StatusEnum status)
	{
	auto commandHandleRef = std::move(mAsyncCommandHandle);
	auto commandHandle = commandHandleRef.Get();

	VerifyOrReturn(nullptr != commandHandle, ChipLogError(Zcl, "SendCommandResponse - commandHandler is null"));

	Commands::RetrieveLogsResponse::Type response;
	response.status = status;
	if (status == StatusEnum::kSuccess)
	{
	if (mTimeStamp.HasValue())
	{
	response.UTCTimeStamp = mTimeStamp;
	}

	if (mTimeSinceBoot.HasValue())
	{
	response.timeSinceBoot = mTimeSinceBoot;
	}
	}
	commandHandle->AddResponse(mRequestPath, response);
	}

	void BDXDiagnosticLogsProvider::Reset()
	{
	assertChipStackLockedByCurrentThread();

	Initiator::ResetTransfer();
	mExchangeCtx = nullptr;

	if (mBDXTransferExchangeCtx != nullptr)
	{
	mBDXTransferExchangeCtx->Close();
	mBDXTransferExchangeCtx = nullptr;
	}

	if (mDelegate != nullptr)
	{
	mDelegate->EndLogCollection(mLogSessionHandle);
	mDelegate = nullptr;
	}

	mFabricIndex.ClearValue();
	mPeerNodeId.ClearValue();
	mIsAcceptReceived = false;
	mLogSessionHandle = kInvalidLogSessionHandle;
	mTimeStamp.ClearValue();
	mTimeSinceBoot.ClearValue();
	mAsyncCommandHandle = nullptr;
	mRequestPath = ConcreteCommandPath(kInvalidEndpointId, kInvalidClusterId, kInvalidCommandId);
	mInitialized = false;
	}

	void BDXDiagnosticLogsProvider::OnExchangeClosing(Messaging::ExchangeContext * ec)
	{
	mBDXTransferExchangeCtx = nullptr;
	}

	} // namespace DiagnosticLogs
	} // namespace Clusters
	} // namespace app
	} // namespace chip

	#endif