cdns-rs 1.2.2

A native Sync/Async Rust implementation of client DNS resolver.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

/*-
 * cdns-rs - a simple sync/async DNS query library
 * 
 * Copyright (C) 2020  Aleksandr Morozov
 * 
 * Copyright (C) 2025 Aleksandr Morozov
 * 
 * The syslog-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *                     
 *   2. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */

use std::hash::{Hash, Hasher};

use crate::error::CDnsResult;

use crate::cfg_resolv_parser::{ResolveConfig, ResolveConfigLookup};

use super::{QDnsName, QType, common::DnsRequestHeader};


#[derive(Debug)]
pub(crate) struct QDnsReq<'req>
{
    req_name: QDnsName<'req>,
    qtype: QType,
    header: Option<DnsRequestHeader>,
}


impl<'req> Eq for QDnsReq<'req> {}

impl<'req> PartialEq for QDnsReq<'req>
{
    fn eq(&self, other: &QDnsReq) -> bool 
    {
        return self.req_name == other.req_name;
    }
}

/*
impl<'req> Ord for QDnsReq<'req> 
{
    fn cmp(&self, other: &Self) -> Ordering 
    {
        // Sort in reverse order
        return self.header.id.cmp(&other.header.id);
    }
}

impl<'req> PartialOrd for QDnsReq<'req> 
{
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> 
    {
        return Some(self.cmp(other));
    }
}*/

impl<'req> Hash for QDnsReq<'req>
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.req_name.hash(state);
    }
}

/*
impl Borrow<u16> for QDnsReq
{
    fn borrow(&self) -> &u16 
    {
        return &self.header.id;
    }
}*/

impl<'req> QDnsReq<'req>
{
    pub(crate)
    fn new(req_name: QDnsName<'req>, qtype: QType, resolvers: &ResolveConfig) -> CDnsResult<Self>
    {
        let lookup = 
            if resolvers.lookup.contains(ResolveConfigLookup::BIND) == true
            {
                Some(DnsRequestHeader::construct_lookup(req_name.clone(), qtype)?)
            }
            else
            {
                None
            };

        return Ok(QDnsReq { req_name: req_name, qtype: qtype, header: lookup });
    }

    pub(crate)
    fn get_header(&self) -> &DnsRequestHeader
    {
        return self.header.as_ref().unwrap();
    }

    pub(crate) 
    fn get_type(&self) -> &QType
    {
        return &self.qtype;
    }

    pub(crate) 
    fn get_req_name(&self) -> &QDnsName<'req>
    {
        return &self.req_name;
    }
}