itsdns 0.1.0

Light weight DNS client based on embedded-nal-async
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#![no_std]
#![feature(impl_trait_projections)]
#![allow(incomplete_features)]
#![feature(async_fn_in_trait)]
#![doc = include_str!("../README.md")]
#![warn(missing_docs)]

use core::sync::atomic::{AtomicU16, Ordering};
use embedded_nal_async::{AddrType, ConnectedUdp, Dns, IpAddr, Ipv4Addr, SocketAddr, UdpStack};
use heapless::String;

mod message;
use message::*;

/// Errors returned by the client.
#[derive(Debug)]
pub enum Error<N> {
    /// Error in the underlying network
    Network(N),
    /// Error specific to DNS
    Dns(DnsError),
    /// DNS entry not found
    NotFound,
}

/// An error related to the DNS message itself.
#[derive(Debug)]
pub enum DnsError {
    /// Error encoding the message.
    Encode,
    /// Error decoding the message.
    Decode,
    /// Message format error.
    FormatError,
    /// Failure occured on server.
    ServerFailure,
    /// Error in name.
    NameError,
    /// Functionality not supported.
    NotImplemented,
    /// Request refused.
    Refused,
}

/// DNS client
pub struct ItsDns<S: UdpStack> {
    id: AtomicU16,
    stack: S,
    server: SocketAddr,
}

impl<S: UdpStack> ItsDns<S> {
    /// Create a new DNS client using the UDP stack and a DNS server.
    pub fn new(stack: S, server: SocketAddr) -> Self {
        Self {
            id: AtomicU16::new(0),
            stack,
            server,
        }
    }

    /// Lookup a host by the name and return the IP address of the host.
    pub async fn get_host_by_name(
        &self,
        host: &str,
        _addr_type: AddrType,
    ) -> Result<IpAddr, Error<S::Error>> {
        let mut packet = [0; 512];

        let id = self.id.fetch_add(1, Ordering::Relaxed);
        let len = DnsMessage {
            id,
            opcode: Opcode::Query,
            questions: Questions::Slice(&[Question {
                qname: Domain::String(host),
                qtype: QType::A,
                qclass: QClass::IN,
            }]),
            answers: Answers::Slice(&[]),
        }
        .encode(&mut packet[..])
        .map_err(Error::Dns)?;

        match self.stack.connect(self.server).await {
            Ok((_, mut server)) => {
                server.send(&packet[..len]).await.map_err(Error::Network)?;

                let len = server
                    .receive_into(&mut packet[..])
                    .await
                    .map_err(Error::Network)?;

                let m = DnsMessage::decode(&packet[..len]).map_err(Error::Dns)?;

                for answer in 0..m.answers.count() {
                    if let Some(answer) = m.answers.get(answer).map_err(Error::Dns)? {
                        if answer.domain == Domain::String(host)
                            && answer.r#type == QType::A
                            && answer.rdata.len() >= 4
                        {
                            let ip = answer.rdata;
                            return Ok(IpAddr::V4(Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3])));
                        }
                    }
                }
                Err(Error::NotFound)
            }
            Err(e) => Err(Error::Network(e)),
        }
    }
}

impl<S: UdpStack> Dns for ItsDns<S> {
    type Error = Error<S::Error>;

    async fn get_host_by_name(
        &self,
        host: &str,
        addr_type: AddrType,
    ) -> Result<IpAddr, Self::Error> {
        ItsDns::get_host_by_name(self, host, addr_type).await
    }

    async fn get_host_by_address(&self, _addr: IpAddr) -> Result<String<256>, Self::Error> {
        todo!()
    }
}