⬆ Update HickoryDNS (#459)

Author: mokeyish

Cargo.lock

@@ -68,7 +68,7 @@ service = [
 
 nft = ["dep:which", "dep:either"]
 
-dnssec = ["hickory-proto/dnssec", "hickory-proto/dnssec-ring", "rustls/ring"]
+dnssec = [ "hickory-proto/dnssec-ring", "rustls/ring"]
 
 experimental = ["experimental-trie", "experimental-phf"]
 
@@ -89,13 +89,13 @@ hostname = { git = "https://github.com/mokeyish/hostname.git", branch = "dev" }
 # enum_dispatch = { git = "https://gitlab.com/mokeyish/enum_dispatch.git", branch = "master"}
 # axum = { git = "https://github.com/tokio-rs/axum.git", rev = "8854e66" }
 # boomphf ={ path = "./target/patch/boomphf-0.6.0"}
-rustls-pki-types = { git = "https://github.com/mokeyish/pki-types.git", rev = "1.9.0.smartdns.1" }
+rustls-pki-types = { git = "https://github.com/mokeyish/pki-types.git", rev = "1.10.1.smartdns.1" }
 
 [dependencies]
 cfg-if = "1"
 clap = { version = "4.5", features = ["derive"] }
 clap-verbosity-flag = "2.2.2"
-thiserror = "1.0"
+thiserror = "2.0"
 anyhow = "1.0"
 once_cell = "1.16.0"
 nom = "7.1.3"
@@ -143,8 +143,8 @@ tracing-subscriber = { version = "0.3", features = [
 # tracing-appender = "0.2"
 
 # hickory dns
-hickory-proto = { git = "https://github.com/mokeyish/hickory-dns.git", rev = "0.25.0-smartdns.5", version = "0.25.0-alpha.2", features = ["serde"]}
-hickory-resolver = { git = "https://github.com/mokeyish/hickory-dns.git", rev = "0.25.0-smartdns.5", version = "0.25.0-alpha.2", features = [
+hickory-proto = { git = "https://github.com/mokeyish/hickory-dns.git", rev = "0.25.0-smartdns.6", version = "0.25.0-alpha.4", features = ["serde"]}
+hickory-resolver = { git = "https://github.com/mokeyish/hickory-dns.git", rev = "0.25.0-smartdns.6", version = "0.25.0-alpha.4", features = [
   "serde",
   "system-config",
 ] }
@@ -155,7 +155,7 @@ quinn = { version = "0.11.2", default-features = false }
 webpki-roots = "0.26"
 rustls = { version = "0.23", default-features = false, features = ["std", "tls12"]  }
 rustls-pemfile = "2"
-rustls-native-certs = "0.7"
+rustls-native-certs = "0.8"
 
 lru = { version = "0.12", default-features = false }
 # time = "0.3"
@@ -167,7 +167,7 @@ csv = "1.1"
 hostname = "0.3"
 byte-unit = { version = "5.0.3", features = ["serde"]}
 ipnet = "2.7"
-which = { version = "6.0.1", optional = true }
+which = { version = "7.0.1", optional = true }
 glob = "0.3.1"
 
 # process
@@ -181,7 +181,7 @@ async-http-proxy = { version = "1.2.5", features = [
 ] }
 
 num-traits = "0.2.19"
-url = "2.5.2"
+url = "2.5.4"
 # regex = "1"
 # rnp = "0.1"
 boomphf = { version = "0.6.0", optional = true }
@@ -223,8 +223,8 @@ anyhow = "1.0"
 
 
 [target.'cfg(target_os = "linux")'.build-dependencies]
-cc = "1.1"
-bindgen = "0.69.4"
+cc = "1.2"
+bindgen = "0.70"
 
 
 # Dev-dependencies are not used when compiling a package for building, but are used for compiling tests, examples, and benchmarks.

Cargo.toml

@@ -337,13 +337,13 @@ async fn process(
     message: SerialMessage,
     server_opts: ServerOpts,
 ) -> SerialMessage {
-    use crate::libdns::proto::error::ProtoError;
     use crate::libdns::proto::op::{Header, Message, MessageType, OpCode, ResponseCode};
+    use crate::libdns::proto::ProtoError;
 
     let addr = message.addr();
     let protocol = message.protocol();
 
-    return match DnsRequest::try_from(message) {
+    match DnsRequest::try_from(message) {
         Ok(request) => {
             match request.message_type() {
                 MessageType::Query => {
@@ -408,6 +408,7 @@ async fn process(
                         OpCode::Status => todo!(),
                         OpCode::Notify => todo!(),
                         OpCode::Update => todo!(),
+                        OpCode::Unknown(_) => todo!(),
                     }
                 }
                 MessageType::Response => todo!(),
@@ -438,5 +439,5 @@ async fn process(
             SerialMessage::raw(response_message, addr, protocol)
         }
         _ => SerialMessage::raw(Default::default(), addr, protocol),
-    };
+    }
 }

src/app.rs

@@ -1,6 +1,5 @@
-use std::ops::Deref;
-
 use crate::libdns::proto::rr::Name;
+use std::ops::Deref;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum WildcardName {
@@ -33,9 +32,9 @@ impl WildcardName {
     pub fn is_match(&self, name: &Name) -> bool {
         match self {
             WildcardName::Default(n) => n.zone_of(name),
-            WildcardName::Suffix(n) => n != name && n.zone_of(name),
-            WildcardName::Sub(n) => n == &name.base_name(),
-            WildcardName::Full(n) => n == name,
+            WildcardName::Suffix(n) => !n.eq_ignore_root_case(name) && n.zone_of(name),
+            WildcardName::Sub(n) => n.eq_ignore_root_case(&name.base_name()),
+            WildcardName::Full(n) => n.eq_ignore_root_case(name),
         }
     }
 }

src/config/domain.rs

@@ -26,7 +26,6 @@ pub struct LogConfig {
     pub num: Option<u64>,
 
     /// log file mode
-
     #[serde(with = "serde_opt_str")]
     pub file_mode: Option<FileMode>,
 

src/config/log.rs

@@ -3,7 +3,7 @@ use super::*;
 impl NomParser for Name {
     fn parse(input: &str) -> IResult<&str, Self> {
         let name = is_not(" \n\t\\/|\"#',!+<>");
-        map_res(name, <Name as std::str::FromStr>::from_str)(input)
+        map_res(name, |s: &str| s.parse())(input)
     }
 }
 

src/config/parser/domain.rs

@@ -150,7 +150,7 @@ pub fn parse_config(input: &str) -> IResult<&str, OneConfig> {
 
     fn parse_item<'a, T: NomParser>(
         keyword: &'static str,
-    ) -> impl FnMut(&'a str) -> IResult<&str, T> {
+    ) -> impl FnMut(&'a str) -> IResult<&'a str, T> {
         preceded(tuple((space0, tag_no_case(keyword), space1)), T::parse)
     }
 

src/config/parser/mod.rs

@@ -14,17 +14,17 @@ use crate::dns_conf::RuntimeConfig;
 pub use crate::dns_rule::DomainRuleGetter;
 
 pub use crate::libdns::proto::{
-    error::ProtoErrorKind,
     op,
     rr::{self, rdata::SOA, Name, RData, Record, RecordType},
+    ProtoErrorKind,
 };
 
 pub use crate::libdns::{
     proto::xfer::Protocol,
     resolver::{
         config::{NameServerConfig, NameServerConfigGroup},
-        error::{ResolveError, ResolveErrorKind},
         lookup::Lookup,
+        ResolveError, ResolveErrorKind,
     },
 };
 
@@ -115,7 +115,7 @@ impl Default for LookupFrom {
 mod serial_message {
 
     use crate::dns_error::LookupError;
-    use crate::libdns::proto::error::ProtoError;
+    use crate::libdns::proto::ProtoError;
     use crate::libdns::Protocol;
     use crate::{config::ServerOpts, libdns::proto::op::Message};
     use bytes::Bytes;
@@ -214,9 +214,9 @@ mod request {
 
     use crate::libdns::{
         proto::{
-            error::ProtoError,
             op::{LowerQuery, Message, Query},
             rr::{Name, RecordType},
+            ProtoError,
         },
         Protocol,
     };
@@ -293,7 +293,7 @@ mod request {
             let rtype = self.query().query_type();
             self.extensions()
                 .as_ref()
-                .map(|e| e.dnssec_ok())
+                .map(|e| e.flags().dnssec_ok)
                 .unwrap_or(rtype.is_dnssec())
         }
     }

src/dns.rs

@@ -22,20 +22,18 @@ use crate::{
 
 use crate::libdns::{
     proto::{
-        error::{ProtoError, ProtoErrorKind, ProtoResult},
         op::{Edns, Message, MessageType, OpCode, Query},
         rr::{
             domain::{IntoName, Name},
             rdata::opt::{ClientSubnet, EdnsOption},
             Record, RecordType,
         },
         xfer::{DnsRequest, DnsRequestOptions, FirstAnswer},
-        DnsHandle,
+        DnsHandle, ProtoError, ProtoErrorKind,
     },
     resolver::{
-        config::{ResolverOpts, ServerOrderingStrategy, TlsClientConfig},
+        config::{ResolverOpts, ServerOrderingStrategy},
         name_server::GenericConnector,
-        TryParseIp,
     },
 };
 
@@ -465,7 +463,7 @@ impl NameServer {
                 tls_client_config.normal
             };
 
-            (Some(url.host().to_string()), Some(TlsClientConfig(config)))
+            (Some(url.host().to_string()), Some(config))
         } else {
             (None, None)
         };
@@ -631,7 +629,7 @@ impl GenericResolver for NameServer {
         name: N,
         options: O,
     ) -> Result<DnsResponse, LookupError> {
-        use crate::libdns::proto::error::ProtoErrorKind;
+        use crate::libdns::proto::ProtoErrorKind;
         let name = name.into_name()?;
         let options: LookupOptions = options.into();
 
@@ -780,32 +778,13 @@ pub trait GenericResolver {
 
 #[async_trait::async_trait]
 pub trait GenericResolverExt {
-    /// Generic lookup for any RecordType
-    ///
-    /// # Arguments
-    ///
-    /// * `name` - name of the record to lookup, if name is not a valid domain name, an error will be returned
-    /// * `record_type` - type of record to lookup, all RecordData responses will be filtered to this type
-    ///
-    /// # Returns
-    ///
-    //  A future for the returned Lookup RData
-    // async fn lookup<N: IntoName + Send>(
-    //     &self,
-    //     name: N,
-    //     record_type: RecordType,
-    // ) -> Result<Lookup, ResolveError>;
-
     /// Performs a dual-stack DNS lookup for the IP for the given hostname.
     ///
     /// See the configuration and options parameters for controlling the way in which A(Ipv4) and AAAA(Ipv6) lookups will be performed. For the least expensive query a fully-qualified-domain-name, FQDN, which ends in a final `.`, e.g. `www.example.com.`, will only issue one query. Anything else will always incur the cost of querying the `ResolverConfig::domain` and `ResolverConfig::search`.
     ///
     /// # Arguments
     /// * `host` - string hostname, if this is an invalid hostname, an error will be returned.
-    async fn lookup_ip<N: IntoName + TryParseIp + Send>(
-        &self,
-        host: N,
-    ) -> Result<DnsResponse, LookupError>;
+    async fn lookup_ip<N: IntoName + Send>(&self, host: N) -> Result<DnsResponse, LookupError>;
 }
 
 #[async_trait::async_trait]
@@ -814,18 +793,16 @@ where
     T: GenericResolver + Sync,
 {
     /// * `host` - string hostname, if this is an invalid hostname, an error will be returned.
-    async fn lookup_ip<N: IntoName + TryParseIp + Send>(
-        &self,
-        host: N,
-    ) -> Result<DnsResponse, LookupError> {
+    async fn lookup_ip<N: IntoName + Send>(&self, host: N) -> Result<DnsResponse, LookupError> {
         let mut finally_ip_addr: Option<Record> = None;
-        let maybe_ip = host.try_parse_ip();
-        let maybe_name: ProtoResult<Name> = host.into_name();
+        let maybe_ip = host.to_ip();
+        let maybe_name: Result<Name, ProtoError> = host.into_name();
 
         // if host is a ip address, return directly.
         if let Some(ip_addr) = maybe_ip {
+            let ip_addr = ip_addr.into();
             let name = maybe_name.clone().unwrap_or_default();
-            let record = Record::from_rdata(name.clone(), MAX_TTL, ip_addr.clone());
+            let record = Record::from_rdata(name.clone(), MAX_TTL, Clone::clone(&ip_addr));
 
             // if ndots are greater than 4, then we can't assume the name is an IpAddr
             //   this accepts IPv6 as well, b/c IPv6 can take the form: 2001:db8::198.51.100.35

src/dns_client.rs

@@ -1,10 +1,10 @@
 use crate::dns::{DefaultSOA as _, DnsResponse};
 use crate::libdns::proto::{
-    error::{ProtoError, ProtoErrorKind},
     op::{Query, ResponseCode},
     rr::{rdata::SOA, Record},
+    ProtoError, ProtoErrorKind,
 };
-use crate::libdns::resolver::error::{ResolveError, ResolveErrorKind};
+use crate::libdns::resolver::{ResolveError, ResolveErrorKind};
 use std::{io, sync::Arc};
 use thiserror::Error;
 
@@ -79,6 +79,7 @@ impl LookupError {
             response_code: ResponseCode::ServFail,
             trusted: true,
             ns: None,
+            authorities: None,
         }
         .into()
     }