resolver.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_RESOLVER_HPP__
#define __JOIN_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