weave/src/lib/profiles/echo/WeaveEchoClient.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 2013-2017 Nest Labs, Inc.
  *    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.
  */

 /**
  *    @file
  *      This file implements an object for a Weave Echo unsolicitied
  *      initiator (client).
  *
  */

 #include <Weave/Core/WeaveCore.h>
 #include "WeaveEcho.h"

 namespace nl {
 namespace Weave {
 namespace Profiles {

 WeaveEchoClient::WeaveEchoClient()
 {
     FabricState = NULL;
     ExchangeMgr = NULL;
     EncryptionType = kWeaveEncryptionType_None;
     KeyId = WeaveKeyId::kNone;
     OnEchoResponseReceived = NULL;
     ExchangeCtx = NULL;
 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     OnAckRcvdReceived = NULL;
     RequestAck = false;
     AckReceived = false;
     ResponseReceived = false;
     WRMPACKDelay = WEAVE_CONFIG_WRMP_DEFAULT_ACK_TIMEOUT;
     WRMPRetransInterval = WEAVE_CONFIG_WRMP_DEFAULT_ACTIVE_RETRANS_TIMEOUT;
     WRMPRetransCount = WEAVE_CONFIG_WRMP_DEFAULT_MAX_RETRANS;
     appContext = 0xcafebabe;
 #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
 }

 WEAVE_ERROR WeaveEchoClient::Init(WeaveExchangeManager *exchangeMgr)
 {
     // Error if already initialized.
     if (ExchangeMgr != NULL)
         return WEAVE_ERROR_INCORRECT_STATE;

     ExchangeMgr = exchangeMgr;
     FabricState = exchangeMgr->FabricState;
     EncryptionType = kWeaveEncryptionType_None;
     KeyId = WeaveKeyId::kNone;
     OnEchoResponseReceived = NULL;
     ExchangeCtx = NULL;

     return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR WeaveEchoClient::Shutdown()
 {
     if (ExchangeCtx != NULL)
     {
         ExchangeCtx->Abort();
         ExchangeCtx = NULL;
     }

     ExchangeMgr = NULL;
     FabricState = NULL;

     return WEAVE_NO_ERROR;
 }

 /**
  * Send an echo request over a WeaveConnection
  *
  * @param con     The connection
  * @param payload A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
  *
  * @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
  *         Other WEAVE_ERROR codes as returned by the lower layers.
  */
 WEAVE_ERROR WeaveEchoClient::SendEchoRequest(WeaveConnection *con, PacketBuffer *payload)
 {
     // Discard any existing exchange context. Effectively we can only have one Echo exchange with
     // a single node at any one time.
     if (ExchangeCtx != NULL)
     {
         ExchangeCtx->Abort();
         ExchangeCtx = NULL;
     }

     // Create a new exchange context.
     ExchangeCtx = ExchangeMgr->NewContext(con, this);
     if (ExchangeCtx == NULL)
     {
         PacketBuffer::Free(payload);
         return WEAVE_ERROR_NO_MEMORY;
     }

     ExchangeCtx->OnConnectionClosed = HandleConnectionClosed;

     return SendEchoRequest(payload);
 }

 /**
  * Send an echo request to a Weave node using the default Weave port and the
  * letting the system's routing table choose the output interface.
  *
  * @param nodeId        The destination's nodeId
  * @param nodeAddr      The destination's ip address
  * @param payload       A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
  *
  * @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
  *         Other WEAVE_ERROR codes as returned by the lower layers.
  */
 WEAVE_ERROR WeaveEchoClient::SendEchoRequest(uint64_t nodeId, IPAddress nodeAddr, PacketBuffer *payload)
 {
     return SendEchoRequest(nodeId, nodeAddr, WEAVE_PORT, INET_NULL_INTERFACEID, payload);
 }

 /**
  * Send an echo request to a Weave node.
  *
  * @param nodeId        The destination's nodeId
  * @param nodeAddr      The destination's ip address
  * @param port          The destination's UDP port (WEAVE_PORT by default)
  * @param sendIntfId    A specific interface to use
  * @param payload       A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
  *
  * @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
  *         Other WEAVE_ERROR codes as returned by the lower layers.
  */
 WEAVE_ERROR WeaveEchoClient::SendEchoRequest(uint64_t nodeId, IPAddress nodeAddr, uint16_t port, InterfaceId sendIntfId, PacketBuffer *payload)
 {
     // Discard any existing exchange context. Effectively we can only have one Echo exchange with
     // a single node at any one time.
     if (ExchangeCtx != NULL)
     {
         ExchangeCtx->Abort();
         ExchangeCtx = NULL;
     }
     if (nodeAddr == IPAddress::Any)
         nodeAddr = FabricState->SelectNodeAddress(nodeId);

     // Create a new exchange context.
     ExchangeCtx = ExchangeMgr->NewContext(nodeId, nodeAddr, WEAVE_PORT, sendIntfId, this);
     if (ExchangeCtx == NULL)
     {
         PacketBuffer::Free(payload);
         return WEAVE_ERROR_NO_MEMORY;
     }

     return SendEchoRequest(payload);
 }

 WEAVE_ERROR WeaveEchoClient::SendEchoRequest(PacketBuffer *payload)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // Configure the encryption and signature types to be used to send the request.
     ExchangeCtx->EncryptionType = EncryptionType;
     ExchangeCtx->KeyId = KeyId;

     // Arrange for messages in this exchange to go to our response handler.
     ExchangeCtx->OnMessageReceived = HandleResponse;

     ExchangeCtx->OnKeyError = HandleKeyError;

     // Send an Echo Request message.  Discard the exchange context if the send fails.
 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     AckReceived = false;
     ResponseReceived = false;

     if (RequestAck)
     {
         ExchangeCtx->OnAckRcvd = HandleAckRcvd;
         ExchangeCtx->OnSendError = HandleSendError;
         ExchangeCtx->mWRMPConfig.mAckPiggybackTimeout = WRMPACKDelay;
         ExchangeCtx->mWRMPConfig.mInitialRetransTimeout = WRMPRetransInterval;
         ExchangeCtx->mWRMPConfig.mActiveRetransTimeout = WRMPRetransInterval;
         ExchangeCtx->mWRMPConfig.mMaxRetrans = WRMPRetransCount;
         err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload, ExchangeContext::kSendFlag_RequestAck, &appContext);
     }
     else
         err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload);
 #else // !WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload);
 #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     payload = NULL;
     if (err != WEAVE_NO_ERROR && ExchangeCtx)
     {
         ExchangeCtx->Abort();
         ExchangeCtx = NULL;
     }

     return err;
 }

 void WeaveEchoClient::HandleResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     WeaveEchoClient *echoApp = (WeaveEchoClient *)ec->AppState;

     // Assert that the exchange context matches the client's current context.
     // This should never fail because even if SendEchoRequest is called
     // back-to-back, the second call will call Close() on the first exchange,
     // which clears the OnMessageReceived callback.
     VerifyOrDie(echoApp && ec == echoApp->ExchangeCtx);

     // Verify that the message is an Echo Response.
     // If not, close the exchange and free the payload.
     if (profileId != kWeaveProfile_Echo || msgType != kEchoMessageType_EchoResponse)
     {
         ec->Close();
         echoApp->ExchangeCtx = NULL;
         ExitNow();
     }

 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     echoApp->ResponseReceived = true;

     if (!echoApp->RequestAck || echoApp->AckReceived || (!echoApp->OnAckRcvdReceived))
 #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     {
         // Remove the EC from the app state now. OnEchoResponseReceived can call
         // SendEchoRequest and install a new one.
         echoApp->ExchangeCtx->Close();
         echoApp->ExchangeCtx = NULL;
     }

     // Call the registered OnEchoResponseReceived handler, if any.
     if (echoApp->OnEchoResponseReceived != NULL)
         echoApp->OnEchoResponseReceived(msgInfo->SourceNodeId, (pktInfo != NULL) ? pktInfo->SrcAddress : IPAddress::Any, payload);

 exit:
     // Free the payload buffer.
     PacketBuffer::Free(payload);
 }

 void WeaveEchoClient::HandleConnectionClosed(ExchangeContext *ec, WeaveConnection *con, WEAVE_ERROR conErr)
 {
     HandleError(ec, conErr);
 }

 void WeaveEchoClient::HandleSendError(ExchangeContext *ec, WEAVE_ERROR sendErr, void *msgCtxt)
 {
     HandleError(ec, sendErr);
 }

 void WeaveEchoClient::HandleKeyError(ExchangeContext *ec, WEAVE_ERROR keyErr)
 {
     HandleError(ec, keyErr);
 }

 void WeaveEchoClient::HandleError(ExchangeContext *ec, WEAVE_ERROR err)
 {
     WeaveEchoClient *echoApp = (WeaveEchoClient *)ec->AppState;

     VerifyOrExit(echoApp && echoApp->ExchangeCtx, /* no action */);

     VerifyOrDie(ec == echoApp->ExchangeCtx);

     if (err != WEAVE_NO_ERROR)
     {
         echoApp->ExchangeCtx->Abort();
     }
     else
     {
         echoApp->ExchangeCtx->Close();
     }
 exit:
     echoApp->ExchangeCtx = NULL;
 }

 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
 void WeaveEchoClient::HandleAckRcvd(ExchangeContext *ec, void *msgCtxt)
 {
     WeaveEchoClient *echoApp = (WeaveEchoClient *)ec->AppState;

     // Assert that the exchange context matches the client's current context.
     // This should never fail because even if SendEchoRequest is called
     // back-to-back, the second call will call Close() on the first exchange,
     // which clears the OnAckReceived callback.
     VerifyOrDie(echoApp && ec == echoApp->ExchangeCtx);

     echoApp->AckReceived = true;

     if (echoApp->ResponseReceived)
     {
         // Remove the EC from the app state now. OnAckRcvdReceived can call
         // SendEchoRequest and install a new one.
         echoApp->ExchangeCtx->Close();
         echoApp->ExchangeCtx = NULL;
     }

     // Call the registered OnEchoResponseReceived handler, if any.
     if (echoApp->OnAckRcvdReceived != NULL)
         echoApp->OnAckRcvdReceived(msgCtxt);
 }

 void WeaveEchoClient::SetRequestAck(bool requestAck)
 {
     RequestAck = requestAck;
 }

 void WeaveEchoClient::SetWRMPACKDelay(uint16_t aWRMPACKDelay)
 {
     WRMPACKDelay = aWRMPACKDelay;
 }

 void WeaveEchoClient::SetWRMPRetransInterval(uint32_t aWRMPRetransInterval)
 {
     WRMPRetransInterval = aWRMPRetransInterval;
 }

 void WeaveEchoClient::SetWRMPRetransCount(uint8_t aWRMPRetransCount)
 {
     WRMPRetransCount = aWRMPRetransCount;
 }
 #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

 } // namespace Profiles
 } // namespace Weave
 } // namespace nl
	/*
	*
	* Copyright (c) 2013-2017 Nest Labs, Inc.
	* 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.
	*/

	/**
	* @file
	* This file implements an object for a Weave Echo unsolicitied
	* initiator (client).
	*
	*/

	#include <Weave/Core/WeaveCore.h>
	#include "WeaveEcho.h"

	namespace nl {
	namespace Weave {
	namespace Profiles {

	WeaveEchoClient::WeaveEchoClient()
	{
	FabricState = NULL;
	ExchangeMgr = NULL;
	EncryptionType = kWeaveEncryptionType_None;
	KeyId = WeaveKeyId::kNone;
	OnEchoResponseReceived = NULL;
	ExchangeCtx = NULL;
	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	OnAckRcvdReceived = NULL;
	RequestAck = false;
	AckReceived = false;
	ResponseReceived = false;
	WRMPACKDelay = WEAVE_CONFIG_WRMP_DEFAULT_ACK_TIMEOUT;
	WRMPRetransInterval = WEAVE_CONFIG_WRMP_DEFAULT_ACTIVE_RETRANS_TIMEOUT;
	WRMPRetransCount = WEAVE_CONFIG_WRMP_DEFAULT_MAX_RETRANS;
	appContext = 0xcafebabe;
	#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	}

	WEAVE_ERROR WeaveEchoClient::Init(WeaveExchangeManager *exchangeMgr)
	{
	// Error if already initialized.
	if (ExchangeMgr != NULL)
	return WEAVE_ERROR_INCORRECT_STATE;

	ExchangeMgr = exchangeMgr;
	FabricState = exchangeMgr->FabricState;
	EncryptionType = kWeaveEncryptionType_None;
	KeyId = WeaveKeyId::kNone;
	OnEchoResponseReceived = NULL;
	ExchangeCtx = NULL;

	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR WeaveEchoClient::Shutdown()
	{
	if (ExchangeCtx != NULL)
	{
	ExchangeCtx->Abort();
	ExchangeCtx = NULL;
	}

	ExchangeMgr = NULL;
	FabricState = NULL;

	return WEAVE_NO_ERROR;
	}

	/**
	* Send an echo request over a WeaveConnection
	*
	* @param con The connection
	* @param payload A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
	*
	* @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
	* Other WEAVE_ERROR codes as returned by the lower layers.
	*/
	WEAVE_ERROR WeaveEchoClient::SendEchoRequest(WeaveConnection con, PacketBuffer payload)
	{
	// Discard any existing exchange context. Effectively we can only have one Echo exchange with
	// a single node at any one time.
	if (ExchangeCtx != NULL)
	{
	ExchangeCtx->Abort();
	ExchangeCtx = NULL;
	}

	// Create a new exchange context.
	ExchangeCtx = ExchangeMgr->NewContext(con, this);
	if (ExchangeCtx == NULL)
	{
	PacketBuffer::Free(payload);
	return WEAVE_ERROR_NO_MEMORY;
	}

	ExchangeCtx->OnConnectionClosed = HandleConnectionClosed;

	return SendEchoRequest(payload);
	}

	/**
	* Send an echo request to a Weave node using the default Weave port and the
	* letting the system's routing table choose the output interface.
	*
	* @param nodeId The destination's nodeId
	* @param nodeAddr The destination's ip address
	* @param payload A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
	*
	* @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
	* Other WEAVE_ERROR codes as returned by the lower layers.
	*/
	WEAVE_ERROR WeaveEchoClient::SendEchoRequest(uint64_t nodeId, IPAddress nodeAddr, PacketBuffer *payload)
	{
	return SendEchoRequest(nodeId, nodeAddr, WEAVE_PORT, INET_NULL_INTERFACEID, payload);
	}

	/**
	* Send an echo request to a Weave node.
	*
	* @param nodeId The destination's nodeId
	* @param nodeAddr The destination's ip address
	* @param port The destination's UDP port (WEAVE_PORT by default)
	* @param sendIntfId A specific interface to use
	* @param payload A PacketBuffer with the payload. This function takes ownership of the PacketBuffer
	*
	* @return WEAVE_ERROR_NO_MEMORY if no ExchangeContext is available.
	* Other WEAVE_ERROR codes as returned by the lower layers.
	*/
	WEAVE_ERROR WeaveEchoClient::SendEchoRequest(uint64_t nodeId, IPAddress nodeAddr, uint16_t port, InterfaceId sendIntfId, PacketBuffer *payload)
	{
	// Discard any existing exchange context. Effectively we can only have one Echo exchange with
	// a single node at any one time.
	if (ExchangeCtx != NULL)
	{
	ExchangeCtx->Abort();
	ExchangeCtx = NULL;
	}
	if (nodeAddr == IPAddress::Any)
	nodeAddr = FabricState->SelectNodeAddress(nodeId);

	// Create a new exchange context.
	ExchangeCtx = ExchangeMgr->NewContext(nodeId, nodeAddr, WEAVE_PORT, sendIntfId, this);
	if (ExchangeCtx == NULL)
	{
	PacketBuffer::Free(payload);
	return WEAVE_ERROR_NO_MEMORY;
	}

	return SendEchoRequest(payload);
	}

	WEAVE_ERROR WeaveEchoClient::SendEchoRequest(PacketBuffer *payload)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// Configure the encryption and signature types to be used to send the request.
	ExchangeCtx->EncryptionType = EncryptionType;
	ExchangeCtx->KeyId = KeyId;

	// Arrange for messages in this exchange to go to our response handler.
	ExchangeCtx->OnMessageReceived = HandleResponse;

	ExchangeCtx->OnKeyError = HandleKeyError;

	// Send an Echo Request message. Discard the exchange context if the send fails.
	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	AckReceived = false;
	ResponseReceived = false;

	if (RequestAck)
	{
	ExchangeCtx->OnAckRcvd = HandleAckRcvd;
	ExchangeCtx->OnSendError = HandleSendError;
	ExchangeCtx->mWRMPConfig.mAckPiggybackTimeout = WRMPACKDelay;
	ExchangeCtx->mWRMPConfig.mInitialRetransTimeout = WRMPRetransInterval;
	ExchangeCtx->mWRMPConfig.mActiveRetransTimeout = WRMPRetransInterval;
	ExchangeCtx->mWRMPConfig.mMaxRetrans = WRMPRetransCount;
	err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload, ExchangeContext::kSendFlag_RequestAck, &appContext);
	}
	else
	err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload);
	#else // !WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	err = ExchangeCtx->SendMessage(kWeaveProfile_Echo, kEchoMessageType_EchoRequest, payload);
	#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	payload = NULL;
	if (err != WEAVE_NO_ERROR && ExchangeCtx)
	{
	ExchangeCtx->Abort();
	ExchangeCtx = NULL;
	}

	return err;
	}

	void WeaveEchoClient::HandleResponse(ExchangeContext ec, const IPPacketInfo pktInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	WeaveEchoClient echoApp = (WeaveEchoClient )ec->AppState;

	// Assert that the exchange context matches the client's current context.
	// This should never fail because even if SendEchoRequest is called
	// back-to-back, the second call will call Close() on the first exchange,
	// which clears the OnMessageReceived callback.
	VerifyOrDie(echoApp && ec == echoApp->ExchangeCtx);

	// Verify that the message is an Echo Response.
	// If not, close the exchange and free the payload.
	if (profileId != kWeaveProfile_Echo \|\| msgType != kEchoMessageType_EchoResponse)
	{
	ec->Close();
	echoApp->ExchangeCtx = NULL;
	ExitNow();
	}

	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	echoApp->ResponseReceived = true;

	if (!echoApp->RequestAck \|\| echoApp->AckReceived \|\| (!echoApp->OnAckRcvdReceived))
	#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	{
	// Remove the EC from the app state now. OnEchoResponseReceived can call
	// SendEchoRequest and install a new one.
	echoApp->ExchangeCtx->Close();
	echoApp->ExchangeCtx = NULL;
	}

	// Call the registered OnEchoResponseReceived handler, if any.
	if (echoApp->OnEchoResponseReceived != NULL)
	echoApp->OnEchoResponseReceived(msgInfo->SourceNodeId, (pktInfo != NULL) ? pktInfo->SrcAddress : IPAddress::Any, payload);

	exit:
	// Free the payload buffer.
	PacketBuffer::Free(payload);
	}

	void WeaveEchoClient::HandleConnectionClosed(ExchangeContext ec, WeaveConnection con, WEAVE_ERROR conErr)
	{
	HandleError(ec, conErr);
	}

	void WeaveEchoClient::HandleSendError(ExchangeContext ec, WEAVE_ERROR sendErr, void msgCtxt)
	{
	HandleError(ec, sendErr);
	}

	void WeaveEchoClient::HandleKeyError(ExchangeContext *ec, WEAVE_ERROR keyErr)
	{
	HandleError(ec, keyErr);
	}

	void WeaveEchoClient::HandleError(ExchangeContext *ec, WEAVE_ERROR err)
	{
	WeaveEchoClient echoApp = (WeaveEchoClient )ec->AppState;

	VerifyOrExit(echoApp && echoApp->ExchangeCtx, /* no action */);

	VerifyOrDie(ec == echoApp->ExchangeCtx);

	if (err != WEAVE_NO_ERROR)
	{
	echoApp->ExchangeCtx->Abort();
	}
	else
	{
	echoApp->ExchangeCtx->Close();
	}
	exit:
	echoApp->ExchangeCtx = NULL;
	}

	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	void WeaveEchoClient::HandleAckRcvd(ExchangeContext ec, void msgCtxt)
	{
	WeaveEchoClient echoApp = (WeaveEchoClient )ec->AppState;

	// Assert that the exchange context matches the client's current context.
	// This should never fail because even if SendEchoRequest is called
	// back-to-back, the second call will call Close() on the first exchange,
	// which clears the OnAckReceived callback.
	VerifyOrDie(echoApp && ec == echoApp->ExchangeCtx);

	echoApp->AckReceived = true;

	if (echoApp->ResponseReceived)
	{
	// Remove the EC from the app state now. OnAckRcvdReceived can call
	// SendEchoRequest and install a new one.
	echoApp->ExchangeCtx->Close();
	echoApp->ExchangeCtx = NULL;
	}

	// Call the registered OnEchoResponseReceived handler, if any.
	if (echoApp->OnAckRcvdReceived != NULL)
	echoApp->OnAckRcvdReceived(msgCtxt);
	}

	void WeaveEchoClient::SetRequestAck(bool requestAck)
	{
	RequestAck = requestAck;
	}

	void WeaveEchoClient::SetWRMPACKDelay(uint16_t aWRMPACKDelay)
	{
	WRMPACKDelay = aWRMPACKDelay;
	}

	void WeaveEchoClient::SetWRMPRetransInterval(uint32_t aWRMPRetransInterval)
	{
	WRMPRetransInterval = aWRMPRetransInterval;
	}

	void WeaveEchoClient::SetWRMPRetransCount(uint8_t aWRMPRetransCount)
	{
	WRMPRetransCount = aWRMPRetransCount;
	}
	#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

	} // namespace Profiles
	} // namespace Weave
	} // namespace nl