tendns 0.2.0

Encrypted TXT discovery and hexadecimal IPv4 resolution, as a library and DNS server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Application-provided DNS transport.

use anyhow::{Context, Result};
use async_trait::async_trait;
use hickory_proto::op::Message;
use tokio::time::Instant;

use crate::deadline;

#[cfg(feature = "cli")]
mod forwarder;
#[cfg(feature = "cli")]
pub use forwarder::Forwarder;

/// Exchanges raw DNS messages without re-entering tendns namespace handling.
///
/// Implementations must associate responses with their requests, and retry
/// truncated UDP responses over a reliable transport before returning them.
#[async_trait]
pub trait Exchange: Send + Sync {
    async fn exchange(&self, message: Message) -> Result<Message>;

    /// Uses the caller's absolute deadline, rather than restarting a timeout for
    /// each TXT owner or CNAME. Override when the underlying resolver supports it.
    async fn exchange_with_deadline(&self, message: Message, deadline: Instant) -> Result<Message> {
        deadline::timeout_at(deadline, async { self.exchange(message).await })
            .await
            .context("DNS exchange timed out")?
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::{future::pending, time::Duration};

    struct PendingExchange;

    #[async_trait]
    impl Exchange for PendingExchange {
        async fn exchange(&self, _: Message) -> Result<Message> {
            pending().await
        }
    }

    #[tokio::test(start_paused = true)]
    async fn default_exchange_enforces_the_callers_deadline() {
        let deadline = Instant::now() + Duration::from_secs(2);
        let error = PendingExchange
            .exchange_with_deadline(Message::query(), deadline)
            .await
            .unwrap_err();
        assert_eq!(error.to_string(), "DNS exchange timed out");
        assert!(error.is::<crate::TimeoutError>());
        assert_eq!(Instant::now(), deadline);
    }

    #[tokio::test(start_paused = true)]
    async fn default_exchange_does_not_poll_work_after_its_deadline() {
        struct UnusedExchange;

        #[async_trait]
        impl Exchange for UnusedExchange {
            async fn exchange(&self, _: Message) -> Result<Message> {
                panic!("expired deadline must not poll the exchange");
            }
        }

        let error = UnusedExchange
            .exchange_with_deadline(Message::query(), Instant::now())
            .await
            .unwrap_err();
        assert_eq!(error.to_string(), "DNS exchange timed out");
        assert!(error.is::<crate::TimeoutError>());
    }
}