~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
147 lines · 5.1 KB Raw History
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::time::Duration;

use hickory_server::Server;
use hickory_server::proto::rr::rdata::{A, AAAA, SOA, TXT};
use hickory_server::proto::rr::{LowerName, Name, RData, Record};
use hickory_server::resolver::config::NameServerConfig;
use hickory_server::store::forwarder::{ForwardConfig, ForwardZoneHandler};
use hickory_server::store::in_memory::InMemoryZoneHandler;
use hickory_server::zone_handler::{AxfrPolicy, Catalog, ZoneType};
use ipnet::IpNet;
use tokio::net::{TcpListener, UdpSocket};
use tokio::sync::watch;

use crate::roster::Roster;

pub const TTL: u32 = 5;
pub const BIND_RETRY: Duration = Duration::from_secs(1);
pub const TCP_TIMEOUT: Duration = Duration::from_secs(5);

pub struct DnsOptions {
    pub listen: Vec<SocketAddr>,
    pub zone: String,
    pub upstream: Vec<SocketAddr>,
}

fn zone_records(origin: &Name, roster: &Roster, serial: u32) -> InMemoryZoneHandler {
    let mut zone = InMemoryZoneHandler::empty(origin.clone(), ZoneType::Primary, AxfrPolicy::Deny);
    let soa = SOA::new(origin.clone(), origin.clone(), serial, 60, 60, 3600, TTL);
    zone.upsert_mut(
        Record::from_rdata(origin.clone(), TTL, RData::SOA(soa)),
        serial,
    );
    for peer in &roster.peers {
        let addrs: Vec<IpAddr> = peer
            .cidrs
            .iter()
            .filter_map(|cidr| cidr.trim().parse::<IpNet>().ok())
            .map(|cidr| cidr.network())
            .collect();
        let under = |label: &str| {
            let name = Name::from_ascii(label).and_then(|n| n.append_domain(origin));
            if name.is_err() {
                tracing::warn!(event = "dns_name_invalid", name = %label);
            }
            name.ok()
        };
        for txt in &peer.txt {
            if let Some(name) = under(&txt.name) {
                let rdata = RData::TXT(TXT::new(vec![txt.value.clone()]));
                zone.upsert_mut(Record::from_rdata(name, TTL, rdata), serial);
            }
        }
        for label in std::iter::once(&peer.name).chain(&peer.names) {
            let Some(name) = under(label) else {
                continue;
            };
            for addr in &addrs {
                let rdata = match addr {
                    IpAddr::V4(v4) => RData::A(A(*v4)),
                    IpAddr::V6(v6) => RData::AAAA(AAAA(*v6)),
                };
                zone.upsert_mut(Record::from_rdata(name.clone(), TTL, rdata), serial);
            }
        }
    }
    zone
}

fn forwarder(upstream: &[SocketAddr]) -> Result<ForwardZoneHandler, String> {
    let name_servers = upstream
        .iter()
        .map(|addr| {
            let mut server = NameServerConfig::udp_and_tcp(addr.ip());
            for connection in &mut server.connections {
                connection.port = addr.port();
            }
            server
        })
        .collect();
    ForwardZoneHandler::builder_tokio(ForwardConfig {
        name_servers,
        options: None,
    })
    .with_origin(Name::root())
    .build()
}

async fn bind(addr: SocketAddr) -> (UdpSocket, TcpListener) {
    let mut warned = false;
    loop {
        match (UdpSocket::bind(addr).await, TcpListener::bind(addr).await) {
            (Ok(udp), Ok(tcp)) => return (udp, tcp),
            (udp, tcp) => {
                if !warned {
                    let err = udp.err().or(tcp.err()).map(|e| e.to_string());
                    tracing::info!(event = "dns_bind_waiting", listen = %addr, error = ?err);
                    warned = true;
                }
                tokio::time::sleep(BIND_RETRY).await;
            }
        }
    }
}

pub fn origin(zone: &str) -> Result<Name, String> {
    Name::from_ascii(zone.trim_end_matches('.'))
        .and_then(|name| name.append_domain(&Name::root()))
        .map_err(|err| format!("--dns-zone {zone}: {err}"))
}

pub async fn run(
    options: DnsOptions,
    mut roster: watch::Receiver<Arc<Roster>>,
) -> Result<(), String> {
    let origin = origin(&options.zone)?;
    let mut serial: u32 = 1;
    let zone = Arc::new(zone_records(&origin, &roster.borrow_and_update(), serial));
    let mut catalog = Catalog::new();
    catalog.upsert(LowerName::new(&origin), vec![zone.clone()]);
    if !options.upstream.is_empty() {
        catalog.upsert(
            LowerName::new(&Name::root()),
            vec![Arc::new(forwarder(&options.upstream)?)],
        );
    }
    let mut server = Server::new(catalog);
    for addr in &options.listen {
        let (udp, tcp) = bind(*addr).await;
        server.register_socket(udp);
        server.register_listener(tcp, TCP_TIMEOUT, 16);
        tracing::info!(event = "dns_listening", listen = %addr, zone = %origin, upstream = ?options.upstream);
    }
    tokio::spawn(async move {
        while roster.changed().await.is_ok() {
            serial = serial.wrapping_add(1);
            let mut fresh = zone_records(&origin, &roster.borrow_and_update(), serial);
            *zone.records_mut().await = std::mem::take(fresh.records_get_mut());
            tracing::info!(event = "dns_zone", zone = %origin, serial);
        }
    });
    server
        .block_until_done()
        .await
        .map_err(|err| err.to_string())
}