resolver.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_RESOLVER_HPP
#define JOIN_FABRIC_RESOLVER_HPP
 
// libjoin.
#include <join/endpoint.hpp>
 
// C++.
#include <functional>
#include <string>
#include <regex>
#include <set>
 
namespace join
{
    using AliasList = std::set<std::string>;
 
    using ServerList = std::set<std::string>;
 
    using ExchangerList = std::set<std::string>;
 
    struct QuestionRecord
    {
        std::string host;      
        uint16_t type     = 0; 
        uint16_t dnsclass = 0; 
    };
 
    struct AnswerRecord : public QuestionRecord
    {
        uint32_t ttl = 0;     
        IpAddress addr;       
        std::string name;     
        std::string mail;     
        uint32_t serial  = 0; 
        uint32_t refresh = 0; 
        uint32_t retry   = 0; 
        uint32_t expire  = 0; 
        uint32_t minimum = 0; 
        uint16_t mxpref  = 0; 
    };
 
    struct DnsPacket
    {
        IpAddress src;                         
        IpAddress dest;                        
        uint16_t port = 0;                     
        std::vector<QuestionRecord> questions; 
        std::vector<AnswerRecord> answers;     
        std::vector<AnswerRecord> authorities; 
        std::vector<AnswerRecord> additionals; 
    };
 
    class Resolver
    {
    public:
        enum RecordType : uint16_t
        {
            A     = 1,  
            NS    = 2,  
            CNAME = 5,  
            SOA   = 6,  
            PTR   = 12, 
            MX    = 15, 
            AAAA  = 28, 
        };
 
        enum RecordClass : uint16_t
        {
            IN = 1, 
        };
 
        Resolver ();
 
        Resolver (const std::string& interface);
 
        Resolver (const Resolver& other) = delete;
 
        Resolver& operator= (const Resolver& other) = delete;
 
        Resolver (Resolver&& other) = delete;
 
        Resolver& operator= (Resolver&& other) = delete;
 
        virtual ~Resolver () = default;
 
        static IpAddressList nameServers ();
 
        IpAddressList resolveAllHost (const std::string& host, int family, const IpAddress& server,
                                      uint16_t port = dnsPort, int timeout = 5000);
 
        static IpAddressList resolveAllHost (const std::string& host, int family);
 
        IpAddressList resolveAllHost (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                                      int timeout = 5000);
 
        static IpAddressList resolveAllHost (const std::string& host);
 
        IpAddress resolveHost (const std::string& host, int family, const IpAddress& server, uint16_t port = dnsPort,
                               int timeout = 5000);
 
        static IpAddress resolveHost (const std::string& host, int family);
 
        IpAddress resolveHost (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                               int timeout = 5000);
 
        static IpAddress resolveHost (const std::string& host);
 
        AliasList resolveAllAddress (const IpAddress& address, const IpAddress& server, uint16_t port = dnsPort,
                                     int timeout = 5000);
 
        static AliasList resolveAllAddress (const IpAddress& address);
 
        std::string resolveAddress (const IpAddress& address, const IpAddress& server, uint16_t port = dnsPort,
                                    int timeout = 5000);
 
        static std::string resolveAddress (const IpAddress& address);
 
        ServerList resolveAllNameServer (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                                         int timeout = 5000);
 
        static ServerList resolveAllNameServer (const std::string& host);
 
        std::string resolveNameServer (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                                       int timeout = 5000);
 
        static std::string resolveNameServer (const std::string& host);
 
        std::string resolveAuthority (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                                      int timeout = 5000);
 
        static std::string resolveAuthority (const std::string& host);
 
        ExchangerList resolveAllMailExchanger (const std::string& host, const IpAddress& server,
                                               uint16_t port = dnsPort, int timeout = 5000);
 
        static ExchangerList resolveAllMailExchanger (const std::string& host);
 
        std::string resolveMailExchanger (const std::string& host, const IpAddress& server, uint16_t port = dnsPort,
                                          int timeout = 5000);
 
        static std::string resolveMailExchanger (const std::string& host);
 
        static uint16_t resolveService (const std::string& service);
 
        static std::string typeName (uint16_t recordType);
 
        static std::string className (uint16_t recordClass);
 
        static constexpr uint16_t dnsPort = 53;
 
        using DnsNotify = std::function<void (const DnsPacket&)>;
 
        DnsNotify _onSuccess;
 
        DnsNotify _onFailure;
 
    protected:
        int lookup (DnsPacket& packet, int timeout);
 
        void setHeader (uint16_t id, uint16_t flags, uint16_t qcount, uint16_t ancount, uint16_t nscount,
                        uint16_t arcount, std::stringstream& data);
 
        void getHeader (uint16_t& id, uint16_t& flags, uint16_t& qcount, uint16_t& ancount, uint16_t& nscount,
                        uint16_t& arcount, std::stringstream& data);
 
        static void encodeName (const std::string& host, std::stringstream& data);
 
        static std::string decodeName (std::stringstream& data);
 
        static std::string decodeMail (std::stringstream& data);
 
        static void encodeQuestion (const std::string& host, uint16_t type, uint16_t dnsclass, std::stringstream& data);
 
        static QuestionRecord decodeQuestion (std::stringstream& data);
 
        static AnswerRecord decodeAnswer (std::stringstream& data);
 
        static std::error_code parseError (int error);
 
#ifdef DEBUG
        /*
         * @brief default callback called when a lookup sequence succeed.
         * @param packet DNS packet.
         */
        static void defaultOnSuccess (const DnsPacket& packet);
 
        /*
         * @brief default callback called when a lookup sequence failed.
         * @param packet DNS packet.
         */
        static void defaultOnFailure (const DnsPacket& packet);
#endif
 
        void notify (const DnsNotify& function, const DnsPacket& packet);
 
        std::string _interface;
    };
}
 
#endif