lazydns 0.3.20

A light and fast DNS server/forwarder implementation in Rust
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

//! Server integration tests
//!
//! Tests the DNS server with real UDP queries

use async_trait::async_trait;
use lazydns::Result;
use lazydns::dns::wire::{parse_message, serialize_message};
use lazydns::dns::{Message, Question, RData, RecordClass, RecordType, ResourceRecord};
use lazydns::server::{RequestHandler, ServerConfig, UdpServer};
use std::net::{Ipv4Addr, SocketAddr};
use std::sync::Arc;
use std::time::Duration;
use tokio::net::UdpSocket;
use tokio::time::{sleep, timeout};

/// A simple test handler that returns a fixed response
struct TestHandler;

#[async_trait]
impl RequestHandler for TestHandler {
    async fn handle(&self, ctx: lazydns::server::RequestContext) -> Result<Message> {
        let mut request = ctx.into_message();
        // Convert query to response
        request.set_response(true);
        request.set_recursion_available(true);

        // Add an answer for any A query
        if !request.questions().is_empty() {
            let question = &request.questions()[0];
            if question.qtype() == RecordType::A {
                request.add_answer(ResourceRecord::new(
                    question.qname().trim_end_matches('.'),
                    RecordType::A,
                    RecordClass::IN,
                    300,
                    RData::A(Ipv4Addr::new(93, 184, 216, 34)),
                ));
            }
        }

        Ok(request)
    }
}

#[tokio::test]
async fn test_udp_server_query_response() {
    // Start server on a random port
    let server_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let config = ServerConfig::default().with_udp_addr(server_addr);
    let handler = Arc::new(TestHandler);

    let server = UdpServer::new(config, handler)
        .await
        .expect("Failed to create server");
    let actual_addr = server.local_addr().expect("Failed to get server address");

    // Spawn server task
    let server_handle = tokio::spawn(async move {
        let _ = server.run().await;
    });

    // Give server time to start
    sleep(Duration::from_millis(100)).await;

    // Create a DNS query
    let mut query = Message::new();
    query.set_id(12345);
    query.set_query(true);
    query.set_recursion_desired(true);
    query.add_question(Question::new(
        "test.example.com",
        RecordType::A,
        RecordClass::IN,
    ));

    // Serialize query
    let query_bytes = serialize_message(&query).expect("Failed to serialize query");

    // Send query to server
    let client_socket = UdpSocket::bind("127.0.0.1:0")
        .await
        .expect("Failed to bind client socket");
    client_socket
        .send_to(&query_bytes, actual_addr)
        .await
        .expect("Failed to send query");

    // Receive response with timeout
    let mut buf = vec![0u8; 512];
    let (len, _) = timeout(Duration::from_secs(5), client_socket.recv_from(&mut buf))
        .await
        .expect("Timeout waiting for response")
        .expect("Failed to receive response");

    // Parse response
    let response = parse_message(&buf[..len]).expect("Failed to parse response");

    // Verify response
    assert_eq!(response.id(), query.id());
    assert!(response.is_response());
    assert!(response.recursion_available());
    assert_eq!(response.question_count(), 1);
    assert_eq!(response.answer_count(), 1);

    // Verify the answer
    let answer = &response.answers()[0];
    assert_eq!(answer.rtype(), RecordType::A);
    match answer.rdata() {
        RData::A(ip) => assert_eq!(*ip, Ipv4Addr::new(93, 184, 216, 34)),
        _ => panic!("Expected A record"),
    }

    // Clean up
    server_handle.abort();
}

#[tokio::test]
async fn test_multiple_sequential_queries() {
    // Start server
    let server_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let config = ServerConfig::default().with_udp_addr(server_addr);
    let handler = Arc::new(TestHandler);

    let server = UdpServer::new(config, handler)
        .await
        .expect("Failed to create server");
    let actual_addr = server.local_addr().expect("Failed to get server address");

    let server_handle = tokio::spawn(async move {
        let _ = server.run().await;
    });

    sleep(Duration::from_millis(100)).await;

    let client_socket = UdpSocket::bind("127.0.0.1:0")
        .await
        .expect("Failed to bind client socket");

    // Send multiple queries
    for i in 0..5 {
        let mut query = Message::new();
        query.set_id(1000 + i);
        query.set_query(true);
        query.set_recursion_desired(true);
        query.add_question(Question::new(
            format!("test{}.example.com", i),
            RecordType::A,
            RecordClass::IN,
        ));

        let query_bytes = serialize_message(&query).expect("Failed to serialize query");
        client_socket
            .send_to(&query_bytes, actual_addr)
            .await
            .expect("Failed to send query");

        let mut buf = vec![0u8; 512];
        let (len, _) = timeout(Duration::from_secs(5), client_socket.recv_from(&mut buf))
            .await
            .expect("Timeout waiting for response")
            .expect("Failed to receive response");

        let response = parse_message(&buf[..len]).expect("Failed to parse response");
        assert_eq!(response.id(), 1000 + i);
        assert!(response.is_response());
        assert_eq!(response.answer_count(), 1);
    }

    server_handle.abort();
}