| /* |
| * |
| * 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 |
| * Server. It manages BDXTransfer objects and interfaces with the |
| * BdxProtocol class to facilitate transfers. |
| */ |
| |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Support/WeaveFaultInjection.h> |
| #include <Weave/Support/logging/WeaveLogging.h> |
| #include <Weave/Profiles/common/CommonProfile.h> |
| |
| #include <Weave/Profiles/bulk-data-transfer/Development/BDXNode.h> |
| |
| namespace nl { |
| namespace Weave { |
| namespace Profiles { |
| namespace WeaveMakeManagedNamespaceIdentifier(BDX, kWeaveManagedNamespaceDesignation_Development) { |
| |
| using namespace ::nl::Weave::Profiles::Common; |
| using namespace ::nl::Weave::Logging; |
| |
| #define BDX_RESPONSE_TIMEOUT_MS WEAVE_CONFIG_BDX_RESPONSE_TIMEOUT_SEC * 1000 |
| |
| /* |
| * Here are the method definitions for the BdxNode class |
| * |
| * the no-arg constructor with defaulting for BDX clients |
| */ |
| BdxNode::BdxNode(void) |
| { |
| mExchangeMgr = NULL; |
| mIsBdxTransferAllowed = false; |
| mInitialized = false; |
| mSendInitHandler = NULL; |
| mReceiveInitHandler = NULL; |
| } |
| |
| /** |
| * @brief |
| * Put all transfers in a default state ready for use, store the |
| * WeaveExchangeManager and any other necessary Weave resources, |
| * and sets allowBdxTransferToRun(true). |
| * |
| * @param[in] anExchangeMgr An exchange manager to use for this bulk transfer operation. |
| * |
| * @retval #WEAVE_NO_ERROR if successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE if mExchangeMgr isn't null, already initialized |
| */ |
| WEAVE_ERROR BdxNode::Init(WeaveExchangeManager *anExchangeMgr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| // Error if already initialized. |
| VerifyOrExit(mExchangeMgr == NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| VerifyOrExit(anExchangeMgr != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| mExchangeMgr = anExchangeMgr; |
| |
| // Initialize all the BDXTransfers |
| for (int i = 0; i < WEAVE_CONFIG_BDX_MAX_NUM_TRANSFERS; i++) |
| { |
| // Error if already initialized. |
| mTransferPool[i].Reset(); |
| } |
| |
| mIsBdxTransferAllowed = true; |
| mInitialized = true; |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Shuts down all transfers and releases any Weave resources |
| * (currently sets mExchangeMgr to NULL). Sets AllowBdxTransferToRun(false) and |
| * disconnects any current callbacks (for example, SendInitHandler). |
| * |
| * @note |
| * The BDX Protocol never calls this function as it is up to the platform |
| * to create and manage the BdxNode. |
| * |
| * @return #WEAVE_NO_ERROR if successfully shut down, other error if AwaitBdxSend/ReceiveInit returns an error |
| */ |
| WEAVE_ERROR BdxNode::Shutdown(void) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| for (int i = 0; i < WEAVE_CONFIG_BDX_MAX_NUM_TRANSFERS; i++) |
| { |
| ShutdownTransfer(&mTransferPool[i]); |
| } |
| |
| AllowBdxTransferToRun(false); |
| |
| #if WEAVE_CONFIG_BDX_SERVER_SUPPORT |
| // Unregister any callbacks BEFORE releasing mExchangeMgr |
| err = AwaitBdxSendInit(NULL); |
| VerifyOrExit(err == WEAVE_NO_ERROR || err == WEAVE_ERROR_INCORRECT_STATE || |
| err == WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER, |
| WeaveLogDetail(BDX, |
| "Error removing existing sendinit callback in ShutdownServer: %d", err); |
| ); |
| |
| err = AwaitBdxReceiveInit(NULL); |
| VerifyOrExit(err == WEAVE_NO_ERROR || err == WEAVE_ERROR_INCORRECT_STATE || |
| err == WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER, |
| WeaveLogDetail(BDX, |
| "Error removing existing receiveinit callback in ShutdownServer: %d", err); |
| ); |
| |
| exit: |
| #endif // WEAVE_CONFIG_BDX_SERVER_SUPPORT |
| |
| mExchangeMgr = NULL; |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Get and set up a new BDXTransfer from transfer pool if available, |
| * or set to NULL otherwise and return an error. |
| * |
| * A BDXTransfer object obtained through this function is considered allocated |
| * by its mIsInitiated member being true. All other values will be the expected |
| * default values (see BDXTransfer::setDefaults()). |
| * |
| * @note |
| * You MUST shutdown this transfer in order to release it to the free pool! |
| * @note |
| * You will not typically use this function and instead should use one of the |
| * other versions, which in turn defer to this function. Only manually set up |
| * a BDXTransfer if you really know what you're doing and are prepared to do |
| * maintenance in the event of future changes to its structure! |
| * |
| * @param[in] aXfer A passed-by-reference pointer that will point to the |
| * new BDXTransfer object if one is available, else NULL. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully found a new BDXTransfer. |
| * @retval #WEAVE_ERROR_TOO_MANY_CONNECTIONS If too many transfers are currently active and aXfer is NULL |
| */ |
| WEAVE_ERROR BdxNode::AllocTransfer(BDXTransfer * &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_TOO_MANY_CONNECTIONS; |
| |
| WEAVE_FAULT_INJECT(FaultInjection::kFault_BDXAllocTransfer, ExitNow()); |
| |
| for (int i = 0; i < WEAVE_CONFIG_BDX_MAX_NUM_TRANSFERS; i++) |
| { |
| aXfer = &mTransferPool[i]; |
| if (aXfer->mIsInitiated) |
| { |
| continue; |
| } |
| |
| if (aXfer->mExchangeContext != NULL) |
| { |
| WeaveLogDetail(BDX, "Error! Xfer is not initiated but has mExchangeContext."); |
| continue; |
| } |
| |
| aXfer->mIsInitiated = true; |
| err = WEAVE_NO_ERROR; |
| ExitNow(); |
| } |
| |
| // All of the connections are in use |
| aXfer = NULL; |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Get and set up a new BDXTransfer from transfer pool if available, |
| * or set to NULL otherwise and return an error. |
| * |
| * @note |
| * You MUST shutdown this transfer in order to release it to the free pool! |
| * @note |
| * If a particular handler should not be used in the transfer you are setting up |
| * (e.g., a PutBlockHandler when Sending), set it to NULL. |
| * @note |
| * See BDXTransferState.h for details about the handlers. |
| * |
| * @param[in] aBinding The Binding to the node we will initiate the transfer with. |
| * It's used to create an associated ExchangeContext for this transfer. |
| * @param[in] aBDXHandlers A structure of BDX callback handlers to be called during the transfer |
| * @param[in] aFileDesignator The file designator for the file that will be transferred. |
| * @param[in] anAppState An application-specific state object to be attached to the |
| * BDXTransfer for use by the user application and associated callbacks. |
| * @param[in] aXfer A passed-by-reference pointer that will point to the |
| * new BDXTransfer object if one is available, else NULL. |
| * |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully found a new BDXTransfer. |
| * @retval #WEAVE_ERROR_NO_MEMORY If unable to create ExchangeContext |
| * @retval #WEAVE_ERROR_TOO_MANY_CONNECTIONS If too many transfers are currently active and aXfer is NULL |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If aBinding is not prepared |
| */ |
| WEAVE_ERROR BdxNode::NewTransfer(Binding * aBinding, BDXHandlers aBDXHandlers, |
| ReferencedString &aFileDesignator, void * anAppState, |
| BDXTransfer * &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| ExchangeContext * ec = NULL; |
| |
| VerifyOrExit(aBinding != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = aBinding->NewExchangeContext(ec); |
| SuccessOrExit(err); |
| |
| // Note: ExchangeContext cleanup is handled within the call below |
| err = NewTransfer(ec, aBDXHandlers, aFileDesignator, anAppState, aXfer); |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Get and set up a new BDXTransfer from transfer pool if available, |
| * or set to NULL otherwise and return an error. |
| * |
| * @note |
| * You MUST shutdown this transfer in order to release it to the free pool! |
| * @note |
| * If a particular handler should not be used in the transfer you are setting up |
| * (e.g., a PutBlockHandler when Sending), set it to NULL. |
| * @note |
| * See BDXTransferState.h for details about the handlers. |
| * |
| * @param[in] aCon The WeaveConnection to the node we will initiate the transfer with. |
| * It's used to create an associated ExchangeContext for this transfer. |
| * @param[in] aBDXHandlers A structure of BDX callback handlers to be called during the transfer |
| * @param[in] aFileDesignator The file designator for the file that will be transferred. |
| * @param[in] anAppState An application-specific state object to be attached to the |
| * BDXTransfer for use by the user application and associated callbacks. |
| * @param[in] aXfer A passed-by-reference pointer that will point to the |
| * new BDXTransfer object if one is available, else NULL. |
| * |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully found a new BDXTransfer. |
| * @retval #WEAVE_ERROR_NO_MEMORY If unable to create ExchangeContext |
| * @retval #WEAVE_ERROR_TOO_MANY_CONNECTIONS If too many transfers are currently active and aXfer is NULL |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If mExchangeMgr has not been set yet or if aCon has not successfully connected |
| */ |
| WEAVE_ERROR BdxNode::NewTransfer(WeaveConnection * aCon, BDXHandlers aBDXHandlers, |
| ReferencedString &aFileDesignator, void * anAppState, |
| BDXTransfer * &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| ExchangeContext *ec = NULL; |
| |
| VerifyOrExit(aCon != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| VerifyOrExit(aCon->State == WeaveConnection::kState_Connected, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| ec = mExchangeMgr->NewContext(aCon); |
| VerifyOrExit(ec != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| // Note: ExchangeContext cleanup is handled within the call below |
| err = NewTransfer(ec, aBDXHandlers, aFileDesignator, anAppState, aXfer); |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Get and set up a new BDXTransfer from transfer pool if available, |
| * or set to NULL otherwise and return an error. The ExchangeContext (and possible |
| * underlying WeaveConnection) will have their AppState pointer set to |
| * the BDXTransfer. |
| * |
| * @note |
| * This is the version of NewTransfer that you should use if you want an encrypted |
| * exchange, which requires setting up the ExchangeContext manually. |
| * @note |
| * You MUST shutdown this transfer in order to release it to the free pool! |
| * @note |
| * If a particular handler should not be used in the transfer you are setting up |
| * (e.g., a PutBlockHandler when Sending), set it to NULL. |
| * @note |
| * See BDXTransferState.h for details about the handlers. |
| * |
| * @param[in] anEc The ExchangeContext with the node we will initiate the transfer with. |
| * The server will handle closing it when the transfer is shutdown. |
| * @param[in] aBDXHandlers A structure of BDX callback handlers to be called during the transfer |
| * @param[in] aFileDesignator The file designator for the file that will be transferred. |
| * @param[in] anAppState An application-specific state object to be attached to the |
| * BDXTransfer for use by the user application and associated callbacks. |
| * @param[in] aXfer A passed-by-reference pointer that will point to the |
| * new BDXTransfer object if one is available, else NULL. |
| * |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully found a new BDXTransfer. |
| * @retval #WEAVE_ERROR_TOO_MANY_CONNECTIONS If too many transfers are currently active (aXfer is NULL) |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If ec is NULL, closed, or otherwise invalid for a transfer |
| */ |
| WEAVE_ERROR BdxNode::NewTransfer(ExchangeContext *anEc, BDXHandlers aBDXHandlers, |
| ReferencedString &aFileDesignator, void * anAppState, |
| BDXTransfer * &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| aXfer = NULL; |
| |
| err = InitTransfer(anEc, aXfer); |
| SuccessOrExit(err); |
| |
| // set up the application-specific state |
| aXfer->mFileDesignator = aFileDesignator; |
| aXfer->mAppState = anAppState; |
| |
| // install application-specifc handlers |
| aXfer->SetHandlers(aBDXHandlers); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (aXfer != NULL) |
| { |
| aXfer->Shutdown(); |
| } |
| else |
| { |
| // Transfer object uninitialized, so we do this manually |
| if (anEc != NULL) |
| { |
| anEc->Close(); |
| anEc = NULL; |
| } |
| } |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Get and set up a new BDXTransfer from transfer pool if available, |
| * or set to NULL otherwise and return an error. |
| * |
| * @note |
| * You likely will not be using this method directly as you'll want to |
| * configure the BDXTransfer's parameters at the same time. |
| * @note |
| * You MUST shutdown this transfer in order to release it to the free pool! |
| * |
| * @param[in] anEc The ExchangeContext with the node we will initiate the transfer with. |
| * The server will handle closing it when the transfer is shutdown. |
| * @param[in] aXfer A passed-by-reference pointer that will point to the |
| * new BDXTransfer object if one is available, else NULL. |
| * |
| * @retval #WEAVE_NO_ERROR If we successfully found a new BDXTransfer. |
| * @retval #WEAVE_ERROR_TOO_MANY_CONNECTIONS If too many transfers are currently active (aXfer is NULL) |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If ec is NULL, closed, or otherwise invalid for a transfer |
| */ |
| WEAVE_ERROR BdxNode::InitTransfer(ExchangeContext *anEc, |
| BDXTransfer * &aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| //TODO: check if there is already an ongoing BDX Transfer on this ExchangeContext: |
| //only one is allowed at a time according to the BDX specification |
| VerifyOrExit(anEc != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| VerifyOrExit(!anEc->IsConnectionClosed(), err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = AllocTransfer(aXfer); |
| SuccessOrExit(err); |
| |
| // Hang new BDXTransfer on exchange context so we can access the xfer object |
| // in the static handlers fired in response to incoming messages on the exchange |
| anEc->AppState = aXfer; |
| |
| // Handle timeouts and other errors on this exchange |
| if (anEc->ResponseTimeout == 0) |
| { |
| anEc->ResponseTimeout = BDX_RESPONSE_TIMEOUT_MS; |
| } |
| anEc->OnResponseTimeout = BdxProtocol::HandleResponseTimeout; |
| anEc->OnConnectionClosed = BdxProtocol::HandleConnectionClosed; |
| anEc->OnKeyError = BdxProtocol::HandleKeyError; |
| |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| anEc->OnSendError = BdxProtocol::HandleSendError; |
| #endif // #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| |
| // Initialize xfer struct |
| aXfer->mExchangeContext = anEc; |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Shutdown the given transfer object and return it to pool. |
| * This simply defers to BDXTransfer::Shutdown() |
| * |
| * @param[in] aXfer The BDXTransfer to shut down |
| */ |
| void BdxNode::ShutdownTransfer(BDXTransfer *aXfer) |
| { |
| aXfer->Shutdown(); |
| } |
| |
| /** |
| * @brief |
| * Use to enable/disable the BDX server without fully shutting it down and restarting. |
| * |
| * @param[in] aEnable Enable (true) or disable (false) |
| */ |
| void BdxNode::AllowBdxTransferToRun(bool aEnable) |
| { |
| mIsBdxTransferAllowed = aEnable; |
| } |
| |
| /** |
| * @brief |
| * Returns true if the BDX server is allowed to start a transfer at this time, false otherwise. |
| * |
| * @return true if BDX transfer is allowed, false if not |
| */ |
| bool BdxNode::CanBdxTransferRun(void) |
| { |
| return mIsBdxTransferAllowed; |
| } |
| |
| /** |
| * @brief |
| * Returns true if this BdxNode has already been initialized. |
| * |
| * @return true if this object has been initalized |
| */ |
| bool BdxNode::IsInitialized(void) |
| { |
| return mInitialized; |
| } |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| /** |
| * @brief |
| * Initializes a BdxReceive transfer with the specified parameters and passes it |
| * to BdxProtocol::InitBdxReceive to send actual ReceiveInit message. |
| * You must first establish a BDXTransfer object via NewTransfer() and configure |
| * it appropriately. |
| * |
| * @param[in] aXfer The initiated and configured transfer state object to |
| * use for this transfer |
| * @param[in] aICanDrive True if the initiator should propose that it can drive, |
| * false otherwise |
| * @param[in] aUCanDrive True if the initiator should propose that the sender can drive, |
| * false otherwise |
| * @param[in] aAsyncOk True if the initiator should propose using async transfer |
| * @param[in] aMetaData (optional) TLV metadata |
| * |
| * @retval #WEAVE_NO_ERROR If successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If BDXTransfer can't run right now |
| * @retval #WEAVE_ERROR_NO_MEMORY BdxProtocol::InitBdxReceive failed to init |
| */ |
| WEAVE_ERROR BdxNode::InitBdxReceive(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, ReferencedTLVData *aMetaData) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(CanBdxTransferRun(), |
| err = WEAVE_ERROR_INCORRECT_STATE; WeaveLogDetail(BDX, "InitBdxReceive called but server cannot run currently")); |
| |
| aXfer.mAmInitiator = true; |
| aXfer.mAmSender = false; |
| |
| // Arrange for messages in this exchange to go to our response handler. |
| // NOTE: we may want to set different handlers for e.g., Receive, Send in the future |
| aXfer.mExchangeContext->OnMessageReceived = BdxProtocol::HandleResponse; |
| |
| err = BdxProtocol::InitBdxReceive(aXfer, aICanDrive, aUCanDrive, aAsyncOk, aMetaData); |
| |
| exit: |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_RECEIVE_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| /** |
| * @brief |
| * Initializes a BdxSend transfer with the specified parameters and passes it |
| * to BdxProtocol::InitBdxSend to send actual SendInit message. |
| * You must first establish a BDXTransfer object via NewTransfer() and configure |
| * it appropriately. |
| * |
| * @param[in] aXfer The initiated and configured transfer state object to |
| * use for this transfer |
| * @param[in] aICanDrive True if the initiator should propose that it can drive, |
| * false otherwise |
| * @param[in] aUCanDrive True if the initiator should propose that the sender can drive, |
| * false otherwise |
| * @param[in] aAsyncOk True if the initiator should propose using async transfer |
| * @param[in] aMetaData (optional) TLV metadata |
| * |
| * @retval #WEAVE_NO_ERROR If successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If BDXTransfer can't run right now |
| * @retval #WEAVE_ERROR_NO_MEMORY BdxProtocol::InitBdxSend failed to init |
| */ |
| WEAVE_ERROR BdxNode::InitBdxSend(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, ReferencedTLVData *aMetaData) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(CanBdxTransferRun(), |
| err = WEAVE_ERROR_INCORRECT_STATE; WeaveLogDetail(BDX, "InitBdxSend called but server cannot run currently")); |
| |
| aXfer.mAmInitiator = true; |
| aXfer.mAmSender = true; |
| |
| // Arrange for messages in this exchange to go to our response handler. |
| aXfer.mExchangeContext->OnMessageReceived = BdxProtocol::HandleResponse; |
| |
| err = BdxProtocol::InitBdxSend(aXfer, aICanDrive, aUCanDrive, aAsyncOk, aMetaData); |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Initializes a BdxSend transfer with the specified parameters and passes it |
| * to BdxProtocol::InitBdxSend to send actual SendInit message. |
| * You must first establish a BDXTransfer object via NewTransfer() and configure |
| * it appropriately. |
| * |
| * @param[in] aXfer The initiated and configured transfer state object to |
| * use for this transfer |
| * @param[in] aICanDrive True if the initiator should propose that it can drive, |
| * false otherwise |
| * @param[in] aUCanDrive True if the initiator should propose that the sender can drive, |
| * false otherwise |
| * @param[in] aAsyncOk True if the initiator should propose using async transfer |
| * @param[in] aMetaDataWriteCallback (optional) Function to write TLV metadata |
| * @param[in] aMetaDataAppState (optional) AppState for aMetaDataWriteCallback |
| * |
| * @retval #WEAVE_NO_ERROR If successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If BDXTransfer can't run right now |
| * @retval #WEAVE_ERROR_NO_MEMORY BdxProtocol::InitBdxSend failed to init |
| */ |
| WEAVE_ERROR BdxNode::InitBdxSend(BDXTransfer &aXfer, bool aICanDrive, bool aUCanDrive, |
| bool aAsyncOk, SendInit::MetaDataTLVWriteCallback aMetaDataWriteCallback, |
| void *aMetaDataAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(CanBdxTransferRun(), |
| err = WEAVE_ERROR_INCORRECT_STATE; WeaveLogDetail(BDX, "InitBdxSend called but server cannot run currently")); |
| |
| aXfer.mAmInitiator = true; |
| aXfer.mAmSender = true; |
| |
| // Arrange for messages in this exchange to go to our response handler. |
| aXfer.mExchangeContext->OnMessageReceived = BdxProtocol::HandleResponse; |
| |
| err = BdxProtocol::InitBdxSend(aXfer, aICanDrive, aUCanDrive, aAsyncOk, aMetaDataWriteCallback, aMetaDataAppState); |
| |
| exit: |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_CLIENT_SEND_SUPPORT |
| |
| #if WEAVE_CONFIG_BDX_SERVER_SUPPORT |
| /** |
| * @brief |
| * Allow unsolicited ReceiveInit messages to be handled by the specified handlers on this server. |
| * |
| * @param[in] aReceiveInitHandler A handler for ReceiveInit messages that configures a |
| * BDXTransfer object and determines whether to accept the |
| * transfer based on the parameters contained within the ReceiveInit message. |
| * |
| * @retval #WEAVE_NO_ERROR If successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If mExchangeMgr hasn't been initialized |
| * @retval other A call to register/unregister a message handler failed |
| */ |
| WEAVE_ERROR BdxNode::AwaitBdxReceiveInit(ReceiveInitHandler aReceiveInitHandler) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| VerifyOrExit(mExchangeMgr != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // Register callback if specified |
| if (aReceiveInitHandler != NULL) |
| { |
| err = mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_BDX, kMsgType_ReceiveInit, HandleReceiveInit, this); |
| SuccessOrExit(err); |
| |
| mReceiveInitHandler = aReceiveInitHandler; |
| } |
| // Otherwise, unregister any currently set one |
| else |
| { |
| err = mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_BDX, kMsgType_ReceiveInit); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Allow unsolicited SendInit messages to be handled by the specified handlers on this server. |
| * |
| * @param[in] aSendInitHandler A handler for SendInit messages that configures a |
| * BDXTransfer object and determines whether to accept the |
| * transfer based on the parameters contained within the SendInit message. |
| * |
| * @retval #WEAVE_NO_ERROR If successful |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If mExchangeMgr hasn't been initialized |
| * @retval other A call to register/unregister a message handler failed |
| */ |
| WEAVE_ERROR BdxNode::AwaitBdxSendInit(SendInitHandler aSendInitHandler) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| VerifyOrExit(mExchangeMgr != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| if (aSendInitHandler != NULL) |
| { |
| err = mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_BDX, kMsgType_SendInit, HandleSendInit, this); |
| SuccessOrExit(err); |
| |
| mSendInitHandler = aSendInitHandler; |
| } |
| else |
| { |
| err = mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_BDX, kMsgType_SendInit); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Handler for ReceiveInit messages that parses the incoming message, grabs a |
| * BDXTransfer object (if one is available), passes the ReceiveInit object |
| * to the previously specified ReceiveInitHandler, which will set up |
| * the BDXTransfer object and determine if the ReceiveInit should be accepted, |
| * in which case the handler sends the appropriate response. If anything fails |
| * in this function, we send a reject to tell the initiator that we can't accept. |
| * |
| * @note |
| * statusCode tracks the BDXProfile Status Error code (to be transferred in case of failure), |
| * while err tracks our internal WEAVE_ERROR, which should never be transmitted. |
| * |
| * @param[in] anEc ExchangeContext to be associated with this receive init |
| * @param[in] aPktInfo Unused here, but needs to match 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] aPayloadReceiveInit The packed message itself |
| */ |
| void BdxNode::HandleReceiveInit(ExchangeContext *anEc, const IPPacketInfo *aPktInfo, |
| const WeaveMessageInfo *aWeaveMsgInfo, |
| uint32_t aProfileId, uint8_t aMessageType, |
| PacketBuffer *aPayloadReceiveInit) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint16_t statusCode = kStatus_Success; |
| BdxNode *bdxApp = NULL; |
| BDXTransfer *xfer = NULL; |
| bool success = false; |
| |
| ReceiveInit receiveInit; |
| // Set version early in case we exit before parsing. This allows us to send |
| // the reject corresponding to the BDX version we're using. |
| receiveInit.mVersion = WEAVE_CONFIG_BDX_VERSION; |
| |
| WeaveLogDetail(BDX, "HandleReceiveInit entering"); |
| |
| VerifyOrExit(anEc != NULL, err = WEAVE_ERROR_INCORRECT_STATE; statusCode = kStatus_ServerBadState); |
| |
| VerifyOrExit(aProfileId == kWeaveProfile_BDX, err = WEAVE_ERROR_INVALID_PROFILE_ID; statusCode = kStatus_BadMessageContents); |
| VerifyOrExit(aMessageType == kMsgType_ReceiveInit, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; statusCode = kStatus_BadMessageContents); |
| |
| // Parse init request and discard payload buffer |
| err = ReceiveInit::parse(aPayloadReceiveInit, receiveInit); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| statusCode = kStatus_BadMessageContents; |
| WeaveLogDetail(BDX, "Error: HandleReceiveInit: Unable to parse Receive Init request: %d", err)); |
| PacketBuffer::Free(aPayloadReceiveInit); |
| aPayloadReceiveInit = NULL; |
| |
| bdxApp = static_cast<BdxNode *>(anEc->AppState); |
| |
| VerifyOrExit(bdxApp->CanBdxTransferRun(), |
| err = WEAVE_ERROR_INCORRECT_STATE; statusCode = kStatus_ServerBadState); |
| |
| // Grab BDXTransfer object for this transfer |
| err = bdxApp->InitTransfer(anEc, xfer); |
| VerifyOrExit(err == WEAVE_NO_ERROR && xfer != NULL, |
| err = WEAVE_ERROR_NO_MEMORY; statusCode = kStatus_ServerBadState); |
| |
| // Configure xfer object |
| xfer->mAmInitiator = false; |
| xfer->mIsAccepted = false; |
| xfer->mAmSender = true; |
| xfer->mMaxBlockSize = receiveInit.mMaxBlockSize; |
| xfer->mVersion = (receiveInit.mVersion > WEAVE_CONFIG_BDX_VERSION) ? WEAVE_CONFIG_BDX_VERSION : receiveInit.mVersion; |
| |
| // Verify we have a legitimate block size or reject |
| VerifyOrExit(receiveInit.mMaxBlockSize > 0, |
| err = WEAVE_ERROR_INVALID_ARGUMENT; statusCode = kStatus_BadRequest); |
| |
| VerifyOrExit(receiveInit.mFileDesignator.theLength > 0, |
| err = WEAVE_ERROR_INVALID_ARGUMENT; statusCode = kStatus_BadRequest); |
| |
| // Fire application callback to validate request and setup transfer |
| // Application should set the transfer mode and accept the transfer. |
| VerifyOrExit(bdxApp->mReceiveInitHandler, |
| err = WEAVE_ERROR_NO_MESSAGE_HANDLER; statusCode = kStatus_ServerBadState); |
| |
| statusCode = bdxApp->mReceiveInitHandler(xfer, &receiveInit); |
| VerifyOrExit(statusCode == kStatus_Success, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // Validate the requested transfer mode |
| VerifyOrExit(!(((xfer->mTransferMode == kMode_ReceiverDrive) && !receiveInit.mReceiverDriveSupported) || |
| ((xfer->mTransferMode == kMode_SenderDrive) && !receiveInit.mSenderDriveSupported) || |
| ((xfer->mTransferMode == kMode_Asynchronous))), |
| //TODO: merge this up one line when async supported: && !receiveInit.mAsynchronousModeSupported) |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; statusCode = kStatus_ServerBadState); |
| |
| // TODO: validate max block size? anything else? |
| WeaveLogDetail(BDX, "HandleReceiveInit validated request\n"); |
| |
| err = SendReceiveAccept(anEc, xfer); |
| VerifyOrExit(err == WEAVE_NO_ERROR, statusCode = kStatus_FailureToSend); |
| |
| WeaveLogDetail(BDX, "HandleReceiveInit exiting (success)\n"); |
| success = true; |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogError(BDX, "HandleReceiveInit exiting (failure = %d)", err); |
| } |
| |
| if (aPayloadReceiveInit) |
| { |
| PacketBuffer::Free(aPayloadReceiveInit); |
| } |
| |
| if (!success) |
| { |
| if (statusCode != kStatus_BadMessageContents) |
| { |
| // Send a reject if we didn't succeed at handling the receive init and |
| // it was not due to bad message contents. |
| err = SendReject(anEc, receiveInit.mVersion, statusCode, kMsgType_ReceiveReject); |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogDetail(BDX, "Sending reject message failed : %d", err); |
| } |
| } |
| |
| if (xfer != NULL) |
| { |
| xfer->Shutdown(); |
| } |
| else |
| { |
| // Transfer object uninitialized, so we do this manually |
| if (anEc != NULL) |
| { |
| if (anEc->Con != NULL) |
| { |
| anEc->Con->Close(); |
| anEc->Con = NULL; |
| } |
| |
| anEc->Close(); |
| anEc = NULL; |
| } |
| } |
| } |
| } |
| |
| /** |
| * @brief |
| * Handler for SendInit messages that parses the incoming message, grabs a |
| * BDXTransfer object (if one is available), passes the SendInit object |
| * to the previously specified SendInitHandler, which will set up |
| * the BDXTransfer object and determine if the SendInit should be accepted, |
| * in which case the handler sends the appropriate response. If anything fails |
| * in this function, we send a reject to tell the initiator that we can't accept. |
| * |
| * @note |
| * statusCode tracks the BDXProfile Status Error code (to be transferred in case of failure), |
| * while err tracks our internal WEAVE_ERROR, which should never be transmitted. |
| * |
| * @param[in] anEc ExchangeContext to be associated with this send init |
| * @param[in] aPktInfo Unused here, but needs to match 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] aPayload The packed message itself |
| */ |
| //TODO: pull in documentation from WeaveExchangeMgr.h::MessageReceiveFunct |
| void BdxNode::HandleSendInit(ExchangeContext *anEc, const IPPacketInfo *aPktInfo, |
| const WeaveMessageInfo *aWeaveMsgInfo, |
| uint32_t aProfileId, uint8_t aMessageType, |
| PacketBuffer *aPayload) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint16_t statusCode = kStatus_Success; |
| BdxNode * bdxApp; |
| BDXTransfer *xfer = NULL; |
| bool success = false; |
| |
| SendInit sendInit; |
| // Set version early in case we exit before parsing. This allows us to send |
| // the reject corresponding to the BDX version we're using. |
| sendInit.mVersion = WEAVE_CONFIG_BDX_VERSION; |
| |
| WeaveLogDetail(BDX, "HandleSendInit entering"); |
| |
| VerifyOrExit(anEc != NULL, err = WEAVE_ERROR_INCORRECT_STATE; statusCode = kStatus_ServerBadState); |
| |
| VerifyOrExit(aProfileId == kWeaveProfile_BDX, err = WEAVE_ERROR_INVALID_PROFILE_ID; statusCode = kStatus_BadMessageContents); |
| VerifyOrExit(aMessageType == kMsgType_SendInit, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE; statusCode = kStatus_BadMessageContents); |
| |
| // Parse init request and discard payload buffer |
| err = SendInit::parse(aPayload, sendInit); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| statusCode = kStatus_BadMessageContents; |
| WeaveLogDetail(BDX, "Error: HandleSendInit: Unable to parse Send Init request: %d", err)); |
| PacketBuffer::Free(aPayload); |
| aPayload = NULL; |
| |
| bdxApp = static_cast<BdxNode *>(anEc->AppState); |
| |
| VerifyOrExit(bdxApp->CanBdxTransferRun(), |
| err = WEAVE_ERROR_INCORRECT_STATE; statusCode = kStatus_ServerBadState); |
| |
| // Grab BDXTransfer object for this transfer |
| err = bdxApp->InitTransfer(anEc, xfer); |
| VerifyOrExit(err == WEAVE_NO_ERROR && xfer != NULL, |
| err = WEAVE_ERROR_NO_MEMORY; statusCode = kStatus_ServerBadState); |
| |
| // Configure xfer object |
| xfer->mIsAccepted = false; |
| xfer->mMaxBlockSize = sendInit.mMaxBlockSize; |
| xfer->mAmInitiator = false; |
| xfer->mAmSender = false; |
| xfer->mVersion = (sendInit.mVersion > WEAVE_CONFIG_BDX_VERSION) ? WEAVE_CONFIG_BDX_VERSION : sendInit.mVersion; |
| |
| // Fire application callback to validate request and setup transfer |
| // Application should set the transfer mode and accept the transfer. |
| VerifyOrExit(bdxApp->mSendInitHandler, |
| err = WEAVE_ERROR_NO_MESSAGE_HANDLER; statusCode = kStatus_ServerBadState); |
| |
| statusCode = bdxApp->mSendInitHandler(xfer, &sendInit); |
| VerifyOrExit(statusCode == kStatus_Success, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| // Validate the requested transfer mode |
| VerifyOrExit(!(((xfer->mTransferMode == kMode_ReceiverDrive) && !sendInit.mReceiverDriveSupported) || |
| ((xfer->mTransferMode == kMode_SenderDrive) && !sendInit.mSenderDriveSupported) || |
| ((xfer->mTransferMode == kMode_Asynchronous))), |
| //TODO: merge this up one line when async supported: && !sendInit.mAsynchronousModeSupported) |
| err = WEAVE_ERROR_INVALID_TRANSFER_MODE; statusCode = kStatus_ServerBadState); |
| |
| WeaveLogDetail(BDX, "HandleSendInit validated request\n"); |
| |
| err = SendSendAccept(anEc, xfer); |
| VerifyOrExit(err == WEAVE_NO_ERROR, statusCode = kStatus_FailureToSend); |
| |
| WeaveLogDetail(BDX, "HandleSendInit exiting (success)\n"); |
| success = true; |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogError(BDX, "HandleSendInit exiting on failure: %s\n", ErrorStr(err)); |
| } |
| |
| if (aPayload) |
| { |
| PacketBuffer::Free(aPayload); |
| } |
| |
| if (!success) |
| { |
| if (statusCode != kStatus_BadMessageContents) |
| { |
| // Send a reject if we didn't succeed at handling the receive init |
| err = SendReject(anEc, sendInit.mVersion, statusCode, kMsgType_SendReject); |
| if (err != WEAVE_NO_ERROR) |
| { |
| WeaveLogDetail(BDX, "Sending reject message failed : %d", err); |
| } |
| } |
| |
| if (xfer != NULL) |
| { |
| xfer->Shutdown(); |
| } |
| else |
| { |
| // Transfer object uninitialized, so we do this manually |
| if (anEc != NULL) |
| { |
| if (anEc->Con != NULL) |
| { |
| anEc->Con->Close(); |
| anEc->Con = NULL; |
| } |
| |
| anEc->Close(); |
| anEc = NULL; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Function to send a reject message with the specified error. |
| */ |
| WEAVE_ERROR BdxNode::SendReject(ExchangeContext *anEc, uint8_t aVersion, uint16_t anErr, uint8_t aMsgType) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| StatusReport rejectStatus; |
| PacketBuffer* responsePayload = NULL; |
| uint16_t flags = 0; |
| |
| VerifyOrExit(aMsgType == kMsgType_SendReject || aMsgType == kMsgType_ReceiveReject, |
| err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| WeaveLogDetail(BDX, "%s sending Reject due to error: %d", __FUNCTION__, anErr); |
| |
| err = rejectStatus.init(kWeaveProfile_BDX, anErr); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendReject error calling Init on rejectStatus: %d", err)); |
| |
| responsePayload = PacketBuffer::New(); |
| VerifyOrExit(responsePayload != NULL, |
| err = WEAVE_ERROR_NO_MEMORY; WeaveLogDetail(BDX, "SendReject couldn't grab PacketBuffer")); |
| |
| err = rejectStatus.pack(responsePayload); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendReject couldn't pack rejectStatus: %d", err)); |
| |
| flags = GetBDXAckFlag(anEc); |
| if (aVersion == 0) |
| { |
| err = anEc->SendMessage(kWeaveProfile_BDX, aMsgType, responsePayload, flags); |
| } |
| else if (aVersion == 1) |
| { |
| err = anEc->SendMessage(kWeaveProfile_Common, Common::kMsgType_StatusReport, responsePayload, flags); |
| } |
| else |
| { |
| err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION; |
| } |
| |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendReject error sending reject message: %d", err)); |
| |
| responsePayload = NULL; |
| |
| exit: |
| if (responsePayload) |
| { |
| PacketBuffer::Free(responsePayload); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * Function to send a receive accept for the given transfer |
| */ |
| WEAVE_ERROR BdxNode::SendReceiveAccept(ExchangeContext *anEc, BDXTransfer *aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| ReceiveAccept receiveAccept; |
| PacketBuffer* payload = NULL; |
| uint16_t flags; |
| |
| // Send a ReceiveAccept response back to the receiver. |
| err = receiveAccept.init(aXfer->mVersion, aXfer->mTransferMode, aXfer->mMaxBlockSize, aXfer->mLength, NULL); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendReceiveAccept error calling Init on receiveAccept: %d", err)); |
| |
| payload = PacketBuffer::New(); |
| VerifyOrExit(payload != NULL, |
| err = WEAVE_ERROR_NO_MEMORY; |
| WeaveLogDetail(BDX, "SendReceiveAccept error grabbing PacketBuffer")); |
| |
| err = receiveAccept.pack(payload); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendReceiveAccept error packing receiveAccept : %d\n", err)); |
| |
| // Set ourselves up to handle first BlockQueryRequest. |
| anEc->OnMessageReceived = BdxProtocol::HandleResponse; |
| |
| // Expect a response if we are not the driver |
| flags = aXfer->GetDefaultFlags(!aXfer->IsDriver()); |
| |
| err = anEc->SendMessage(kWeaveProfile_BDX, kMsgType_ReceiveAccept, payload, flags); |
| payload = NULL; |
| VerifyOrExit(err == WEAVE_NO_ERROR, WeaveLogDetail(BDX, "SendReceiveAccept error sending accept message: %d", err)); |
| |
| // Send first block if we're driving |
| if (aXfer->IsDriver()) |
| { |
| WeaveLogDetail(BDX, "ReceiveAccept sent: Am driving so sending first block"); |
| if (aXfer->mVersion == 1) |
| { |
| err = BdxProtocol::SendNextBlockV1(*aXfer); |
| } |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| else if (aXfer->mVersion == 0) |
| { |
| err = BdxProtocol::SendNextBlock(*aXfer); |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| else |
| { |
| err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION; |
| } |
| |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "Error sending first block in SendReceiveAccept: %d", err)); |
| } |
| |
| exit: |
| if (payload) |
| { |
| PacketBuffer::Free(payload); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * Function to send a send accept for the given transfer |
| */ |
| WEAVE_ERROR BdxNode::SendSendAccept(ExchangeContext *anEc, BDXTransfer *aXfer) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| SendAccept sendAccept; |
| PacketBuffer* payload = NULL; |
| uint16_t flags; |
| |
| // Send a ReceiveAccept response back to the receiver. |
| err = sendAccept.init(aXfer->mVersion, aXfer->mTransferMode, aXfer->mMaxBlockSize, NULL); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendSendAccept error calling Init on sendAccept: %d", err)); |
| |
| payload = PacketBuffer::New(); |
| VerifyOrExit(payload != NULL, |
| err = WEAVE_ERROR_NO_MEMORY; |
| WeaveLogDetail(BDX, "SendSendAccept error grabbing PacketBuffer")); |
| |
| err = sendAccept.pack(payload); |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendSendAccept error packing sendAccept : %d\n", err)); |
| |
| // Set ourselves up to handle first BlockQueryRequest. |
| anEc->OnMessageReceived = BdxProtocol::HandleResponse; |
| |
| // Expect a response if we are not the driver |
| flags = aXfer->GetDefaultFlags(!aXfer->IsDriver()); |
| |
| err = anEc->SendMessage(kWeaveProfile_BDX, kMsgType_SendAccept, payload, flags); |
| payload = NULL; |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "SendSendAccept error sending accept message: %d", err)); |
| |
| // Send a block query if we're driving |
| if (aXfer->IsDriver()) |
| { |
| WeaveLogDetail(BDX, "SendAccept sent: Am driving so sending first block query"); |
| if (aXfer->mVersion == 1) |
| { |
| err = BdxProtocol::SendBlockQueryV1(*aXfer); |
| } |
| #if WEAVE_CONFIG_BDX_V0_SUPPORT |
| else if (aXfer->mVersion == 0) |
| { |
| err = BdxProtocol::SendBlockQuery(*aXfer); |
| } |
| #endif // WEAVE_CONFIG_BDX_V0_SUPPORT |
| else |
| { |
| err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION; |
| } |
| |
| VerifyOrExit(err == WEAVE_NO_ERROR, |
| WeaveLogDetail(BDX, "Error sending first block query in SendSendAccept: %d", err)); |
| } |
| |
| exit: |
| if (payload) |
| { |
| PacketBuffer::Free(payload); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_BDX_SERVER_SUPPORT |
| |
| } // namespace BulkDataTransfer |
| } // namespace Profiles |
| } // namespace Weave |
| } // namespace nl |
