thread_helper.hpp

Go to the documentation of this file.

/*
 *    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.
 */
 
#ifndef OTBR_THREAD_HELPER_HPP_
#define OTBR_THREAD_HELPER_HPP_
 
#include <chrono>
#include <functional>
#include <map>
#include <random>
#include <string>
#include <vector>
 
#include <openthread/instance.h>
#include <openthread/ip6.h>
#include <openthread/jam_detection.h>
#include <openthread/joiner.h>
#include <openthread/netdata.h>
#include <openthread/thread.h>
 
namespace otbr {
namespace Ncp {
class ControllerOpenThread;
}
} // namespace otbr
 
namespace otbr {
namespace agent {
 
class ThreadHelper
{
public:
    using DeviceRoleHandler       = std::function<void(otDeviceRole)>;
    using ScanHandler             = std::function<void(otError, const std::vector<otActiveScanResult> &)>;
    using EnergyScanHandler       = std::function<void(otError, const std::vector<otEnergyScanResult> &)>;
    using ResultHandler           = std::function<void(otError)>;
    using AttachHandler           = std::function<void(otError, int64_t)>;
    using UpdateMeshCopTxtHandler = std::function<void(std::map<std::string, std::vector<uint8_t>>)>;
    using DatasetChangeHandler    = std::function<void(const otOperationalDatasetTlvs &)>;
 
    ThreadHelper(otInstance *aInstance, otbr::Ncp::ControllerOpenThread *aNcp);
 
    void AddDeviceRoleHandler(DeviceRoleHandler aHandler);
 
    void AddActiveDatasetChangeHandler(DatasetChangeHandler aHandler);
 
    otError PermitUnsecureJoin(uint16_t aPort, uint32_t aSeconds);
 
    void Scan(ScanHandler aHandler);
 
    void EnergyScan(uint32_t aScanDuration, EnergyScanHandler aHandler);
 
    void Attach(const std::string &         aNetworkName,
                uint16_t                    aPanId,
                uint64_t                    aExtPanId,
                const std::vector<uint8_t> &aNetworkKey,
                const std::vector<uint8_t> &aPSKc,
                uint32_t                    aChannelMask,
                AttachHandler               aHandler);
 
    otError Detach(void);
 
    void Attach(AttachHandler aHandler);
 
    void AttachAllNodesTo(const std::vector<uint8_t> &aDatasetTlvs, AttachHandler aHandler);
 
    otError Reset(void);
 
    void JoinerStart(const std::string &aPskd,
                     const std::string &aProvisioningUrl,
                     const std::string &aVendorName,
                     const std::string &aVendorModel,
                     const std::string &aVendorSwVersion,
                     const std::string &aVendorData,
                     ResultHandler      aHandler);
 
    otError TryResumeNetwork(void);
 
    otInstance *GetInstance(void) { return mInstance; }
 
    void StateChangedCallback(otChangedFlags aFlags);
 
#if OTBR_ENABLE_DBUS_SERVER
 
    void SetUpdateMeshCopTxtHandler(UpdateMeshCopTxtHandler aHandler)
    {
        mUpdateMeshCopTxtHandler = std::move(aHandler);
    }
 
    void OnUpdateMeshCopTxt(std::map<std::string, std::vector<uint8_t>> aUpdate);
#endif
 
    void DetachGracefully(ResultHandler aHandler);
 
    static void LogOpenThreadResult(const char *aAction, otError aError);
 
private:
    static void ActiveScanHandler(otActiveScanResult *aResult, void *aThreadHelper);
    void        ActiveScanHandler(otActiveScanResult *aResult);
 
    static void EnergyScanCallback(otEnergyScanResult *aResult, void *aThreadHelper);
    void        EnergyScanCallback(otEnergyScanResult *aResult);
 
    static void JoinerCallback(otError aError, void *aThreadHelper);
    void        JoinerCallback(otError aResult);
 
    static void MgmtSetResponseHandler(otError aResult, void *aContext);
    void        MgmtSetResponseHandler(otError aResult);
 
    static void DetachGracefullyCallback(void *aContext);
    void        DetachGracefullyCallback(void);
 
    void    RandomFill(void *aBuf, size_t size);
    uint8_t RandomChannelFromChannelMask(uint32_t aChannelMask);
 
    void ActiveDatasetChangedCallback(void);
 
    otInstance *mInstance;
 
    otbr::Ncp::ControllerOpenThread *mNcp;
 
    ScanHandler                     mScanHandler;
    std::vector<otActiveScanResult> mScanResults;
    EnergyScanHandler               mEnergyScanHandler;
    std::vector<otEnergyScanResult> mEnergyScanResults;
 
    std::vector<DeviceRoleHandler>    mDeviceRoleHandlers;
    std::vector<DatasetChangeHandler> mActiveDatasetChangeHandlers;
 
    std::map<uint16_t, size_t> mUnsecurePortRefCounter;
 
    int64_t       mAttachDelayMs = 0;
    AttachHandler mAttachHandler;
    ResultHandler mJoinerHandler;
 
    ResultHandler mDetachGracefullyHandler = nullptr;
 
    otOperationalDatasetTlvs mAttachPendingDatasetTlvs = {};
 
    std::random_device mRandomDevice;
 
#if OTBR_ENABLE_DBUS_SERVER
    UpdateMeshCopTxtHandler mUpdateMeshCopTxtHandler;
#endif
};
 
} // namespace agent
} // namespace otbr
 
#endif // OTBR_THREAD_HELPER_HPP_