chore: prepare dyns v0.7.0-beta.1

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "dyns"
 description = "DNS discovery and resolver support for DHTTP applications"
-version = "0.6.0-beta.3"
+version = "0.7.0-beta.1"
 edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/genmeta/ddns"

src/core/parser/record/endpoint.rs

@@ -558,6 +558,14 @@ pub(crate) fn be_endpoint_addr_compat(
     ];
 
     if legacy_lengths.contains(&(rdlen as usize)) {
+        // Modern records have variable length, so a valid modern encoding can
+        // legitimately be 12, 18, or 36 bytes as well. Prefer a complete
+        // modern parse and only fall back to the legacy layout when it fails.
+        if let Ok((remaining, endpoint)) = be_endpoint_addr(input)
+            && remaining.is_empty()
+        {
+            return Ok((remaining, endpoint));
+        }
         return be_legacy_endpoint_addr_by_length(input, rdlen);
     }
 
@@ -1025,6 +1033,33 @@ mod tests {
         }
     }
 
+    #[test]
+    fn compat_parser_does_not_misclassify_modern_lengths_as_legacy() {
+        let mut direct = EndpointAddr::direct_v4("203.0.113.10:4433".parse().unwrap());
+        direct.set_main(true);
+        direct.set_sequence(CertificateSequence::try_from(10u32).unwrap());
+        direct.set_load(Some(1.0));
+
+        let mut nat = EndpointAddr::nat_v4(
+            "198.51.100.10:4433".parse().unwrap(),
+            "192.0.2.10:4433".parse().unwrap(),
+        );
+        nat.set_main(true);
+        nat.set_sequence(CertificateSequence::from(1u8));
+        nat.set_load(Some(2.0));
+
+        for endpoint in [direct, nat] {
+            let mut buf = BytesMut::new();
+            buf.put_endpoint_addr(&endpoint);
+            assert!([12, 18].contains(&buf.len()));
+
+            let (remaining, decoded) =
+                be_endpoint_addr_compat(&buf, u16::try_from(buf.len()).unwrap()).unwrap();
+            assert!(remaining.is_empty());
+            assert_eq!(decoded, endpoint);
+        }
+    }
+
     #[test]
     fn endpoint_signature_roundtrip_and_verify() {
         #[derive(Debug)]

src/h3/lookup.rs

@@ -21,16 +21,16 @@ use crate::{
 
 const LOOKUP_API_PATH: &str = "/api/v2/lookup";
 
-fn lookup_url(base_url: &url::Url, name: &str, sequence: Option<CertificateSequence>) -> url::Url {
+fn lookup_url(
+    base_url: &url::Url,
+    name: &str,
+    lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
+) -> url::Url {
     let mut url = base_url
         .join(LOOKUP_API_PATH)
         .expect("h3 dns lookup api path must be valid");
     url.query_pairs_mut().append_pair("host", name);
-    if let Some(sequence) = sequence {
-        let sequence_text = sequence.get().to_string();
-        url.query_pairs_mut()
-            .append_pair("sequence", &sequence_text);
-    }
+    crate::resolvers::endpoint_candidates::append_endpoint_lookup_query(&mut url, lookup);
     url
 }
 
@@ -244,7 +244,10 @@ where
             return Ok(stream.boxed());
         }
 
-        let url = lookup_url(&self.base_url, domain, sequence);
+        let endpoint_lookup = sequence
+            .map(crate::resolvers::endpoint_candidates::EndpointLookup::exact)
+            .unwrap_or_default();
+        let url = lookup_url(&self.base_url, domain, endpoint_lookup);
         let uri: http::Uri = url.as_str().parse().expect("URL should be valid URI");
 
         tracing::trace!("sending lookup request to {}", self.base_url);
@@ -281,15 +284,19 @@ where
     fn lookup_endpoint_candidates<'a>(
         &'a self,
         name: &'a str,
+        lookup: crate::resolvers::endpoint_candidates::EndpointLookup,
     ) -> crate::resolvers::endpoint_candidates::EndpointCandidateFuture<'a> {
         Box::pin(async move {
-            let Some((domain, _sequence)) =
+            let Some((domain, sequence)) =
                 crate::resolvers::endpoint_lookup_name_and_sequence(name)
             else {
                 return Err(io::Error::other("no DNS record found"));
             };
 
-            let url = lookup_url(&self.base_url, domain, None);
+            let lookup = sequence
+                .map(crate::resolvers::endpoint_candidates::EndpointLookup::exact)
+                .unwrap_or(lookup);
+            let url = lookup_url(&self.base_url, domain, lookup);
             let uri: http::Uri = url.as_str().parse().expect("URL should be valid URI");
             let response = self
                 .lookup_response_with_retry(uri)
@@ -298,18 +305,21 @@ where
             let source = Source::H3 {
                 server: Arc::from(self.base_url.origin().ascii_serialization()),
             };
-            let groups = LookupRecords::decode_candidate_groups(domain, response.as_ref())
-                .map_err(io::Error::other)?
-                .into_iter()
-                .map(|(chain, endpoints)| EndpointCandidateGroup {
-                    chain,
-                    endpoints: endpoints
-                        .into_iter()
-                        .map(|((), endpoint)| endpoint)
-                        .collect(),
-                    sources: vec![source.clone()],
-                })
-                .collect();
+            let groups = crate::resolvers::endpoint_candidates::select_group_pairs(
+                LookupRecords::decode_candidate_groups(domain, response.as_ref())
+                    .map_err(io::Error::other)?,
+                lookup.sequences,
+            )
+            .into_iter()
+            .map(|(chain, endpoints)| EndpointCandidateGroup {
+                chain,
+                endpoints: endpoints
+                    .into_iter()
+                    .map(|((), endpoint)| endpoint)
+                    .collect(),
+                sources: vec![source.clone()],
+            })
+            .collect();
 
             Ok(EndpointCandidates { groups })
         })
@@ -318,13 +328,16 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::{collections::HashMap, net::SocketAddrV4};
+    use std::{collections::HashMap, net::SocketAddrV4, num::NonZeroUsize};
 
     use super::*;
-    use crate::core::{
-        MdnsPacket,
-        parser::record::endpoint::EndpointAddr as DnsEndpointAddr,
-        wire::{MultiResponse, ResponseRecord},
+    use crate::{
+        core::{
+            MdnsPacket,
+            parser::record::endpoint::EndpointAddr as DnsEndpointAddr,
+            wire::{MultiResponse, ResponseRecord},
+        },
+        resolvers::endpoint_candidates::EndpointLookup,
     };
 
     fn direct(addr: &str, main: bool, sequence: u32) -> DnsEndpointAddr {
@@ -368,7 +381,7 @@ mod tests {
     #[test]
     fn h3_lookup_url_targets_v2_api_from_origin_base() {
         let base_url = url::Url::parse("https://dns.example.test:4433").expect("url");
-        let url = lookup_url(&base_url, "demo.dhttp.net", None);
+        let url = lookup_url(&base_url, "demo.dhttp.net", EndpointLookup::default());
 
         assert_eq!(
             url.as_str(),
@@ -379,7 +392,7 @@ mod tests {
     #[test]
     fn h3_lookup_url_does_not_duplicate_v2_base_path() {
         let base_url = url::Url::parse("https://dns.example.test:4433/api/v2/").expect("url");
-        let url = lookup_url(&base_url, "demo.dhttp.net", None);
+        let url = lookup_url(&base_url, "demo.dhttp.net", EndpointLookup::default());
 
         assert_eq!(
             url.as_str(),
@@ -393,7 +406,7 @@ mod tests {
         let url = lookup_url(
             &base_url,
             "demo.dhttp.net",
-            Some(CertificateSequence::from(3u8)),
+            EndpointLookup::exact(CertificateSequence::from(3u8)),
         );
 
         assert_eq!(
@@ -402,6 +415,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn h3_lookup_url_encodes_endpoint_lookup_matrix() {
+        let base_url = url::Url::parse("https://dns.example.test:4433").expect("url");
+        let one = NonZeroUsize::new(1).unwrap();
+        let cases = [
+            (
+                EndpointLookup::default(),
+                "https://dns.example.test:4433/api/v2/lookup?host=demo.dhttp.net",
+            ),
+            (
+                EndpointLookup::exact(CertificateSequence::from(2u8)),
+                "https://dns.example.test:4433/api/v2/lookup?host=demo.dhttp.net&sequence=2",
+            ),
+            (
+                EndpointLookup::limit(one),
+                "https://dns.example.test:4433/api/v2/lookup?host=demo.dhttp.net&sequence_limit=1",
+            ),
+            (
+                EndpointLookup::all().with_record_limit(one),
+                "https://dns.example.test:4433/api/v2/lookup?host=demo.dhttp.net&sequence_limit=all&record_limit=1",
+            ),
+        ];
+
+        for (lookup, expected) in cases {
+            assert_eq!(
+                lookup_url(&base_url, "demo.dhttp.net", lookup).as_str(),
+                expected
+            );
+        }
+    }
+
     #[test]
     fn lookup_records_selects_first_server_ordered_group() {
         let response = response_for(