mdns.hpp

Go to the documentation of this file.

/*
 *    Copyright (c) 2017, 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_AGENT_MDNS_HPP_
#define OTBR_AGENT_MDNS_HPP_
 
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include <sys/select.h>
 
#include "common/callback.hpp"
#include "common/code_utils.hpp"
#include "common/time.hpp"
#include "common/types.hpp"
 
namespace otbr {
 
namespace Mdns {
 
class Publisher : private NonCopyable
{
public:
    struct TxtEntry
    {
        std::string          mName;  
        std::vector<uint8_t> mValue; 
 
        TxtEntry(const char *aName, const char *aValue)
            : TxtEntry(aName, reinterpret_cast<const uint8_t *>(aValue), strlen(aValue))
        {
        }
 
        TxtEntry(const char *aName, const uint8_t *aValue, size_t aValueLength)
            : TxtEntry(aName, strlen(aName), aValue, aValueLength)
        {
        }
 
        TxtEntry(const char *aName, size_t aNameLength, const uint8_t *aValue, size_t aValueLength)
            : mName(aName, aNameLength)
            , mValue(aValue, aValue + aValueLength)
        {
        }
 
        bool operator==(const TxtEntry &aOther) const { return mName == aOther.mName && mValue == aOther.mValue; }
    };
 
    typedef std::vector<TxtEntry>    TxtList;
    typedef std::vector<std::string> SubTypeList;
    typedef std::vector<Ip6Address>  AddressList;
 
    struct DiscoveredInstanceInfo
    {
        bool                    mRemoved    = false; 
        uint32_t                mNetifIndex = 0;     
        std::string             mName;               
        std::string             mHostName;           
        std::vector<Ip6Address> mAddresses;          
        uint16_t                mPort     = 0;       
        uint16_t                mPriority = 0;       
        uint16_t                mWeight   = 0;       
        std::vector<uint8_t>    mTxtData;            
        uint32_t                mTtl = 0;            
    };
 
    struct DiscoveredHostInfo
    {
        std::string             mHostName;  
        std::vector<Ip6Address> mAddresses; 
        uint32_t                mTtl = 0;   
    };
 
    using DiscoveredServiceInstanceCallback =
        std::function<void(const std::string &aType, const DiscoveredInstanceInfo &aInstanceInfo)>;
 
    using DiscoveredHostCallback =
        std::function<void(const std::string &aHostName, const DiscoveredHostInfo &aHostInfo)>;
 
    enum class State
    {
        kIdle,  
        kReady, 
    };
 
    using StateCallback = std::function<void(State aNewState)>;
 
    using ResultCallback = OnceCallback<void(otbrError aError)>;
 
    virtual otbrError Start(void) = 0;
 
    virtual void Stop(void) = 0;
 
    virtual bool IsStarted(void) const = 0;
 
    void PublishService(const std::string &aHostName,
                        const std::string &aName,
                        const std::string &aType,
                        const SubTypeList &aSubTypeList,
                        uint16_t           aPort,
                        const TxtList &    aTxtList,
                        ResultCallback &&  aCallback);
 
    virtual void UnpublishService(const std::string &aName, const std::string &aType, ResultCallback &&aCallback) = 0;
 
    void PublishHost(const std::string &aName, const std::vector<Ip6Address> &aAddresses, ResultCallback &&aCallback);
 
    virtual void UnpublishHost(const std::string &aName, ResultCallback &&aCallback) = 0;
 
    virtual void SubscribeService(const std::string &aType, const std::string &aInstanceName) = 0;
 
    virtual void UnsubscribeService(const std::string &aType, const std::string &aInstanceName) = 0;
 
    virtual void SubscribeHost(const std::string &aHostName) = 0;
 
    virtual void UnsubscribeHost(const std::string &aHostName) = 0;
 
    uint64_t AddSubscriptionCallbacks(DiscoveredServiceInstanceCallback aInstanceCallback,
                                      DiscoveredHostCallback            aHostCallback);
 
    void RemoveSubscriptionCallbacks(uint64_t aSubscriberId);
 
    const MdnsTelemetryInfo &GetMdnsTelemetryInfo() const { return mTelemetryInfo; }
 
    virtual ~Publisher(void) = default;
 
    static Publisher *Create(StateCallback aCallback);
 
    static void Destroy(Publisher *aPublisher);
 
    static otbrError EncodeTxtData(const TxtList &aTxtList, std::vector<uint8_t> &aTxtData);
 
    static otbrError DecodeTxtData(TxtList &aTxtList, const uint8_t *aTxtData, uint16_t aTxtLength);
 
protected:
    static constexpr uint8_t kMaxTextEntrySize = 255;
 
    class Registration
    {
    public:
        ResultCallback mCallback;
        Publisher *    mPublisher;
 
        Registration(ResultCallback &&aCallback, Publisher *aPublisher)
            : mCallback(std::move(aCallback))
            , mPublisher(aPublisher)
        {
        }
        virtual ~Registration(void);
 
        // Tells whether the service registration has been completed (typically by calling
        // `ServiceRegistration::Complete`).
        bool IsCompleted() const { return mCallback.IsNull(); }
 
    protected:
        // Completes the service registration with given result/error.
        void TriggerCompleteCallback(otbrError aError)
        {
            if (!IsCompleted())
            {
                std::move(mCallback)(aError);
            }
        }
    };
 
    class ServiceRegistration : public Registration
    {
    public:
        std::string mHostName;
        std::string mName;
        std::string mType;
        SubTypeList mSubTypeList;
        uint16_t    mPort;
        TxtList     mTxtList;
 
        ServiceRegistration(std::string      aHostName,
                            std::string      aName,
                            std::string      aType,
                            SubTypeList      aSubTypeList,
                            uint16_t         aPort,
                            TxtList          aTxtList,
                            ResultCallback &&aCallback,
                            Publisher *      aPublisher)
            : Registration(std::move(aCallback), aPublisher)
            , mHostName(std::move(aHostName))
            , mName(std::move(aName))
            , mType(std::move(aType))
            , mSubTypeList(SortSubTypeList(std::move(aSubTypeList)))
            , mPort(aPort)
            , mTxtList(SortTxtList(std::move(aTxtList)))
        {
        }
        ~ServiceRegistration(void) override { OnComplete(OTBR_ERROR_ABORTED); }
 
        void Complete(otbrError aError);
 
        void OnComplete(otbrError aError);
 
        // Tells whether this `ServiceRegistration` object is outdated comparing to the given parameters.
        bool IsOutdated(const std::string &aHostName,
                        const std::string &aName,
                        const std::string &aType,
                        const SubTypeList &aSubTypeList,
                        uint16_t           aPort,
                        const TxtList &    aTxtList) const;
    };
 
    class HostRegistration : public Registration
    {
    public:
        std::string             mName;
        std::vector<Ip6Address> mAddresses;
 
        HostRegistration(std::string aName, AddressList aAddresses, ResultCallback &&aCallback, Publisher *aPublisher)
            : Registration(std::move(aCallback), aPublisher)
            , mName(std::move(aName))
            , mAddresses(SortAddressList(std::move(aAddresses)))
        {
        }
 
        ~HostRegistration(void) { OnComplete(OTBR_ERROR_ABORTED); }
 
        void Complete(otbrError aError);
 
        void OnComplete(otbrError);
 
        // Tells whether this `HostRegistration` object is outdated comparing to the given parameters.
        bool IsOutdated(const std::string &aName, const std::vector<Ip6Address> &aAddresses) const;
    };
 
    using ServiceRegistrationPtr = std::unique_ptr<ServiceRegistration>;
    using ServiceRegistrationMap = std::map<std::string, ServiceRegistrationPtr>;
    using HostRegistrationPtr    = std::unique_ptr<HostRegistration>;
    using HostRegistrationMap    = std::map<std::string, HostRegistrationPtr>;
 
    static SubTypeList SortSubTypeList(SubTypeList aSubTypeList);
    static TxtList     SortTxtList(TxtList aTxtList);
    static AddressList SortAddressList(AddressList aAddressList);
    static std::string MakeFullServiceName(const std::string &aName, const std::string &aType);
    static std::string MakeFullHostName(const std::string &aName);
 
    virtual otbrError PublishServiceImpl(const std::string &aHostName,
                                         const std::string &aName,
                                         const std::string &aType,
                                         const SubTypeList &aSubTypeList,
                                         uint16_t           aPort,
                                         const TxtList &    aTxtList,
                                         ResultCallback &&  aCallback)                            = 0;
    virtual otbrError PublishHostImpl(const std::string &            aName,
                                      const std::vector<Ip6Address> &aAddresses,
                                      ResultCallback &&              aCallback)                               = 0;
    virtual void      OnServiceResolveFailedImpl(const std::string &aType,
                                                 const std::string &aInstanceName,
                                                 int32_t            aErrorCode)                            = 0;
    virtual void      OnHostResolveFailedImpl(const std::string &aHostName, int32_t aErrorCode) = 0;
 
    virtual otbrError DnsErrorToOtbrError(int32_t aError) = 0;
 
    void AddServiceRegistration(ServiceRegistrationPtr &&aServiceReg);
    void RemoveServiceRegistration(const std::string &aName, const std::string &aType, otbrError aError);
    ServiceRegistration *FindServiceRegistration(const std::string &aName, const std::string &aType);
    void                 OnServiceResolved(const std::string &aType, const DiscoveredInstanceInfo &aInstanceInfo);
    void OnServiceResolveFailed(const std::string &aType, const std::string &aInstanceName, int32_t aErrorCode);
    void OnServiceRemoved(uint32_t aNetifIndex, const std::string &aType, const std::string &aInstanceName);
    void OnHostResolved(const std::string &aHostName, const DiscoveredHostInfo &aHostInfo);
    void OnHostResolveFailed(const std::string &aHostName, int32_t aErrorCode);
 
    // Handles the cases that there is already a registration for the same service.
    // If the returned callback is completed, current registration should be considered
    // success and no further action should be performed.
    ResultCallback HandleDuplicateServiceRegistration(const std::string &aHostName,
                                                      const std::string &aName,
                                                      const std::string &aType,
                                                      const SubTypeList &aSubTypeList,
                                                      uint16_t           aPort,
                                                      const TxtList &    aTxtList,
                                                      ResultCallback &&  aCallback);
 
    ResultCallback HandleDuplicateHostRegistration(const std::string &            aName,
                                                   const std::vector<Ip6Address> &aAddresses,
                                                   ResultCallback &&              aCallback);
 
    void              AddHostRegistration(HostRegistrationPtr &&aHostReg);
    void              RemoveHostRegistration(const std::string &aName, otbrError aError);
    HostRegistration *FindHostRegistration(const std::string &aName);
 
    static void UpdateMdnsResponseCounters(otbr::MdnsResponseCounters &aCounters, otbrError aError);
    static void UpdateEmaLatency(uint32_t &aEmaLatency, uint32_t aLatency, otbrError aError);
 
    void UpdateServiceRegistrationEmaLatency(const std::string &aInstanceName,
                                             const std::string &aType,
                                             otbrError          aError);
    void UpdateHostRegistrationEmaLatency(const std::string &aHostName, otbrError aError);
    void UpdateServiceInstanceResolutionEmaLatency(const std::string &aInstanceName,
                                                   const std::string &aType,
                                                   otbrError          aError);
    void UpdateHostResolutionEmaLatency(const std::string &aHostName, otbrError aError);
 
    ServiceRegistrationMap mServiceRegistrations;
    HostRegistrationMap    mHostRegistrations;
 
    uint64_t mNextSubscriberId = 1;
 
    std::map<uint64_t, std::pair<DiscoveredServiceInstanceCallback, DiscoveredHostCallback>> mDiscoveredCallbacks;
    // {instance name, service type} -> the timepoint to begin service registration
    std::map<std::pair<std::string, std::string>, Timepoint> mServiceRegistrationBeginTime;
    // host name -> the timepoint to begin host registration
    std::map<std::string, Timepoint> mHostRegistrationBeginTime;
    // {instance name, service type} -> the timepoint to begin service resolution
    std::map<std::pair<std::string, std::string>, Timepoint> mServiceInstanceResolutionBeginTime;
    // host name -> the timepoint to begin host resolution
    std::map<std::string, Timepoint> mHostResolutionBeginTime;
 
    otbr::MdnsTelemetryInfo mTelemetryInfo{};
};
 
} // namespace Mdns
 
} // namespace otbr
 
#endif // OTBR_AGENT_MDNS_HPP_