| /* |
| * |
| * 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 |
| * Implementations for the abstract DMClient base class. |
| * |
| * This file contains implementations for the abstract DMClient base |
| * class, which serves as the basis for application-specific clients |
| * based on WDM. See the document, "Nest Weave-Data Management |
| * Protocol" document for a complete(ish) description. |
| */ |
| |
| #ifndef __STDC_FORMAT_MACROS |
| #define __STDC_FORMAT_MACROS |
| #endif // __STDC_FORMAT_MACROS |
| |
| #include <Weave/Profiles/data-management/Legacy/WdmManagedNamespace.h> |
| |
| #include <SystemLayer/SystemStats.h> |
| #include <Weave/Support/CodeUtils.h> |
| |
| #include <Weave/Profiles/data-management/DataManagement.h> |
| |
| using namespace ::nl; |
| using namespace ::nl::Inet; |
| using namespace ::nl::Weave; |
| using namespace ::nl::Weave::TLV; |
| using namespace ::nl::Weave::Profiles; |
| using namespace ::nl::Weave::Profiles::Common; |
| using namespace ::nl::Weave::Profiles::DataManagement; |
| using namespace ::nl::Weave::Profiles::StatusReporting; |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| // C++ requires this be declared here. |
| |
| ClientNotifier DMClient::sNotifier; |
| |
| #endif |
| |
| /** |
| * @brief |
| * The default constructor for DMClient objects. |
| * |
| * Clears all internal state. A DMClient requires further |
| * initialization with Init() before use. |
| */ |
| |
| DMClient::DMClient(void) |
| { |
| Clear(); |
| } |
| |
| /** |
| * @brief |
| * The destructor for DMClient objects. |
| * |
| * Clears all internal state and, if necessary cancels pending |
| * subscriptions. |
| */ |
| |
| DMClient::~DMClient(void) |
| { |
| Finalize(); |
| } |
| |
| /** |
| * @brief |
| * Clear the internal state associated with a DMClient object. |
| * |
| * In particular, this method clears all the client transaction |
| * pools. For clients that have been in use the Finalize() method is |
| * preferable since it also cancels subscriptions and cleans up the |
| * transaction and binding tables. |
| * |
| * @sa Finalize() |
| */ |
| |
| void DMClient::Clear(void) |
| { |
| int i; |
| |
| for (i = 0; i<kViewPoolSize; i++) |
| mViewPool[i].Free(); |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumViews); |
| |
| for (i = 0; i<kUpdatePoolSize; i++) |
| mUpdatePool[i].Free(); |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumUpdates); |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| for (i = 0; i<kSubscribePoolSize; i++) |
| mSubscribePool[i].Free(); |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumSubscribes); |
| |
| for (i = 0; i<kCancelSubscriptionPoolSize; i++) |
| mCancelSubscriptionPool[i].Free(); |
| SYSTEM_STATS_RESET(nl::Weave::System::Stats::kWDMClient_NumCancels); |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| } |
| |
| /** |
| * @brief |
| * Shut down an operating DMClient. |
| * |
| * Clears all the operating state associated with the client and |
| * removes all related subscriptions from the notifier. After a call |
| * to Finalize() a DMClient may be reinitialized simply by calling |
| * Init(). Finalize() is invoked by the DMClient destructor but may |
| * be called in the case where a DMClient requires cleanup, e.g. in |
| * case of failure or temporary shutdown, but may need to be |
| * reconstituted at some later time. |
| */ |
| |
| void DMClient::Finalize(void) |
| { |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| sNotifier.RemoveSubscription(kTopicIdNotSpecified, kNodeIdNotSpecified, this); |
| |
| #endif |
| |
| Clear(); |
| |
| ProtocolEngine::Finalize(); |
| } |
| |
| /** |
| * @brief |
| * Handle the "incompletion" of a binding in use by the client. |
| * |
| * When a binding fails unexpectedly, e.g. if the connection involved |
| * in the binding is closed, then this method is called. |
| * |
| * @param [in] aBinding A pointer to the Binding that has |
| * become incomplete. |
| * |
| * @param [in] aReport A reference to a status report |
| * giving a reason for the failure. |
| */ |
| |
| void DMClient::IncompleteIndication(Binding *aBinding, StatusReport &aReport) |
| { |
| ProtocolEngine::IncompleteIndication(aBinding, aReport); |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| sNotifier.FailSubscription(kTopicIdNotSpecified, aBinding->mPeerNodeId, this, aReport); |
| |
| #endif |
| } |
| |
| /** |
| * @name |
| * View methods. |
| * |
| * @brief |
| * View, under WDM, is used by a client to request a snapshot of |
| * specified data managed by a publisher. |
| * |
| * See Detailed Description for discussion of WDM request method |
| * signatures. |
| * |
| * @{ |
| */ |
| |
| /** |
| * @brief |
| * Request a view of published data. |
| * |
| * Request a view of data residing on and managed by a specified |
| * remote publisher. |
| * |
| * @param [in] aDestinationId A reference to the 64-bit |
| * node ID of the remote |
| * publisher. |
| * |
| * @param [in] aPathList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded path |
| * list indicating the requested |
| * data. |
| * |
| * @param [in] aTxnId, An identifier for the WDM |
| * transaction set up to manage |
| * this view operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the view response. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If a transaction couldn't be allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::ViewRequest(const uint64_t &aDestinationId, ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_INCORRECT_STATE; |
| Binding *binding = GetBinding(aDestinationId); |
| View *view; |
| |
| if (binding) |
| { |
| view = NewView(); |
| |
| if (view) |
| { |
| err = view->Init(this, aPathList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(view, binding); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Request a view of data on default publisher. |
| * |
| * Request a view of data residing on and managed by the "default" |
| * publisher, i.e. the first (or only) publisher in the client's |
| * binding table. |
| * |
| * @param [in] aPathList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded path |
| * list indicating the requested |
| * data. |
| * |
| * @param [in] aTxnId An identifier for the WDM |
| * transaction set up to manage |
| * this view operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the view response. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If a transaction couldn't be |
| * allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::ViewRequest(ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| View *view = NewView(); |
| |
| if (view) |
| { |
| err = view->Init(this, aPathList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(view); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @} |
| */ |
| |
| /** |
| * @name |
| * Subscribe methods. |
| * |
| * @brief |
| * Subscription, under WDM, is used by a client to request a |
| * snapshot of specified data managed by a publisher as with a |
| * view, but in addition requests notification when the data of |
| * interest changes, |
| * |
| * See Detailed Description for discussion of WDM request method |
| * signatures. |
| * |
| * @{ |
| */ |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| /** |
| * @brief |
| * Check if this client has a particular subscription with a |
| * specified publisher. |
| * |
| * @param [in] aTopicId A reference to a topic ID to |
| * search or. This may be a |
| * well-known ID or the "working" |
| * publisher-assigned ID and it |
| * may be the value kAnyTopicId |
| * in the case where the caller |
| * doesn't care. |
| * |
| * @param [in] aPublisherId A reference to the 64-bit node |
| * ID of a publisher to search |
| * for. This may have a value of |
| * kAnyNodeId in the case where |
| * the caller doesn't care. |
| * |
| * @return true if a match is found, false otherwise. |
| */ |
| |
| bool DMClient::HasSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId) |
| { |
| bool retVal = false; |
| |
| retVal = sNotifier.HasSubscription(aTopicId, aPublisherId, this); |
| |
| return retVal; |
| } |
| |
| /** |
| * @brief |
| * Start a subscription. |
| * |
| * This method installs a subscription to a particular assigned |
| * ID/requested ID pair in the notifier's subscription table with the |
| * current client as the client requiring notification. |
| * |
| * @param [in] aAssignedId A reference to the "working" topic ID |
| * assigned by the publisher. In |
| * the case where the |
| * subscription is unilateral |
| * this parameter shall have a |
| * value of |
| * kTopicIdNotSpecified. In the |
| * case where the a subscribe |
| * request has been sent to the |
| * publisher and no well-known ID |
| * has been supplied, the |
| * "working" topic ID is |
| * delivered as a parameter to |
| * the SubscribeConfirm() method |
| * that results form the receipt |
| * of a successful response. |
| * |
| * @param [in] aRequestedId A reference to a well-known |
| * topic ID given in the initial |
| * request. This parameter may |
| * take a value of |
| * kTopicIdNotSpecified in the |
| * case where there was no |
| * requested topic. |
| * |
| * @param [in] aPublisherId A reference to the 64-bit node |
| * ID of the publisher. |
| * |
| * @return #WEAVE_NO_ERROR On success. Otherwise return a |
| * #WEAVE_ERROR reflecting a failure to install the subscription. |
| */ |
| |
| WEAVE_ERROR DMClient::BeginSubscription(const TopicIdentifier &aAssignedId, const TopicIdentifier &aRequestedId, const uint64_t &aPublisherId) |
| { |
| WEAVE_ERROR err; |
| |
| err = sNotifier.InstallSubscription(aAssignedId, aRequestedId, aPublisherId, this); |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Stop, and remove, a subscription. |
| * |
| * Remove a subscription from the notifier's subscription table |
| * thereby stopping any future notifications from being delivered to |
| * this client. |
| * |
| * @note |
| * This method simply removes the subscription locally. To cancel a |
| * subscription that has been established using SubscribeRequest(), |
| * use CancelSubscriptionRequest(). |
| * |
| * @sa CancelSubscriptionRequest(const uint64_t &aDestinationId, const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| * |
| * @param [in] aTopicId A reference to a topic ID |
| * associated with the |
| * subscription. This may be the |
| * "working" ID or the requested |
| * ID. |
| * |
| * @param [in] aPublisherId A reference to the 64-bit node |
| * ID of the publisher. |
| * |
| * @return #WEAVE_NO_ERROR On success. Otherwise return a |
| * #WEAVE_ERROR reflecting a failure to remove the subscription. |
| */ |
| |
| WEAVE_ERROR DMClient::EndSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| sNotifier.RemoveSubscription(aTopicId, aPublisherId, this); |
| |
| return err; |
| |
| } |
| |
| /** |
| * @brief |
| * Request a subscription to a published topic from a specified |
| * publisher. |
| * |
| * Request a view of data residing on and managed by a specified |
| * remote publisher and request subsequent updates, at the discretion |
| * of the publisher in the case that the data changes. This version |
| * uses a known topic ID. |
| * |
| * @param [in] aDestinationId A reference to the 64-bit node |
| * ID of the remote publisher. |
| * |
| * @param [in] aTopicId A reference to a well-known |
| * topic identifier representing |
| * the requested data. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If a binding to the |
| * destination could not be found. |
| * |
| * @return #WEAVE_ERROR_NO_MEMORY If a transaction couldn't be allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::SubscribeRequest(const uint64_t &aDestinationId, const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| Binding *binding = GetBinding(aDestinationId); |
| Subscribe *subscribe; |
| |
| if (binding) |
| { |
| subscribe = NewSubscribe(); |
| |
| if (subscribe) |
| { |
| err = subscribe->Init(this, aTopicId, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(subscribe, binding); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_INCORRECT_STATE; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Request a subscription to a published topic on the default |
| * publisher. |
| * |
| * Request a view of data residing on and managed by the "default" |
| * publisher, i.e. the first (or only) publisher in the client's |
| * binding table request subsequent updates, at the discretion of the |
| * publisher in the case that the data changes. This version uses a |
| * known topic ID. |
| * |
| * @param [in] aTopicId A reference to a well-known |
| * topic identifier representing |
| * the requested data. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If a transaction couldn't be allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::SubscribeRequest(const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| Subscribe *subscribe = NewSubscribe(); |
| |
| if (subscribe) |
| { |
| err = subscribe->Init(this, aTopicId, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(subscribe); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Request a subscrption to published data from a specified |
| * publisher. |
| * |
| * Request a view of data residing on and managed by a specified |
| * remote publisher and request subsequent updates, at the discretion |
| * of the publisher in the case that the data changes. This version |
| * uses a path list to specify the data of interest. |
| * |
| * @param [in] aDestinationId A reference to the 64-bit node ID |
| * of the remote publisher. |
| * |
| * @param [in] aPathList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded path |
| * list representing the |
| * requested data. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @retval #WEAVE_NO_ERROR On success. |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If a binding to the |
| * destination could not be found. |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY If a transaction couldn't be allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::SubscribeRequest(const uint64_t &aDestinationId, ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| Binding *binding = GetBinding(aDestinationId); |
| Subscribe *subscribe; |
| |
| if (binding) |
| { |
| subscribe = NewSubscribe(); |
| |
| if (subscribe) |
| { |
| err = subscribe->Init(this, aPathList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(subscribe, binding); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_INCORRECT_STATE; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Request a subscription to data on the default publisher. |
| * |
| * Request a view of data residing on and managed by the "default" |
| * publisher, i.e. the first (or only) publisher in the client's |
| * binding table and request subsequent updates, at the discretion of |
| * the publisher in the case that the data changes. This version uses |
| * a path list to specify the data of interest. |
| * |
| * @param [in] aPathList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded path |
| * list representing the |
| * requested data. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @retval #WEAVE_NO_ERROR on success, |
| * |
| * @retval #WEAVE_ERROR_NO_MEMORY if a transaction couldn't be |
| * allocated. |
| * |
| * @return Otherwise, a #WEAVE_ERROR reflecting the failure to |
| * initialize or start the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::SubscribeRequest(ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| Subscribe *subscribe = NewSubscribe(); |
| |
| if (subscribe) |
| { |
| err = subscribe->Init(this, aPathList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(subscribe); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Cancel a subscription. |
| * |
| * Request the cancellation of a subscription from a given publisher, |
| * and remove the corresponding subscription from the local notifier |
| * table. |
| * |
| * @note |
| * This method should be used to cancel a subscription that has |
| * been establish using SubscribeRequest(). To simply remove a |
| * subscription locally, use EndSubscription(). |
| * |
| * @sa EndSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId) |
| * |
| * @param [in] aDestinationId A reference to the 64-bit node |
| * ID of the remote publisher to |
| * which the request is being |
| * sent. |
| * |
| * @param [in] aTopicId A reference to a topic ID for |
| * this subscription. Note this |
| * this may be either the |
| * publisher-assigned "working" |
| * ID or the well-known topic ID |
| * associated with the original |
| * request. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @return #WEAVE_NO_ERROR on success or a #WEAVE_ERROR reflecting |
| * a failure to cancel the subscription. |
| */ |
| |
| WEAVE_ERROR DMClient::CancelSubscriptionRequest(const uint64_t &aDestinationId, const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| Binding *binding; |
| |
| if (HasSubscription(aTopicId, aDestinationId)) |
| { |
| /* |
| * we should get rid of the subscription here and not rely |
| * on the publisher to respond before we get rid of it. this |
| * may result in a status message with "unknown topic" also |
| * being sent to the publisher, but it saves us from keeping |
| * the subscription around indefinitely if the publisher |
| * fails to respond or the packet gets lost. |
| */ |
| |
| sNotifier.RemoveSubscription(aTopicId, aDestinationId, this); |
| |
| binding = GetBinding(aDestinationId); |
| |
| if (binding) |
| { |
| CancelSubscription *cancel = NewCancelSubscription(); |
| |
| if (cancel) |
| { |
| err = cancel->Init(this, aTopicId, aTxnId, aTimeout); |
| |
| if (err == WEAVE_NO_ERROR) |
| err = StartTransaction(cancel, binding); |
| } |
| |
| else |
| |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_INCORRECT_STATE; |
| } |
| } |
| |
| /* |
| * if the subscription didn't exist, the NHL may |
| * still want a confirmation. |
| */ |
| |
| else |
| { |
| StatusReport s; |
| |
| s.init(kWeaveProfile_Common, kStatus_Success); |
| |
| err = CancelSubscriptionConfirm(aDestinationId, aTopicId, s, aTxnId); |
| } |
| |
| return err; |
| } |
| |
| /** |
| * @brief |
| * Cancel a subscription on the default publisher. |
| * |
| * Request the cancellation of a subscription on the "default" |
| * publisher, i.e. the first (or only) publisher in the client's |
| * binding table and remove the corresponding subscription from the |
| * local notifier table. |
| * |
| * @note |
| * This method should be used to cancel a subscription that has |
| * been establish using SubscribeRequest(). To simply remove a |
| * subscription locally, use EndSubscription(). |
| * |
| * @sa EndSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId) |
| * |
| * @param [in] aTopicId A reference to a topic ID for |
| * this subscription. Note this |
| * this may be either the |
| * publisher-assigned "working" |
| * ID or the well-known topic ID |
| * associated with the original |
| * request. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * this subscribe operation. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the subscribe |
| * response. |
| * |
| * @return #WEAVE_NO_ERROR on success or a #WEAVE_ERROR reflecting |
| * a failure to cancel the subscription. |
| */ |
| |
| WEAVE_ERROR DMClient::CancelSubscriptionRequest(const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_INCORRECT_STATE; |
| uint64_t &defaultPeer = mBindingTable[kDefaultBindingTableIndex].mPeerNodeId; |
| |
| if (defaultPeer != kNodeIdNotSpecified) |
| err = CancelSubscriptionRequest(defaultPeer, aTopicId, aTxnId, aTimeout); |
| |
| return err; |
| } |
| |
| /** |
| * @} |
| */ |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| /** |
| * @name |
| * Update methods. |
| * |
| * @brief |
| * Update, under WDM, is used by a client to request a |
| * change to specified data managed by a publisher. |
| * |
| * See Detailed Description for discussion of WDM request method |
| * signatures. |
| * |
| * @{ |
| */ |
| |
| /** |
| * @brief |
| * Request an update to published data. |
| * |
| * Request that a remote publisher update data under management. |
| * |
| * @param [in] aDestinationId A reference to the 64-bit node |
| * ID of the remote publisher to |
| * which the request is being |
| * sent. |
| * |
| * @param [in] aDataList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded data |
| * list containing a |
| * representation of the update |
| * including the paths to which |
| * the update is to be applied. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * the update request. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the corresponding |
| * status report. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * an update transaction could not be allocated. Otherwise, return a |
| * #WEAVE_ERROR reflecting an update failure. |
| */ |
| |
| WEAVE_ERROR DMClient::UpdateRequest(const uint64_t &aDestinationId, ReferencedTLVData &aDataList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_INCORRECT_STATE; |
| Binding *binding = GetBinding(aDestinationId); |
| Update *update; |
| |
| if (binding) |
| { |
| update = NewUpdate(); |
| |
| if (update) |
| { |
| err = update->Init(this, aDataList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(update, binding); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_INCORRECT_STATE; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /* |
| * if we're allowing old-style updates with the legacy message types, |
| * e.g. for Amber, then this is how it works. the "real" method just |
| * calls the compatibility method with the "use legacy msg type" flag |
| * set to false. in order to use the compatibility mode, use the call |
| * with the flag set to true. |
| */ |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| /** |
| * @brief |
| * Request an update to data on the default publisher. |
| * |
| * Request that a remote publisher update data under management. This |
| * version directs the request to the publisher that is the target of |
| * the client's default binding. |
| * |
| * @param [in] aDataList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded data |
| * list containing a |
| * representation of the update |
| * including the paths to which |
| * the update is to be applied. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * the update request. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the corresponding |
| * status report. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * an update transaction could not be allocated. Otherwise, return a |
| * #WEAVE_ERROR reflecting an update failure. |
| */ |
| |
| WEAVE_ERROR DMClient::UpdateRequest(ReferencedTLVData &aDataList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| return UpdateRequest(aDataList, aTxnId, aTimeout, false); |
| } |
| |
| |
| /** |
| * @brief |
| * Request an update to published data. |
| * |
| * Request that a remote publisher update data under management. This |
| * version takes a boolean selector for legacy message types - see |
| * DMConstants.h |
| * |
| * @param [in] aDataList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded data |
| * list containing a |
| * representation of the update |
| * including the paths to which |
| * the update is to be applied. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * the update request. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the corresponding |
| * status report. |
| * |
| * @param [in] aUseLegacyMsgType A control flag that should be |
| * true if the message is to be |
| * sent with the message type |
| * defined in the WDM spec. up |
| * through v1.2. Otherwise the |
| * message should be sent using |
| * the type defined in the WDM2.0 |
| * spec and beyond. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * an update transaction could not be allocated. Otherwise, return a |
| * #WEAVE_ERROR reflecting an update failure. |
| */ |
| |
| WEAVE_ERROR DMClient::UpdateRequest(ReferencedTLVData &aDataList, uint16_t aTxnId, uint32_t aTimeout, bool aUseLegacyMsgType) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| Update *update = NewUpdate(); |
| |
| if (update) |
| { |
| err = update->Init(this, aDataList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| update->mUseLegacyMsgType = aUseLegacyMsgType; |
| |
| err = StartTransaction(update); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /* |
| * otherwise, there's no compatiblity method defined. |
| */ |
| |
| #else // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| /** |
| * @brief |
| * Request an update to data on the default publisher. |
| * |
| * Request that a remote publisher update data under management. This |
| * version directs the request to the publisher that is the target of |
| * the client's default binding. |
| * |
| * @param [in] aDataList A reference to a |
| * ReferencedTLVData object |
| * containing a TLV-encoded data |
| * list containing a |
| * representation of the update |
| * including the paths to which |
| * the update is to be applied. |
| * |
| * @param [in] aTxnId An identifier for the |
| * transaction set up to manage |
| * the update request. |
| * |
| * @param [in] aTimeout A maximum time in milliseconds |
| * to wait for the corresponding |
| * status report. |
| * |
| * @return #WEAVE_NO_ERROR on success or #WEAVE_ERROR_NO_MEMORY if |
| * an update transaction could not be allocated. Otherwise, return a |
| * #WEAVE_ERROR reflecting an update failure. |
| */ |
| |
| WEAVE_ERROR DMClient::UpdateRequest(ReferencedTLVData &aDataList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY; |
| Update *update = NewUpdate(); |
| |
| if (update) |
| { |
| err = update->Init(this, aDataList, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| err = StartTransaction(update); |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_NO_MEMORY; |
| } |
| |
| exit: |
| return err; |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| /** |
| * @} |
| */ |
| |
| /** |
| * @brief |
| * Request that an executing transaction be canceled. |
| * This method doesn't generate network traffic, but just release resources allocated for |
| * the specified transaction(s) |
| * |
| * @param [in] aTxnId The number of the transaction |
| * to be canceled. If kTransactionIdNotSpecified is provided, |
| * all transactions would be canceled. |
| * |
| * @return #WEAVE_NO_ERROR on success or a #WEAVE_ERROR reflecting |
| * a failure to cancel the transaction. |
| */ |
| |
| WEAVE_ERROR DMClient::CancelTransactionRequest(uint16_t aTxnId, WEAVE_ERROR aError) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| int i; |
| |
| if (aTxnId == kTransactionIdNotSpecified) |
| { |
| for (i = 0; i<kViewPoolSize; i++) |
| mViewPool[i].Finalize(); |
| |
| for (i = 0; i<kUpdatePoolSize; i++) |
| mUpdatePool[i].Finalize(); |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| for (i = 0; i<kSubscribePoolSize; i++) |
| mSubscribePool[i].Finalize(); |
| |
| for (i = 0; i<kCancelSubscriptionPoolSize; i++) |
| mCancelSubscriptionPool[i].Finalize(); |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| } |
| |
| else |
| { |
| for (i = 0; i<kViewPoolSize; i++) |
| { |
| View &v = mViewPool[i]; |
| |
| if (!v.IsFree()) |
| VerifyOrExit(v.mTxnId != aTxnId, err = v.Finalize()); |
| } |
| |
| for (i = 0; i<kUpdatePoolSize; i++) |
| { |
| Update &u = mUpdatePool[i]; |
| |
| if (!u.IsFree()) |
| VerifyOrExit(u.mTxnId != aTxnId, err = u.Finalize()); |
| } |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| for (i = 0; i<kSubscribePoolSize; i++) |
| { |
| Subscribe &s = mSubscribePool[i]; |
| |
| if (!s.IsFree()) |
| VerifyOrExit(s.mTxnId != aTxnId, err = s.Finalize()); |
| } |
| |
| for (i = 0; i<kCancelSubscriptionPoolSize; i++) |
| { |
| CancelSubscription &c = mCancelSubscriptionPool[i]; |
| |
| if (!c.IsFree()) |
| VerifyOrExit(c.mTxnId != aTxnId, err = c.Finalize()); |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| } |
| |
| exit: |
| return err; |
| } |
| |
| /* |
| * the following transaction-related methods are not a part of the |
| * public interface to WDM and so are declared protected in DMClient.h |
| */ |
| |
| WEAVE_ERROR DMClient::View::Init(DMClient *aClient, ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| DMTransaction::Init(aClient, aTxnId, aTimeout); |
| |
| mPathList = aPathList; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void DMClient::View::Free(void) |
| { |
| DMTransaction::Free(); |
| |
| mPathList.free(); |
| |
| SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kWDMClient_NumViews); |
| } |
| |
| WEAVE_ERROR DMClient::View::SendRequest(PacketBuffer *aBuffer, uint16_t aSendFlags) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| VerifyOrExit(mExchangeCtx, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = mPathList.pack(aBuffer); |
| SuccessOrExit(err); |
| |
| err = mExchangeCtx->SendMessage(kWeaveProfile_WDM, kMsgType_ViewRequest, aBuffer, aSendFlags); |
| aBuffer = NULL; |
| |
| exit: |
| if (aBuffer != NULL) |
| { |
| PacketBuffer::Free(aBuffer); |
| } |
| |
| /* |
| * and free the path list since we're done with it. note |
| * that this ONLY does something substantive if the path |
| * list has an PacketBuffer associated with it. |
| */ |
| |
| mPathList.free(); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR DMClient::View::OnStatusReceived(const uint64_t &aResponderId, StatusReport &aStatus) |
| { |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| Finalize(); |
| |
| return client->ViewConfirm(aResponderId, aStatus, txnId); |
| } |
| |
| WEAVE_ERROR DMClient::View::OnResponseReceived(const uint64_t &aResponderId, uint8_t aMsgType, PacketBuffer *aMsg) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WEAVE_ERROR appErr = WEAVE_NO_ERROR; |
| |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| ReferencedTLVData dataList; |
| |
| VerifyOrExit(aMsgType == kMsgType_ViewResponse, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| |
| err = ReferencedTLVData::parse(aMsg, dataList); |
| SuccessOrExit(err); |
| |
| Finalize(); |
| |
| appErr = client->ViewConfirm(aResponderId, dataList, txnId); |
| |
| if (appErr != WEAVE_NO_ERROR) |
| WeaveLogError(DataManagement, "DMClient::ViewConfirm => %s", ErrorStr(appErr)); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| OnError(aResponderId, err); |
| |
| return err; |
| } |
| |
| DMClient::View *DMClient::NewView(void) |
| { |
| int i; |
| View *result = NULL; |
| |
| for (i = 0; i < kViewPoolSize; i++) |
| { |
| if (mViewPool[i].IsFree()) |
| { |
| result = &mViewPool[i]; |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumViews); |
| |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| WEAVE_ERROR DMClient::Subscribe::Init(DMClient *aClient, const TopicIdentifier &aTopicId, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if (aTopicId == kTopicIdNotSpecified) |
| { |
| err = WEAVE_ERROR_INVALID_ARGUMENT; |
| } |
| |
| else |
| { |
| DMTransaction::Init(aClient, aTxnId, aTimeout); |
| |
| mPathList.free(); |
| mTopicId = aTopicId; |
| } |
| |
| return err; |
| } |
| |
| WEAVE_ERROR DMClient::Subscribe::Init(DMClient *aClient, ReferencedTLVData &aPathList, uint16_t aTxnId, uint32_t aTimeout) |
| { |
| DMTransaction::Init(aClient, aTxnId, aTimeout); |
| |
| mTopicId = kTopicIdNotSpecified; |
| mPathList = aPathList; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void DMClient::Subscribe::Free(void) |
| { |
| DMTransaction::Free(); |
| |
| mTopicId = kTopicIdNotSpecified; |
| mPathList.free(); |
| |
| SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kWDMClient_NumSubscribes); |
| } |
| |
| WEAVE_ERROR DMClient::Subscribe::SendRequest(PacketBuffer *aBuffer, uint16_t aSendFlags) |
| { |
| WEAVE_ERROR err; |
| |
| VerifyOrExit(mExchangeCtx, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| { |
| MessageIterator i(aBuffer); |
| i.append(); |
| |
| err = i.write64(mTopicId); |
| SuccessOrExit(err); |
| |
| if (!mPathList.isEmpty()) |
| { |
| err = mPathList.pack(i); |
| SuccessOrExit(err); |
| } |
| } |
| |
| err = mExchangeCtx->SendMessage(kWeaveProfile_WDM, kMsgType_SubscribeRequest, aBuffer, aSendFlags); |
| aBuffer = NULL; |
| |
| exit: |
| if (aBuffer != NULL) |
| { |
| PacketBuffer::Free(aBuffer); |
| } |
| |
| /* |
| * and free the path list since we're done with it. note that this |
| * ONLY does something substantive if the path list has an |
| * PacketBuffer associated with it. |
| */ |
| |
| mPathList.free(); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR DMClient::Subscribe::OnStatusReceived(const uint64_t &aResponderId, StatusReport &aStatus) |
| { |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| Finalize(); |
| |
| return client->SubscribeConfirm(aResponderId, aStatus, txnId); |
| } |
| |
| WEAVE_ERROR DMClient::Subscribe::OnResponseReceived(const uint64_t &aResponderId, uint8_t aMsgType, PacketBuffer *aMsg) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WEAVE_ERROR appErr = WEAVE_NO_ERROR; |
| ReferencedTLVData dataList; |
| TopicIdentifier topicId; |
| |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| { |
| MessageIterator i(aMsg); |
| |
| VerifyOrExit(aMsgType == kMsgType_SubscribeResponse, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE); |
| |
| err = i.read64(&topicId); |
| SuccessOrExit(err); |
| |
| err = ReferencedTLVData::parse(i, dataList); |
| SuccessOrExit(err); |
| } |
| |
| /* |
| * install the subscription here rather than burdening higher layers with it. |
| */ |
| |
| err = client->BeginSubscription(topicId, mTopicId, aResponderId); |
| SuccessOrExit(err); |
| |
| /* |
| * if the subscription was requested under a well-known topic |
| * ID then pass that up to the client code rather than the |
| * publisher-assigned one. |
| */ |
| |
| if (mTopicId != kTopicIdNotSpecified) |
| topicId = mTopicId; |
| |
| Finalize(); |
| |
| if (dataList.isEmpty()) |
| appErr = client->SubscribeConfirm(aResponderId, topicId, txnId); |
| |
| else |
| appErr = client->SubscribeConfirm(aResponderId, topicId, dataList, txnId); |
| |
| if (appErr != WEAVE_NO_ERROR) |
| WeaveLogError(DataManagement, "DMClient::SubscribeConfirm => %s", ErrorStr(appErr)); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| OnError(aResponderId, err); |
| |
| return err; |
| } |
| |
| DMClient::Subscribe *DMClient::NewSubscribe(void) |
| { |
| int i; |
| Subscribe *result = NULL; |
| |
| for (i = 0; i < kSubscribePoolSize; i++) |
| { |
| if (mSubscribePool[i].IsFree()) |
| { |
| result = &mSubscribePool[i]; |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumSubscribes); |
| |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| WEAVE_ERROR DMClient::CancelSubscription::Init(DMClient *aClient, |
| const TopicIdentifier &aTopicId, |
| uint16_t aTxnId, |
| uint32_t aTimeout) |
| { |
| WEAVE_ERROR err; |
| |
| err = DMTransaction::Init(aClient, aTxnId, aTimeout); |
| SuccessOrExit(err); |
| |
| mTopicId = aTopicId; |
| |
| exit: |
| return err; |
| } |
| |
| void DMClient::CancelSubscription::Free(void) |
| { |
| DMTransaction::Free(); |
| |
| mTopicId = kTopicIdNotSpecified; |
| |
| SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kWDMClient_NumCancels); |
| } |
| |
| WEAVE_ERROR DMClient::CancelSubscription::SendRequest(PacketBuffer *aBuffer, uint16_t aSendFlags) |
| { |
| WEAVE_ERROR err; |
| |
| VerifyOrExit(mExchangeCtx, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| { |
| MessageIterator i(aBuffer); |
| i.append(); |
| |
| err = i.write64(mTopicId); |
| SuccessOrExit(err); |
| } |
| |
| err = mExchangeCtx->SendMessage(kWeaveProfile_WDM, kMsgType_CancelSubscriptionRequest, aBuffer, aSendFlags); |
| aBuffer = NULL; |
| |
| exit: |
| if (aBuffer != NULL) |
| { |
| PacketBuffer::Free(aBuffer); |
| } |
| |
| return err; |
| } |
| |
| WEAVE_ERROR DMClient::CancelSubscription::OnStatusReceived(const uint64_t &aResponderId, StatusReport &aStatus) |
| { |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| Finalize(); |
| |
| return client->CancelSubscriptionConfirm(aResponderId, mTopicId, aStatus, txnId); |
| } |
| |
| DMClient::CancelSubscription *DMClient::NewCancelSubscription(void) |
| { |
| int i; |
| CancelSubscription *result = NULL; |
| |
| for (i = 0; i < kCancelSubscriptionPoolSize; i++) |
| { |
| if (mCancelSubscriptionPool[i].IsFree()) |
| { |
| result = &mCancelSubscriptionPool[i]; |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumCancels); |
| |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| WEAVE_ERROR DMClient::Update::Init(DMClient *aClient, |
| ReferencedTLVData &aDataList, |
| uint16_t aTxnId, |
| uint32_t aTimeout) |
| { |
| DMTransaction::Init(aClient, aTxnId, aTimeout); |
| |
| mDataList = aDataList; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void DMClient::Update::Free(void) |
| { |
| DMTransaction::Free(); |
| |
| mDataList.free(); |
| |
| SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kWDMClient_NumUpdates); |
| } |
| |
| WEAVE_ERROR DMClient::Update::SendRequest(PacketBuffer *aBuffer, uint16_t aSendFlags) |
| { |
| WEAVE_ERROR err; |
| uint8_t msgType = kMsgType_UpdateRequest; |
| |
| VerifyOrExit(mExchangeCtx, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = mDataList.pack(aBuffer); |
| SuccessOrExit(err); |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| if (mUseLegacyMsgType) |
| msgType = kMsgType_UpdateRequest_Deprecated; |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| err = mExchangeCtx->SendMessage(kWeaveProfile_WDM, msgType, aBuffer, aSendFlags); |
| aBuffer = NULL; |
| |
| exit: |
| if (aBuffer != NULL) |
| { |
| PacketBuffer::Free(aBuffer); |
| } |
| |
| /* |
| * and free the data list since we're done with it. note |
| * that this ONLY does something substantive if the data |
| * list has an PacketBuffer associated with it. |
| */ |
| |
| mDataList.free(); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR DMClient::Update::OnStatusReceived(const uint64_t &aResponderId, StatusReport &aStatus) |
| { |
| DMClient *client = static_cast<DMClient *>(mEngine); |
| uint16_t txnId = mTxnId; |
| |
| Finalize(); |
| |
| return client->UpdateConfirm(aResponderId, aStatus, txnId); |
| } |
| |
| DMClient::Update *DMClient::NewUpdate(void) |
| { |
| int i; |
| Update *result = NULL; |
| |
| for (i = 0; i < kUpdatePoolSize; i++) |
| { |
| if (mUpdatePool[i].IsFree()) |
| { |
| result = &mUpdatePool[i]; |
| SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kWDMClient_NumUpdates); |
| |
| break; |
| } |
| } |
| |
| return result; |
| } |
