feat: validate address when reading the config

src/config.rs

@@ -1,6 +1,6 @@
 use std::{
     ffi::OsStr,
-    fs,
+    fs, net,
     path::{Path, PathBuf},
 };
 
@@ -14,9 +14,8 @@ pub struct Config {
 
 #[derive(Debug, Deserialize)]
 pub struct Server {
-    // I can't use `SocketAddr` directly here if I wanted
-    // to make the port optional.
-    pub address: String,
+    #[serde(deserialize_with = "deserialize_address")]
+    pub address: net::SocketAddr,
     pub name: String,
 }
 
@@ -50,3 +49,20 @@ where
         }
     }
 }
+
+/// Parse address string into `SocketAddr`
+fn deserialize_address<'de, D>(deserializer: D) -> Result<net::SocketAddr, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let address: String = Deserialize::deserialize(deserializer)?;
+
+    if address.contains(':') {
+        address.parse().map_err(serde::de::Error::custom)
+    } else {
+        // Use default port
+        format!("{address}:53")
+            .parse()
+            .map_err(serde::de::Error::custom)
+    }
+}

src/dns.rs

@@ -1,3 +1,4 @@
+use std::net;
 use std::str::FromStr;
 
 use hickory_client::client::{Client, SyncClient};
@@ -7,21 +8,14 @@ use hickory_client::udp::UdpClientConnection;
 
 use crate::error::Error;
 
-pub fn query(domain: &str, rtype: RecordType, address: &str) -> Result<DnsResponse, Error> {
-    let socket_address = parse_address(address)?;
-    let conn = UdpClientConnection::new(socket_address)?;
+pub fn query(
+    domain: &str,
+    rtype: RecordType,
+    address: net::SocketAddr,
+) -> Result<DnsResponse, Error> {
+    let conn = UdpClientConnection::new(address)?;
     let client = SyncClient::new(conn);
 
     let name = Name::from_str(&format!("{}.", domain))?;
     Ok(client.query(&name, DNSClass::IN, rtype)?)
 }
-
-/// Parse address string into `SocketAddr`
-fn parse_address(address: &str) -> Result<std::net::SocketAddr, Error> {
-    if address.contains(':') {
-        Ok(address.parse::<std::net::SocketAddr>()?)
-    } else {
-        // Use default port
-        Ok(format!("{address}:53").parse::<std::net::SocketAddr>()?)
-    }
-}

src/error.rs

@@ -41,12 +41,6 @@ impl std::convert::From<std::io::Error> for Error {
     }
 }
 
-impl std::convert::From<std::net::AddrParseError> for Error {
-    fn from(err: std::net::AddrParseError) -> Self {
-        Self::InvalidArgument(err.to_string())
-    }
-}
-
 impl std::convert::From<hickory_client::error::ClientError> for Error {
     fn from(err: hickory_client::error::ClientError) -> Self {
         Self::InvalidArgument(err.to_string())

src/output.rs

@@ -22,7 +22,7 @@ impl Printer {
     }
     pub fn print(&self) -> Result<(), crate::Error> {
         for server in &self.config.servers {
-            let response = dns::query(&self.domain, self.record_type, &server.address);
+            let response = dns::query(&self.domain, self.record_type, server.address);
             trace!("Response -> {:?}", response);
 
             stdout(&server.name.to_string());

tests/integration_test.rs

@@ -111,8 +111,8 @@ name = "Google"
 
     cmd.arg("example.net").arg("-c").arg(config.to_path_buf());
     cmd.assert()
-        .success()
-        .stdout(predicate::str::contains("invalid socket address syntax"));
+        .failure()
+        .stderr(predicate::str::contains("invalid socket address syntax"));
 
     temp_dir.close()?;
     Ok(())