Update trust dns

Cargo.toml

@@ -16,8 +16,8 @@ maintenance = { status = "actively-developed" }
 
 [dependencies]
 async-trait = "0.1.57"
-trust-dns-client = "0.20.0"
-trust-dns-resolver = "0.20.0"
+hickory-client = { version = "0.24.1", features = ["dnssec-ring"] }
+hickory-resolver = "0.24.1"
 structopt = "0.3.1"
 futures = "0.3.1"
 anyhow = "1.0"

src/backend.rs

@@ -2,20 +2,20 @@
 use std::net::SocketAddr;
 
 use async_trait::async_trait;
-use tokio::net::{TcpStream, UdpSocket};
-use trust_dns_client::{
+use hickory_client::{
     client::{AsyncClient, ClientFuture, ClientHandle},
     rr,
     tcp::TcpClientStream,
     udp::UdpClientStream,
 };
-use trust_dns_resolver::{
+use hickory_resolver::{
     config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts},
-    error::ResolveError,
+    error::{ResolveError, ResolveResult},
     lookup, lookup_ip,
-    proto::{error::ProtoError, xfer::dns_request::DnsRequestOptions},
+    proto::error::ProtoError,
     TokioAsyncResolver,
 };
+use tokio::net::{TcpStream, UdpSocket};
 
 pub use tokio::runtime::Runtime;
 
@@ -28,30 +28,26 @@ pub trait Resolver: Clone {
         name: rr::Name,
         rtype: rr::RecordType,
     ) -> Result<lookup::Lookup, ResolveError>;
-    async fn lookup_ip(&self, host: rr::Name) -> Result<lookup_ip::LookupIp, ResolveError>;
-    async fn lookup_soa(&self, name: rr::Name) -> Result<lookup::SoaLookup, ResolveError>;
-    async fn lookup_ns(&self, name: rr::Name) -> Result<lookup::NsLookup, ResolveError>;
+    async fn lookup_ip(&self, host: rr::Name) -> ResolveResult<lookup_ip::LookupIp>;
+    async fn lookup_soa(&self, name: rr::Name) -> ResolveResult<lookup::SoaLookup>;
+    async fn lookup_ns(&self, name: rr::Name) -> ResolveResult<lookup::NsLookup>;
 }
 
 #[async_trait]
 impl Resolver for TokioAsyncResolver {
-    async fn lookup(
-        &self,
-        name: rr::Name,
-        rtype: rr::RecordType,
-    ) -> Result<lookup::Lookup, ResolveError> {
-        TokioAsyncResolver::lookup(self, name, rtype, DnsRequestOptions::default()).await
+    async fn lookup(&self, name: rr::Name, rtype: rr::RecordType) -> ResolveResult<lookup::Lookup> {
+        TokioAsyncResolver::lookup(self, name, rtype).await
     }
 
-    async fn lookup_ip(&self, host: rr::Name) -> Result<lookup_ip::LookupIp, ResolveError> {
+    async fn lookup_ip(&self, host: rr::Name) -> ResolveResult<lookup_ip::LookupIp> {
         TokioAsyncResolver::lookup_ip(self, host).await
     }
 
-    async fn lookup_soa(&self, name: rr::Name) -> Result<lookup::SoaLookup, ResolveError> {
+    async fn lookup_soa(&self, name: rr::Name) -> ResolveResult<lookup::SoaLookup> {
         TokioAsyncResolver::soa_lookup(self, name).await
     }
 
-    async fn lookup_ns(&self, name: rr::Name) -> Result<lookup::NsLookup, ResolveError> {
+    async fn lookup_ns(&self, name: rr::Name) -> ResolveResult<lookup::NsLookup> {
         TokioAsyncResolver::ns_lookup(self, name).await
     }
 }
@@ -65,8 +61,8 @@ pub trait Backend: Clone {
         runtime: &Runtime,
         addr: SocketAddr,
     ) -> Result<Self::Client, ProtoError>;
-    fn open_resolver(&mut self, addr: SocketAddr) -> Result<Self::Resolver, ResolveError>;
-    fn open_system_resolver(&mut self) -> Result<Self::Resolver, ResolveError>;
+    fn open_resolver(&mut self, addr: SocketAddr) -> Self::Resolver;
+    fn open_system_resolver(&mut self) -> ResolveResult<Self::Resolver>;
 }
 
 #[derive(Debug, Clone)]
@@ -82,18 +78,18 @@ impl Backend for TcpBackend {
         runtime: &Runtime,
         addr: SocketAddr,
     ) -> Result<Self::Client, ProtoError> {
-        use trust_dns_resolver::proto::iocompat::AsyncIoTokioAsStd;
+        use hickory_resolver::proto::iocompat::AsyncIoTokioAsStd;
         let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TcpStream>>::new(addr);
         let (client, bg) = AsyncClient::new(Box::new(stream), sender, None).await?;
         runtime.spawn(bg);
         Ok(client)
     }
 
-    fn open_resolver(&mut self, addr: SocketAddr) -> Result<Self::Resolver, ResolveError> {
+    fn open_resolver(&mut self, addr: SocketAddr) -> Self::Resolver {
         make_resolver(addr, Protocol::Tcp)
     }
 
-    fn open_system_resolver(&mut self) -> Result<Self::Resolver, ResolveError> {
+    fn open_system_resolver(&mut self) -> ResolveResult<Self::Resolver> {
         TokioAsyncResolver::tokio_from_system_conf()
     }
 }
@@ -117,22 +113,23 @@ impl Backend for UdpBackend {
         Ok(client)
     }
 
-    fn open_resolver(&mut self, addr: SocketAddr) -> Result<Self::Resolver, ResolveError> {
+    fn open_resolver(&mut self, addr: SocketAddr) -> Self::Resolver {
         make_resolver(addr, Protocol::Udp)
     }
 
-    fn open_system_resolver(&mut self) -> Result<Self::Resolver, ResolveError> {
+    fn open_system_resolver(&mut self) -> ResolveResult<Self::Resolver> {
         TokioAsyncResolver::tokio_from_system_conf()
     }
 }
 
-fn make_resolver(addr: SocketAddr, protocol: Protocol) -> Result<TokioAsyncResolver, ResolveError> {
+fn make_resolver(addr: SocketAddr, protocol: Protocol) -> TokioAsyncResolver {
     let mut config = ResolverConfig::new();
     config.add_name_server(NameServerConfig {
         socket_addr: addr,
         protocol,
         tls_dns_name: None,
-        trust_nx_responses: true,
+        trust_negative_responses: true,
+        bind_addr: None,
     });
     TokioAsyncResolver::tokio(config, ResolverOpts::default())
 }

src/bin/tdns.rs

@@ -11,10 +11,10 @@ use std::{
 use anyhow::anyhow;
 use data_encoding::BASE64;
 use futures::{future, StreamExt};
+use hickory_client::{proto::error::ProtoError, rr};
+use hickory_resolver::error::{ResolveError, ResolveErrorKind};
 use structopt::StructOpt;
 use tokio::runtime::Runtime;
-use trust_dns_client::{proto::error::ProtoError, rr};
-use trust_dns_resolver::error::{ResolveError, ResolveErrorKind};
 
 use tdns_cli::{
     query::{self, perform_query, Query},
@@ -302,7 +302,7 @@ fn open_resolver<D: Backend + 'static>(
     addr: Option<SocketAddr>,
 ) -> Result<D::Resolver, ResolveError> {
     if let Some(addr) = addr {
-        Ok(dns.open_resolver(addr)?)
+        Ok(dns.open_resolver(addr))
     } else {
         Ok(dns.open_system_resolver()?)
     }

src/query.rs

@@ -8,12 +8,12 @@ use chrono::DateTime;
 use data_encoding::{Encoding, BASE32, BASE64, HEXLOWER};
 use futures::stream::{FuturesUnordered, Stream};
 
-use trust_dns_client::rr::{
+use hickory_client::proto::rr::dnssec::Nsec3HashAlgorithm;
+use hickory_client::rr::{
     self,
-    dnssec::Nsec3HashAlgorithm,
     rdata::{self, caa, DNSSECRData},
 };
-use trust_dns_resolver::error::ResolveError;
+use hickory_resolver::error::ResolveError;
 
 use crate::Resolver;
 
@@ -241,9 +241,7 @@ impl<'a> fmt::Display for DisplayRData<'a> {
                 }
             }
             // TODO: What to do with records that have no specified presentation?
-            NULL(_) | OPT(_) | Unknown { .. } | ZERO | HINFO(_) | HTTPS(_) | SVCB(_) => {
-                write!(f, "{:?}", self.0)?
-            }
+            _ => write!(f, "{:?}", self.0)?,
         }
         Ok(())
     }
@@ -368,11 +366,9 @@ impl<'a> fmt::Display for DisplayDNSSECRData<'a> {
                 )?;
             }
             Unknown { rdata, .. } => {
-                // This is dubiuos, and I'm not sure how we can even end up here.
-                if let Some(data) = rdata.anything() {
-                    write!(f, "{}", DisplayEncoded(&BASE64, data))?;
-                }
+                write!(f, "{}", DisplayEncoded(&BASE64, rdata.anything()))?;
             }
+            _ => todo!(),
         }
         Ok(())
     }
@@ -443,18 +439,22 @@ pub fn write_record<W: io::Write>(
 ) -> io::Result<()> {
     match format {
         DisplayFormat::Short => {
-            write!(writer, "{}", DisplayRData(record.rdata()))?;
+            if let Some(rdata) = record.data() {
+                write!(writer, "{}", DisplayRData(rdata))?;
+            }
         }
         DisplayFormat::Zone => {
             write!(
                 writer,
-                "{} {} {} {} {}",
+                "{} {} {} {}",
                 record.name(),
                 record.ttl(),
                 record.dns_class(),
                 record.record_type(),
-                DisplayRData(record.rdata()),
             )?;
+            if let Some(rdata) = record.data() {
+                write!(writer, " {}", DisplayRData(rdata))?;
+            }
         }
     }
     Ok(())

src/record.rs

@@ -7,7 +7,7 @@ use std::{
     string::FromUtf8Error,
 };
 
-use trust_dns_client::rr::{self, rdata};
+use hickory_client::rr::{self, rdata};
 
 /// This is a representation of the record set as described in RFC 2136.
 ///
@@ -115,8 +115,10 @@ impl<'a> Iterator for RsDataIter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         use RsDataIterInner::*;
         match &mut self.0 {
-            A(iter) => iter.next().map(|item| rr::RData::A(*item)),
-            AAAA(iter) => iter.next().map(|item| rr::RData::AAAA(*item)),
+            A(iter) => iter.next().map(|item| rr::RData::A(rr::rdata::A(*item))),
+            AAAA(iter) => iter
+                .next()
+                .map(|item| rr::RData::AAAA(rr::rdata::AAAA(*item))),
             TXT(iter) => iter
                 .next()
                 .map(|item| rr::RData::TXT(rdata::TXT::new(vec![item.into()]))),
@@ -290,22 +292,20 @@ impl TryFrom<&[rr::Record]> for RecordSet {
             0 => Err(TryFromRecordsError::Empty),
             1 => {
                 let key = keys.iter().next().unwrap();
-                // TODO: I'm not sure if `trust-dns` actually guarantees that
-                // these `unwrap` calls never panic, but I'd guess so. I should
-                // study its code and submit a documentation patch to clarify
-                // behavior in either case.
                 let data = match key.record_type {
-                    rr::RecordType::A => {
-                        RsData::A(rrs.iter().map(|rr| *rr.rdata().as_a().unwrap()).collect())
-                    }
+                    rr::RecordType::A => RsData::A(
+                        rrs.iter()
+                            .filter_map(|rr| Some(rr.data()?.as_a()?.0))
+                            .collect(),
+                    ),
                     rr::RecordType::AAAA => RsData::AAAA(
                         rrs.iter()
-                            .map(|rr| *rr.rdata().as_aaaa().unwrap())
+                            .filter_map(|rr| Some(rr.data()?.as_aaaa()?.0))
                             .collect(),
                     ),
                     rr::RecordType::TXT => RsData::TXT(
                         rrs.iter()
-                            .map(|rr| txt_string(rr.rdata().as_txt().unwrap()))
+                            .filter_map(|rr| Some(txt_string(rr.data()?.as_txt()?)))
                             .collect::<Result<_, _>>()?,
                     ),
                     rtype => return Err(TryFromRecordsError::UnsupportedType(rtype)),

src/tsig.rs

@@ -6,14 +6,14 @@ use std::{
 };
 
 use digest::KeyInit;
-use hmac::{Hmac, Mac};
-use once_cell::sync::Lazy;
-use trust_dns_client::{
+use hickory_client::{
     op,
     proto::error::{ProtoError, ProtoResult},
     rr,
     serialize::binary::{BinEncodable, BinEncoder},
 };
+use hmac::{Hmac, Mac};
+use once_cell::sync::Lazy;
 
 #[derive(Debug)]
 pub enum Error {
@@ -198,7 +198,7 @@ impl TryFrom<TSIG> for rr::RData {
         encoder.set_canonical_names(true);
         tsig.emit(&mut encoder)?;
         Ok(rr::RData::Unknown {
-            code: 250,
+            code: rr::RecordType::Unknown(250),
             rdata: rr::rdata::null::NULL::with(encoded),
         })
     }

src/update.rs

@@ -8,12 +8,12 @@ use std::{
 
 use anyhow::anyhow;
 use futures::stream::{FuturesUnordered, TryStreamExt};
-use tokio::time::{sleep, timeout};
-use trust_dns_client::{
+use hickory_client::{
     op::{Message, Query},
     proto::xfer::{DnsHandle, DnsRequestOptions},
     rr,
 };
+use tokio::time::{sleep, timeout};
 
 use crate::{
     record::{RecordSet, RsData},
@@ -180,9 +180,9 @@ where
     } else {
         return Err(anyhow!("SOA record for {} not found", options.zone));
     };
-    let mut server = dns.open(runtime, master).await?;
-    // TODO: probably should check response
-    server.send(message).await?;
+    let server = dns.open(runtime, master).await?;
+    // TODO: probably should check responses
+    let _reponses: Vec<_> = server.send(message).try_collect().await?;
     Ok(())
 }
 
@@ -219,7 +219,7 @@ async fn poll_for_update<D, I>(
     options: Rc<Monitor>,
 ) -> anyhow::Result<()>
 where
-    I: IntoIterator<Item = rr::Name>,
+    I: IntoIterator<Item = rr::rdata::name::NS>,
     D: Backend,
 {
     let results: FuturesUnordered<_> = authorative
@@ -229,7 +229,7 @@ where
                 runtime,
                 dns.clone(),
                 resolver.clone(),
-                server_name,
+                server_name.0,
                 Rc::clone(&options),
             )
         })
@@ -257,22 +257,26 @@ where
     if options.exclude.contains(&ip) {
         return Ok(());
     }
-    let mut server = dns.open(runtime, SocketAddr::new(ip, 53)).await?;
+    let server = dns.open(runtime, SocketAddr::new(ip, 53)).await?;
     let server_name = server_name.clone();
     let options = Rc::clone(&options);
     let query = options.get_query();
     loop {
-        if let Ok(response) = server
+        if let Ok(responses) = server
             .lookup(query.clone(), DnsRequestOptions::default())
+            .try_collect::<Vec<_>>()
             .await
         {
-            let answers = response.answers();
-            let hit = options.expectation.satisfied_by(answers);
+            let answers: Vec<_> = responses
+                .into_iter()
+                .flat_map(|response| response.into_message().take_answers())
+                .collect();
+            let hit = options.expectation.satisfied_by(&answers);
             if options.verbose {
                 if hit {
                     println!("{}: match found", &server_name);
                 } else {
-                    let rset = match RecordSet::try_from(answers) {
+                    let rset = match RecordSet::try_from(&answers[..]) {
                         Ok(rs) => format!("{}", rs.data()),
                         Err(e) => format!("{}", e),
                     };