+# Copyright (c) 2020 Project CHIP Authors

 class AppTask     void PostEvent(AppEvent * event);     void UpdateClusterState(); -private:+    // private:

 void AppTask::ButtonEventHandler(uint32_t button_state, uint32_t has_changed)     } } +#ifdef CONFIG_CHIP_PW_RPC

 int LightingManager::Init(const char * gpioDeviceName, gpio_pin_t gpioPin)      if (!mGPIODevice)     {+#ifndef CONFIG_CHIP_PW_RPC         LOG_ERR("Cannot find GPIO port %s", log_strdup(gpioDeviceName));+#else+        LOG_ERR("Cannot find GPIO port %s", gpioDeviceName);

 otError Ip6::HandleExtensionHeaders(Message &    aMessage,     return error; } -otError Ip6::HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto)+void Ip6::HandlePayload(Message &          aMessage,+                        MessageInfo &      aMessageInfo,+                        uint8_t            aIpProto,+                        Message::Ownership aMessageOwnership) {-    otError error = OT_ERROR_NONE;+    otError  error = OT_ERROR_NONE;+    Message *message;++    switch (aMessageOwnership)+    {+    case Message::kTakeCustody:+        message = &aMessage;+        break;++    case Message::kCopyToUse:+        VerifyOrExit((message = aMessage.Clone()) != nullptr, error = OT_ERROR_NO_BUFS);+        break;++    default:+        message = nullptr;+        OT_ASSERT(false);+        break;+    }      switch (aIpProto)     {     case kProtoUdp:-        error = mUdp.HandleMessage(aMessage, aMessageInfo);+        error = mUdp.HandleMessage(*message, aMessageInfo);         if (error == OT_ERROR_DROP)         {             otLogNoteIp6("Error UDP Checksum");         }         break;      case kProtoIcmp6:-        error = mIcmp.HandleMessage(aMessage, aMessageInfo);+        error = mIcmp.HandleMessage(*message, aMessageInfo);         break;      default:         break;     } -    return error;+exit:+    if (error != OT_ERROR_NONE)+    {+        otLogNoteIp6("Failed to handle payload: %s", otThreadErrorToString(error));+    }++    if (message != nullptr)+    {+        message->Free();+    }

 otError Ip6::HandleDatagram(Message &aMessage, Netif *aNetif, const void *aLinkM         } #endif -        IgnoreError(ProcessReceiveCallback(aMessage, messageInfo, nextHeader, aFromNcpHost, Message::kCopyToUse));+        error = ProcessReceiveCallback(aMessage, messageInfo, nextHeader, aFromNcpHost, Message::kCopyToUse);++        if ((error == OT_ERROR_NONE || error == OT_ERROR_NO_ROUTE) && forward &&+            !ShouldForwardToThread(messageInfo, aFromNcpHost))+        {+            forward = false;+        }

 otError Ip6::HandleExtensionHeaders(Message &    aMessage,     return error; } -otError Ip6::HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto)+void Ip6::HandlePayload(Message &          aMessage,+                        MessageInfo &      aMessageInfo,+                        uint8_t            aIpProto,+                        Message::Ownership aMessageOwnership) {-    otError error = OT_ERROR_NONE;+    otError  error = OT_ERROR_NONE;+    Message *message;++    switch (aMessageOwnership)+    {+    case Message::kTakeCustody:+        message = &aMessage;+        break;++    case Message::kCopyToUse:+        VerifyOrExit((message = aMessage.Clone()) != nullptr, error = OT_ERROR_NO_BUFS);+        break;++    default:

 otError Ip6::HandleExtensionHeaders(Message &    aMessage,     return error; } -otError Ip6::HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto)+void Ip6::HandlePayload(Message &          aMessage,+                        MessageInfo &      aMessageInfo,+                        uint8_t            aIpProto,+                        Message::Ownership aMessageOwnership) {-    otError error = OT_ERROR_NONE;+    otError  error = OT_ERROR_NONE;+    Message *message;+

 typedef struct otMessageInfo                                  ///< Otherwise, specifies the IPv6 Hop Limit.     bool mIsHostInterface : 1;   ///< TRUE if packets sent/received via host interface, FALSE otherwise.     bool mAllowZeroHopLimit : 1; ///< TRUE to allow IPv6 Hop Limit 0 in `mHopLimit`, FALSE otherwise.+    bool mMulticastLoop : 1;     ///< TRUE to allow looping back mutlicast, FALSE otherwise.

 class Message : public Buffer      */     bool IsSubTypeMle(void) const; +    /**+     * This method checks whether this multicast message may be looped back.+     *+     * @retval TRUE   If message may be looped back.+     * @retval FALSE  If message must not be looped back.+     *+     */+    bool GetMulticastLoop(void) const { return GetMetadata().mMulticastLoop; }

+/*+ *  Copyright (c) 2020, The OpenThread Authors.+ *  All rights reserved.+ *+ *  Redistribution and use in source and binary forms, with or without+ *  modification, are permitted provided that the following conditions are met:+ *  1. Redistributions of source code must retain the above copyright+ *     notice, this list of conditions and the following disclaimer.+ *  2. Redistributions in binary form must reproduce the above copyright+ *     notice, this list of conditions and the following disclaimer in the+ *     documentation and/or other materials provided with the distribution.+ *  3. Neither the name of the copyright holder nor the+ *     names of its contributors may be used to endorse or promote products+ *     derived from this software without specific prior written permission.+ *+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE+ *  POSSIBILITY OF SUCH DAMAGE.+ */++/**+ * @file+ *   This file includes definitions for Dataset Updater.+ */++#ifndef DATASET_UPDATER_HPP_+#define DATASET_UPDATER_HPP_++#include "openthread-core-config.h"++#include <openthread/dataset_updater.h>++#include "common/locator.hpp"+#include "common/message.hpp"+#include "common/non_copyable.hpp"+#include "common/notifier.hpp"+#include "common/timer.hpp"+#include "meshcop/dataset.hpp"+#include "meshcop/meshcop_tlvs.hpp"++namespace ot {+namespace Utils {++#if (OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE || OPENTHREAD_CONFIG_CHANNEL_MANAGER_ENABLE) && OPENTHREAD_FTD++/**+ * This class implements the Dataset Updater.+ *+ */+class DatasetUpdater : public InstanceLocator, private NonCopyable+{+    friend class ot::Notifier;++public:+    /**+     * This constructor initializes a `DatasetUpdater` object.+     *+     * @param[in]   aInstance  A reference to the OpenThread instance.+     *+     */+    explicit DatasetUpdater(Instance &aInstance);++    /**+     * This type represents the callback function pointer which is called when a Dataset update request finishes,+     * reporting success or failure status of the request.+     *+     * The function pointer has the syntax `void (*Callback)(otError aError, void *aContext)`.+     *+     * @param[in] aError   The error status.+     *                     OT_ERROR_NONE           indicates Dataset update successfully finished.+     *                     OT_ERROR_INVALID_STATE  indicates failure due invalid state (MLE being disabled).+     *                     OT_ERROR_ALREADY        indicates failure due to another device within network requesting+     *                                             a conflicting Dataset update.+     * @param[in] aContext A pointer to the arbitrary context provided by the user.+     *+     */+    typedef otDatasetUpdaterCallback Callback;++    /**+     * This method requests an update to Operational Dataset.+     *+     * @p aDataset should contain the fields to be updated and their new value. It must not contain Active or Pending+     * Timestamp fields. The Delay field is optional, if not provided a default value (`kDefaultDelay`) would be used.+     *+     * @param[in]  aDataset                Dataset info containing fields to change.+     * @param[in]  aCallback               A callback to indicate when Dataset update request finishes.+     * @param[in]  aContext                An arbitrary context passed to callback.+     * @param[in]  aRetryWaitInterval      The wait time after sending Pending dataset before retrying (interval in ms).+     *+     * @retval OT_ERROR_NONE           Dataset update started successfully (@p aCallback will be invoked on completion).+     * @retval OT_ERROR_INVALID_STATE  Device is disabled (MLE is disabled).+     * @retval OT_ERROR_INVALID_ARGS   The @p aDataset is not valid (contains Active or Pending Timestamp).+     * @retval OT_ERROR_BUSY           Cannot start update, a previous one is ongoing

+/*+ *  Copyright (c) 2020, The OpenThread Authors.+ *  All rights reserved.+ *+ *  Redistribution and use in source and binary forms, with or without+ *  modification, are permitted provided that the following conditions are met:+ *  1. Redistributions of source code must retain the above copyright+ *     notice, this list of conditions and the following disclaimer.+ *  2. Redistributions in binary form must reproduce the above copyright+ *     notice, this list of conditions and the following disclaimer in the+ *     documentation and/or other materials provided with the distribution.+ *  3. Neither the name of the copyright holder nor the+ *     names of its contributors may be used to endorse or promote products+ *     derived from this software without specific prior written permission.+ *+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE+ *  POSSIBILITY OF SUCH DAMAGE.+ */++/**+ * @file+ * @brief+ *   This file includes the OpenThread API for Dataset Updater module.+ */++#ifndef OPENTHREAD_DATASET_UPDATER_H_+#define OPENTHREAD_DATASET_UPDATER_H_++#include <openthread/dataset.h>+#include <openthread/instance.h>++#ifdef __cplusplus+extern "C" {+#endif++/**+ * @addtogroup api-dataset-updater+ *+ * @brief+ *   This module includes functions for Dataset Updater.+ *+ *   The functions in this module are available when Dataset Updater feature is enabled (i.e.+ *   `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is set to 1). Further this feature is available only on an FTD build.+ *+ * @{+ *+ */++/**+ * This callback function pointer is called when a Dataset update request finishes, reporting success or failure status+ * of the Dataset update request.+ *+ * @param[in] aError   The error status.+ *                     OT_ERROR_NONE            indicates successful Dataset update.+ *                     OT_ERROR_INVALID_STATE   indicates failure due invalid state (MLE being disabled).+ *                     OT_ERROR_ALREADY         indicates failure due to another device within network requesting+ *                                              a conflicting Dataset update.+ *+ * @param[in] aContext A pointer to the arbitrary context (provided by user in `otDatasetUpdaterRequestUpdate()`).+ *+ */+typedef void (*otDatasetUpdaterCallback)(otError aError, void *aContext);++/**+ * This function requests an update to Operational Dataset.+ *+ * @p aDataset should contain the fields to be updated and their new value. It must not contain Active or Pending+ * Timestamp fields. The Delay field is optional, if not provided a default value (1000 ms) would be used.+ *+ * @param[in]  aInstance               A pointer to an OpenThread instance.+ * @param[in]  aDataset                A pointer to the Dataset containing the fields to change.+ * @param[in]  aCallback               A callback to indicate when Dataset update request finishes.+ * @param[in]  aContext                An arbitrary context passed to callback.+ * @param[in]  aRetryWaitInterval      The wait time after sending Pending dataset before retrying (interval in ms).+ *+ * @retval OT_ERROR_NONE           Dataset update started successfully (@p aCallback will be invoked on completion).+ * @retval OT_ERROR_INVALID_STATE  Device is disabled (MLE is disabled).+ * @retval OT_ERROR_INVALID_ARGS   The @p aDataset is not valid (contains Active or Pending Timestamp).+ * @retval OT_ERROR_BUSY           Cannot start update, a previous one is ongoing

 class Dataset             mComponents.mIsSecurityPolicyPresent = true;         } +        /**+         * This method sets the Security Policy in the Dataset.+         *+         * @param[in] aRotationTime  A value for Key Rotation (in units of hours).+         * @param[in] aFlags         Security policy flags

 typedef struct     int8_t       mLastRssi;             ///< Last observed RSSI     uint16_t     mFrameErrorRate;       ///< Frame error rate (0xffff->100%). Requires error tracking feature.     uint16_t     mMessageErrorRate;     ///< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature.+    uint16_t     mQueuedMessageCnt;     ///< Number of queued indirect messages for the child.