Add a queryable zone tree

Cargo.toml

@@ -22,25 +22,31 @@ pin-project-lite = "0.2"
 time             =  { version = "0.3.1", default-features = false }
 
 rand           = { version = "0.8", optional = true }
+arc-swap       = { version = "1.7.0", optional = true }
 bytes          = { version = "1.0", optional = true, default-features = false }
-chrono         = { version = "0.4.6", optional = true, default-features = false }
+chrono         = { version = "0.4.35", optional = true, default-features = false } # 0.4.35 deprecates Duration::seconds()
+futures        = { version = "0.3.22", optional = true } # Force futures to at least 0.3.22 for minimal-version build
 futures-util   = { version = "0.3", optional = true }
 heapless       = { version = "0.8", optional = true }
+hex            = { version = "0.4", optional = true }
+libc           = { version = "0.2.153", default-features = false, optional = true } # 0.2.79 is the first version that has IP_PMTUDISC_OMIT
+parking_lot    = { version = "0.11.2", optional = true }
 moka           = { version = "0.12.3", optional = true, features = ["future"] }
-#openssl       = { version = "0.10", optional = true }
+proc-macro2    = { version = "1.0.69", optional = true } # Force proc-macro2 to at least 1.0.69 for minimal-version build
 ring           = { version = "0.17", optional = true }
 serde          = { version = "1.0.130", optional = true, features = ["derive"] }
 siphasher      = { version = "1", optional = true }
 smallvec       = { version = "1.3", optional = true }
 tokio          = { version = "1.33", optional = true, features = ["io-util", "macros", "net", "time", "sync", "rt-multi-thread" ] }
 tokio-rustls   = { version = "0.24", optional = true, features = [] }
+tracing        = { version = "0.1.40", optional = true }
 
-# XXX Force proc-macro2 to at least 1.0.69 for minimal-version build
-proc-macro2    = "1.0.69"
+# For testing in integration tests:
+mock_instant = { version = "0.3.2", optional = true, features = ["sync"] }
 
 [target.'cfg(macos)'.dependencies]
 # specifying this overrides minimum-version mio's 0.2.69 libc dependency, which allows the build to work
-libc = { version = "0.2.71", default-features = false, optional = true }
+libc = { version = "0.2.153", default-features = false, optional = true }
 
 [features]
 default     = ["std", "rand"]
@@ -59,26 +65,37 @@ zonefile    = ["bytes", "std"]
 
 # Unstable features
 unstable-client-transport = [ "moka" ]
+unstable-server-transport = ["arc-swap", "chrono/clock", "hex", "libc", "tracing"]
+unstable-zonetree = ["futures", "parking_lot", "serde", "tokio", "tracing"]
+
+# Test features
+mock-time = ["mock_instant"]
 
 [dev-dependencies]
-rstest             = "0.18.2"
-rustls             = { version = "0.21.9" }
-serde_test         = "1.0.130"
-serde_json         = "1.0.113"
-serde_yaml         = "0.9"
-tokio              = { version = "1", features = ["rt-multi-thread", "io-util", "net"] }
-tokio-test	   = "0.4"
-tracing            = "0.1.40"
-webpki-roots       = { version = "0.25" }
+rstest       = "0.18.2"
+rustls       = { version = "0.21.9" }
+serde_test   = "1.0.130"
+serde_json   = "1.0.113"
+serde_yaml   = "0.9"
+tokio        = { version = "1", features = ["rt-multi-thread", "io-util", "net", "test-util"] }
+tokio-test	 = "0.4"
+webpki-roots = { version = "0.25" }
+
+rustls-pemfile = { version = "1.0" }
+socket2        = { version = "0.5.5" }
+tokio-tfo      = { version = "0.2.0" }
+
+# For tracing support in integration tests:
+lazy_static        = { version = "1.4.0" } # Force lazy_static to > 1.0.0 for https://github.com/rust-lang-nursery/lazy-static.rs/pull/107
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+
+# For the "mysql-zone" example
+#sqlx = { version = "0.6", features = [ "runtime-tokio-native-tls", "mysql" ] }
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[[example]]
-name = "readzone"
-required-features = ["zonefile"]
-
 [[example]]
 name = "download-rust-lang"
 required-features = ["resolv"]
@@ -98,3 +115,30 @@ required-features = ["std", "rand"]
 [[example]]
 name = "client-transports"
 required-features = ["net", "unstable-client-transport"]
+
+[[example]]
+name = "server-transports"
+required-features = ["net", "unstable-server-transport"]
+
+[[example]]
+name = "read-zone"
+required-features = ["zonefile"]
+
+[[example]]
+name = "query-zone"
+required-features = ["zonefile", "unstable-zonetree"]
+
+[[example]]
+name = "serve-zone"
+required-features = ["zonefile", "net", "unstable-server-transport", "unstable-zonetree"]
+
+# This example is commented out because it is difficult, if not impossible,
+# when including the sqlx dependency, to make the dependency tree compatible
+# with both `cargo +nightly update -Z minimal versions` and the crate minimum
+# supported Rust version (1.67 at the time of writing), both of which are
+# tested by our CI setup. To try this example, uncomment the lines below and
+# the sqlx dependency above, then run `cargo run --example mysql-zone`.
+#[[example]]
+#name = "mysql-zone"
+#path = "examples/other/mysql-zone.rs"
+#required-features = ["zonefile", "net", "unstable-server-transport", "unstable-zonetree"]

examples/client-transports.rs

@@ -76,7 +76,7 @@ async fn main() {
     // Get the reply
     println!("Wating for UDP+TCP reply");
     let reply = request.get_response().await;
-    println!("UDP+TCP reply: {:?}", reply);
+    println!("UDP+TCP reply: {reply:?}");
 
     // The query may have a reference to the connection. Drop the query
     // when it is no longer needed.
@@ -94,15 +94,15 @@ async fn main() {
     // Get the reply
     println!("Wating for cache reply");
     let reply = request.get_response().await;
-    println!("Cache reply: {:?}", reply);
+    println!("Cache reply: {reply:?}");
 
     // Send the request message again.
     let mut request = cache.send_request(req.clone());
 
     // Get the reply
     println!("Wating for cached reply");
     let reply = request.get_response().await;
-    println!("Cached reply: {:?}", reply);
+    println!("Cached reply: {reply:?}");
 
     // Create a new TCP connections object. Pass the destination address and
     // port as parameter.
@@ -130,7 +130,7 @@ async fn main() {
     println!("Wating for multi TCP reply");
     let reply =
         timeout(Duration::from_millis(500), request.get_response()).await;
-    println!("multi TCP reply: {:?}", reply);
+    println!("multi TCP reply: {reply:?}");
 
     drop(request);
 
@@ -181,7 +181,7 @@ async fn main() {
     println!("Wating for TLS reply");
     let reply =
         timeout(Duration::from_millis(500), request.get_response()).await;
-    println!("TLS reply: {:?}", reply);
+    println!("TLS reply: {reply:?}");
 
     drop(request);
 
@@ -205,7 +205,7 @@ async fn main() {
         let mut request = redun.send_request(req.clone());
         let reply = request.get_response().await;
         if i == 2 {
-            println!("redundant connection reply: {:?}", reply);
+            println!("redundant connection reply: {reply:?}");
         }
     }
 
@@ -224,16 +224,15 @@ async fn main() {
     //
     // Get the reply
     let reply = request.get_response().await;
-    println!("Dgram reply: {:?}", reply);
+    println!("Dgram reply: {reply:?}");
 
     // Create a single TCP transport connection. This is usefull for a
     // single request or a small burst of requests.
     let tcp_conn = match TcpStream::connect(server_addr).await {
         Ok(conn) => conn,
         Err(err) => {
             println!(
-                "TCP Connection to {} failed: {}, exiting",
-                server_addr, err
+                "TCP Connection to {server_addr} failed: {err}, exiting",
             );
             return;
         }
@@ -250,7 +249,7 @@ async fn main() {
 
     // Get the reply
     let reply = request.get_response().await;
-    println!("TCP reply: {:?}", reply);
+    println!("TCP reply: {reply:?}");
 
     drop(tcp);
 }

examples/client.rs

@@ -92,9 +92,9 @@ fn main() {
     for option in response.opt().unwrap().opt().iter::<AllOptData<_, _>>() {
         let opt = option.unwrap();
         match opt {
-            AllOptData::Nsid(nsid) => println!("{}", nsid),
+            AllOptData::Nsid(nsid) => println!("{nsid}"),
             AllOptData::ExtendedError(extendederror) => {
-                println!("{}", extendederror)
+                println!("{extendederror}")
             }
             _ => println!("NO OPT!"),
         }

examples/common/serve-utils.rs

@@ -0,0 +1,119 @@
+use bytes::Bytes;
+use domain::base::{Dname, Message, MessageBuilder, ParsedDname, Rtype};
+use domain::rdata::ZoneRecordData;
+use domain::zonetree::Answer;
+
+pub fn generate_wire_query(
+    qname: &Dname<Bytes>,
+    qtype: Rtype,
+) -> Message<Vec<u8>> {
+    let query = MessageBuilder::new_vec();
+    let mut query = query.question();
+    query.push((qname, qtype)).unwrap();
+    query.into()
+}
+
+pub fn generate_wire_response(
+    wire_query: &Message<Vec<u8>>,
+    zone_answer: Answer,
+) -> Message<Vec<u8>> {
+    let builder = MessageBuilder::new_vec();
+    let response = zone_answer.to_message(wire_query, builder);
+    response.into()
+}
+
+pub fn print_dig_style_response(
+    query: &Message<Vec<u8>>,
+    response: &Message<Vec<u8>>,
+    short: bool,
+) {
+    if !short {
+        let qh = query.header();
+        let rh = response.header();
+        println!("; (1 server found)");
+        println!(";; global options:");
+        println!(";; Got answer:");
+        println!(
+            ";; ->>HEADER<<- opcode: {}, status: {}, id: {}",
+            qh.opcode(),
+            rh.rcode(),
+            rh.id()
+        );
+        print!(";; flags: ");
+        if rh.aa() {
+            print!("aa ");
+        }
+        if rh.ad() {
+            print!("ad ");
+        }
+        if rh.cd() {
+            print!("cd ");
+        }
+        if rh.qr() {
+            print!("qr ");
+        }
+        if rh.ra() {
+            print!("ra ");
+        }
+        if rh.rd() {
+            print!("rd ");
+        }
+        if rh.tc() {
+            print!("tc ");
+        }
+        let counts = response.header_counts();
+        println!(
+            "; QUERY: {}, ANSWER: {}, AUTHORITY: {}, ADDITIONAL: {}",
+            counts.qdcount(),
+            counts.ancount(),
+            counts.arcount(),
+            counts.adcount()
+        );
+
+        // TODO: add OPT PSEUDOSECTION
+
+        if let Ok(question) = query.sole_question() {
+            println!(";; QUESTION SECTION:");
+            println!(
+                ";{} {} {}",
+                question.qname(),
+                question.qclass(),
+                question.qtype()
+            );
+            println!();
+        }
+    }
+
+    let sections = [
+        ("ANSWER", response.answer()),
+        ("AUTHORITY", response.authority()),
+        ("ADDITIONAL", response.additional()),
+    ];
+    for (name, section) in sections {
+        if let Ok(section) = section {
+            if section.count() > 0 {
+                if !short {
+                    println!(";; {name} SECTION:");
+                }
+
+                for record in section {
+                    let record = record
+                        .unwrap()
+                        .into_record::<ZoneRecordData<_, ParsedDname<_>>>()
+                        .unwrap()
+                        .unwrap();
+
+                    if short {
+                        println!("{}", record.data());
+                    } else {
+                        println!("{record}");
+                    }
+                }
+
+                if !short {
+                    println!();
+                }
+            }
+        }
+    }
+}

examples/download-rust-lang.rs

@@ -16,7 +16,7 @@ async fn main() {
     {
         Ok(addr) => addr,
         Err(err) => {
-            eprintln!("DNS query failed: {}", err);
+            eprintln!("DNS query failed: {err}");
             return;
         }
     };
@@ -30,7 +30,7 @@ async fn main() {
     let mut socket = match TcpStream::connect(&addr).await {
         Ok(socket) => socket,
         Err(err) => {
-            eprintln!("Failed to connect to {}: {}", addr, err);
+            eprintln!("Failed to connect to {addr}: {err}");
             return;
         }
     };
@@ -45,12 +45,12 @@ async fn main() {
         )
         .await
     {
-        eprintln!("Failed to send request: {}", err);
+        eprintln!("Failed to send request: {err}");
         return;
     };
     let mut response = Vec::new();
     if let Err(err) = socket.read_to_end(&mut response).await {
-        eprintln!("Failed to read response: {}", err);
+        eprintln!("Failed to read response: {err}");
         return;
     }