dns_client.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_DNS_DNS_CLIENT_HPP__
#define NEFORCE_NETWORK_DNS_DNS_CLIENT_HPP__

 
#include "NeForce/core/async/future.hpp"
#include "NeForce/core/async/promise.hpp"
#include "NeForce/core/async/shared_mutex.hpp"
#include "NeForce/core/async/thread_pool.hpp"
#include "NeForce/core/container/unordered_map.hpp"
#ifndef NEFORCE_PLATFORM_WINDOWS
#    include "NeForce/core/system/pipe.hpp"
#endif
#include "NeForce/core/time/clocks.hpp"
#include "NeForce/core/utility/optional.hpp"
#include "NeForce/network/dns/dns_message.hpp"
#include "NeForce/network/udp_socket.hpp"
#include "NeForce/network/util/ports.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API dns_client {
public:
    struct config {
        string server{"8.8.8.8"};   
        ports port{ports::DNS};     
        milliseconds timeout{5000}; 
    };
 
private:
    struct pending_entry {
        _NEFORCE promise<dns_query_result> promise;
        byte_vector query_data;
        steady_clock::time_point created_at{steady_clock::now()};
    };
 
    config config_{};                                                               
    unordered_map<string, pair<dns_query_result, steady_clock::time_point>> cache_; 
    mutable shared_mutex cache_mutex_;                                              
    seconds cache_ttl_{300};                                                        
    bool use_tcp_ = false;                                                          
    bool recursion_desired_ = true;                                                 
    uint16_t edns_udp_payload_{edns::DEFAULT_UDP_PAYLOAD};                          
    bool dnssec_ok_ = false;                                                        
 
    udp_socket shared_socket_;                               
    unordered_map<uint16_t, pending_entry> pending_queries_; 
    mutable mutex pending_mutex_;                            
    mutable mutex send_mutex_;                               
    thread_pool io_pool_;                                    
#ifndef NEFORCE_PLATFORM_WINDOWS
    pipe wake_pipe_; 
#endif
    atomic<bool> io_running_{false}; 
 
private:
    void ensure_io_started();
    void start_io();
    void stop_io();
    void io_receive_loop();
 
    void send_query(const byte_vector& query);
    byte_vector send_tcp_query(const byte_vector& query);
 
    optional<dns_query_result> check_cache(const string& key);
    void update_cache(const string& key, const dns_query_result& result);
 
public:
    dns_client() :
    dns_client(config()) {}

    explicit dns_client(config cfg, bool use_tcp = false);
 
    ~dns_client();
 
    dns_client(const dns_client&) = delete;
    dns_client& operator=(const dns_client&) = delete;
    dns_client(dns_client&&) = delete;
    dns_client& operator=(dns_client&&) = delete;

    void set_config(config cfg) noexcept { config_ = move(cfg); }

    void set_timeout(const milliseconds timeout) noexcept { config_.timeout = timeout; }

    void set_use_tcp(const bool use_tcp) noexcept { use_tcp_ = use_tcp; }

    void set_cache_ttl(const seconds ttl) noexcept { cache_ttl_ = ttl; }

    void set_recursion_desired(const bool rd) { recursion_desired_ = rd; }

    void set_edns_udp_payload(const uint16_t payload_size) noexcept { edns_udp_payload_ = payload_size; }

    void set_dnssec_ok(const bool ok) noexcept { dnssec_ok_ = ok; }

    void clear_cache() noexcept { cache_.clear(); }

    dns_query_result query(string_view domain, dns_record::raw type = dns_record::A,
                           dns_class qclass = dns_class::INTERNET);

    future<dns_query_result> query_async(const string& domain, dns_record::raw type = dns_record::A,
                                         dns_class qclass = dns_class::INTERNET);

    vector<string> resolve_a(string_view domain);

    vector<string> resolve_aaaa(string_view domain);

    vector<string> resolve_cname(string_view domain);

    vector<string> resolve_mx(string_view domain);

    vector<string> resolve_txt(string_view domain);

    vector<dns_srv_record> resolve_srv(string_view domain);

    optional<dns_soa_record> resolve_soa(string_view domain);

    string reverse_query(string_view ip);

    vector<dns_query_result> batch_query(const vector<string>& domains, dns_record::raw type = dns_record::A);

    static byte_vector build_query(string_view domain, dns_record::raw type = dns_record::A,
                                   dns_class qclass = dns_class::INTERNET, bool rd = true, bool edns_enable = true,
                                   bool dnssec_ok = false, uint16_t edns_payload = edns::DEFAULT_UDP_PAYLOAD);

    static dns_query_result parse_response(const byte_vector& response, uint16_t expected_id = 0);
};
 // DNS
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_DNS_DNS_CLIENT_HPP__