weave/src/test-apps/nlweavebdxclient-development.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 "development" (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"


 namespace nl {
 namespace Weave {
 namespace Profiles {
 namespace BulkDataTransfer {


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

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

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

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

     mDestFile = NULL;

     return WEAVE_NO_ERROR;
 }

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

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

     return WEAVE_NO_ERROR;
 }

 /*
  * Public file upload/download API
  */

 WEAVE_ERROR BulkDataTransferClient::SendFile(const char *DestFileName, WeaveConnection *aCon)
 {
     printf("Sending file %s\n", DestFileName);

     mDestFile = fopen(DestFileName, "r");
     if (!mDestFile)
         return INET_MapOSError(errno);

     return SendSendInitRequest(aCon);
 }

 WEAVE_ERROR BulkDataTransferClient::SendFile(const char *DestFileName, uint64_t nodeId, IPAddress nodeAddr)
 {
     printf("Sending file %s\n", DestFileName);

     mDestFile = fopen(DestFileName, "r");
     if (!mDestFile)
         return INET_MapOSError(errno);

     return SendSendInitRequest(nodeId, nodeAddr);
 }

 WEAVE_ERROR BulkDataTransferClient::ReceiveFile(const char *DestFileName, WeaveConnection *aCon)
 {
     printf("Receiving file %s\n", DestFileName);

     mDestFile = fopen(DestFileName, "w");
     if (!mDestFile)
         return INET_MapOSError(errno);

     return SendSendInitRequest(aCon);
 }

 WEAVE_ERROR BulkDataTransferClient::ReceiveFile(const char *DestFileName, uint64_t nodeId, IPAddress nodeAddr)
 {
     printf("Receiving file %s\n", DestFileName);

     mDestFile = fopen(DestFileName, "w");
     if (!mDestFile)
         return INET_MapOSError(errno);

     return SendSendInitRequest(nodeId, nodeAddr);
 }

 /*
  * SendInit request
  */

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

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

     return SendSendInitRequest();
 }

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

 WEAVE_ERROR BulkDataTransferClient::SendSendInitRequest(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 (mExchangeCtx != NULL)
     {
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
     }

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

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

     return SendSendInitRequest();
 }

 #define BDX_MAX_BLOCK_SIZE 256
 #define BDX_START_OFFSET 0

 WEAVE_ERROR BulkDataTransferClient::SendSendInitRequest()
 {
     if (!mExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

     printf("0 SendSendInitRequest entering\n");

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

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

     /*
      * Build the SendInit 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[] = "file:///var/log/heatlink.elf"; //FIXME: temporary hack for the purpose of testing
     aFileDesignator.init((uint16_t)(sizeof(aFileDesignatorStr)-1), aFileDesignatorStr);

     SendInit sendInit;
     bool asyncMode = false, senderDriven = true;
     sendInit.init(senderDriven, false /*ReceiverDrive*/, asyncMode, BDX_MAX_BLOCK_SIZE,
                         (uint32_t)BDX_START_OFFSET, (uint32_t)0 /*Length (zero means undefined length)*/, aFileDesignator, NULL /*MetaData*/);
     PacketBuffer* sendInitPayload = PacketBuffer::New();
     sendInit.pack(sendInitPayload);

     // Send a SendInit request message. Discard the exchange context if the send fails.
     WEAVE_ERROR err = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_SendInit, sendInitPayload);
     sendInitPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendSendInitRequest\n");
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
     }

     printf("2 SendSendInitRequest exiting\n");

     return err;
 }

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

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

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

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

     if (msgType == kMsgType_SendAccept)
     {
         printf("3 HandleSendInitResponse\n");

         DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

         // Parse info from response, set variables, and start sending blocks
         SendAccept sendAccept;
         err = SendAccept::parse(payload, sendAccept);
         VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error parsing SendAccept payload!"));

         bdxApp->mTransferMode = sendAccept.mTransferMode;
         //TODO: validate the transfer mode, possibly looking back at what we requested?
         if (bdxApp->IsSenderDriveMode())
         {
             ec->OnMessageReceived = HandleBlockAck;
         }

         printf("Max block size negotiated: %d\n", sendAccept.mMaxBlockSize);
         bdxApp->mMaxBlockSize = sendAccept.mMaxBlockSize;
         PacketBuffer::Free(payload);
         payload = NULL;

         bdxApp->SendBlock();
     }
     else if (msgType == kMsgType_SendReject)
     {
         printf("4 HandleSendAcceptResponse rejected\n");

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

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

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         printf("HandleSendInitResponse exiting with error: %d\n", err);
     }
     else
     {
         printf("5 HandleSendInitResponse exiting\n");
     }

     return err;
 }

 void BulkDataTransferClient::HandleBlockAck(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     BlockAck ack;
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     printf("HandleBlock Ack entering\n");

     err = BlockAck::parse(payload, ack);
     VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error parsing BlockAck: %d\n", err));
     VerifyOrExit(msgType == kMsgType_BlockAck,
                  err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; printf("Error in HandleBlockAck: expected BlockAck but got %d\n", msgType);

     //TODO: verify that we got the right block number in this ACK

     BulkDataTransferClient *bdxApp = (BulkDataTransferClient *)ec->AppState;
     err = bdxApp->SendBlock();
     VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error trying to SendBlock: %d\n", err));

 exit:
     if (err != WEAVE_NO_ERROR)
     {
         printf("HandleBlockAck exiting with error: %d\n", err);
     }

     return;
 }

 void BulkDataTransferClient::HandleBlockEOFAck(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     VerifyOrExit(msgType == kMsgType_BlocEOFkAck,
                  err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; printf("Expected BlockEOFAck but got %d\n", msgType);

     // Close out the connections so the client can exit
     BulkDataTransferClient *bdxApp = (BulkDataTransferClient *)ec->AppState;
     bdxApp->mExchangeCtx->Close();
     bdxApp->mExchangeCtx = NULL;
     bdxApp->mCon->Close();
     bdxApp->mCon = NULL;
     //TODO: not use a global variable...
     Done = true;
     printf("BlockEOFAck Received. Transfer complete.  Exiting...\n");

 exit:
     return err;
 }

 /*
  * 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 (mExchangeCtx != NULL)
     {
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
     }

     // Create a new exchange context.
     mExchangeCtx = ExchangeMgr->NewContext(con, this);
     if (mExchangeCtx == 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 (mExchangeCtx != NULL)
     {
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
     }

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

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

     return SendReceiveInitRequest();
 }

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

     printf("0 SendReceiveInitRequest entering\n");

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

     // Arrange for messages in this exchange to go to our response handler.
     mExchangeCtx->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[] = "file:///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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveInit, receiveInitPayload);
     receiveInitPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendReceiveInitRequest\n");
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
     }

     printf("2 SendReceiveInitRequest exiting\n");

     return err;
 }

 WEAVE_ERROR BulkDataTransferClient::HandleReceiveInitResponse(ExchangeContext *ec, const IPPacketInfo *packetInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     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 err;
     }

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

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

         ReceiveInit ri;
         ReceiveInit::parse(payload, ri);
         printf("Supposed maxBlockSize: %d\n", ri.mMaxBlockSize);
         DumpMemory(payload->Start(), payload->DataLength(), "--> ", 16);

         //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");

     return err;
 }

 /*
  * BlockSend message
  */
 WEAVE_ERROR BulkDataTransferClient::SendBlock()
 {
     printf("0 SendBlock entering\n");

     if (!mExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

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

     // Read the data from the file and build the BlockSend message
     printf("Reading data\n");
     uint8_t blockData[mMaxBlockSize];
     int bytesRead = fread(blockData, 1, mMaxBlockSize, mDestFile);
     printf("Data read: %d bytes of max size %d\n", bytesRead, mMaxBlockSize);

     BlockSend blockSend;
     blockSend.init(mBlockCounter++, bytesRead, blockData); //first block sent is zero (next will be one, next two, etc)
     PacketBuffer* blockSendPayload = PacketBuffer::New();
     blockSend.pack(blockSendPayload);

     // Send a BlockSend message. Make sure it's an EOF if this is the last block.
     // Discard the exchange context if the send fails.
     //
     // FIXME: we can reach EOF and have read exactly mMaxBlockSize,
     // but all the C API functions require us to try reading another byte
     // and receive the EOF character before being able to recognize that we're finished.
     // Therefore, we'll have to add complexity by pre-fetching each block and transmitting
     // the last one so that we can see if the pre-fetched block is of size 0,
     // indicating that the last fetched one should be sent as BlockEOF.
     bool atEOF = bytesRead < mMaxBlockSize;
     if (atEOF)
     {
         printf("Sending BlockEOF\n");
         mExchangeCtx->OnMessageReceived = HandleBlockEOFAck;
     }
     else
         printf("Sending Block...\n");

     WEAVE_ERROR err = mExchangeCtx->SendMessage(kWeaveProfile_BDX, atEOF ? kMsgType_BlockEOF : kMsgType_BlockSend, blockSendPayload);
     blockSendPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendBlock\n");
         mExchangeCtx->Close();
         mExchangeCtx = NULL;
         mCon->Close();
         mCon = NULL;
     }

     printf("2 SendBlock exiting\n");

     return err;
 }

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

     if (!mExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

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

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

     /*
      * Build the BlockQuery request
      */

     BlockQuery blockQuery;
     //FIXME: let's not increment the counter here so that we can e.g. resend the same block or test it easier
     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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQuery, blockQueryPayload);
     blockQueryPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         printf("1 SendBlockQueryRequest\n");
         mExchangeCtx->Close();
         mExchangeCtx = 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->mExchangeCtx)
     {
         printf("2 HandleBlockQueryResponse\n");

         return;
     }

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

         if (bdxApp->mDestFile) {
             // Write bulk data to disk.
             // TODO: ensure this isn't writing the header info to disk as well
             int wtd = fwrite(payload->Start(), 1, payload->DataLength(), bdxApp->mDestFile);
             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);

         //TODO: this isn't writing the payload to the file!!!!!
         if (bdxApp->mDestFile) {
             // Close destination file.
             if (fclose(bdxApp->mDestFile) == EOF)
             {
                 printf("Error closing file! %d\n", ferror(bdxApp->mDestFile));
                 exit(-1);
             }
         }

         //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 (!mExchangeCtx)
         return WEAVE_ERROR_INCORRECT_STATE;

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

     // Arrange for messages in this exchange to go to our response handler.
     mExchangeCtx->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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAck, blockEOFAckPayload);
     blockEOFAckPayload = NULL;
     if (err != WEAVE_NO_ERROR)
     {
         mExchangeCtx->Close();
         mExchangeCtx = 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");
 }

 bool BulkDataTransferClient::IsAsyncMode()
 {
     return mTransferMode & kMode_Asynchronous;
 }

 bool BulkDataTransferClient::IsSenderDriveMode()
 {
     return mTransferMode & kMode_SenderDrive;
 }

 bool BulkDataTransferClient::IsReceiverDriveMode()
 {
     return mTransferMode & kMode_ReceiverDrive;
 }

 } // namespace BulkDataTransfer
 } // 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 "development" (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"


	namespace nl {
	namespace Weave {
	namespace Profiles {
	namespace BulkDataTransfer {


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

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

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

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

	mDestFile = NULL;

	return WEAVE_NO_ERROR;
	}

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

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

	return WEAVE_NO_ERROR;
	}

	/*
	* Public file upload/download API
	*/

	WEAVE_ERROR BulkDataTransferClient::SendFile(const char DestFileName, WeaveConnection aCon)
	{
	printf("Sending file %s\n", DestFileName);

	mDestFile = fopen(DestFileName, "r");
	if (!mDestFile)
	return INET_MapOSError(errno);

	return SendSendInitRequest(aCon);
	}

	WEAVE_ERROR BulkDataTransferClient::SendFile(const char *DestFileName, uint64_t nodeId, IPAddress nodeAddr)
	{
	printf("Sending file %s\n", DestFileName);

	mDestFile = fopen(DestFileName, "r");
	if (!mDestFile)
	return INET_MapOSError(errno);

	return SendSendInitRequest(nodeId, nodeAddr);
	}

	WEAVE_ERROR BulkDataTransferClient::ReceiveFile(const char DestFileName, WeaveConnection aCon)
	{
	printf("Receiving file %s\n", DestFileName);

	mDestFile = fopen(DestFileName, "w");
	if (!mDestFile)
	return INET_MapOSError(errno);

	return SendSendInitRequest(aCon);
	}

	WEAVE_ERROR BulkDataTransferClient::ReceiveFile(const char *DestFileName, uint64_t nodeId, IPAddress nodeAddr)
	{
	printf("Receiving file %s\n", DestFileName);

	mDestFile = fopen(DestFileName, "w");
	if (!mDestFile)
	return INET_MapOSError(errno);

	return SendSendInitRequest(nodeId, nodeAddr);
	}

	/*
	* SendInit request
	*/

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

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

	return SendSendInitRequest();
	}

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

	WEAVE_ERROR BulkDataTransferClient::SendSendInitRequest(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 (mExchangeCtx != NULL)
	{
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	}

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

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

	return SendSendInitRequest();
	}

	#define BDX_MAX_BLOCK_SIZE 256
	#define BDX_START_OFFSET 0

	WEAVE_ERROR BulkDataTransferClient::SendSendInitRequest()
	{
	if (!mExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

	printf("0 SendSendInitRequest entering\n");

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

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

	/*
	* Build the SendInit 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[] = "file:///var/log/heatlink.elf"; //FIXME: temporary hack for the purpose of testing
	aFileDesignator.init((uint16_t)(sizeof(aFileDesignatorStr)-1), aFileDesignatorStr);

	SendInit sendInit;
	bool asyncMode = false, senderDriven = true;
	sendInit.init(senderDriven, false /ReceiverDrive/, asyncMode, BDX_MAX_BLOCK_SIZE,
	(uint32_t)BDX_START_OFFSET, (uint32_t)0 /Length (zero means undefined length)/, aFileDesignator, NULL /MetaData/);
	PacketBuffer* sendInitPayload = PacketBuffer::New();
	sendInit.pack(sendInitPayload);

	// Send a SendInit request message. Discard the exchange context if the send fails.
	WEAVE_ERROR err = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_SendInit, sendInitPayload);
	sendInitPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendSendInitRequest\n");
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	}

	printf("2 SendSendInitRequest exiting\n");

	return err;
	}

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

	BulkDataTransferClient bdxApp = (BulkDataTransferClient )ec->AppState;

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

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

	if (msgType == kMsgType_SendAccept)
	{
	printf("3 HandleSendInitResponse\n");

	DumpMemory(payload->Start(), payload->DataLength(), "==> ", 16);

	// Parse info from response, set variables, and start sending blocks
	SendAccept sendAccept;
	err = SendAccept::parse(payload, sendAccept);
	VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error parsing SendAccept payload!"));

	bdxApp->mTransferMode = sendAccept.mTransferMode;
	//TODO: validate the transfer mode, possibly looking back at what we requested?
	if (bdxApp->IsSenderDriveMode())
	{
	ec->OnMessageReceived = HandleBlockAck;
	}

	printf("Max block size negotiated: %d\n", sendAccept.mMaxBlockSize);
	bdxApp->mMaxBlockSize = sendAccept.mMaxBlockSize;
	PacketBuffer::Free(payload);
	payload = NULL;

	bdxApp->SendBlock();
	}
	else if (msgType == kMsgType_SendReject)
	{
	printf("4 HandleSendAcceptResponse rejected\n");

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

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

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	printf("HandleSendInitResponse exiting with error: %d\n", err);
	}
	else
	{
	printf("5 HandleSendInitResponse exiting\n");
	}

	return err;
	}

	void BulkDataTransferClient::HandleBlockAck(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	BlockAck ack;
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	printf("HandleBlock Ack entering\n");

	err = BlockAck::parse(payload, ack);
	VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error parsing BlockAck: %d\n", err));
	VerifyOrExit(msgType == kMsgType_BlockAck,
	err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; printf("Error in HandleBlockAck: expected BlockAck but got %d\n", msgType);

	//TODO: verify that we got the right block number in this ACK

	BulkDataTransferClient bdxApp = (BulkDataTransferClient )ec->AppState;
	err = bdxApp->SendBlock();
	VerifyOrExit(err == WEAVE_NO_ERROR, printf("Error trying to SendBlock: %d\n", err));

	exit:
	if (err != WEAVE_NO_ERROR)
	{
	printf("HandleBlockAck exiting with error: %d\n", err);
	}

	return;
	}

	void BulkDataTransferClient::HandleBlockEOFAck(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	VerifyOrExit(msgType == kMsgType_BlocEOFkAck,
	err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; printf("Expected BlockEOFAck but got %d\n", msgType);

	// Close out the connections so the client can exit
	BulkDataTransferClient bdxApp = (BulkDataTransferClient )ec->AppState;
	bdxApp->mExchangeCtx->Close();
	bdxApp->mExchangeCtx = NULL;
	bdxApp->mCon->Close();
	bdxApp->mCon = NULL;
	//TODO: not use a global variable...
	Done = true;
	printf("BlockEOFAck Received. Transfer complete. Exiting...\n");

	exit:
	return err;
	}

	/*
	* 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 (mExchangeCtx != NULL)
	{
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	}

	// Create a new exchange context.
	mExchangeCtx = ExchangeMgr->NewContext(con, this);
	if (mExchangeCtx == 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 (mExchangeCtx != NULL)
	{
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	}

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

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

	return SendReceiveInitRequest();
	}

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

	printf("0 SendReceiveInitRequest entering\n");

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

	// Arrange for messages in this exchange to go to our response handler.
	mExchangeCtx->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[] = "file:///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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveInit, receiveInitPayload);
	receiveInitPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendReceiveInitRequest\n");
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	}

	printf("2 SendReceiveInitRequest exiting\n");

	return err;
	}

	WEAVE_ERROR BulkDataTransferClient::HandleReceiveInitResponse(ExchangeContext ec, const IPPacketInfo packetInfo, const WeaveMessageInfo msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer payload)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	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 err;
	}

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

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

	ReceiveInit ri;
	ReceiveInit::parse(payload, ri);
	printf("Supposed maxBlockSize: %d\n", ri.mMaxBlockSize);
	DumpMemory(payload->Start(), payload->DataLength(), "--> ", 16);

	//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");

	return err;
	}

	/*
	* BlockSend message
	*/
	WEAVE_ERROR BulkDataTransferClient::SendBlock()
	{
	printf("0 SendBlock entering\n");

	if (!mExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

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

	// Read the data from the file and build the BlockSend message
	printf("Reading data\n");
	uint8_t blockData[mMaxBlockSize];
	int bytesRead = fread(blockData, 1, mMaxBlockSize, mDestFile);
	printf("Data read: %d bytes of max size %d\n", bytesRead, mMaxBlockSize);

	BlockSend blockSend;
	blockSend.init(mBlockCounter++, bytesRead, blockData); //first block sent is zero (next will be one, next two, etc)
	PacketBuffer* blockSendPayload = PacketBuffer::New();
	blockSend.pack(blockSendPayload);

	// Send a BlockSend message. Make sure it's an EOF if this is the last block.
	// Discard the exchange context if the send fails.
	//
	// FIXME: we can reach EOF and have read exactly mMaxBlockSize,
	// but all the C API functions require us to try reading another byte
	// and receive the EOF character before being able to recognize that we're finished.
	// Therefore, we'll have to add complexity by pre-fetching each block and transmitting
	// the last one so that we can see if the pre-fetched block is of size 0,
	// indicating that the last fetched one should be sent as BlockEOF.
	bool atEOF = bytesRead < mMaxBlockSize;
	if (atEOF)
	{
	printf("Sending BlockEOF\n");
	mExchangeCtx->OnMessageReceived = HandleBlockEOFAck;
	}
	else
	printf("Sending Block...\n");

	WEAVE_ERROR err = mExchangeCtx->SendMessage(kWeaveProfile_BDX, atEOF ? kMsgType_BlockEOF : kMsgType_BlockSend, blockSendPayload);
	blockSendPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendBlock\n");
	mExchangeCtx->Close();
	mExchangeCtx = NULL;
	mCon->Close();
	mCon = NULL;
	}

	printf("2 SendBlock exiting\n");

	return err;
	}

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

	if (!mExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

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

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

	/*
	* Build the BlockQuery request
	*/

	BlockQuery blockQuery;
	//FIXME: let's not increment the counter here so that we can e.g. resend the same block or test it easier
	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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQuery, blockQueryPayload);
	blockQueryPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	printf("1 SendBlockQueryRequest\n");
	mExchangeCtx->Close();
	mExchangeCtx = 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->mExchangeCtx)
	{
	printf("2 HandleBlockQueryResponse\n");

	return;
	}

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

	if (bdxApp->mDestFile) {
	// Write bulk data to disk.
	// TODO: ensure this isn't writing the header info to disk as well
	int wtd = fwrite(payload->Start(), 1, payload->DataLength(), bdxApp->mDestFile);
	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);

	//TODO: this isn't writing the payload to the file!!!!!
	if (bdxApp->mDestFile) {
	// Close destination file.
	if (fclose(bdxApp->mDestFile) == EOF)
	{
	printf("Error closing file! %d\n", ferror(bdxApp->mDestFile));
	exit(-1);
	}
	}

	//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 (!mExchangeCtx)
	return WEAVE_ERROR_INCORRECT_STATE;

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

	// Arrange for messages in this exchange to go to our response handler.
	mExchangeCtx->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 = mExchangeCtx->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAck, blockEOFAckPayload);
	blockEOFAckPayload = NULL;
	if (err != WEAVE_NO_ERROR)
	{
	mExchangeCtx->Close();
	mExchangeCtx = 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");
	}

	bool BulkDataTransferClient::IsAsyncMode()
	{
	return mTransferMode & kMode_Asynchronous;
	}

	bool BulkDataTransferClient::IsSenderDriveMode()
	{
	return mTransferMode & kMode_SenderDrive;
	}

	bool BulkDataTransferClient::IsReceiverDriveMode()
	{
	return mTransferMode & kMode_ReceiverDrive;
	}

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