lazydns 0.2.63

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

//! DNS protocol implementation module
//!
//! This module provides comprehensive DNS protocol support including:
//! - DNS message parsing and serialization (RFC 1035)
//! - Support for all common DNS record types
//! - EDNS0 support (RFC 6891)
//! - DNS message validation and error handling
//!
//! # Example
//!
//! ```rust,no_run
//! use lazydns::dns::{Message, Question, RecordType, RecordClass};
//!
//! // Create a DNS query message
//! let mut message = Message::new();
//! message.set_query(true);
//! message.add_question(Question::new(
//!     "example.com".to_string(),
//!     RecordType::A,
//!     RecordClass::IN,
//! ));
//! ```

pub mod message;
pub mod question;
pub mod rdata;
pub mod record;
pub mod types;
pub mod wire;

// Re-export commonly used types
pub use message::Message;
pub use question::Question;
pub use rdata::RData;
pub use record::{Record, ResourceRecord};
pub use types::{OpCode, RecordClass, RecordType, ResponseCode};
pub use wire::{parse_message, serialize_message};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dns_types_reexports() {
        // Verify all re-exported types are accessible
        let _msg = Message::new();
        let _question = Question::new("example.com".to_string(), RecordType::A, RecordClass::IN);
        let _opcode = OpCode::Query;
        let _rcode = ResponseCode::NoError;
    }

    #[test]
    fn test_record_types_accessible() {
        // Verify RecordType enum variants are accessible
        assert_eq!(RecordType::A.to_u16(), 1);
        assert_eq!(RecordType::AAAA.to_u16(), 28);
        assert_eq!(RecordType::CNAME.to_u16(), 5);
    }

    #[test]
    fn test_record_classes_accessible() {
        // Verify RecordClass enum variants are accessible
        assert_eq!(RecordClass::IN.to_u16(), 1);
        assert_eq!(RecordClass::CH.to_u16(), 3);
    }

    #[test]
    fn test_message_serialization() {
        // Verify wire format functions are accessible
        let message = Message::new();
        let serialized = serialize_message(&message);
        assert!(serialized.is_ok());

        let wire_data = serialized.unwrap();
        let parsed = parse_message(&wire_data);
        assert!(parsed.is_ok());
    }
}