dns_message.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_DNS_DNS_MESSAGE_HPP__
#define NEFORCE_NETWORK_DNS_DNS_MESSAGE_HPP__

 
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/exception/system_exception.hpp"
#include "NeForce/core/string/string.hpp"
#include "NeForce/core/time/duration.hpp"
NEFORCE_BEGIN_NAMESPACE__


enum class dns_opcode : uint8_t {
    QUERY = 0,  
    IQUERY = 1, 
    STATUS = 2, 
    NOTIFY = 4, 
    UPDATE = 5  
};

enum class dns_class : uint16_t {
    INTERNET = 1, 
    CHAOS = 3,    
    HESIOD = 4,   
    ANY = 255     
};

enum class dns_response : uint8_t {
    NON_ERROR = 0,       
    FORMAT_ERROR = 1,    
    SERVER_FAILURE = 2,  
    NAME_ERROR = 3,      
    NOT_IMPLEMENTED = 4, 
    REFUSED = 5          
};
 // DNS


class dns_exception final : public network_exception {
public:
    enum class code {
        TIMEOUT,        
        NETWORK_ERROR,  
        PARSE_ERROR,    
        SERVER_FAILURE, 
        TRUNCATED,      
        NO_RECORD       
    };
 
    explicit dns_exception(const string& info) :
    network_exception(info.data()) {}
 
    dns_exception(const string& info, const code code) :
    network_exception(info.data(), error_code{static_cast<int>(code), generic_category()}) {}

    static dns_exception timeout() { return {"DNS query timeout", code::TIMEOUT}; }

    static dns_exception network_error(const string& detail, const code code = code::NETWORK_ERROR) {
        return {"Network error: " + detail, code};
    }

    static dns_exception parse_error(const string& detail) { return {"Parse error: " + detail, code::PARSE_ERROR}; }
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "dns_exception"; }
};
 // Exceptions


struct dns_record {
    enum raw : uint16_t {
        A = 1,     
        NS = 2,    
        CNAME = 5, 
        SOA = 6,   
        PTR = 12,  
        MX = 15,   
        TXT = 16,  
        AAAA = 28, 
        SRV = 33   
    };
 
    string name;          
    string data;          
    uint32_t ttl;         
    raw type{raw::A};     
    dns_class class_type; 

    dns_record() = default;

    dns_record(string n, const raw t, const dns_class c, const uint32_t ttl_val, string d) noexcept :
    name(_NEFORCE move(n)),
    data(_NEFORCE move(d)),
    ttl(ttl_val),
    type(t),
    class_type(c) {}
};

struct dns_query_result {
    vector<dns_record> answers;                          
    vector<dns_record> authorities;                      
    vector<dns_record> additional;                       
    milliseconds query_time;                             
    dns_response response_code{dns_response::NON_ERROR}; 
    uint8_t extended_rcode{0};                           
    uint16_t udp_payload_size{512};                      
    uint8_t edns_version{0};                             
    bool dnssec_ok{false};                               
    bool authoritative{false};                           
    bool truncated{false};                               
    bool recursive_available{false};                     

    NEFORCE_NODISCARD bool is_success() const noexcept { return response_code == dns_response::NON_ERROR; }

    NEFORCE_NODISCARD uint16_t full_rcode() const noexcept {
        return static_cast<uint16_t>(response_code) | (static_cast<uint16_t>(extended_rcode) << 4);
    }
};

struct dns_header {
    uint16_t id = 0;      
    uint16_t flags = 0;   
    uint16_t qdcount = 0; 
    uint16_t ancount = 0; 
    uint16_t nscount = 0; 
    uint16_t arcount = 0; 
};

namespace edns {
    NEFORCE_INLINE17 constexpr uint16_t OPT_TYPE = 41;              
    NEFORCE_INLINE17 constexpr uint16_t DEFAULT_UDP_PAYLOAD = 1232; 
    NEFORCE_INLINE17 constexpr uint16_t MAX_UDP_PAYLOAD = 4096;     
    NEFORCE_INLINE17 constexpr uint8_t VERSION = 0;                 
    NEFORCE_INLINE17 constexpr uint8_t EXT_RCODE_SHIFT = 24;        
    NEFORCE_INLINE17 constexpr uint8_t VERSION_SHIFT = 16;          
    NEFORCE_INLINE17 constexpr uint16_t DO_BIT = 0x8000;            
    NEFORCE_INLINE17 constexpr uint8_t MAX_UDP_RETRIES = 2;         
    NEFORCE_INLINE17 constexpr seconds NEGATIVE_CACHE_TTL{30};      
} // namespace edns

struct dns_srv_record {
    uint16_t priority{0}; 
    uint16_t weight{0};   
    uint16_t port{0};     
    string target;        
 
    dns_srv_record() = default;
    dns_srv_record(const uint16_t prio, const uint16_t w, const uint16_t p, string t) :
    priority(prio),
    weight(w),
    port(p),
    target(_NEFORCE move(t)) {}
};

struct dns_soa_record {
    string mname;        
    string rname;        
    uint32_t serial{0};  
    uint32_t refresh{0}; 
    uint32_t retry{0};   
    uint32_t expire{0};  
    uint32_t minimum{0}; 
 
    dns_soa_record() = default;
};
 // DNS
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_DNS_DNS_MESSAGE_HPP__