| /* |
| * |
| * 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 contains definitions for the Weave Bulk Data Transfer |
| * Protocol. It is set up as a collection of event handlers for processing incoming BDX |
| * Weave messages and responding appropriately. It does not maintain any state |
| * but instead operates on the state-carrying BDXTransfer object, which should |
| * be managed by the BdxNode. |
| * |
| */ |
| |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Support/logging/WeaveLogging.h> |
| #include <Weave/Core/WeaveEncoding.h> |
| #include <Weave/Core/WeaveServerBase.h> |
| #include <Weave/Profiles/bulk-data-transfer/Development/BDXProtocol.h> |
| #include <Weave/Support/WeaveFaultInjection.h> |
| |
| namespace nl { |
| namespace Weave { |
| namespace Profiles { |
| namespace WeaveMakeManagedNamespaceIdentifier(BDX, kWeaveManagedNamespaceDesignation_Development) { |
| namespace BdxProtocol { |
| |
| using namespace ::nl::Weave::Profiles::StatusReporting; |
| using namespace nl::Weave::Logging; |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| /** |
| * @brief |
| * Sends a ReceiveInit message for the given parameters and initiated BDXTransfer |
| * |
| * param[in] aXfer The transfer state object representing this new transfer |
| * param[in] aICanDrive True if the initiator should propose that it drive, |
| * false otherwise |
| * param[in] aUCanDrive True if the initiator should propose that the sender drive, |
| * param[in] aAsyncOk True if the initiator should propose using async transfer |
| * param[in] aMetaData (optional) TLV metadata |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If we could not get an PacketBuffer for sending the message |
| * @retval #WEAVE_NO_ERROR If the message was successfully sent |
| */ |
| WEAVE_ERROR InitBdxReceive(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, ReferencedTLVData *aMetaData) |
| { |
| WEAVE_ERROR err; |
| ReceiveInit msg; |
| PacketBuffer* buffer = PacketBuffer::New(); |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (aXfer.mIsWideRange) |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aUCanDrive, aICanDrive, aAsyncOk, aXfer.mMaxBlockSize, aXfer.mStartOffset, aXfer.mLength, aXfer.mFileDesignator, aMetaData); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aUCanDrive, aICanDrive, aAsyncOk, aXfer.mMaxBlockSize, (uint32_t) aXfer.mStartOffset, (uint32_t) aXfer.mLength, aXfer.mFileDesignator, aMetaData); |
| SuccessOrExit(err); |
| } |
| |
| err = msg.pack(buffer); |
| SuccessOrExit(err); |
| |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveInit, buffer, flags); |
| SuccessOrExit(err); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| /** |
| * @brief |
| * Sends a SendInit message for the given parameters and initiated BDXTransfer: |
| * |
| * @param[in] aXfer The transfer state object representing this new transfer |
| * @param[in] aICanDrive True if the initiator should propose that it drive, |
| * false otherwise |
| * @param[in] aUCanDrive True if the initiator should propose that its counterpart drive, |
| * false otherwise |
| * @param[in] aSynchOK True if the initiator can do asynchronous mode, false otherwise |
| * @param[in] aMetaData (optional) TLV metadata |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If we could not get an PacketBuffer for sending the message |
| * @retval #WEAVE_NO_ERROR If the message was successfully sent |
| */ |
| WEAVE_ERROR InitBdxSend(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, ReferencedTLVData *aMetaData) |
| { |
| WEAVE_ERROR err; |
| SendInit msg; |
| PacketBuffer* buffer = PacketBuffer::New(); |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (aXfer.mIsWideRange) |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aICanDrive, aUCanDrive, aAsyncOk, aXfer.mMaxBlockSize, aXfer.mStartOffset, aXfer.mLength, aXfer.mFileDesignator, aMetaData); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aICanDrive, aUCanDrive, aAsyncOk, aXfer.mMaxBlockSize, (uint32_t)aXfer.mStartOffset, (uint32_t) aXfer.mLength, aXfer.mFileDesignator, aMetaData); |
| SuccessOrExit(err); |
| } |
| |
| err = msg.pack(buffer); |
| SuccessOrExit(err); |
| |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_SendInit, buffer, flags); |
| SuccessOrExit(err); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Sends a SendInit message for the given parameters and initiated BDXTransfer: |
| * |
| * @param[in] aXfer The transfer state object representing this new transfer |
| * @param[in] aICanDrive True if the initiator should propose that it drive, |
| * false otherwise |
| * @param[in] aUCanDrive True if the initiator should propose that its counterpart drive, |
| * false otherwise |
| * @param[in] aSynchOK True if the initiator can do asynchronous mode, false otherwise |
| * @param[in] aMetaDataWriteCallback (optional) Function to write TLV metadata |
| * @param[in] aMetaDataAppState (optional) AppState for aMetaDataWriteCallback |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If we could not get an PacketBuffer for sending the message |
| * @retval #WEAVE_NO_ERROR If the message was successfully sent |
| */ |
| WEAVE_ERROR InitBdxSend(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, SendInit::MetaDataTLVWriteCallback aMetaDataWriteCallback, |
| void *aMetaDataAppState) |
| { |
| WEAVE_ERROR err; |
| SendInit msg; |
| PacketBuffer* buffer = PacketBuffer::New(); |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (aXfer.mIsWideRange) |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aICanDrive, aUCanDrive, aAsyncOk, aXfer.mMaxBlockSize, aXfer.mStartOffset, aXfer.mLength, aXfer.mFileDesignator, aMetaDataWriteCallback, aMetaDataAppState); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| err = msg.init(WEAVE_CONFIG_BDX_VERSION, aICanDrive, aUCanDrive, aAsyncOk, aXfer.mMaxBlockSize, (uint32_t)aXfer.mStartOffset, (uint32_t) aXfer.mLength, aXfer.mFileDesignator, aMetaDataWriteCallback, aMetaDataAppState); |
| SuccessOrExit(err); |
| } |
| |
| err = msg.pack(buffer); |
| SuccessOrExit(err); |
| |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_SendInit, buffer, flags); |
| SuccessOrExit(err); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| |
| WEAVE_ERROR SendBadBlockCounterStatusReport(BDXTransfer & aXfer) |
| { |
| SendStatusReport(aXfer.mExchangeContext, kWeaveProfile_BDX, kStatus_BadBlockCounter); |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| /** |
| * @brief |
| * This function sends a BlockQuery message for the given BDXTransfer. The requested |
| * block number is equal to aXfer.mBlockCounter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockQuery for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| WEAVE_ERROR SendBlockQuery(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQuery::kPayloadLen); |
| BlockQuery outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = outMsg.init(static_cast<uint8_t>(aXfer.mBlockCounter)); |
| SuccessOrExit(err); |
| |
| err = outMsg.pack(buffer); |
| SuccessOrExit(err); |
| |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQuery, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| /** |
| * @brief |
| * This function sends a BlockQueryV1 message for the given BDXTransfer. The requested |
| * block number is equal to aXfer.mBlockCounter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockQuery for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| WEAVE_ERROR SendBlockQueryV1(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQueryV1::kPayloadLen); |
| BlockQueryV1 outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = outMsg.init(aXfer.mBlockCounter)); |
| SuccessOrExit(err = outMsg.pack(buffer)); |
| |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockQueryV1, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| /** |
| * @brief |
| * This function sends a BlockAck message for the given BDXTransfer. |
| * The acknowledged block number is equal to aXfer.mBlockCounter - 1 |
| * as this function may only be called after the state transfer |
| * advanced to the next counter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockAck for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| static WEAVE_ERROR SendBlockAck(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQuery::kPayloadLen); |
| BlockAck outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = outMsg.init(static_cast<uint8_t>(aXfer.mBlockCounter - 1))); |
| SuccessOrExit(err = outMsg.pack(buffer)); |
| |
| flags = aXfer.GetDefaultFlags(false); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockAck, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| /** |
| * @brief |
| * This function sends a BlockAckV1 message for the given |
| * BDXTransfer. The acknowledged block number is equal to |
| * aXfer.mBlockCounter - 1 as this function may only be called after |
| * the transfer state advanced to the next counter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockAck for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| static WEAVE_ERROR SendBlockAckV1(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQueryV1::kPayloadLen); |
| BlockAckV1 outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = outMsg.init(aXfer.mBlockCounter - 1)); |
| SuccessOrExit(err = outMsg.pack(buffer)); |
| |
| flags = aXfer.GetDefaultFlags(false); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockAckV1, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| /** |
| * @brief |
| * This function sends a BlockEOFAck message for the given BDXTransfer. The acknowledged |
| * block number is equal to aXfer.mBlockCounter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockEOFAck for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| static WEAVE_ERROR SendBlockEOFAck(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQuery::kPayloadLen); |
| BlockEOFAck outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = outMsg.init(static_cast<uint8_t>(aXfer.mBlockCounter))); |
| SuccessOrExit(err = outMsg.pack(buffer)); |
| |
| flags = aXfer.GetDefaultFlags(false); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAck, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogDetail(BDX, "SendBlockEOFAck failed."); |
| } |
| |
| aXfer.mIsCompletedSuccessfully = true; |
| aXfer.DispatchXferDoneHandler(); |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| /** |
| * @brief |
| * This function sends a BlockEOFAckV1 message for the given BDXTransfer. The acknowledged |
| * block number is equal to aXfer.mBlockCounter. |
| * |
| * @param[in] aXfer The BDXTransfer we're sending a BlockEOFAck for. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully sent the message. |
| * @retval #WEAVE_ERROR_NO_MEMORY If no available PacketBuffers. |
| */ |
| static WEAVE_ERROR SendBlockEOFAckV1(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buffer = PacketBuffer::NewWithAvailableSize(BlockQueryV1::kPayloadLen); |
| BlockEOFAckV1 outMsg; |
| uint16_t flags; |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = outMsg.init(aXfer.mBlockCounter)); |
| SuccessOrExit(err = outMsg.pack(buffer)); |
| |
| flags = aXfer.GetDefaultFlags(false); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, kMsgType_BlockEOFAckV1, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogDetail(BDX, "SendBlockEOFAckV1 failed."); |
| } |
| |
| aXfer.mIsCompletedSuccessfully = true; |
| aXfer.DispatchXferDoneHandler(); |
| |
| return err; |
| } |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| /** |
| * @brief |
| * This function sends the next BlockSend retrieved by calling the BDXTransfer's |
| * GetBlockHandler. |
| * |
| * @param[in] aXfer The BDXTransfer whose GetBlockHandler is called to get the |
| * next block before sending it using the associated ExchangeContext |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If the GetBlockHandler is NULL |
| * |
| * @note |
| * This function defers to SendBlock once the next block has been grabbed |
| */ |
| WEAVE_ERROR SendNextBlock(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint64_t length; |
| uint8_t* data; |
| bool isLast; |
| uint8_t msgType; |
| uint8_t counter; |
| PacketBuffer* buffer = PacketBuffer::New(); |
| uint16_t flags; |
| |
| counter = static_cast<uint8_t>(aXfer.mBlockCounter); |
| WeaveLogDetail(BDX, "Sending next block # %hd\n", counter); |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| // Before anything, we need to ensure that we have a registered GetBlockHandler |
| // or else length, data, and isLast won't be properly initialized and we'll |
| // be sending hard-to-debug garbage out. See WEAV-524. |
| VerifyOrExit(aXfer.mHandlers.mGetBlockHandler != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // TODO: this should probably have an error code so we can properly handle/log issues detected by the user's callback |
| // OR we could at least define some contract about when we will actually send a block |
| // vs. returning some error (e.g. not send unless length > 0 && data != NULL). |
| // pack the message, no additional abstraction for now. |
| |
| data = buffer->Start(); |
| |
| WEAVE_FAULT_INJECT(FaultInjection::kFault_BDXBadBlockCounter, counter++); |
| nl::Weave::Encoding::Write8(data, counter); |
| |
| data += sizeof(counter); |
| length = buffer->AvailableDataLength() - sizeof(counter); |
| |
| aXfer.DispatchGetBlockHandler(&length, &data, &isLast); |
| |
| // Ensure that we can fit the buffer within the PacketBuffer, fail |
| // if we cannot. |
| |
| VerifyOrExit((length + sizeof(counter)) <= buffer->AvailableDataLength(), err = WEAVE_ERROR_BUFFER_TOO_SMALL); |
| |
| // if the data pointer has changed, the callee used her own |
| // buffer. Copy the contents. |
| |
| if (data != (buffer->Start() + sizeof(counter))) |
| { |
| memcpy(buffer->Start() + sizeof(counter), data, length); |
| } |
| |
| buffer->SetDataLength(length + sizeof(counter)); |
| |
| if (isLast) |
| { |
| msgType = kMsgType_BlockEOF; |
| } |
| else |
| { |
| msgType = kMsgType_BlockSend; |
| } |
| |
| // TODO: for async aXfer, don't expect response. For now, we always expect an ACK or |
| // another BlockQuery |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, msgType, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| /** |
| * @brief |
| * This function sends the next BlockSendV1 retrieved by calling the BDXTransfer's |
| * GetBlockHandler. |
| * |
| * @param[in] aXfer The BDXTransfer whose GetBlockHandler is called to get the |
| * next block before sending it using the associated ExchangeContext |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If the GetBlockHandler is NULL |
| */ |
| WEAVE_ERROR SendNextBlockV1(BDXTransfer &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint64_t length; |
| uint8_t* data; |
| bool isLast; |
| uint8_t msgType; |
| PacketBuffer* buffer = PacketBuffer::New(); |
| uint16_t flags; |
| uint32_t blockCounter; |
| |
| WeaveLogDetail(BDX, "Sending next block # %d\n", aXfer.mBlockCounter); |
| |
| VerifyOrExit(aXfer.mHandlers.mGetBlockHandler != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| // pack the message, no additional abstraction for now. |
| |
| data = buffer->Start(); |
| |
| blockCounter = aXfer.mBlockCounter; |
| WEAVE_FAULT_INJECT(FaultInjection::kFault_BDXBadBlockCounter, blockCounter++); |
| |
| nl::Weave::Encoding::LittleEndian::Write32(data, blockCounter); |
| |
| length = buffer->AvailableDataLength() - sizeof(aXfer.mBlockCounter); |
| |
| if (length > aXfer.mMaxBlockSize) |
| { |
| length = aXfer.mMaxBlockSize; |
| } |
| |
| aXfer.DispatchGetBlockHandler(&length, &data, &isLast); |
| |
| // Ensure that we can fit the buffer within the PacketBuffer, fail |
| // if we cannot. |
| |
| VerifyOrExit((length + sizeof(aXfer.mBlockCounter)) <= buffer->AvailableDataLength(), err = WEAVE_ERROR_BUFFER_TOO_SMALL); |
| |
| // if the data pointer has changed, the callee used her own |
| // buffer. Copy the contents. |
| |
| if (data != (buffer->Start() + sizeof(aXfer.mBlockCounter))) |
| { |
| memcpy(buffer->Start() + sizeof(aXfer.mBlockCounter), data, length); |
| } |
| |
| buffer->SetDataLength(length + sizeof(aXfer.mBlockCounter)); |
| |
| if (isLast) |
| { |
| msgType = kMsgType_BlockEOFV1; |
| } |
| else |
| { |
| msgType = kMsgType_BlockSendV1; |
| } |
| |
| // TODO: for async aXfer, don't expect response. For now, we always expect an ACK or |
| // another BlockQuery |
| flags = aXfer.GetDefaultFlags(true); |
| |
| err = aXfer.mExchangeContext->SendMessage(kWeaveProfile_BDX, msgType, buffer, flags); |
| buffer = NULL; |
| |
| exit: |
| if (buffer != NULL) |
| { |
| PacketBuffer::Free(buffer); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * The main handler for messages arriving on the BDX exchange. It essentially |
| * acts as a router to extract the appropriate BDX header info and data, |
| * dispatching the appropriate handler to act on this object. |
| * |
| * @param[in] anEc The exchange context in case we need it |
| * @param[in] aPktInfo Unused, but need to match the function prototype |
| * @param[in] aWeaveMsgInfo Weave Message Information for the message |
| * @param[in] aProfileId ID of the profile under which the message is defined |
| * @param[in] aMessageType The message type of that profile |
| * @param[in] aPacketBuffer The packed message itself |
| */ |
| void HandleResponse(ExchangeContext *anEc, const IPPacketInfo *aPktInfo, const WeaveMessageInfo *aWeaveMsgInfo, |
| uint32_t aProfileId, uint8_t aMessageType, PacketBuffer *aPacketBuffer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; // we'll use this later |
| // extract the BDXTransfer object from the exchange context to access state |
| BDXTransfer *xfer = static_cast<BDXTransfer *>(anEc->AppState); |
| |
| VerifyOrExit(aProfileId == kWeaveProfile_BDX || (aProfileId == kWeaveProfile_Common && aMessageType == Common::kMsgType_StatusReport), err = WEAVE_ERROR_INVALID_PROFILE_ID); |
| VerifyOrExit(xfer->mIsInitiated, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // (Re-)Initialize the next action to take |
| xfer->mNext = NULL; |
| |
| if (xfer->mIsAccepted) |
| { |
| if (xfer->mAmSender) |
| { |
| #if WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| err = HandleResponseTransmit(*xfer, aProfileId, aMessageType, aPacketBuffer); |
| #endif // WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| } |
| else |
| { |
| #if WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| err = HandleResponseReceive(*xfer, aProfileId, aMessageType, aPacketBuffer); |
| #endif // WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| } |
| } |
| else |
| { |
| err = HandleResponseNotAccepted(*xfer, aProfileId, aMessageType, aPacketBuffer); |
| } |
| |
| PacketBuffer::Free(aPacketBuffer); |
| aPacketBuffer = NULL; |
| |
| if (xfer->mNext) |
| { |
| err = xfer->mNext(*xfer); |
| xfer->mNext = NULL; |
| } |
| |
| exit: |
| if (aPacketBuffer != NULL) |
| PacketBuffer::Free(aPacketBuffer); |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| xfer->DispatchErrorHandler(err); |
| } |
| } |
| |
| /** |
| * @brief |
| * Handler for when the connection itself is closed. Calls the associated transfer's error handler |
| * and shuts down the transfer. |
| * |
| * @param[in] anEc Exchange context that detected a closed connection |
| * We can find the associated BDXTransfer from this |
| * @param[in] aCon The weave connection, unused in the actual function |
| * @param[in] aConErr Error associated with the connection closing |
| */ |
| void HandleConnectionClosed(ExchangeContext *anEc, WeaveConnection *aCon, WEAVE_ERROR aConErr) |
| { |
| BDXTransfer *xfer = static_cast<BDXTransfer *>(anEc->AppState); |
| |
| // If the other end closed the connection, pass WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY to the application if it didn't already have an error attached. |
| if (aConErr == WEAVE_NO_ERROR) |
| { |
| aConErr = WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY; |
| } |
| |
| // Forward the error to the app's error handler. |
| xfer->DispatchErrorHandler(aConErr); |
| } |
| |
| /** |
| * @brief |
| * Handler for when we timeout waiting for a response. Shuts down the transfer that timed out, |
| * and calls that transfer's error handler. |
| * |
| * @param[in] anEc Exchange context which we can find the BDXTransfer from |
| */ |
| void HandleResponseTimeout(ExchangeContext *anEc) |
| { |
| BDXTransfer *xfer = static_cast<BDXTransfer *>(anEc->AppState); |
| |
| WeaveLogDetail(BDX, "Exchange timed out while waiting for reply"); |
| xfer->DispatchErrorHandler(WEAVE_ERROR_TIMEOUT); |
| } |
| |
| /** |
| * @brief |
| * Handler for when the key used to encrypt and authenticate Weave messages is no longer usable. |
| * |
| * @param[in] anEc Exchange context that detected a key error |
| * We can find the associated BDXTransfer from this |
| * @param[in] aKeyErr Error associated with the key no longer being usable |
| */ |
| void HandleKeyError(ExchangeContext *anEc, WEAVE_ERROR aKeyErr) |
| { |
| BDXTransfer *xfer = static_cast<BDXTransfer *>(anEc->AppState); |
| |
| WeaveLogDetail(BDX, "Encryption and authentication key became unusable"); |
| xfer->DispatchErrorHandler(aKeyErr); |
| } |
| |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| /** |
| * @brief |
| * Handler for when the WRMP message we sent was not acknowledged. |
| * |
| * @param[in] anEc Exchange context that had an unacknowleged message |
| * We can find the associated BDXTransfer from this |
| * @param[in] aSendErr Error associated with the message send failure |
| * @param[in] aMsgCtxt An arbitrary message context that was associated |
| * with the unacknowledged message. |
| */ |
| void HandleSendError(ExchangeContext *anEc, WEAVE_ERROR aSendErr, void *aMsgCtxt) |
| { |
| BDXTransfer *xfer = static_cast<BDXTransfer *>(anEc->AppState); |
| |
| WeaveLogDetail(BDX, "WMRP message was not acknowledged"); |
| xfer->DispatchErrorHandler(aSendErr); |
| } |
| #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| /** |
| * @brief |
| * Sends a transfer error message with the associated profile id, status code, and exchange context. |
| * |
| * @param[in] anEc The exchange context where we should be sending the transfer error message |
| * @param[in] aProfileId Profile ID |
| * @param[in] aStatusCode Code associated with the transfer error |
| */ |
| void SendTransferError(ExchangeContext *anEc, uint32_t aProfileId, uint16_t aStatusCode) |
| { |
| TransferError transferError; |
| PacketBuffer* payloadTransferError = PacketBuffer::New(); |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(payloadTransferError != NULL, |
| WeaveLogDetail(BDX, |
| "Error (out of PacketBuffers) in SendTransferError")); |
| |
| err = transferError.init(aProfileId, aStatusCode); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, |
| "Error initializing TransferError: %d", err)); |
| |
| err = transferError.pack(payloadTransferError); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, |
| "Error packing TransferError: %d", err)); |
| |
| //TODO: open question: should we dispatch the callback when sending an error or only when receiving? |
| //dispatchXferErrorHandler(aProfileId, aStatusCode); |
| |
| err = anEc->SendMessage(kWeaveProfile_BDX, kMsgType_TransferError, payloadTransferError, GetBDXAckFlag(anEc)); |
| payloadTransferError = NULL; |
| |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, |
| "Error sending TransferError message: %d", err)); |
| |
| exit: |
| if (payloadTransferError != NULL) |
| PacketBuffer::Free(payloadTransferError); |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| /** |
| * @brief |
| * Sends a status report message with the associated profile id, status code, and exchange context. |
| * |
| * @param[in] anEc The exchange context where we should be sending the status report message |
| * @param[in] aProfileId Profile ID |
| * @param[in] aStatusCode Code associated with the transfer error |
| */ |
| void SendStatusReport(ExchangeContext *anEc, uint32_t aProfileId, uint16_t aStatusCode) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| //TODO: open question: should we dispatch the callback when sending an error or only when receiving? |
| //dispatchXferErrorHandler(aProfileId, aStatusCode); |
| |
| err = nl::Weave::WeaveServerBase::SendStatusReport(anEc, aProfileId, aStatusCode, WEAVE_NO_ERROR, GetBDXAckFlag(anEc)); |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogDetail(BDX, "Error sending StatusReport message: %d", err); |
| } |
| } |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| /* |
| * the transfer has been started and i'm the sender. |
| * If I'm driving, I should expect an ACK from my counterpart |
| * and should send the next block. |
| * Otherwise, I should expect a BlockQuery and should respond |
| * with the right block. |
| */ |
| WEAVE_ERROR HandleResponseTransmit(BDXTransfer &aXfer, uint32_t aProfileId, uint8_t aMessageType, PacketBuffer *aPacketBuffer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint32_t rcvdCounter; |
| |
| if (aProfileId == kWeaveProfile_Common && aMessageType == Common::kMsgType_StatusReport) |
| { |
| StatusReport statusReport; |
| |
| err = StatusReport::parse(aPacketBuffer, statusReport); |
| if (err == WEAVE_NO_ERROR) |
| { |
| aXfer.DispatchXferErrorHandler(&statusReport); |
| } |
| } |
| else if (aProfileId == kWeaveProfile_BDX) |
| { |
| switch (aMessageType) |
| { |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_BlockAck: |
| /* |
| * Receiver MAY send an Ack before BlockQuery. We should |
| * free any resources associated with that block so we |
| * can stop resending it, but currently have no support |
| * for such activity. |
| * Similarly, we simply ignore Acks during async xfer. |
| */ |
| { |
| BlockAck ack; |
| |
| // Don't set error here - simply ignore the message. |
| VerifyOrExit(aXfer.IsDriver() && !aXfer.IsAsync(), err = WEAVE_NO_ERROR); |
| |
| err = BlockAck::parse(aPacketBuffer, ack); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockAck parse failed.")); |
| |
| rcvdCounter = ack.mBlockCounter; |
| |
| if (rcvdCounter == static_cast<uint8_t>(aXfer.mBlockCounter)) |
| { |
| // Update the counter and send the next block |
| aXfer.mBlockCounter++; |
| aXfer.mNext = SendNextBlock; |
| } |
| else if (rcvdCounter < static_cast<uint8_t>(aXfer.mBlockCounter)) |
| { |
| // just ignore the packet |
| WeaveLogDetail(BDX, "Received BlockAck for old block: %hd\n", rcvdCounter); |
| } |
| else |
| { |
| // bad scene we've somehow fallen behind |
| WeaveLogDetail(BDX, "Received BlockAck for future block???: %d\n", rcvdCounter); |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| case kMsgType_BlockAckV1: |
| { |
| BlockAckV1 ackV1; |
| |
| VerifyOrExit(aXfer.IsDriver() && !aXfer.IsAsync(), err = WEAVE_NO_ERROR); |
| |
| err = BlockAckV1::parse(aPacketBuffer, ackV1); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockAckV1 parse failed.")); |
| |
| rcvdCounter = ackV1.mBlockCounter; |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| // Update the counter and send the next block |
| aXfer.mBlockCounter++; |
| aXfer.mNext = SendNextBlockV1; |
| } |
| else |
| { |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected: %d", rcvdCounter, aXfer.mBlockCounter); |
| |
| if (rcvdCounter > aXfer.mBlockCounter) |
| { |
| // Only send a status report if the block counter is later than expected, and ignore |
| // earlier than expected due to the possibility of duplicate messages |
| aXfer.mNext = SendBadBlockCounterStatusReport; |
| } |
| } |
| } |
| |
| break; |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_BlockQuery: |
| { |
| BlockQuery query; |
| |
| VerifyOrExit(!aXfer.IsDriver() && !aXfer.IsAsync(), err = WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| |
| err = BlockQuery::parse(aPacketBuffer, query); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockQuery parse failed.")); |
| |
| rcvdCounter = query.mBlockCounter; |
| |
| // For the first query, look for counter = 0. |
| if (aXfer.mFirstQuery && rcvdCounter == 0) |
| { |
| aXfer.mFirstQuery = false; |
| aXfer.mNext = SendNextBlock; |
| } |
| // Afterwards, check that the received counter is the one after our block counter |
| else if (rcvdCounter == static_cast<uint8_t>(aXfer.mBlockCounter + 1)) |
| { |
| // Increment block counter after verifying block query message + block counter if it isn't the first query |
| // This is because we need to stay on the same block counter if the receiver decides to send an ack |
| // Ex. Recv BlockQuery for #2, send Block #2, get ack back for #2. Need to have block counter on |
| // 2 to verify the ack, and only increment when we receive the next block query. |
| aXfer.mBlockCounter++; |
| aXfer.mNext = SendNextBlock; |
| } |
| else |
| { |
| // just ignore the packet |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected %d\n", rcvdCounter, aXfer.mBlockCounter + 1); |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| case kMsgType_BlockQueryV1: |
| { |
| BlockQueryV1 queryV1; |
| |
| VerifyOrExit(!aXfer.IsDriver() && !aXfer.IsAsync(), err = WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| |
| err = BlockQueryV1::parse(aPacketBuffer, queryV1); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockQueryV1 parse failed.")); |
| |
| rcvdCounter = queryV1.mBlockCounter; |
| |
| // For the first query, look for counter = 0. |
| if (aXfer.mFirstQuery && rcvdCounter == 0) |
| { |
| aXfer.mFirstQuery = false; |
| aXfer.mNext = SendNextBlockV1; |
| } |
| // Afterwards, check that the received counter is the one after our block counter |
| else if (rcvdCounter == aXfer.mBlockCounter + 1) |
| { |
| // Increment block counter after verifying block query message + block counter if it isn't the first query |
| // This is because we need to stay on the same block counter if the receiver decides to send an ack |
| // Ex. Recv BlockQuery for #2, send Block #2, get ack back for #2. Need to have block counter on |
| // 2 to verify the ack, and only increment when we receive the next block query. |
| aXfer.mBlockCounter++; |
| aXfer.mNext = SendNextBlockV1; |
| } |
| else |
| { |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected: %d", rcvdCounter, aXfer.mBlockCounter + 1); |
| |
| if (rcvdCounter > aXfer.mBlockCounter + 1) |
| { |
| // Only send a status report if the block counter is later than expected, and ignore |
| // earlier than expected due to the possibility of duplicate messages |
| aXfer.mNext = SendBadBlockCounterStatusReport; |
| } |
| } |
| } |
| |
| break; |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_BlockEOFAck: |
| // TODO: should we bother parsing the message here just |
| // to verify the block counter is correct? if we do parse it, |
| // only set mIsCompletedSuccessfully to true on no error |
| { |
| aXfer.mIsCompletedSuccessfully = true; |
| aXfer.DispatchXferDoneHandler(); |
| aXfer.mFirstQuery = true; |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| case kMsgType_BlockEOFAckV1: |
| { |
| BlockEOFAckV1 EOFAckV1; |
| err = BlockEOFAckV1::parse(aPacketBuffer, EOFAckV1); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockEOFAckV1 parse failed.")); |
| |
| rcvdCounter = EOFAckV1.mBlockCounter; |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| aXfer.mIsCompletedSuccessfully = true; |
| aXfer.DispatchXferDoneHandler(); |
| aXfer.mFirstQuery = true; |
| } |
| else |
| { |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected: %d", rcvdCounter, aXfer.mBlockCounter); |
| aXfer.mNext = SendBadBlockCounterStatusReport; |
| } |
| } |
| |
| break; |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_TransferError: |
| { |
| TransferError inMsg; |
| TransferError::parse(aPacketBuffer, inMsg); |
| aXfer.DispatchXferErrorHandler(&inMsg); |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| default: |
| { |
| aXfer.DispatchErrorHandler(WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| } |
| |
| break; |
| } |
| } |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogError(BDX, "HandleResponseTransmit exit with error: %d", err); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| /* |
| * otherwise, I'm the receiver. I should expect to get |
| * a block here and then, If I'm driving, send out a |
| * query for the next block otherwise just send an ACK. |
| */ |
| WEAVE_ERROR HandleResponseReceive(BDXTransfer &aXfer, uint32_t aProfileId, uint8_t aMessageType, PacketBuffer *aPacketBuffer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint32_t rcvdCounter; |
| |
| if (aProfileId == kWeaveProfile_Common && aMessageType == Common::kMsgType_StatusReport) |
| { |
| StatusReport statusReport; |
| |
| err = StatusReport::parse(aPacketBuffer, statusReport); |
| if (err == WEAVE_NO_ERROR) |
| { |
| aXfer.DispatchXferErrorHandler(&statusReport); |
| } |
| } |
| else if (aProfileId == kWeaveProfile_BDX) |
| { |
| switch (aMessageType) |
| { |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_BlockSend: |
| { |
| BlockSend blockSend; |
| |
| err = BlockSend::parse(aPacketBuffer, blockSend); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockSend parse failed.")); |
| |
| aXfer.DispatchPutBlockHandler(blockSend.mLength, blockSend.mData, false); |
| |
| aXfer.mBlockCounter++; |
| // SendBlockAck will by design send out the ack for mBlockCounter - 1 |
| aXfer.mNext = aXfer.IsDriver() ? SendBlockQuery : SendBlockAck; |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| case kMsgType_BlockSendV1: |
| { |
| BlockSendV1 blockSendV1; |
| err = BlockSendV1::parse(aPacketBuffer, blockSendV1); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockSendV1 parse failed.")); |
| |
| rcvdCounter = blockSendV1.mBlockCounter; |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| aXfer.DispatchPutBlockHandler(blockSendV1.mLength, blockSendV1.mData, false); |
| } |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| aXfer.mBlockCounter++; |
| aXfer.mNext = aXfer.IsDriver() ? SendBlockQueryV1 : SendBlockAckV1; |
| } |
| else |
| { |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected: %d", rcvdCounter, aXfer.mBlockCounter); |
| |
| if (rcvdCounter > aXfer.mBlockCounter) |
| { |
| // Only send a status report if the block counter is later than expected, and ignore |
| // earlier than expected due to the possibility of duplicate messages |
| aXfer.mNext = SendBadBlockCounterStatusReport; |
| } |
| } |
| } |
| |
| break; |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_BlockEOF: |
| // TODO: add a consistency check on the overall size of the file received |
| // i.e. the sum of all received blocks should match the expected file size |
| // this would require us to keep track of the number of bytes received |
| // as we can imagine a case where a block in the middle wasn't full |
| { |
| BlockEOF blockEOF; |
| |
| // Only try to parse if we have a data length of > 0 |
| if (aPacketBuffer->DataLength() != 0) |
| { |
| err = BlockEOF::parse(aPacketBuffer, blockEOF); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockEOF parse failed.")); |
| |
| aXfer.DispatchPutBlockHandler(blockEOF.mLength, blockEOF.mData, true); |
| } |
| |
| // ACK the EOF and clean up transfer |
| aXfer.mNext = SendBlockEOFAck; |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| case kMsgType_BlockEOFV1: |
| { |
| BlockEOFV1 blockEOFV1; |
| err = BlockEOFV1::parse(aPacketBuffer, blockEOFV1); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "BlockEOFV1 parse failed.")); |
| |
| rcvdCounter = blockEOFV1.mBlockCounter; |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| aXfer.DispatchPutBlockHandler(blockEOFV1.mLength, blockEOFV1.mData, true); |
| } |
| |
| if (rcvdCounter == aXfer.mBlockCounter) |
| { |
| aXfer.mNext = SendBlockEOFAckV1; |
| } |
| else |
| { |
| WeaveLogDetail(BDX, "Received bad block counter: %d, expected: %d", rcvdCounter, aXfer.mBlockCounter); |
| aXfer.mNext = SendBadBlockCounterStatusReport; |
| } |
| } |
| |
| break; |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_TransferError: |
| { |
| TransferError inMsg; |
| |
| TransferError::parse(aPacketBuffer, inMsg); |
| aXfer.DispatchXferErrorHandler(&inMsg); |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| default: |
| { |
| aXfer.DispatchErrorHandler(WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| } |
| |
| break; |
| } |
| } |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogError(BDX, "HandleResponseReceive exit with error: %d", err); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| |
| WEAVE_ERROR HandleResponseNotAccepted(BDXTransfer &aXfer, uint32_t aProfileId, uint8_t aMessageType, PacketBuffer *aPacketBuffer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| // V1 - Handle Status Report - if we received a status report and it hasn't been accepted, |
| // we should treat the transfer as rejected. |
| if (aProfileId == kWeaveProfile_Common && aMessageType == Common::kMsgType_StatusReport) |
| { |
| StatusReport statusReport; |
| |
| err = StatusReport::parse(aPacketBuffer, statusReport); |
| if (err == WEAVE_NO_ERROR) |
| { |
| aXfer.DispatchRejectHandler(&statusReport); |
| } |
| } |
| else if (aProfileId == kWeaveProfile_BDX) |
| { |
| /* |
| * here the tranfer hasn't been accepted yet, and we're waiting |
| * either for an accept or a reject message. |
| */ |
| switch (aMessageType) |
| { |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_TransferError: |
| { |
| TransferError inMsg; |
| |
| TransferError::parse(aPacketBuffer, inMsg); |
| aXfer.DispatchXferErrorHandler(&inMsg); |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| case kMsgType_SendAccept: |
| /* |
| * The send is accepted. now we figure out who's driving and, |
| * if necessary, kick it off. |
| */ |
| { |
| uint8_t xferMode; |
| SendAccept inMsg; |
| |
| err = SendAccept::parse(aPacketBuffer, inMsg); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "SendAccept parse failed.")); |
| // This implies we're compatible with any version equal or below WEAVE_CONFIG_BDX_VERSION |
| VerifyOrExit(inMsg.mVersion <= WEAVE_CONFIG_BDX_VERSION, |
| err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION; |
| WeaveLogDetail(BDX, "SendAccept returned an incompatible version: %d.", inMsg.mVersion)); |
| |
| aXfer.mIsAccepted = true; |
| aXfer.mMaxBlockSize = inMsg.mMaxBlockSize; |
| aXfer.mTransferMode = inMsg.mTransferMode; |
| aXfer.mVersion = inMsg.mVersion; |
| err = aXfer.DispatchSendAccept(&inMsg); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "DispatchSendAccept failed.")); |
| |
| xferMode = inMsg.mTransferMode; |
| |
| switch (xferMode) |
| { |
| case kMode_SenderDrive: |
| // Try and send the first block |
| VerifyOrExit(aXfer.mVersion < 2, err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION); |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| aXfer.mNext = aXfer.mVersion == 1 ? SendNextBlockV1 : SendNextBlock; |
| #else |
| aXfer.mNext = aXfer.mVersion == 1 ? SendNextBlockV1 : NULL; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| break; |
| |
| case kMode_ReceiverDrive: |
| // Do nothing else as now we just wait for a BlockQuery |
| break; |
| |
| case kMode_Asynchronous: |
| WeaveLogDetail(BDX, "Received request for Async transfer mode, but it's not implemented yet!"); |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; |
| break; |
| |
| default: |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; |
| break; |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_SendReject: |
| { |
| SendReject sendReject; |
| |
| err = SendReject::parse(aPacketBuffer, sendReject); |
| if (err == WEAVE_NO_ERROR) |
| { |
| aXfer.DispatchRejectHandler(&sendReject); |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| case kMsgType_ReceiveAccept: |
| /* |
| * The receive is accepted. now we figure out who's driving and, |
| * if necessary, kick it off. |
| */ |
| { |
| uint8_t xferMode; |
| ReceiveAccept inMsg; |
| |
| err = ReceiveAccept::parse(aPacketBuffer, inMsg); |
| |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "ReceiveAccept parse failed.")); |
| // This implies we're compatible with any version equal or below WEAVE_CONFIG_BDX_VERSION |
| VerifyOrExit(inMsg.mVersion <= WEAVE_CONFIG_BDX_VERSION, |
| err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION; |
| WeaveLogDetail(BDX, "ReceiveAccept returned an incompatible version: %d.", inMsg.mVersion)); |
| |
| // Set up the aXfer object and call callback |
| aXfer.mIsAccepted = true; |
| aXfer.mMaxBlockSize = inMsg.mMaxBlockSize; |
| aXfer.mTransferMode = inMsg.mTransferMode; |
| aXfer.mVersion = inMsg.mVersion; |
| aXfer.mLength = inMsg.mLength; |
| err = aXfer.DispatchReceiveAccept(&inMsg); |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "DispatchReceiveAccept failed.")); |
| xferMode = inMsg.mTransferMode; |
| |
| switch (xferMode) |
| { |
| case kMode_SenderDrive: |
| WeaveLogDetail(BDX, "Receive accepted: am not driving, so waiting for first BlockSend"); |
| // Do nothing else as now we just expect the first BlockSend |
| break; |
| |
| case kMode_ReceiverDrive: |
| WeaveLogDetail(BDX, "Receive accepted: am driving, so sending first query"); |
| VerifyOrExit(aXfer.mVersion < 2, err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION); |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| aXfer.mNext = aXfer.mVersion == 1 ? SendBlockQueryV1 : SendBlockQuery; |
| #else |
| aXfer.mNext = aXfer.mVersion == 1 ? SendBlockQueryV1 : NULL; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| break; |
| |
| case kMode_Asynchronous: |
| WeaveLogDetail(BDX, "Received request for Async transfer mode, but it's not implemented yet!"); |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; |
| break; |
| |
| default: |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; |
| break; |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| case kMsgType_ReceiveReject: |
| { |
| ReceiveReject receiveReject; |
| err = ReceiveReject::parse(aPacketBuffer, receiveReject); |
| if (err == WEAVE_NO_ERROR) |
| { |
| aXfer.DispatchRejectHandler(&receiveReject); |
| } |
| } |
| |
| break; |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| |
| default: |
| aXfer.DispatchErrorHandler(WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| break; |
| } |
| } |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogError(BDX, "HandleResponseNotAccepted exit with error: %d", err); |
| } |
| |
| return err; |
| } |
| |
| } // BdxProtocol |
| } // BulkDataTransfer |
| } // Profiles |
| } // Weave |
| } // nl |
