weave/src/test-apps/nlweavebdxclient.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 unsolicited initiator (i.e., client)
  *      for the "legacy" (see [Managed Namespaces](@ref mns)) Weave
  *      Bulk Data Transfer (BDX) profile used for functional testing
  *      of the implementation of core message handlers and protocol
  *      engine for that profile.
  *
  */

 #include "ToolCommon.h"
 #include "nlweavebdxclient.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>

 namespace nl {
 namespace Weave {
 namespace Profiles {


 using namespace nl::Weave::Profiles::BulkDataTransfer;

 BulkDataTransferClient::BulkDataTransferClient()
 {
     FabricState = NULL;
     ExchangeMgr = NULL;
     mBlockCounter = 0;
 }

 BulkDataTransferClient::~BulkDataTransferClient()
 {
     FabricState = NULL;
     ExchangeMgr = NULL;
     mBlockCounter = 0;
 }

 WEAVE_ERROR BulkDataTransferClient::Init(WeaveExchangeManager *exchangeMgr, const char* DestFileName)
 {
     // Error if already initialized.
     if (ExchangeMgr != NULL)
         return WEAVE_ERROR_INCORRECT_STATE;

     ExchangeMgr = exchangeMgr;
     FabricState = exchangeMgr->FabricState;
     mBlockCounter = 0;

     if (DestFileName)
     {
         DestFile = open(DestFileName, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
         if (DestFile < 0)
             return INET_MapOSError(errno);
     }

     return WEAVE_NO_ERROR;
 }

 void BulkDataTransferClient::setCon(WeaveConnection *con)
 {
     mCon = con;
 }

 WEAVE_ERROR BulkDataTransferClient::Shutdown()
 {
     ExchangeMgr = NULL;
     FabricState = NULL;
     mBlockCounter = 0;

     return WEAVE_NO_ERROR;
 }


 /*
  * ReceiveInit request
  */

 WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(WeaveConnection *con)
 {
     // Discard any existing exchange context.
     // Effectively we can only have one BDX exchange with a single node at any one time.
     if (ExchangeCtx != NULL)
     {
         ExchangeCtx->Close();
         ExchangeCtx = NULL;
     }

     // Create a new exchange context.
     ExchangeCtx = ExchangeMgr->NewContext(con, this);
     if (ExchangeCtx == NULL)
         return WEAVE_ERROR_NO_MEMORY;

     return SendReceiveInitRequest();
 }

 WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(uint64_t nodeId, IPAddress nodeAddr)
 {
     return SendReceiveInitRequest(nodeId, nodeAddr, WEAVE_PORT);
 }

 WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(uint64_t nodeId, IPAddress nodeAddr, uint16_t port)
 {
     // Discard any existing exchange context.
     // Effectively we can only have one BDX exchange with a single node at any one time.
     if (ExchangeCtx != NULL)
     {
         ExchangeCtx->Close();
         ExchangeCtx = NULL;
     }

     if (nodeAddr == IPAddress::Any)
         nodeAddr = FabricState->SelectNodeAddress(nodeId);

     // Create a new exchange context.
     ExchangeCtx = ExchangeMgr->NewContext(nodeId, nodeAddr, this);
     if (ExchangeCtx == NULL)
         return WEAVE_ERROR_NO_MEMORY;

     return SendReceiveInitRequest();
 }

 #define BDX_MAX_BLOCK_SIZE 256
 #define BDX_START_OFFSET 0

 WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest()
 {
     if (!ExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

     printf("0 SendReceiveInitRequest entering\n");

     // 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 = HandleReceiveInitResponse;

     /*
      * Build the ReceiveInit request
      */

     ReferencedString aFileDesignator;
     //NOTE: normally this URI would have been agreed upon with the SWU protocol
     //      Ex.: the SWU server returned "bdx://nestlabs/share/heatlink/data/firmware/production/heatlink.elf",
     //      so the file name is extracted and is sent to the BDX server.
     char aFileDesignatorStr[] = "/var/log/heatlink.elf"; //FIXME: temporary hack for the purpose of testing
     aFileDesignator.init((uint16_t)(sizeof(aFileDesignatorStr)-1), aFileDesignatorStr);

     ReceiveInit receiveInit;
     receiveInit.init(false /*SenderDrive*/, true /*ReceiverDrive*/, false /*AsynchMode*/, BDX_MAX_BLOCK_SIZE,
                         (uint32_t)BDX_START_OFFSET, (uint32_t)0 /*Length (zero means undefined length)*/, aFileDesignator, NULL /*MetaData*/);
     PacketBuffer* receiveInitPayload = PacketBuffer::New();
     receiveInit.pack(receiveInitPayload);

     // Send a ReceiveInit request message. Discard the exchange context if the send fails.
     WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveInit, receiveInitPayload);
     receiveInitPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendReceiveInitRequest\n");
         ExchangeCtx->Close();
         ExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
     }

     printf("2 SendReceiveInitRequest exiting\n");

     return err;
 }

 void BulkDataTransferClient::HandleReceiveInitResponse(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     printf("0 HandleReceiveInitResponse entering\n");

     BulkDataTransferClient *bdxApp = (BulkDataTransferClient *)ec->AppState;

     // Verify that the message is a ReceiveInit Response.
     if (profileId != kWeaveProfile_BDX || (msgType != kMsgType_ReceiveAccept && msgType != kMsgType_ReceiveReject))
     {
         printf("1 HandleReceiveInitResponse\n");
         // TODO: handle unexpected response
         return;
     }

     // Verify that the exchange context matches our current context. Bail if not.
     if (ec != bdxApp->ExchangeCtx)
     {
         printf("2 HandleReceiveInitResponse\n");
         return;
     }

     if (msgType == kMsgType_ReceiveAccept)
     {
         printf("3 HandleReceiveInitResponse\n");

         //Send BlockQuery request
         bdxApp->SendBlockQueryRequest();
     }
     else if (msgType == kMsgType_ReceiveReject)
     {
         printf("4 HandleReceiveInitResponse\n");

         bdxApp->mCon->Close();
         bdxApp->mCon = NULL;
     }

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

     printf("5 HandleReceiveInitResponse exiting\n");
 }


 /*
  * BlockQuery request
  */
 WEAVE_ERROR BulkDataTransferClient::SendBlockQueryRequest()
 {
     printf("0 SendBlockQueryRequest entering\n");

     if (!ExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

     // 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 = HandleBlockQueryResponse;

     /*
      * Build the BlockQuery request
      */

     BlockQuery blockQuery;
     blockQuery.init(mBlockCounter++); //first block requested is zero (next will be one, next two, etc)
     PacketBuffer* blockQueryPayload = PacketBuffer::New();
     blockQuery.pack(blockQueryPayload);

     // Send a BlockQuery request message. Discard the exchange context if the send fails.
     WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQuery, blockQueryPayload);
     blockQueryPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendBlockQueryRequest\n");
         ExchangeCtx->Close();
         ExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
     }

     printf("2 SendBlockQueryRequest exiting\n");

     return err;
 }

 void BulkDataTransferClient::HandleBlockQueryResponse(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     printf("0 HandleBlockQueryResponse entering\n");

     BulkDataTransferClient *bdxApp = (BulkDataTransferClient *)ec->AppState;

     // Verify that the message is a ReceiveInit Response.
     if (profileId != kWeaveProfile_BDX || (msgType != kMsgType_BlockSend && msgType != kMsgType_BlockEOF))
     {
         printf("1 HandleBlockQueryResponse\n");

         // TODO: handle unexpected response
         return;
     }

     // Verify that the exchange context matches our current context. Bail if not.
     if (ec != bdxApp->ExchangeCtx)
     {
         printf("2 HandleBlockQueryResponse\n");

         return;
     }

     //dump received block/payload
 //    DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

     if (msgType == kMsgType_BlockSend)
     {
         printf("3 HandleBlockQueryResponse (BlockSend)\n");
         DumpMemory(payload->Start(), payload->DataLength(), "--> ", 16);

         if (bdxApp->DestFile > 0) {
             // Write bulk data to disk.
             int wtd = write(bdxApp->DestFile, payload->Start(), payload->DataLength());
             printf("Wrote %d bytes to disk.\n", wtd);
         }

         //Send another BlockQuery
         bdxApp->SendBlockQueryRequest();
     }
     else if (msgType == kMsgType_BlockEOF)
     {
         printf("4 HandleBlockQueryResponse (BlockEOF)\n");
         DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

         if (bdxApp->DestFile > 0) {
             // Close destination file.
             close(bdxApp->DestFile);
         }

         //Send final BlockEOFAck
         bdxApp->SendBlockEOFAck();
     }

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

     printf("5 HandleBlockQueryResponse exiting\n");
 }


 /*
  * BlockEOFAck
  */
 WEAVE_ERROR BulkDataTransferClient::SendBlockEOFAck()
 {
     printf("0 SendBlockEOFAck entering\n");

     if (!ExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

     // 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 = HandleBlockEOFAckResponse;

     /*
      * Build the BlockEOFAck
      */

     BlockEOFAck blockEOFAck;
     blockEOFAck.init(mBlockCounter-1); //final ack uses same block-counter of last block-query request
     PacketBuffer* blockEOFAckPayload = PacketBuffer::New();
     blockEOFAck.pack(blockEOFAckPayload);

     // Send an BlockEOFAck request message. Discard the exchange context if the send fails.
     WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAck, blockEOFAckPayload);
     blockEOFAckPayload = NULL;
 //    if (err != WEAVE_NO_ERROR)
 //    {
         ExchangeCtx->Close();
         ExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
 //    }

     printf("1 SendBlockEOFAck exiting\n");
     Done = true;

     return err;
 }

 void BulkDataTransferClient::HandleBlockEOFAckResponse(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     printf("A response to BlockEOFAck is NOT expected!\n");
 }

 } // 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 unsolicited initiator (i.e., client)
	* for the "legacy" (see [Managed Namespaces](@ref mns)) Weave
	* Bulk Data Transfer (BDX) profile used for functional testing
	* of the implementation of core message handlers and protocol
	* engine for that profile.
	*
	*/

	#include "ToolCommon.h"
	#include "nlweavebdxclient.h"

	#include <unistd.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>

	namespace nl {
	namespace Weave {
	namespace Profiles {


	using namespace nl::Weave::Profiles::BulkDataTransfer;

	BulkDataTransferClient::BulkDataTransferClient()
	{
	FabricState = NULL;
	ExchangeMgr = NULL;
	mBlockCounter = 0;
	}

	BulkDataTransferClient::~BulkDataTransferClient()
	{
	FabricState = NULL;
	ExchangeMgr = NULL;
	mBlockCounter = 0;
	}

	WEAVE_ERROR BulkDataTransferClient::Init(WeaveExchangeManager exchangeMgr, const char DestFileName)
	{
	// Error if already initialized.
	if (ExchangeMgr != NULL)
	return WEAVE_ERROR_INCORRECT_STATE;

	ExchangeMgr = exchangeMgr;
	FabricState = exchangeMgr->FabricState;
	mBlockCounter = 0;

	if (DestFileName)
	{
	DestFile = open(DestFileName, O_RDWR \| O_CREAT, S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP);
	if (DestFile < 0)
	return INET_MapOSError(errno);
	}

	return WEAVE_NO_ERROR;
	}

	void BulkDataTransferClient::setCon(WeaveConnection *con)
	{
	mCon = con;
	}

	WEAVE_ERROR BulkDataTransferClient::Shutdown()
	{
	ExchangeMgr = NULL;
	FabricState = NULL;
	mBlockCounter = 0;

	return WEAVE_NO_ERROR;
	}


	/*
	* ReceiveInit request
	*/

	WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(WeaveConnection *con)
	{
	// Discard any existing exchange context.
	// Effectively we can only have one BDX exchange with a single node at any one time.
	if (ExchangeCtx != NULL)
	{
	ExchangeCtx->Close();
	ExchangeCtx = NULL;
	}

	// Create a new exchange context.
	ExchangeCtx = ExchangeMgr->NewContext(con, this);
	if (ExchangeCtx == NULL)
	return WEAVE_ERROR_NO_MEMORY;

	return SendReceiveInitRequest();
	}

	WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(uint64_t nodeId, IPAddress nodeAddr)
	{
	return SendReceiveInitRequest(nodeId, nodeAddr, WEAVE_PORT);
	}

	WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest(uint64_t nodeId, IPAddress nodeAddr, uint16_t port)
	{
	// Discard any existing exchange context.
	// Effectively we can only have one BDX exchange with a single node at any one time.
	if (ExchangeCtx != NULL)
	{
	ExchangeCtx->Close();
	ExchangeCtx = NULL;
	}

	if (nodeAddr == IPAddress::Any)
	nodeAddr = FabricState->SelectNodeAddress(nodeId);

	// Create a new exchange context.
	ExchangeCtx = ExchangeMgr->NewContext(nodeId, nodeAddr, this);
	if (ExchangeCtx == NULL)
	return WEAVE_ERROR_NO_MEMORY;

	return SendReceiveInitRequest();
	}

	#define BDX_MAX_BLOCK_SIZE 256
	#define BDX_START_OFFSET 0

	WEAVE_ERROR BulkDataTransferClient::SendReceiveInitRequest()
	{
	if (!ExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

	printf("0 SendReceiveInitRequest entering\n");

	// 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 = HandleReceiveInitResponse;

	/*
	* Build the ReceiveInit request
	*/

	ReferencedString aFileDesignator;
	//NOTE: normally this URI would have been agreed upon with the SWU protocol
	// Ex.: the SWU server returned "bdx://nestlabs/share/heatlink/data/firmware/production/heatlink.elf",
	// so the file name is extracted and is sent to the BDX server.
	char aFileDesignatorStr[] = "/var/log/heatlink.elf"; //FIXME: temporary hack for the purpose of testing
	aFileDesignator.init((uint16_t)(sizeof(aFileDesignatorStr)-1), aFileDesignatorStr);

	ReceiveInit receiveInit;
	receiveInit.init(false /SenderDrive/, true /ReceiverDrive/, false /AsynchMode/, BDX_MAX_BLOCK_SIZE,
	(uint32_t)BDX_START_OFFSET, (uint32_t)0 /Length (zero means undefined length)/, aFileDesignator, NULL /MetaData/);
	PacketBuffer* receiveInitPayload = PacketBuffer::New();
	receiveInit.pack(receiveInitPayload);

	// Send a ReceiveInit request message. Discard the exchange context if the send fails.
	WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveInit, receiveInitPayload);
	receiveInitPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendReceiveInitRequest\n");
	ExchangeCtx->Close();
	ExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	}

	printf("2 SendReceiveInitRequest exiting\n");

	return err;
	}

	void BulkDataTransferClient::HandleReceiveInitResponse(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	printf("0 HandleReceiveInitResponse entering\n");

	BulkDataTransferClient bdxApp = (BulkDataTransferClient )ec->AppState;

	// Verify that the message is a ReceiveInit Response.
	if (profileId != kWeaveProfile_BDX \|\| (msgType != kMsgType_ReceiveAccept && msgType != kMsgType_ReceiveReject))
	{
	printf("1 HandleReceiveInitResponse\n");
	// TODO: handle unexpected response
	return;
	}

	// Verify that the exchange context matches our current context. Bail if not.
	if (ec != bdxApp->ExchangeCtx)
	{
	printf("2 HandleReceiveInitResponse\n");
	return;
	}

	if (msgType == kMsgType_ReceiveAccept)
	{
	printf("3 HandleReceiveInitResponse\n");

	//Send BlockQuery request
	bdxApp->SendBlockQueryRequest();
	}
	else if (msgType == kMsgType_ReceiveReject)
	{
	printf("4 HandleReceiveInitResponse\n");

	bdxApp->mCon->Close();
	bdxApp->mCon = NULL;
	}

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

	printf("5 HandleReceiveInitResponse exiting\n");
	}


	/*
	* BlockQuery request
	*/
	WEAVE_ERROR BulkDataTransferClient::SendBlockQueryRequest()
	{
	printf("0 SendBlockQueryRequest entering\n");

	if (!ExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

	// 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 = HandleBlockQueryResponse;

	/*
	* Build the BlockQuery request
	*/

	BlockQuery blockQuery;
	blockQuery.init(mBlockCounter++); //first block requested is zero (next will be one, next two, etc)
	PacketBuffer* blockQueryPayload = PacketBuffer::New();
	blockQuery.pack(blockQueryPayload);

	// Send a BlockQuery request message. Discard the exchange context if the send fails.
	WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQuery, blockQueryPayload);
	blockQueryPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendBlockQueryRequest\n");
	ExchangeCtx->Close();
	ExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	}

	printf("2 SendBlockQueryRequest exiting\n");

	return err;
	}

	void BulkDataTransferClient::HandleBlockQueryResponse(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	printf("0 HandleBlockQueryResponse entering\n");

	BulkDataTransferClient bdxApp = (BulkDataTransferClient )ec->AppState;

	// Verify that the message is a ReceiveInit Response.
	if (profileId != kWeaveProfile_BDX \|\| (msgType != kMsgType_BlockSend && msgType != kMsgType_BlockEOF))
	{
	printf("1 HandleBlockQueryResponse\n");

	// TODO: handle unexpected response
	return;
	}

	// Verify that the exchange context matches our current context. Bail if not.
	if (ec != bdxApp->ExchangeCtx)
	{
	printf("2 HandleBlockQueryResponse\n");

	return;
	}

	//dump received block/payload
	// DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

	if (msgType == kMsgType_BlockSend)
	{
	printf("3 HandleBlockQueryResponse (BlockSend)\n");
	DumpMemory(payload->Start(), payload->DataLength(), "--> ", 16);

	if (bdxApp->DestFile > 0) {
	// Write bulk data to disk.
	int wtd = write(bdxApp->DestFile, payload->Start(), payload->DataLength());
	printf("Wrote %d bytes to disk.\n", wtd);
	}

	//Send another BlockQuery
	bdxApp->SendBlockQueryRequest();
	}
	else if (msgType == kMsgType_BlockEOF)
	{
	printf("4 HandleBlockQueryResponse (BlockEOF)\n");
	DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

	if (bdxApp->DestFile > 0) {
	// Close destination file.
	close(bdxApp->DestFile);
	}

	//Send final BlockEOFAck
	bdxApp->SendBlockEOFAck();
	}

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

	printf("5 HandleBlockQueryResponse exiting\n");
	}


	/*
	* BlockEOFAck
	*/
	WEAVE_ERROR BulkDataTransferClient::SendBlockEOFAck()
	{
	printf("0 SendBlockEOFAck entering\n");

	if (!ExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

	// 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 = HandleBlockEOFAckResponse;

	/*
	* Build the BlockEOFAck
	*/

	BlockEOFAck blockEOFAck;
	blockEOFAck.init(mBlockCounter-1); //final ack uses same block-counter of last block-query request
	PacketBuffer* blockEOFAckPayload = PacketBuffer::New();
	blockEOFAck.pack(blockEOFAckPayload);

	// Send an BlockEOFAck request message. Discard the exchange context if the send fails.
	WEAVE_ERROR err = ExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAck, blockEOFAckPayload);
	blockEOFAckPayload = NULL;
	// if (err != WEAVE_NO_ERROR)
	// {
	ExchangeCtx->Close();
	ExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	// }

	printf("1 SendBlockEOFAck exiting\n");
	Done = true;

	return err;
	}

	void BulkDataTransferClient::HandleBlockEOFAckResponse(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	printf("A response to BlockEOFAck is NOT expected!\n");
	}

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