thread_api_dbus.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_API_DBUS_HPP_
#define OTBR_THREAD_API_DBUS_HPP_
 
#include <functional>
 
#include <dbus/dbus.h>
 
#include "common/types.hpp"
#include "dbus/common/constants.hpp"
#include "dbus/common/error.hpp"
#include "dbus/common/types.hpp"
 
namespace otbr {
namespace DBus {
 
bool IsThreadActive(DeviceRole aRole);
 
class ThreadApiDBus
{
public:
    using DeviceRoleHandler = std::function<void(DeviceRole)>;
    using ScanHandler       = std::function<void(const std::vector<ActiveScanResult> &)>;
    using EnergyScanHandler = std::function<void(const std::vector<EnergyScanResult> &)>;
    using OtResultHandler   = std::function<void(ClientError)>;
 
    ThreadApiDBus(DBusConnection *aConnection);
 
    ThreadApiDBus(DBusConnection *aConnection, const std::string &aInterfaceName);
 
    void AddDeviceRoleHandler(const DeviceRoleHandler &aHandler);
 
    ClientError PermitUnsecureJoin(uint16_t aPort, uint32_t aSeconds);
 
    ClientError Scan(const ScanHandler &aHandler);
 
    ClientError EnergyScan(uint32_t aScanDuration, const EnergyScanHandler &aHandler);
 
    ClientError 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,
                       const OtResultHandler &     aHandler);
 
    ClientError Attach(const OtResultHandler &aHandler);
 
    ClientError Detach(const OtResultHandler &aHandler);
 
    ClientError AttachAllNodesTo(const std::vector<uint8_t> &aDataset);
 
    ClientError FactoryReset(const OtResultHandler &aHandler);
 
    ClientError Reset(void);
 
    ClientError 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,
                            const OtResultHandler &aHandler);
 
    ClientError JoinerStop(void);
 
    ClientError AddOnMeshPrefix(const OnMeshPrefix &aPrefix);
 
    ClientError RemoveOnMeshPrefix(const Ip6Prefix &aPrefix);
 
    ClientError AddExternalRoute(const ExternalRoute &aExternalRoute);
 
    ClientError RemoveExternalRoute(const Ip6Prefix &aPrefix);
 
    ClientError SetMeshLocalPrefix(const std::array<uint8_t, OTBR_IP6_PREFIX_SIZE> &aPrefix);
 
    ClientError SetLegacyUlaPrefix(const std::array<uint8_t, OTBR_IP6_PREFIX_SIZE> &aPrefix);
 
    ClientError SetActiveDatasetTlvs(const std::vector<uint8_t> &aDataset);
 
    ClientError SetFeatureFlagListData(const std::vector<uint8_t> &aFeatureFlagListData);
 
    ClientError SetLinkMode(const LinkModeConfig &aConfig);
 
    ClientError SetRadioRegion(const std::string &aRadioRegion);
 
    ClientError SetNat64Enabled(bool aEnabled);
 
    ClientError GetLinkMode(LinkModeConfig &aConfig);
 
    ClientError GetDeviceRole(DeviceRole &aDeviceRole);
 
    ClientError GetNetworkName(std::string &aName);
 
    ClientError GetPanId(uint16_t &aPanId);
 
    ClientError GetExtPanId(uint64_t &aExtPanId);
 
    ClientError GetChannel(uint16_t &aChannel);
 
    ClientError GetNetworkKey(std::vector<uint8_t> &aNetworkKey);
 
    ClientError GetCcaFailureRate(uint16_t &aFailureRate);
 
    ClientError GetLinkCounters(MacCounters &aCounters); // For telemetry
 
    ClientError GetIp6Counters(IpCounters &aCounters); // For telemetry
 
    ClientError GetSupportedChannelMask(uint32_t &aChannelMask);
 
    ClientError GetRloc16(uint16_t &aRloc16);
 
    ClientError GetExtendedAddress(uint64_t &aExtendedAddress);
 
    ClientError GetRouterId(uint8_t &aRouterId);
 
    ClientError GetLeaderData(LeaderData &aLeaderData);
 
    ClientError GetNetworkData(std::vector<uint8_t> &aNetworkData);
 
    ClientError GetStableNetworkData(std::vector<uint8_t> &aNetworkData);
 
    ClientError GetLocalLeaderWeight(uint8_t &aWeight);
 
    ClientError GetChannelMonitorSampleCount(uint32_t &aSampleCount);
 
    ClientError GetChannelMonitorAllChannelQualities(std::vector<ChannelQuality> &aChannelQualities);
 
    ClientError GetChildTable(std::vector<ChildInfo> &aChildTable);
 
    ClientError GetNeighborTable(std::vector<NeighborInfo> &aNeighborTable);
 
    ClientError GetPartitionId(uint32_t &aPartitionId);
 
    ClientError GetInstantRssi(int8_t &aRssi);
 
    ClientError GetRadioTxPower(int8_t &aTxPower);
 
    ClientError GetExternalRoutes(std::vector<ExternalRoute> &aExternalRoutes);
 
    ClientError GetOnMeshPrefixes(std::vector<OnMeshPrefix> &aOnMeshPrefixes);
 
    ClientError GetActiveDatasetTlvs(std::vector<uint8_t> &aDataset);
 
    ClientError GetFeatureFlagListData(std::vector<uint8_t> &aFeatureFlagListData);
 
    ClientError GetRadioRegion(std::string &aRadioRegion);
 
    ClientError GetSrpServerInfo(SrpServerInfo &aSrpServerInfo);
 
    ClientError GetMdnsTelemetryInfo(MdnsTelemetryInfo &aMdnsTelemetryInfo);
 
#if OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
 
    ClientError GetDnssdCounters(DnssdCounters &aDnssdCounters);
#endif
 
    std::string GetInterfaceName(void);
 
    ClientError UpdateVendorMeshCopTxtEntries(std::vector<TxtEntry> &aUpdate);
 
    ClientError GetNat64State(Nat64ComponentState &aState);
 
    ClientError GetNat64Mappings(std::vector<Nat64AddressMapping> &aMappings);
 
    ClientError GetNat64ProtocolCounters(Nat64ProtocolCounters &aCounters);
 
    ClientError GetNat64ErrorCounters(Nat64ErrorCounters &aCounters);
 
private:
    ClientError CallDBusMethodSync(const std::string &aMethodName);
    ClientError CallDBusMethodAsync(const std::string &aMethodName, DBusPendingCallNotifyFunction aFunction);
 
    template <typename ArgType> ClientError CallDBusMethodSync(const std::string &aMethodName, const ArgType &aArgs);
 
    template <typename ArgType>
    ClientError CallDBusMethodAsync(const std::string &           aMethodName,
                                    const ArgType &               aArgs,
                                    DBusPendingCallNotifyFunction aFunction);
 
    template <typename ValType> ClientError SetProperty(const std::string &aPropertyName, const ValType &aValue);
 
    template <typename ValType> ClientError GetProperty(const std::string &aPropertyName, ValType &aValue);
 
    ClientError              SubscribeDeviceRoleSignal(void);
    static DBusHandlerResult sDBusMessageFilter(DBusConnection *aConnection, DBusMessage *aMessage, void *aData);
    DBusHandlerResult        DBusMessageFilter(DBusConnection *aConnection, DBusMessage *aMessage);
 
    template <void (ThreadApiDBus::*Handler)(DBusPendingCall *aPending)>
    static void sHandleDBusPendingCall(DBusPendingCall *aPending, void *aThreadApiDBus);
 
    void        AttachPendingCallHandler(DBusPendingCall *aPending);
    void        DetachPendingCallHandler(DBusPendingCall *aPending);
    void        FactoryResetPendingCallHandler(DBusPendingCall *aPending);
    void        JoinerStartPendingCallHandler(DBusPendingCall *aPending);
    static void sScanPendingCallHandler(DBusPendingCall *aPending, void *aThreadApiDBus);
    void        ScanPendingCallHandler(DBusPendingCall *aPending);
    void        EnergyScanPendingCallHandler(DBusPendingCall *aPending);
 
    static void EmptyFree(void *) {}
 
    std::string mInterfaceName;
 
    DBusConnection *mConnection;
 
    ScanHandler       mScanHandler;
    EnergyScanHandler mEnergyScanHandler;
    OtResultHandler   mAttachHandler;
    OtResultHandler   mDetachHandler;
    OtResultHandler   mFactoryResetHandler;
    OtResultHandler   mJoinerHandler;
 
    std::vector<DeviceRoleHandler> mDeviceRoleHandlers;
};
 
} // namespace DBus
} // namespace otbr
 
#endif // OTBR_THREAD_API_DBUS_HPP_