| /* |
| * |
| * Copyright (c) 2016-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 |
| * |
| * @brief |
| * Impementations for the ProtocolEngine class. |
| * |
| * This file implements common methods and callbacks for the WDM |
| * ProtocoleEngine, most applicable to both client and publisher. |
| * |
| * ProtocolEngine is not, in itself, part of the publish interface to |
| * WDM but it provides the basis of that interface. |
| */ |
| |
| #include <Weave/Profiles/data-management/Legacy/WdmManagedNamespace.h> |
| |
| #include <Weave/Support/CodeUtils.h> |
| |
| #include <Weave/Profiles/data-management/DataManagement.h> |
| #include <SystemLayer/SystemStats.h> |
| |
| using namespace ::nl::Inet; |
| |
| using namespace ::nl::Weave::TLV; |
| using namespace ::nl::Weave::Profiles; |
| using namespace ::nl::Weave::Profiles::Common; |
| using namespace ::nl::Weave::Profiles::DataManagement; |
| |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| using namespace ::nl::Weave::Profiles::ServiceDirectory; |
| #endif |
| |
| using namespace ::nl::Weave::Profiles::StatusReporting; |
| |
| using nl::Weave::WeaveConnection; |
| using nl::Weave::ExchangeContext; |
| using nl::Weave::ExchangeMgr; |
| using nl::Weave::WeaveMessageInfo; |
| |
| static void TxnResponseHandler(ExchangeContext *anExchangeCtx, |
| const IPPacketInfo *anAddrInfo, |
| const WeaveMessageInfo *aMsgInfo, |
| uint32_t aProfileId, |
| uint8_t aMsgType, |
| PacketBuffer *aMsg) |
| { |
| ProtocolEngine::DMTransaction *txn = static_cast<ProtocolEngine::DMTransaction *>(anExchangeCtx->AppState); |
| |
| txn->OnMsgReceived(aMsgInfo->SourceNodeId, aProfileId, aMsgType, aMsg); |
| } |
| |
| static void TxnTimeoutHandler(ExchangeContext *anExchangeCtx) |
| { |
| ProtocolEngine::DMTransaction *txn = static_cast<ProtocolEngine::DMTransaction *>(anExchangeCtx->AppState); |
| |
| txn->OnResponseTimeout(anExchangeCtx->PeerNodeId); |
| } |
| |
| WEAVE_ERROR DataManagement::SendStatusReport(ExchangeContext *aExchangeCtx, StatusReport &aStatus) |
| { |
| WEAVE_ERROR err; |
| PacketBuffer *buf = PacketBuffer::New(); |
| uint16_t sendFlags = 0; |
| |
| VerifyOrExit(buf != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = aStatus.pack(buf); |
| SuccessOrExit(err); |
| |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| if (aExchangeCtx->HasPeerRequestedAck()) |
| { |
| sendFlags = ExchangeContext::kSendFlag_RequestAck; |
| } |
| #endif |
| |
| err = aExchangeCtx->SendMessage(kWeaveProfile_Common, kMsgType_StatusReport, |
| buf, sendFlags); |
| buf = NULL; |
| SuccessOrExit(err); |
| |
| exit: |
| |
| if (buf) |
| { |
| PacketBuffer::Free(buf); |
| } |
| |
| return err; |
| } |
| |
| void ProtocolEngine::DMTransaction::OnMsgReceived(const uint64_t &aResponderId, |
| uint32_t aProfileId, |
| uint8_t aMsgType, |
| PacketBuffer *aMsg) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| StatusReport report; |
| |
| if (aProfileId == kWeaveProfile_StatusReport_Deprecated || (aProfileId == kWeaveProfile_Common && aMsgType == kMsgType_StatusReport)) |
| { |
| err = StatusReport::parse(aMsg, report); |
| SuccessOrExit(err); |
| |
| if (report.mProfileId == kWeaveProfile_Common && report.mStatusCode == kStatus_Relocated) |
| { |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| /* |
| * here, the message is, specifically, a status report |
| * from the service explaining that the client needs |
| * to go find another service tier. so, we unresolve |
| * the service directory in preparation for whatever |
| * comes next. |
| */ |
| |
| Binding *svcBinding = mEngine->GetBinding(kServiceEndpoint_Data_Management); |
| |
| VerifyOrExit(svcBinding && svcBinding->mServiceMgr, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| svcBinding->mServiceMgr->unresolve(); |
| #endif |
| } |
| |
| OnStatusReceived(aResponderId, report); |
| } |
| |
| else if (aProfileId == kWeaveProfile_WDM || aProfileId == kWeaveProfile_Common) |
| { |
| OnResponseReceived(aResponderId, aMsgType, aMsg); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_INVALID_PROFILE_ID; |
| } |
| |
| exit: |
| |
| PacketBuffer::Free(aMsg); |
| |
| if (err != WEAVE_NO_ERROR) |
| OnError(aResponderId, err); |
| } |
| |
| /* |
| * the default here is that we don't receive a response. for |
| * transactions in which a response is expected, this method is |
| * overridden elsewhere. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::DMTransaction::OnResponseReceived(const uint64_t &aResponderId, uint8_t aMsgType, PacketBuffer *aMsg) |
| { |
| OnError(aResponderId, WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| |
| return WEAVE_ERROR_INVALID_MESSAGE_TYPE; |
| } |
| |
| void ProtocolEngine::DMTransaction::OnResponseTimeout(const uint64_t &aResponderId) |
| { |
| OnError(aResponderId, WEAVE_ERROR_TIMEOUT); |
| } |
| |
| |
| WEAVE_ERROR ProtocolEngine::DMTransaction::Init(ProtocolEngine *aEngine, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| mEngine = aEngine; |
| mTxnId = aTxnId; |
| mTimeout = aTimeout; |
| |
| mExchangeCtx = NULL; |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| mUseLegacyMsgType = false; |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void ProtocolEngine::DMTransaction::Free(void) |
| { |
| mEngine = NULL; |
| mTxnId = kTransactionIdNotSpecified; |
| mTimeout = kResponseTimeoutNotSpecified; |
| mExchangeCtx = NULL; |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| mUseLegacyMsgType = false; |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| } |
| |
| bool ProtocolEngine::DMTransaction::IsFree(void) |
| { |
| return mEngine == NULL; |
| } |
| |
| WEAVE_ERROR ProtocolEngine::DMTransaction::Start(uint8_t aTransport) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| PacketBuffer* buf = PacketBuffer::New(); |
| |
| uint16_t flags = ExchangeContext::kSendFlag_ExpectResponse; |
| |
| VerifyOrExit(buf, err = WEAVE_ERROR_NO_MEMORY); |
| |
| mExchangeCtx->ResponseTimeout = mTimeout; |
| mExchangeCtx->OnMessageReceived = TxnResponseHandler; |
| mExchangeCtx->OnResponseTimeout = TxnTimeoutHandler; |
| |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| if (aTransport == kTransport_WRMP) |
| flags |= ExchangeContext::kSendFlag_RequestAck; |
| #endif |
| |
| err = SendRequest(buf, flags); |
| buf = NULL; |
| |
| exit: |
| |
| if (buf) |
| { |
| PacketBuffer::Free(buf); |
| } |
| |
| return err; |
| } |
| |
| WEAVE_ERROR ProtocolEngine::DMTransaction::Finalize(void) |
| { |
| if (!IsFree()) |
| { |
| if (mEngine) |
| { |
| mEngine->DequeueTransaction(this); |
| } |
| |
| if (mExchangeCtx) |
| mExchangeCtx->Close(); |
| |
| Free(); |
| } |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void ProtocolEngine::DMTransaction::OnError(const uint64_t &aResponderId, WEAVE_ERROR aError) |
| { |
| StatusReport report; |
| report.init(aError); |
| |
| OnStatusReceived(aResponderId, report); |
| }; |
| |
| ProtocolEngine::ProtocolEngine(void) |
| { |
| Clear(); |
| } |
| |
| ProtocolEngine::~ProtocolEngine(void) |
| { |
| Finalize(); |
| } |
| |
| WEAVE_ERROR ProtocolEngine::Init(WeaveExchangeManager *aExchangeMgr) |
| { |
| return Init(aExchangeMgr, kResponseTimeoutNotSpecified); |
| } |
| |
| WEAVE_ERROR ProtocolEngine::Init(WeaveExchangeManager *aExchangeMgr, uint32_t aResponseTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if (mExchangeMgr != NULL) |
| { |
| err = WEAVE_ERROR_INCORRECT_STATE; |
| } |
| |
| else if (aExchangeMgr == NULL) |
| { |
| err = WEAVE_ERROR_INVALID_ARGUMENT; |
| } |
| |
| else |
| { |
| mExchangeMgr = aExchangeMgr; |
| mResponseTimeout = aResponseTimeout; |
| } |
| |
| return err; |
| } |
| |
| void ProtocolEngine::Finalize(void) |
| { |
| FinalizeBindingTable(); |
| |
| FinalizeTransactionTable(); |
| |
| Clear(); |
| } |
| |
| void ProtocolEngine::Clear(void) |
| { |
| mExchangeMgr = NULL; |
| mResponseTimeout = kResponseTimeoutNotSpecified; |
| |
| ClearBindingTable(); |
| |
| ClearTransactionTable(); |
| } |
| |
| /** |
| * @brief |
| * Request a binding using a known peer node ID and transport |
| * specifier. |
| * |
| * Given a peer node ID and a transport specification this request sets up |
| * a binding to that peer. The biding will require additional completion |
| * ONLY if the transport is TCP. If a binding to the peer is already present, |
| * it is re-used. |
| * |
| * @sa #WeaveTransportOption |
| * |
| * @param [in] aPeerNodeId A reference to the 64-bit node ID |
| * of the peer entity that is the |
| * binding target. |
| * |
| * @param [in] aTransport The transport to use. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * the binding table is full. Otherwise return a #WEAVE_ERROR |
| * reflecting a failure to initialize the binding. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::BindRequest(const uint64_t &aPeerNodeId, uint8_t aTransport) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| Binding *b; |
| |
| /* |
| * if a binding is already there then re-use it. it is, i think, |
| * way too complicated to maintain bindings with different |
| * protocols to the sam enode so we're just not going to sdupport |
| * it unless someone can think of a real use case for it. |
| */ |
| |
| b = GetBinding(aPeerNodeId); |
| |
| if (b) |
| { |
| err = WEAVE_NO_ERROR; |
| } |
| |
| else |
| { |
| b = NewBinding(); |
| |
| if (b) |
| err = b->Init(aPeerNodeId, aTransport); |
| } |
| |
| return err; |
| } |
| |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| /** |
| * @brief |
| * Request a binding to the Weave service's WDM endpoint. |
| * |
| * Often devices will want to engage in WDM exchanges with the Weave |
| * service. Bindings established in this way must be completed using |
| * the service manager. |
| * |
| * @param [in] aServiceMgr A pointer to a service manager |
| * instance to be used in subsequent |
| * communications with the Weave |
| * service. |
| * |
| * @param [in] aAuthMode The authentication mode to employ |
| * in making requests to the service. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * the binding table is full. Otherwise return a #WEAVE_ERROR |
| * reflecting a failure to initialize the binding. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::BindRequest(WeaveServiceManager *aServiceMgr, WeaveAuthMode aAuthMode) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| Binding *b; |
| |
| /* |
| * if a binding is already there then re-use it. |
| */ |
| |
| b = GetBinding(kServiceEndpoint_Data_Management); |
| |
| if (b) |
| err = WEAVE_NO_ERROR; |
| |
| else |
| { |
| b = NewBinding(); |
| |
| if (b) |
| err = b->Init(kServiceEndpoint_Data_Management, aServiceMgr, aAuthMode); |
| } |
| |
| return err; |
| } |
| #endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| |
| /** |
| * @brief |
| * Request a binding using an active Weave connection. |
| * |
| * A binding may also be established using an existing, and open, |
| * connection. Note that bindings that are established in this way |
| * require no additional completion. |
| * |
| * @param [in] aConnection A Pointer to a Weave connection to |
| * be used by the binding. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * the binding table is full. Otherwise return an error reflecting a |
| * failure to inititialize the binding. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::BindRequest(WeaveConnection *aConnection) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| Binding *b; |
| |
| /* |
| * if a binding is already there then re-use it. |
| */ |
| |
| b = GetBinding(aConnection->PeerNodeId); |
| |
| if (b) |
| err = WEAVE_NO_ERROR; |
| |
| else |
| { |
| b = NewBinding(); |
| |
| if (b) |
| err = b->Init(aConnection); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Handle confirmation that a bind request has been successfully |
| * completed. |
| * |
| * Once a binding has been completed, the protocol engine goes through |
| * the transaction table and starts any transactions that are dependent |
| * on that binding. |
| * |
| * @param [in] aBinding A pointer to the completed binding. |
| * |
| * @return #WEAVE_NO_ERROR On success. Otherwise return a |
| * #WEAVE_ERROR reflecting an inability to start a transaction. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::BindConfirm(Binding *aBinding) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| TransactionTableEntry *item; |
| DMTransaction *txn; |
| ExchangeContext *ctx = NULL; |
| |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| item = &(mTransactionTable[i]); |
| txn = item->mTransaction; |
| |
| if (txn && item->mBinding == aBinding) |
| { |
| |
| ctx = aBinding->GetExchangeCtx(mExchangeMgr, txn); |
| VerifyOrExit(ctx, err = WEAVE_ERROR_NO_MEMORY); |
| |
| /* |
| * assign the exchange context here ONLY if you actually |
| * managed to make one. |
| */ |
| |
| txn->mExchangeCtx = ctx; |
| |
| err = txn->Start(aBinding->mTransport); |
| SuccessOrExit(err); |
| } |
| } |
| |
| exit: |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (!item->IsFree()) |
| item->Free(); |
| |
| if (ctx && !txn->IsFree()) |
| txn->OnError(aBinding->mPeerNodeId, err); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Handle confirmation that a bind request has failed. |
| * |
| * When a bind request fails, the protocol engine must go through the |
| * transaction table and fail any transactions depending on the |
| * binding. |
| * |
| * @param [in] aBinding A pointer to the failed binding. |
| * |
| * @param [in] aReport A reference to a StatusReport |
| * object detailing the reason for |
| * failure. |
| * |
| * @return #WEAVE_NO_ERROR. |
| */ |
| |
| WEAVE_ERROR ProtocolEngine::BindConfirm(Binding *aBinding, StatusReport &aReport) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| FailTransactions(aBinding, aReport); |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Request that a binding be undone and removed from the binding |
| * table. |
| * |
| * When a binding is "unbound" any transactions that currently depend |
| * on it should be removed as well. This method finalizes |
| * all transactions with this binding automatically. |
| * |
| * @param[in] aPeerNodeId A reference to the 64-bit node ID or |
| * service endpoint that identifies the binding. |
| * |
| * @param[in] aErr WEAVE_NO_ERROR if there is no specific reason for this |
| * unbind request, otherwise the cause of error would be passed down. |
| * |
| * @sa UnbindRequest(const uint64_t) |
| */ |
| |
| void ProtocolEngine::UnbindRequest(const uint64_t &aPeerNodeId, WEAVE_ERROR aErr) |
| { |
| for (int i = 0; i < kBindingTableSize; i++) |
| { |
| Binding &b = mBindingTable[i]; |
| |
| if (b.mPeerNodeId == aPeerNodeId) |
| { |
| FinalizeTransactions(&b); |
| |
| b.Finalize(aErr); |
| |
| break; |
| } |
| } |
| } |
| |
| /** |
| * @brief |
| * Request that a binding be undone and removed from the binding |
| * table. |
| * |
| * When a binding is "unbound" any transactions that currently depend |
| * on it should be removed as well. This method finalizes |
| * all transactions with this binding automatically. |
| * |
| * @param[in] aPeerNodeId A reference to the 64-bit node ID or |
| * service endpoint that identifies the binding. |
| * |
| * @sa UnbindRequest(const uint64_t, WEAVE_ERROR) |
| */ |
| |
| void ProtocolEngine::UnbindRequest(const uint64_t &aPeerNodeId) |
| { |
| UnbindRequest(aPeerNodeId, WEAVE_NO_ERROR); |
| } |
| |
| /** |
| * @brief |
| * Handle an indication that a binding has failed. |
| * |
| * When a binding becomes incomplete, i.e. when the connection is |
| * closed for a TCP binding, the protocol engine must fail any |
| * transactions that depend on it, which includes calling their status |
| * handlers. Also, the incomplete indication is passed up to any |
| * superclass object implementing the alternate form of this method |
| * that takes a peer ID. |
| * |
| * @param [in] aBinding A pointer to the failed binding. |
| * |
| * @param [in] aReport A reference to a StatusReport |
| * object detailing the reason for |
| * failure. |
| */ |
| |
| void ProtocolEngine::IncompleteIndication(Binding *aBinding, StatusReport &aReport) |
| { |
| bool indicated = FailTransactions(aBinding, aReport); |
| |
| if (!indicated) |
| IncompleteIndication(aBinding->mPeerNodeId, aReport); |
| } |
| |
| Binding *ProtocolEngine::FromExchangeCtx(ExchangeContext *aExchangeCtx) |
| { |
| WeaveConnection *con = aExchangeCtx->Con; |
| uint64_t peerId = aExchangeCtx->PeerNodeId; |
| Binding *binding = GetBinding(peerId); |
| |
| if (!binding) |
| { |
| binding = NewBinding(); |
| |
| if (binding) |
| { |
| if (con) |
| { |
| binding->Init(con); |
| } |
| |
| else |
| { |
| /* |
| * the problem is that there's not really a good way to tell |
| * if you're using WRMP. so... for now i'm using the protocol |
| * version. |
| */ |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| if (aExchangeCtx->mMsgProtocolVersion == kWeaveMessageVersion_V2) |
| { |
| binding->Init(peerId, kTransport_WRMP); |
| } |
| else |
| #endif |
| { |
| binding->Init(peerId, kTransport_UDP); |
| } |
| } |
| } |
| } |
| |
| return binding; |
| } |
| |
| Binding *ProtocolEngine::GetBinding(const uint64_t &aPeerNodeId) |
| { |
| Binding *retVal = NULL; |
| |
| if (aPeerNodeId != kNodeIdNotSpecified) |
| { |
| for (int i = 0; i < kBindingTableSize; i++) |
| { |
| Binding &b = mBindingTable[i]; |
| |
| if (b.mPeerNodeId == aPeerNodeId) |
| { |
| retVal = &b; |
| |
| break; |
| } |
| } |
| } |
| |
| return retVal; |
| } |
| |
| Binding *ProtocolEngine::NewBinding(void) |
| { |
| Binding *retVal = NULL; |
| |
| for (int i = 0; i < kBindingTableSize; i++) |
| { |
| Binding &b = mBindingTable[i]; |
| |
| if (b.IsFree()) |
| { |
| retVal = &b; |
| |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumBindings); |
| |
| break; |
| } |
| } |
| |
| return retVal; |
| } |
| |
| void ProtocolEngine::ClearBindingTable(void) |
| { |
| for (int i = 0; i < kBindingTableSize; i++) |
| mBindingTable[i].Free(); |
| |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumBindings); |
| } |
| |
| void ProtocolEngine::FinalizeBindingTable(void) |
| { |
| for (int i = 0; i < kBindingTableSize; i++) |
| { |
| Binding &binding = mBindingTable[i]; |
| |
| binding.Finalize(); |
| } |
| |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumBindings); |
| } |
| |
| WEAVE_ERROR ProtocolEngine::StartTransaction(DMTransaction *aTransaction, Binding *aBinding) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| ExchangeContext *ctx = NULL; |
| |
| VerifyOrExit(!aBinding->IsFree(), err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = EnqueueTransaction(aTransaction, aBinding); |
| SuccessOrExit(err); |
| |
| if (aBinding->IsComplete()) |
| { |
| ctx = aBinding->GetExchangeCtx(mExchangeMgr, aTransaction); |
| VerifyOrExit(ctx, err = WEAVE_ERROR_NO_MEMORY); |
| |
| /* |
| * assign the exchange context here ONLY if you actually |
| * managed to make one. |
| */ |
| |
| aTransaction->mExchangeCtx = ctx; |
| |
| err = aTransaction->Start(aBinding->mTransport); |
| } |
| |
| else |
| { |
| err = aBinding->CompleteRequest(this); |
| } |
| |
| exit: |
| |
| /* |
| * the reason we just call Finalize() here is to avoid, in some |
| * cases, double-invocation of the higher-layer error handling |
| * code, BUT, it is possible for this to happen anyway so, be |
| * prepared for it. |
| */ |
| |
| if (err != WEAVE_NO_ERROR) |
| aTransaction->Finalize(); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR ProtocolEngine::EnqueueTransaction(DMTransaction *aTxn, Binding *aBinding) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| TransactionTableEntry &entry = mTransactionTable[i]; |
| |
| if (entry.IsFree()) |
| { |
| err = WEAVE_NO_ERROR; |
| |
| entry.Init(aTxn, aBinding); |
| |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumTransactions); |
| |
| break; |
| } |
| } |
| |
| return err; |
| } |
| |
| void ProtocolEngine::DequeueTransaction(DMTransaction *aTransaction) |
| { |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| TransactionTableEntry &entry = mTransactionTable[i]; |
| |
| if (entry.mTransaction == aTransaction) |
| { |
| entry.Free(); |
| |
| break; |
| } |
| } |
| } |
| |
| void ProtocolEngine::FinalizeTransactions(Binding *aBinding) |
| { |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| TransactionTableEntry &entry = mTransactionTable[i]; |
| |
| if (entry.mBinding == aBinding) |
| entry.Finalize(); |
| } |
| } |
| |
| bool ProtocolEngine::FailTransactions(Binding *aBinding, StatusReport &aReport) |
| { |
| bool indicated = false; |
| |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| TransactionTableEntry &entry = mTransactionTable[i]; |
| |
| if (!entry.IsFree() && entry.mBinding == aBinding) |
| { |
| indicated = true; |
| |
| entry.Fail(aBinding->mPeerNodeId, aReport); |
| } |
| } |
| |
| return indicated; |
| } |
| |
| void ProtocolEngine::ClearTransactionTable(void) |
| { |
| for (int i = 0; i < kTransactionTableSize; i++) |
| |
| mTransactionTable[i].Free(); |
| |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumTransactions); |
| } |
| |
| void ProtocolEngine::FinalizeTransactionTable(void) |
| { |
| for (int i = 0; i < kTransactionTableSize; i++) |
| { |
| TransactionTableEntry &entry = mTransactionTable[i]; |
| |
| if (!entry.IsFree()) |
| { |
| Binding *binding = entry.mBinding; |
| |
| entry.Finalize(); |
| |
| binding->Finalize(); |
| } |
| } |
| } |
| |
| /* |
| * transaction table entries are pretty simple but the methods below |
| * encapsulate specific behaviors. in particular, Fail() fails the |
| * transaction only on the theory that transaction handlers have a |
| * privileged status. And, finalizing a transaction table entry |
| * finalizes the transaction but preserves the binding since these are |
| * intended to have a logner life-cycle. |
| */ |
| |
| void ProtocolEngine::TransactionTableEntry::Finalize(void) |
| { |
| if (!IsFree()) |
| { |
| if (mTransaction->mExchangeCtx) |
| mTransaction->mExchangeCtx->Close(); |
| |
| mTransaction->Free(); |
| |
| Free(); |
| } |
| } |
| |
| void ProtocolEngine::TransactionTableEntry::Fail(const uint64_t &aPeerId, StatusReport &aReport) |
| { |
| DMTransaction *txn = mTransaction; |
| |
| if (!IsFree()) |
| { |
| Free(); |
| |
| txn->OnStatusReceived(aPeerId, aReport); |
| } |
| } |
