Update edition to 2021 and use cargo fmt

Signed-off-by: Andrew Gunnerson <[email protected]>

Cargo.toml

@@ -5,7 +5,7 @@ repository = "https://github.com/chenxiaolong/ddns-updater"
 readme = "README.md"
 license = "GPL-3.0"
 version = "0.1.8"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

README.md

@@ -31,7 +31,7 @@ The resulting executable will be in `target/release/ddns-updater` or `target\rel
 
 If an issue occurs, the best way to troubleshoot is to set `log_level` to `debug` or `trace` in the config file. The `debug` level includes information like the detected IP addresses, while the `trace` level will also print out the raw DNS update request and response. Note that the `trace` output is not safe to paste online because it includes a dump of the TSIG key.
 
-To enable trace logging for everything, including the underlying trust-dns library, set the `RUST_LOG` environment variable to `trace`.
+To enable trace logging for everything, including the underlying hickory-dns library, set the `RUST_LOG` environment variable to `trace`.
 
 ## Limitations
 

config.sample.toml

@@ -23,7 +23,7 @@ name_server = ""
 #
 # Due to a bug, using `tcp` will currently result in a 5 second delay after the
 # DDNS update response is received. See:
-# https://github.com/bluejekyll/trust-dns/issues/1607
+# https://github.com/hickory-dns/hickory-dns/issues/1607
 #protocol = "udp"
 
 # The interface to query IP addresses for populating A/AAAA records. If no

src/config.rs

@@ -1,20 +1,8 @@
-use {
-    std::{
-        fmt,
-        path::Path,
-        time::Duration,
-    },
-    serde::Deserialize,
-    serde_with::{
-        base64::Base64,
-        serde_as,
-        DisplayFromStr,
-    },
-    hickory_client::rr::{
-        rdata::tsig::TsigAlgorithm,
-        Name,
-    },
-};
+use std::{fmt, path::Path, time::Duration};
+
+use hickory_client::rr::{rdata::tsig::TsigAlgorithm, Name};
+use serde::Deserialize;
+use serde_with::{base64::Base64, serde_as, DisplayFromStr};
 
 const DEFAULT_TTL: u32 = 300;
 const DEFAULT_TIMEOUT: u64 = 5;

src/dns.rs

@@ -1,49 +1,46 @@
-use {
-    std::{
-        future::Future,
-        net::{IpAddr, SocketAddr},
-        pin::Pin,
-        time::Duration,
+use hickory_client::{
+    client::{AsyncClient, Client, SyncClient},
+    error::ClientResult,
+    op::{Edns, Message, MessageType, OpCode, Query, UpdateMessage},
+    proto::{
+        error::ProtoError,
+        rr::{dnssec::tsig::TSigner, DNSClass, Name, RData, Record, RecordType},
+        xfer::DnsExchangeSend,
     },
-    hickory_client::{
-        client::{AsyncClient, Client, SyncClient},
-        error::ClientResult,
-        op::{Edns, Message, MessageType, OpCode, Query, UpdateMessage},
-        proto::{
-            error::ProtoError,
-            rr::{
-                dnssec::tsig::TSigner,
-                DNSClass, Name, RData, Record, RecordType,
-            },
-            xfer::DnsExchangeSend,
-        },
-        tcp::TcpClientConnection,
-        udp::UdpClientConnection,
-    },
-    crate::config::Protocol,
+    tcp::TcpClientConnection,
+    udp::UdpClientConnection,
+};
+
+use std::{
+    future::Future,
+    net::{IpAddr, SocketAddr},
+    pin::Pin,
+    time::Duration,
 };
 
-/// `trust_dns_client::client::NewFutureObj` is not public
+use crate::config::Protocol;
+
+/// `hickory_client::client::NewFutureObj` is not public
 type NewFutureObj<H> = Pin<
     Box<
         dyn Future<
-            Output = Result<
-                (
-                    H,
-                    Box<dyn Future<Output = Result<(), ProtoError>> + 'static + Send + Unpin>,
-                ),
-                ProtoError,
-            >,
-        >
-        + 'static
-        + Send,
+                Output = Result<
+                    (
+                        H,
+                        Box<dyn Future<Output = Result<(), ProtoError>> + 'static + Send + Unpin>,
+                    ),
+                    ProtoError,
+                >,
+            >
+            + 'static
+            + Send,
     >,
 >;
 
 /// Small wrapper to avoid callers needing to distinguish between TCP/UDP.
 pub enum DnsClient {
-    Tcp(SyncClient::<TcpClientConnection>),
-    Udp(SyncClient::<UdpClientConnection>),
+    Tcp(SyncClient<TcpClientConnection>),
+    Udp(SyncClient<UdpClientConnection>),
 }
 
 impl DnsClient {
@@ -87,9 +84,6 @@ pub fn replace_addrs_message(
     ttl: u32,
     addrs: &[IpAddr],
 ) -> Message {
-    // trust_dns_client::client::AsyncClient::MAX_PAYLOAD_LEN is not public
-    const MAX_PAYLOAD_LEN: u16 = 1232;
-
     let mut zone = Query::new();
     zone.set_name(zone_origin.clone())
         .set_query_class(DNSClass::IN)
@@ -121,7 +115,7 @@ pub fn replace_addrs_message(
     message
         .extensions_mut()
         .get_or_insert_with(Edns::new)
-        .set_max_payload(MAX_PAYLOAD_LEN)
+        .set_max_payload(hickory_client::proto::op::update_message::MAX_PAYLOAD_LEN)
         .set_version(0);
 
     message

src/iface.rs

@@ -1,11 +1,10 @@
-use {
-    std::{
-        io,
-        net::{IpAddr, SocketAddr, TcpStream},
-    },
-    netif::Interface,
+use std::{
+    io,
+    net::{IpAddr, SocketAddr, TcpStream},
 };
 
+use netif::Interface;
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("Could not connect to: {0}: {1}")]
@@ -24,19 +23,17 @@ pub struct Interfaces {
 
 impl Interfaces {
     pub fn new() -> Result<Self> {
-        let ifaces = netif::up()
-            .map_err(Error::QueryInterface)?
-            .collect();
+        let ifaces = netif::up().map_err(Error::QueryInterface)?.collect();
 
-        Ok(Self {
-            ifaces,
-        })
+        Ok(Self { ifaces })
     }
 
     pub fn get_addrs_by_name(&self, name: &str) -> Option<Vec<IpAddr>> {
         let mut found = false;
 
-        let addrs = self.ifaces.iter()
+        let addrs = self
+            .ifaces
+            .iter()
             .filter(|iface| iface.name() == name)
             .inspect(|_| found = true)
             .map(|iface| *iface.address())
@@ -52,7 +49,8 @@ impl Interfaces {
     pub fn get_iface_by_tcp_source_ip(&self, server: SocketAddr) -> Result<&str> {
         let source_ip = Self::get_tcp_source_ip(server)?;
 
-        self.ifaces.iter()
+        self.ifaces
+            .iter()
             .find(|iface| *iface.address() == source_ip)
             .map(Interface::name)
             .ok_or(Error::InterfaceNotFound(source_ip))