dns test works

dns_test.rs

use std::collections::BTreeMap;
use std::net::Ipv4Addr;
use std::net::SocketAddr;
use std::str::FromStr;
use std::sync::Arc;
use std::sync::RwLock;
use std::time::Duration;
use tokio::net::TcpListener;
use tokio::net::UdpSocket;
use trust_dns_client::rr::LowerName;
use trust_dns_client::rr::RecordType;
use trust_dns_client::rr::RrKey;
use trust_dns_server::authority::Catalog;
use trust_dns_server::authority::ZoneType;
use trust_dns_server::proto::rr::rdata::soa::SOA;
use trust_dns_server::proto::rr::record_data::RData;
use trust_dns_server::proto::rr::resource::Record;
use trust_dns_server::proto::rr::Name;
use trust_dns_server::proto::rr::RecordSet;
use trust_dns_server::store::in_memory::InMemoryAuthority;
use trust_dns_server::ServerFuture;

const DNS_PORT: u16 = 4553;

#[tokio::main]
async fn main() {
    let dns_server_fut = run_dns_server();
    let handle = tokio::spawn(dns_server_fut);

    let dig_handle = tokio::spawn(async {
        eprintln!("dig start!");
        let dig_output = std::process::Command::new("dig")
            .arg("@127.0.0.1")
            .arg("-p")
            .arg("4553")
            .arg("www.example.com")
            .output()
            .unwrap();
        dbg!(String::from_utf8_lossy(&dig_output.stdout));
        dbg!(String::from_utf8_lossy(&dig_output.stderr));
    });

    let _ = tokio::join!(handle, dig_handle);
}
// Setup DNS server for testing
async fn run_dns_server() {
    let catalog = {
        let records = {
            let mut map = BTreeMap::new();
            let lookup_name = "www.example.com".parse::<Name>().unwrap();
            let lookup_name_lower = LowerName::new(&lookup_name);

            // Inserts SOA record
            let soa = SOA::new(
                Name::from_str("net").unwrap(),
                Name::from_str("example").unwrap(),
                0,
                i32::MAX,
                i32::MAX,
                i32::MAX,
                0,
            );
            let rdata = RData::SOA(soa);
            let record = Record::from_rdata(Name::new(), u32::MAX, rdata);
            let record_set = RecordSet::from(record);
            map.insert(RrKey::new(Name::root().into(), RecordType::SOA), record_set);

            // Inserts A record
            let rdata = RData::A(Ipv4Addr::new(1, 2, 3, 4));
            let record = Record::from_rdata(lookup_name.clone(), u32::MAX, rdata);
            let record_set = RecordSet::from(record);
            map.insert(
                RrKey::new(lookup_name_lower.clone(), RecordType::A),
                record_set,
            );

            map
        };

        let authority = Box::new(Arc::new(RwLock::new(
            InMemoryAuthority::new(
                Name::from_str("com").unwrap(),
                records,
                ZoneType::Primary,
                false,
            )
            .unwrap(),
        )));
        let mut c = Catalog::new();
        c.upsert(Name::root().into(), authority);
        c
    };

    let mut server_fut = ServerFuture::new(catalog);
    let socket_addr = SocketAddr::from(([127, 0, 0, 1], DNS_PORT));
    let tcp_listener = TcpListener::bind(socket_addr).await.unwrap();
    let udp_socket = UdpSocket::bind(socket_addr).await.unwrap();
    server_fut.register_socket(udp_socket);
    server_fut.register_listener(tcp_listener, Duration::from_secs(2));
    server_fut.block_until_done().await.unwrap();
}