swift-dns

A high-performance Swift DNS library built on top of SwiftNIO; aiming to provide DNS client, resolver and server implementations.

Usage

Initialize a DNSClient, then use the query methods:

import DNSClient
import DNSModels

/// Create a `DNSClient`
let client = try DNSClient(
    transport: .default(
        serverAddress: .domain(
            /// Connect to Cloudflare's DNS primary server @ 1.1.1.1
            domainName: DomainName(ipv4: IPv4Address(1, 1, 1, 1)),
            port: 53
        )
    )
)

try await withThrowingTaskGroup(of: Void.self) { taskGroup in
    /// Use `addImmediateTask` instead of `addTask` on macOS 26 or Linux.
    taskGroup.addTask {
        try await client.run()  /// !important
    }

    /// You can use the client while the `client.run()` method is not cancelled.

    /// Send the query
    /// `response` will be of type `Message`
    let response = try await client.queryA(
        message: .forQuery(domainName: "mahdibm.com")
    )

    /// Read the answers
    for answer in response.answers {
        /// `a` will be of type `A`
        let a = try answer.rdata
        /// `ipv4` will be of type `IPv4Address`
        let ipv4 = a.value
        print("Got ipv4 \(ipv4) for domain \(response.queries.first?.domainName.description ?? "n/a")")
    }

    /// To shutdown the client, cancel its run method, by cancelling the taskGroup.
    taskGroup.cancelAll()
}

You can use different transports if you so desire. The default transport is preferUDPOrUseTCP similar to other DNS clients and resolvers. Currently a TCP-only transport is also supported:

/// Create a `DNSClient` with the TCP transport
let client = try DNSClient(
    transport: .tcp(
        serverAddress: .domain(
            domainName: DomainName(ipv4: IPv4Address(1, 1, 1, 1)),
            port: 53
        )
    )
)

Operators

I'm experimenting with using operators that do checks in debug builds, but are unchecked in optimized builds.

These operators always have 2 of the last character of the normal operator, and they should in theory always result in the same value as their stdlib version.

Some examples of these operators are:

• &+ -> &++
• &+= -> &+==
• &>> -> &>>>

Checklist

• DNS Parsing
  • IDNA support for non-ASCII domain names.
• DNS client
  • DNS over UDP
  • DNS over TCP
  • DoT (DNS Over TLS)
  • DoH (DNS Over HTTPS)
  • DoQ (DNS Over Quic)
  • MDNS
• DNS resolver (DNS client but with caching etc...)
• DNS server
• DNSSEC

Credits

• https://github.com/apple/swift-nio
  • The networking library used to implement this library.
• https://github.com/hickory-dns/hickory-dns
  • Some data type / parsing implementations were heavily inspired by hickory-dns.
• https://github.com/valkey-io/valkey-swift
  • Helped a lot in putting together an initial version of the connection handling.