🥮 mooncakes.io

moon-dns-stub

Native DNS wire format codec and async stub resolver. Supports A/AAAA/MX/SRV/TXT/CNAME/NS/PTR/SOA with name compression, UDP/TCP fallback, CNAME chain, and TTL cache.

dns
network
stub-resolver
rfc1035
codec
native
moon add jinshengmeng46/moon-dns-stub@0.1.0
Download zip
Version
0.1.0
License
Apache-2.0
Repository
Last updated
6 hours ago
Downloads
4

Dependencies

README

#moon-dns-stub

一个 Native MoonBit DNS stub resolver：包含 DNS wire codec、EDNS(0)、真实 UDP 查询与 TCP fallback、CNAME 跟踪和 TTL/LRU 缓存。

当前 0.1.0 功能范围已经冻结；后续变更以修复缺陷、兼容 MoonBit 工具链和维护文档为主。

#当前支持范围

  • DNS Header、Question、完整 Message 和 name compression 的编解码；编码端会压缩重复名称。
  • A、AAAA、CNAME、NS、PTR、MX、TXT、SOA、SRV、OPT(EDNS) 与未知 RR。
  • 严格的 RDLENGTH 边界、压缩指针环/越界检查，以及 label、域名、报文资源上限；名称 API 使用可逆的 \\DDD 十进制转义，二进制 label 中的 .、\\ 和控制字节不会丢失。
  • EDNS(0) 查询（默认 UDP payload 为 1232）、DO bit、OPT option 和扩展 RCODE。
  • 可注入 DnsTransport；默认实现使用 Native UDP，收到 TC 后用 DNS-over-TCP 重发原请求。 支持 timeout、retry、IPv4、[IPv6]:port、域名服务器名和默认 53 端口。
  • resolve_a/aaaa/mx/srv/txt/ns/cname/soa/ptr；请求/响应 ID、QR、opcode、question 校验；同包或跨查询 CNAME；正、负 TTL 缓存和 LRU。

这是 Native-only 的完整根包：src/moon.pkg 将 codec、cache、resolver 和 transport 共同限制为 Native。DnsTransport 注入点用于 Native mock、受控代理和自定义 Native transport；当前包不能被 JS/Wasm 下游导入。未来如需非 Native 支持，必须先把 codec、cache 和 resolver 抽取成不依赖 async socket/TLS 的独立 portable package，再分别验证各 target。

不包含 DNSSEC、DoH/DoT、mDNS 或递归权威服务器功能。

#文档

  • 总体架构：package 结构、类型所有权、数据流与设计决策。
  • 项目申报书：项目价值、交付范围、原创性和合规边界的提交版摘要。

#安装与快速开始

需要 MoonBit 0.10.3 或更新的工具链。当前仓库可直接从源码运行：

moon check --target native --warn-list +73 --deny-warn
moon run --target native src/cmd/main -- resolve example.com A --server 1.1.1.1:53 --short
moon run --target native src/cmd/main -- resolve example.com MX --server 8.8.8.8 --verbose
moon run --target native src/cmd/main -- resolve example.com AAAA --json
moon run --target native src/examples/a_aaaa -- --server 1.1.1.1:53
moon run --target native src/examples/mx_srv -- --server 8.8.8.8:53

两个示例的 --server 可省略，默认使用 1.1.1.1:53；运行 moon run --target native src/examples/a_aaaa -- --help 可查看参数。示例和 CLI 在参数非法或任一 DNS 查询失败时都会以非零状态退出，不会把失败伪装成成功的演示记录； --help 与 --version 正常返回零。

该库已发布到 mooncakes.io。在下游项目根目录安装 v0.1.0：

moon add jinshengmeng46/moon-dns-stub@0.1.0

命令格式：

resolve <name> <A|AAAA|MX|NS|CNAME|TXT|SOA|PTR|SRV>
  [--server <host[:port]|[ipv6]:port>]
  [--timeout <milliseconds>]
  [--short|--verbose|--json]

--short 是默认输出。--json 会转义记录文字。单次 CLI 不提供 cache-stats：缓存仅存在于 该 resolver 进程实例中，单独启动一次 CLI 查询统计没有意义。

嵌入 Native 应用时，创建 Resolver::new(options=ResolveOptions::new(...))；测试或 自定义 Native 网络环境可用 Resolver::with_transport 注入自己的传输实现。

#作为 MoonBit 库使用

CLI 只是一个入口；包名为 jinshengmeng46/moon-dns-stub，核心能力以异步 MoonBit API 提供。Native 可执行 package 需要在 moon.pkg 中同时启用 async runtime：

import {
  "jinshengmeng46/moon-dns-stub" @dns,
  "moonbitlang/async",
}

supported_targets = "native"

pkgtype(kind: "executable")

对应的 main.mbt 与 src/examples/a_aaaa 使用相同的公开接口：

async fn main {
  let resolver = @dns.Resolver::new(
    options=@dns.ResolveOptions::new(
      server="1.1.1.1:53",
      timeout_ms=3000,
      retries=1,
    ),
  )
  match resolver.resolve_a("example.com") {
    Ok(addresses) => println(addresses.join(", "))
    Err(error) =>
      raise Failure::Failure("DNS query failed: \{to_repr(error)}")
  }
}

Resolver::new 使用 Native UDP，并在响应的 TC 位被置位时以 TCP 重发同一个请求。 ResolveOptions::new 可设置 server、timeout_ms、retries、递归位 recurse 和 CNAME 最大深度 max_depth；省略时使用默认值。一个 resolver 实例持有自己的缓存，应该在 应用生命周期内复用，而不是每次查询都新建。

#Resolver 查询接口

所有查询都是 async，并返回 Result[..., ResolveError]。NXDomain、NoData、超时、 响应不匹配和 CNAME 环均是显式错误，不会被折叠成空的成功结果。

方法成功结果
resolve(name, qtype)原始 DnsResult（RR answers 与 CNAME 链）
resolve_a / resolve_aaaaArray[String] 地址
resolve_ipv4第一个 IPv4 地址 String
resolve_mxArray[(Int, String)]，按 preference 升序
resolve_ns / resolve_cname / resolve_txt / resolve_ptrArray[String]
resolve_soaArray[SoaResult]
resolve_srvArray[SrvResult]，按 priority 升序、同 priority 按 weight 降序
cache_stats()当前 resolver 的 CacheStats（hit、miss、entry 数）

#注入 transport（Native 测试、代理或自定义适配器）

DnsTransport 的边界是完整 DNS wire message：回调接收 resolver 构造的请求字节，必须返回 对应响应字节，或返回 TransportError。因此 Native socket、Native DoH 代理和本地 mock 都可以在调用方实现；resolver 仍负责 EDNS、响应校验、CNAME 和缓存。

// request_over_doh 接收并返回完整 DNS wire message。
let transport = @dns.DnsTransport::from_request(
  payload => request_over_doh(payload),
  udp_payload_size=1232,
)
let resolver = @dns.Resolver::with_transport(transport~)
let answers = resolver.resolve_aaaa("example.com")

其中 request_over_doh 的类型为 async (Array[Byte]) -> Result[Array[Byte], @dns.TransportError]。udp_payload_size 会成为 resolver EDNS OPT 中通告的 UDP payload 大小。使用自定义 transport 时， ResolveOptions.server 不会替调用方发起网络连接；该连接的地址、超时与重试策略由适配器负责。 测试可进一步用 Resolver::with_transport_and_clock(transport~, clock=...) 注入兼容的 32 位单调毫秒时钟。长期运行服务应使用 Resolver::with_transport_and_clock64(transport~, clock=...)；默认 resolver 和缓存内部 全程使用 Int64 单调毫秒，不会在约 24.855 天处溢出。 DNS TTL 的完整 UInt32 范围不会在高位被截短；CNAME cache 只保存相对链，并在每次顶层 查询中重建 provenance，避免别名链在不同 cache key 之间串线。

#Codec 与缓存 API

wire codec 也可独立使用，不必创建 resolver：

  • encode_name_checked / decode_name：校验并编解码 DNS 名称；
  • Header、Question、RR、RData、Message：表示完整 DNS 报文； Message::encode_checked 与 decode_message 用于安全的完整报文编解码；
  • OptRR、OptOption、build_query_with_edns_checked、OptRR::to_rr_checked 与 opt_from_rr：构造、读取 EDNS(0)；ECS/Cookie/Keepalive 提供 checked builder，并在 builder、RR conversion、编码和解码时复核长度、prefix、RDLENGTH 与 100ms 单位；
  • DnsCache::new、lookup、put_positive、put_negative、stats：需要单独管理缓存时使用。

所有 codec 的可变长度字段均有边界检查；格式错误返回 Err，不会把截断或非法压缩指针转换为 空记录。resolver 的默认缓存使用单调时间，并区分正缓存、NXDOMAIN 与 NODATA。 传入名称时未转义的 . 分隔 label；\\DDD 表示一个 0–255 的十进制字节，\\X 表示非数字 字节 X 的字面值（数字使用无歧义的三位写法）。decode_name 对不可直接打印的字节统一返回 \\DDD，因此 decode→encode 保持 wire 语义；大小写、十进制转义/字面转义和未转义终止根点 按 DNS 名称规则归一。
  • pretty_print_rdata：人类可读的 DNS 记录表达；short_print_rdata：面向 CLI 和 dig +short 语义差分的单行表达；pretty_print_result_json：有效 JSON 结果表达。

#Target 约束

当前发布的根包整体是 Native-only，不仅是 Resolver::new。虽然部分 codec/cache 实现逻辑本身可移植，但它们与 Native resolver 位于同一个受限 package 中，因此不能把 moon check --target all 对非 Native 显示的 no work to do 当成跨 target 验证证据。 JS/Wasm portable package 拆分和独立测试属于后续版本，不是 0.1.0 的交付承诺。

#验证

moon check --target native --warn-list +73 --deny-warn
moon build --target native --warn-list +73 --deny-warn
moon test --target native --warn-list +73 --deny-warn -v
moon fmt --check
moon package --list
bash scripts/cli_failure_smoke.sh
DNS_DIFF_REQUIRED=1 bash scripts/dig_diff.sh
DNS_DIFF_REQUIRED=1 bash scripts/dig_diff_doh.sh

单元测试完全离线；真实差分需要 dig、Python 3 和可访问的 DNS UDP/53 或 HTTPS/443。

#协议行为约定

  • UDP 响应 TC=1 时，transport 用相同请求经 TCP 重试。
  • 查询 ID 使用 Native TLS/OpenSSL 随机源；不能产生随机数时显式报错。
  • MX 按 preference 升序；SRV 按 priority 升序、同 priority 按 weight 降序，便于调用方按需选择。
  • NXDOMAIN 与 NODATA 均作为不同的显式负结果返回（不会变成空成功）；负缓存 TTL 取 authority SOA 的 TTL 与 MINIMUM 的较小值。
  • authority 中只有 IN class 的 NS 且没有 IN class SOA 的 NOERROR 空答案被视为 referral， 不会伪装成 NODATA 或写入负缓存；没有 SOA 的负响应也不会被缓存。
  • TTL=0 会立即失效，替换同 key 的旧缓存项但不会为了一个不可缓存结果驱逐其他 LRU 条目； cache hit 的公开 RR TTL 是剩余寿命而非最初 TTL。

#许可证

Apache License 2.0，见 LICENSE。

本项目为原创 MoonBit 实现，不移植或复制第三方 DNS 库代码。

#
CacheLookup

source
pub enum CacheLookup {
  Miss
  Positive(DnsResult)
  Negative(NegativeCacheKind, DnsResult)
}

#
CacheStats

source
pub struct CacheStats {
  hits : Int
  misses : Int
  entries : Int
  expired : Int
}

#
CnameTracker

source
pub struct CnameTracker {
  max_depth : Int
  chain : Array[String]
}

#
CnameTracker::contains

source
fn CnameTracker::contains(self : CnameTracker, name : String) -> Bool

#
CnameTracker::depth

source
fn CnameTracker::depth(self : CnameTracker) -> Int

#
CnameTracker::follow

source
fn CnameTracker::follow(self : CnameTracker, target : String) -> Result[Unit, String]

#
CnameTracker::get_chain

source
fn CnameTracker::get_chain(self : CnameTracker) -> Array[String]

#
CnameTracker::is_at_max

source
fn CnameTracker::is_at_max(self : CnameTracker) -> Bool

#
CnameTracker::new

source
fn CnameTracker::new(origin : String, max_depth? : Int) -> CnameTracker

#
DnsCache

source
pub struct DnsCache {
  hash : 
HashMap[String, DnsResult]
  expires : 
HashMap[String, Int64]
  negative : 
HashMap[String, NegativeCacheKind]
  access_order : 
HashMap[String, Int64]
  next_counter : 
Ref[Int64]
  max_size : Int
  hit_count : 
Ref[Int64]
  miss_count : 
Ref[Int64]
  expired_count : 
Ref[Int64]
}

#
DnsCache::contains

source
fn DnsCache::contains(self : DnsCache, name : String, qtype : UInt16, now_ms : Int) -> Bool

#
DnsCache::get

source
fn DnsCache::get(self : DnsCache, name : String, qtype : UInt16, now_ms : Int) -> DnsResult?

#
DnsCache::is_empty

source
fn DnsCache::is_empty(self : DnsCache) -> Bool

#
DnsCache::len

source
fn DnsCache::len(self : DnsCache) -> Int

#
DnsCache::lookup

source
fn DnsCache::lookup(self : DnsCache, name : String, qtype : UInt16, now_ms : Int) -> CacheLookup

#
DnsCache::new

source
fn DnsCache::new(max_size? : Int) -> DnsCache

#
DnsCache::prune_expired

source
fn DnsCache::prune_expired(self : DnsCache, now_ms : Int) -> Unit

#
DnsCache::put

source
fn DnsCache::put(self : DnsCache, name : String, qtype : UInt16, result : DnsResult, ttl : Int, is_negative : Bool, now_ms : Int) -> Unit

#
DnsCache::put_negative

source
fn DnsCache::put_negative(self : DnsCache, name : String, qtype : UInt16, kind : NegativeCacheKind, ttl_seconds : Int, now_ms : Int) -> Unit

#
DnsCache::put_positive

source
fn DnsCache::put_positive(self : DnsCache, name : String, qtype : UInt16, result : DnsResult, ttl_seconds : Int, now_ms : Int) -> Unit

#
DnsCache::remove_entry

source
fn DnsCache::remove_entry(self : DnsCache, name : String, qtype : UInt16) -> Unit

#
DnsCache::stats

source
fn DnsCache::stats(self : DnsCache) -> CacheStats

#
DnsResult

source
pub(all) struct DnsResult {
  answers : Array[RR]
  cname_chain : Array[String]
}

#
DnsTransport

source
pub(all) struct DnsTransport {
  request : async (Array[Byte]) -> Result[Array[Byte], TransportError]
  udp_payload_size : UInt16
}

An injectable asynchronous DNS transport.

The callback boundary keeps the resolver independent from socket backends and makes deterministic resolver tests possible without a network connection.

#
DnsTransport::from_request

source
fn DnsTransport::from_request(request : async (Array[Byte]) -> Result[Array[Byte], TransportError], udp_payload_size? : UInt16) -> DnsTransport

#
DnsTransport::max_payload

source
fn DnsTransport::max_payload(self : DnsTransport) -> UInt16

#
DnsTransport::send

source
async fn DnsTransport::send(self : DnsTransport, payload : Array[Byte]) -> Result[Array[Byte], TransportError]

#
FallbackStats

source
pub struct FallbackStats {
  udp_successes : 
Ref[Int]
  udp_truncated : 
Ref[Int]
  tcp_successes : 
Ref[Int]
  tcp_failures : 
Ref[Int]
}

#
FallbackStats::new

source

#
FallbackStats::record_tcp_failure

source
fn FallbackStats::record_tcp_failure(self : FallbackStats) -> Unit

#
FallbackStats::record_tcp_success

source
fn FallbackStats::record_tcp_success(self : FallbackStats) -> Unit

#
FallbackStats::record_truncation

source
fn FallbackStats::record_truncation(self : FallbackStats) -> Unit

#
FallbackStats::record_udp_success

source
fn FallbackStats::record_udp_success(self : FallbackStats) -> Unit

#
FallbackStats::truncation_rate

source
fn FallbackStats::truncation_rate(self : FallbackStats) -> Int

#
FallbackTransport

source
pub struct FallbackTransport {
  udp : UdpTransport
  tcp : TcpTransport
}

#
FallbackTransport::as_transport

source

#
FallbackTransport::max_payload

source
fn FallbackTransport::max_payload(self : FallbackTransport) -> UInt16

#
FallbackTransport::new

source
fn FallbackTransport::new(server : String) -> FallbackTransport

#
FallbackTransport::send

source
async fn FallbackTransport::send(self : FallbackTransport, payload : Array[Byte]) -> Result[Array[Byte], TransportError]

#
FallbackTransport::with_options

source
fn FallbackTransport::with_options(server : String, timeout_ms : Int, retries : Int, udp_payload_size? : UInt16) -> FallbackTransport

pub struct Header {
  id : UInt16
  flags : UInt16
  qdcount : UInt16
  ancount : UInt16
  nscount : UInt16
  arcount : UInt16
}

#
Header::encode

source
fn Header::encode(self : Header) -> Array[Byte]

#
Message

source
pub struct Message {
  header : Header
  questions : Array[Question]
  answers : Array[RR]
  authorities : Array[RR]
  additionals : Array[RR]
}

#
Message::encode

source
fn Message::encode(self : Message) -> Array[Byte]

#
Message::encode_checked

source
fn Message::encode_checked(self : Message) -> Result[Array[Byte], String]

#
NegativeCacheKind

source
pub enum NegativeCacheKind {
  NXDomain
  NoData
}

#
OptOption

source
pub struct OptOption {
  opt_code : UInt16
  opt_data : Array[Byte]
}

#
OptRR

source
pub struct OptRR {
  udp_payload_size : UInt16
  ext_rcode : UInt16
  edns_version : UInt16
  flags : UInt16
  options : Array[OptOption]
}

#
OptRR::default

source
fn OptRR::default() -> OptRR

#
OptRR::encode

source
fn OptRR::encode(self : OptRR) -> Array[Byte]

#
OptRR::encode_checked

source
fn OptRR::encode_checked(self : OptRR) -> Result[Array[Byte], String]

#
OptRR::to_rr

source
fn OptRR::to_rr(self : OptRR) -> RR

Compatibility wrapper for the original API. Invalid EDNS fields abort explicitly instead of constructing an RR that bypasses checked validation.

#
OptRR::to_rr_checked

source
fn OptRR::to_rr_checked(self : OptRR) -> Result[RR, String]

#
OptRR::with_dnssec

source
fn OptRR::with_dnssec(payload_size : UInt16) -> OptRR

#
Question

source
pub struct Question {
  name : String
  qtype : UInt16
  qclass : UInt16
}

#
Question::encode

source
fn Question::encode(self : Question) -> Array[Byte]

#
Question::encode_checked

source
fn Question::encode_checked(self : Question) -> Result[Array[Byte], String]

#
RData

source
pub enum RData {
  A(Int)
  AAAA(Int, Int, Int, Int)
  CNAME(String)
  NS(String)
  PTR(String)
  MX(Int, String)
  TXT(Array[String])
  SOA(String, String, UInt, UInt, UInt, UInt, UInt)
  SRV(UInt, UInt, UInt, String)
  OPT(Array[OptOption])
  Unknown(Array[Byte])
}

#
RData::encode

source
fn RData::encode(self : RData) -> Array[Byte]

#
RData::encode_checked

source
fn RData::encode_checked(self : RData) -> Result[Array[Byte], String]

#
RData::rtype

source
fn RData::rtype(self : RData) -> UInt16

pub struct RR {
  name : String
  rtype : UInt16
  rclass : UInt16
  ttl : UInt
  rdlength : UInt16
  rdata : RData
}

#
RR::encode

source
fn RR::encode(self : RR) -> Array[Byte]

#
RR::encode_checked

source
fn RR::encode_checked(self : RR) -> Result[Array[Byte], String]

#
ResolveError

source
pub enum ResolveError {
  FormatError(String)
  ResponseMismatch(String)
  RandomnessUnavailable
  FormErr
  NXDomain
  NoData
  Referral
  ServFail
  Refused
  NotImplemented
  ExtendedRcode(Int)
  Timeout
  TruncatedAndTcpFailed
  ConnectionFailed(String)
  CnameLoop(String)
} derive(Eq, 
Debug)

#
ResolveOptions

source
pub(all) struct ResolveOptions {
  server : String
  timeout_ms : Int
  retries : Int
  recurse : Bool
  max_cname_depth : Int
}

#
ResolveOptions::default

source

#
ResolveOptions::new

source
fn ResolveOptions::new(server~ : String, timeout_ms? : Int, retries? : Int, recurse? : Bool, max_depth? : Int) -> ResolveOptions

Construct resolver options for callers outside this package. The fields of public structs are read-only across MoonBit package boundaries, so exposing this constructor makes server, timeout, and retry configuration available to the CLI and embedding applications.

#
Resolver

source
pub struct Resolver {
  transport : DnsTransport
  cache : DnsCache
  recurse : Bool
  max_cname_depth : Int
  clock : () -> Int64
}

#
Resolver::cache_stats

source
fn Resolver::cache_stats(self : Resolver) -> CacheStats

#
Resolver::new

source
fn Resolver::new(options? : ResolveOptions) -> Resolver

#
Resolver::resolve

source
async fn Resolver::resolve(self : Resolver, name : String, qtype : UInt16) -> Result[DnsResult, ResolveError]

#
Resolver::resolve_a

source
async fn Resolver::resolve_a(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::resolve_aaaa

source
async fn Resolver::resolve_aaaa(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::resolve_cname

source
async fn Resolver::resolve_cname(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::resolve_ipv4

source
async fn Resolver::resolve_ipv4(self : Resolver, host : String) -> Result[String, ResolveError]

#
Resolver::resolve_mx

source
async fn Resolver::resolve_mx(self : Resolver, name : String) -> Result[Array[(Int, String)], ResolveError]

#
Resolver::resolve_ns

source
async fn Resolver::resolve_ns(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::resolve_ptr

source
async fn Resolver::resolve_ptr(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::resolve_soa

source
async fn Resolver::resolve_soa(self : Resolver, name : String) -> Result[Array[SoaResult], ResolveError]

#
Resolver::resolve_srv

source
async fn Resolver::resolve_srv(self : Resolver, name : String) -> Result[Array[SrvResult], ResolveError]

#
Resolver::resolve_txt

source
async fn Resolver::resolve_txt(self : Resolver, name : String) -> Result[Array[String], ResolveError]

#
Resolver::with_transport

source
fn Resolver::with_transport(transport~ : DnsTransport, options? : ResolveOptions) -> Resolver

#
Resolver::with_transport_and_clock

source
fn Resolver::with_transport_and_clock(transport~ : DnsTransport, clock~ : () -> Int, options? : ResolveOptions) -> Resolver

#
Resolver::with_transport_and_clock64

source
fn Resolver::with_transport_and_clock64(transport~ : DnsTransport, clock~ : () -> Int64, options? : ResolveOptions) -> Resolver

Construct a resolver with a caller-controlled Int64 monotonic millisecond source. Use this API for long-running processes and tests that cross the 32-bit millisecond boundary. The older Int clock constructor remains as a compatibility wrapper.

#
RrTypeInfo

source
pub struct RrTypeInfo {
  rtype : UInt16
  name : String
  description : String
  is_domain_based : Bool
}

#
ServerAddress

source
pub(all) struct ServerAddress {
  host : String
  port : Int
} derive(Eq, 
Debug)

#
SoaResult

source
pub(all) struct SoaResult {
  mname : String
  rname : String
  serial : UInt
  refresh : UInt
  retry : UInt
  expire : UInt
  minimum : UInt
}

#
SrvResult

source
pub(all) struct SrvResult {
  priority : UInt
  weight : UInt
  port : UInt
  target : String
}

#
TcpTransport

source
pub struct TcpTransport {
  server : String
  timeout_ms : Int
  max_retries : Int
}

#
TcpTransport::as_transport

source
fn TcpTransport::as_transport(self : TcpTransport) -> DnsTransport

#
TcpTransport::new

source
fn TcpTransport::new(server : String) -> TcpTransport

#
TcpTransport::send

source
async fn TcpTransport::send(self : TcpTransport, payload : Array[Byte]) -> Result[Array[Byte], TransportError]

Send a DNS request over a new TCP connection and read exactly one framed response. Partial reads are handled by Reader::read_exactly.

#
TcpTransport::with_options

source
fn TcpTransport::with_options(server : String, timeout_ms : Int, max_retries : Int) -> TcpTransport

#
TcpTransport::with_timeout

source
fn TcpTransport::with_timeout(server : String, timeout_ms : Int) -> TcpTransport

#
TransportError

source
pub enum TransportError {
  Timeout(Int)
  Truncated
  ConnectionFailed(String)
  SendFailed(String)
  RecvFailed(String)
  InvalidServer(String)
  InvalidMessage(String)
} derive(Eq, 
Debug)

#
TransportStats

source
pub struct TransportStats {
  bytes_sent : 
Ref[Int]
  bytes_received : 
Ref[Int]
  packets_sent : 
Ref[Int]
  packets_received : 
Ref[Int]
  errors : 
Ref[Int]
  timeouts : 
Ref[Int]
  truncations : 
Ref[Int]
}

#
TransportStats::average_send_size

source
fn TransportStats::average_send_size(self : TransportStats) -> Int

#
TransportStats::new

source

#
TransportStats::record_error

source
fn TransportStats::record_error(self : TransportStats, err : TransportError) -> Unit

#
TransportStats::record_recv

source
fn TransportStats::record_recv(self : TransportStats, bytes : Int) -> Unit

#
TransportStats::record_send

source
fn TransportStats::record_send(self : TransportStats, bytes : Int) -> Unit

#
UdpTransport

source
pub struct UdpTransport {
  server : String
  timeout_ms : Int
  max_retries : Int
  udp_payload_size : UInt16
}

#
UdpTransport::as_transport

source
fn UdpTransport::as_transport(self : UdpTransport) -> DnsTransport

#
UdpTransport::max_payload

source
fn UdpTransport::max_payload(self : UdpTransport) -> UInt16

#
UdpTransport::new

source
fn UdpTransport::new(server : String) -> UdpTransport

#
UdpTransport::send

source
async fn UdpTransport::send(self : UdpTransport, payload : Array[Byte]) -> Result[Array[Byte], TransportError]

Send one DNS datagram. A connected UDP socket only accepts responses from the configured server; the OS therefore enforces the source-address check.

#
UdpTransport::with_options

source
fn UdpTransport::with_options(server : String, timeout_ms : Int, max_retries : Int, udp_payload_size? : UInt16) -> UdpTransport

#
UdpTransport::with_retries

source
fn UdpTransport::with_retries(server : String, timeout_ms : Int, max_retries : Int) -> UdpTransport

#
UdpTransport::with_timeout

source
fn UdpTransport::with_timeout(server : String, timeout_ms : Int) -> UdpTransport

#
build_client_subnet_option

source
fn build_client_subnet_option(family : UInt16, source_prefix : UInt16, scope_prefix : UInt16, address : Array[Byte]) -> OptOption

Compatibility constructor for the original API. Invalid input aborts immediately instead of returning an option that could become illegal wire. New code should use build_client_subnet_option_checked.

#
build_client_subnet_option_checked

source
fn build_client_subnet_option_checked(family : UInt16, source_prefix : UInt16, scope_prefix : UInt16, address : Array[Byte]) -> Result[OptOption, String]

fn build_cookie_option(client_cookie : Array[Byte], server_cookie : Array[Byte]) -> OptOption

Compatibility constructor for the original API. Invalid cookie lengths abort immediately; new code should use build_cookie_option_checked.
fn build_cookie_option_checked(client_cookie : Array[Byte], server_cookie : Array[Byte]) -> Result[OptOption, String]

#
build_keepalive_option

source
fn build_keepalive_option(timeout_ms : UInt16) -> OptOption

Compatibility constructor accepting the original UInt16 millisecond argument. The encoded field is converted to RFC 7828's 100ms units.

#
build_keepalive_option_checked

source
fn build_keepalive_option_checked(timeout_ms : Int) -> Result[OptOption, String]

#
build_keepalive_request_option

source
fn build_keepalive_request_option() -> OptOption

Build the empty TCP Keepalive option sent in a DNS request.

#
build_padding_option

source
fn build_padding_option(target_size : UInt16) -> OptOption

#
build_query

source
fn build_query(id : UInt16, name : String, qtype : UInt16, recurse : Bool) -> Message

#
build_query_with_edns

source
fn build_query_with_edns(id : UInt16, name : String, qtype : UInt16, recurse : Bool, opt : OptRR) -> Message

Compatibility wrapper for the original API. Resolver internals use the checked variant so malformed input is returned as a typed error.

#
build_query_with_edns_checked

source
fn build_query_with_edns_checked(id : UInt16, name : String, qtype : UInt16, recurse : Bool, opt : OptRR) -> Result[Message, String]

#
decode_header

source
fn decode_header(bytes : Array[Byte], offset? : Int) -> Result[(Header, Int), String]

#
decode_message

source
fn decode_message(bytes : Array[Byte]) -> Result[Message, String]

#
decode_name

source
fn decode_name(bytes : Array[Byte], offset : Int, msg_start : Int) -> Result[(String, Int), String]

#
decode_opt_rr

source
fn decode_opt_rr(bytes : Array[Byte], offset : Int, rdlength : UInt16, _msg_start : Int) -> Result[(OptRR, Int), String]

#
decode_question

source
fn decode_question(bytes : Array[Byte], offset : Int, msg_start : Int) -> Result[(Question, Int), String]

#
decode_questions

source
fn decode_questions(bytes : Array[Byte], offset : Int, count : UInt16, msg_start : Int) -> Result[(Array[Question], Int), String]

#
decode_rdata

source
fn decode_rdata(rtype : UInt16, bytes : Array[Byte], offset : Int, rdlength : UInt16, msg_start : Int) -> Result[(RData, Int), String]

#
decode_rr

source
fn decode_rr(bytes : Array[Byte], offset : Int, msg_start : Int) -> Result[(RR, Int), String]

#
decode_rrs

source
fn decode_rrs(bytes : Array[Byte], offset : Int, count : UInt16, msg_start : Int) -> Result[(Array[RR], Int), String]

#
default_retries

source
let default_retries : Int

#
default_timeout_ms

source
let default_timeout_ms : Int

#
default_udp_size

source
let default_udp_size : Int

#
dns_cloudflare_primary

source
let dns_cloudflare_primary : String

#
dns_cloudflare_secondary

source
let dns_cloudflare_secondary : String

#
dns_google_primary

source
let dns_google_primary : String

#
dns_google_secondary

source
let dns_google_secondary : String

#
dns_header_size

source
let dns_header_size : Int

#
dns_port

source
let dns_port : UInt16

#
dns_quad9_primary

source
let dns_quad9_primary : String

#
ede_blocked

source
let ede_blocked : UInt16

#
ede_cached_error

source
let ede_cached_error : UInt16

#
ede_censored

source
let ede_censored : UInt16

#
ede_dnskey_missing

source
let ede_dnskey_missing : UInt16

#
ede_dnssec_bogus

source
let ede_dnssec_bogus : UInt16

#
ede_dnssec_indeterminate

source
let ede_dnssec_indeterminate : UInt16

#
ede_filtered

source
let ede_filtered : UInt16

#
ede_forged_answer

source
let ede_forged_answer : UInt16

#
ede_invalid_data

source
let ede_invalid_data : UInt16

#
ede_network_error

source
let ede_network_error : UInt16

#
ede_no_reachable_authority

source
let ede_no_reachable_authority : UInt16

#
ede_no_zone_key

source
let ede_no_zone_key : UInt16

#
ede_not_authoritative

source
let ede_not_authoritative : UInt16

#
ede_not_ready

source
let ede_not_ready : UInt16

#
ede_not_supported

source
let ede_not_supported : UInt16

#
ede_nsec_missing

source
let ede_nsec_missing : UInt16

#
ede_other

source
let ede_other : UInt16

#
ede_prohibited

source
let ede_prohibited : UInt16

#
ede_rrsigs_missing

source
let ede_rrsigs_missing : UInt16

#
ede_signature_expired

source
let ede_signature_expired : UInt16

#
ede_signature_expired_before

source
let ede_signature_expired_before : UInt16

#
ede_signature_not_yet_valid

source
let ede_signature_not_yet_valid : UInt16

#
ede_stale_answer

source
let ede_stale_answer : UInt16

#
ede_stale_nxdomain

source
let ede_stale_nxdomain : UInt16

#
ede_too_early

source
let ede_too_early : UInt16

#
ede_unable_to_conform

source
let ede_unable_to_conform : UInt16

#
ede_unsupported_dnskey_algorithm

source
let ede_unsupported_dnskey_algorithm : UInt16

#
ede_unsupported_ds_digest

source
let ede_unsupported_ds_digest : UInt16

#
ede_unsupported_nsec3_iterations

source
let ede_unsupported_nsec3_iterations : UInt16

#
edns_default_udp_size

source
let edns_default_udp_size : UInt16

#
edns_flag_do

source
let edns_flag_do : UInt16

#
edns_opt_chain

source
let edns_opt_chain : UInt16

#
edns_opt_client_subnet

source
let edns_opt_client_subnet : UInt16

#
edns_opt_client_tag

source
let edns_opt_client_tag : UInt16

let edns_opt_cookie : UInt16

#
edns_opt_dau

source
let edns_opt_dau : UInt16

#
edns_opt_dhu

source
let edns_opt_dhu : UInt16

#
edns_opt_expire

source
let edns_opt_expire : UInt16

#
edns_opt_extended_error

source
let edns_opt_extended_error : UInt16

#
edns_opt_key_tag

source
let edns_opt_key_tag : UInt16

#
edns_opt_n3u

source
let edns_opt_n3u : UInt16

#
edns_opt_nsid

source
let edns_opt_nsid : UInt16

#
edns_opt_padding

source
let edns_opt_padding : UInt16

#
edns_opt_server_tag

source
let edns_opt_server_tag : UInt16

#
edns_opt_tcp_keepalive

source
let edns_opt_tcp_keepalive : UInt16

#
edns_option_name

source
fn edns_option_name(code : UInt16) -> String

#
encode_name_checked

source
fn encode_name_checked(name : String) -> Result[Array[Byte], String]

#
encode_name_uncompressed

source
fn encode_name_uncompressed(name : String) -> Array[Byte]

#
encode_questions

source
fn encode_questions(questions : Array[Question]) -> Array[Byte]

#
encode_tcp_message

source
fn encode_tcp_message(payload : Array[Byte]) -> Result[Array[Byte], TransportError]

Prefix a DNS payload with its two-octet RFC 7766 TCP length field.

#
extended_error_name

source
fn extended_error_name(code : UInt16) -> String

#
extract_cname_targets

source
fn extract_cname_targets(answers : Array[RR]) -> Array[String]

#
filter_terminal_records

source
fn filter_terminal_records(answers : Array[RR]) -> Array[RR]

#
find_cname_final_target

source
fn find_cname_final_target(answers : Array[RR], original_name : String) -> String

#
flag_aa

source
let flag_aa : UInt16

#
flag_qr

source
let flag_qr : UInt16

#
flag_ra

source
let flag_ra : UInt16

#
flag_rd

source
let flag_rd : UInt16

#
flag_tc

source
let flag_tc : UInt16

#
is_known_edns_option

source
fn is_known_edns_option(code : UInt16) -> Bool

#
is_retryable

source
fn is_retryable(err : TransportError) -> Bool

#
is_timeout

source
fn is_timeout(err : TransportError) -> Bool

#
lookup_rr_type

source
fn lookup_rr_type(rtype : UInt16) -> RrTypeInfo?

#
mask_aa

source
let mask_aa : UInt16

#
mask_opcode

source
let mask_opcode : UInt16

#
mask_qr

source
let mask_qr : UInt16

#
mask_ra

source
let mask_ra : UInt16

#
mask_rcode

source
let mask_rcode : UInt16

#
mask_rd

source
let mask_rd : UInt16

#
mask_tc

source
let mask_tc : UInt16

#
mask_z

source
let mask_z : UInt16

#
max_cname_depth

source
let max_cname_depth : Int

#
max_dns_labels

source
let max_dns_labels : Int

#
max_dns_message_len

source
let max_dns_message_len : Int

#
max_edns_options

source
let max_edns_options : Int

#
max_label_len

source
let max_label_len : Int

#
max_lifetime_ms

source
let max_lifetime_ms : Int

#
max_name_len

source
let max_name_len : Int

#
max_pointer_hops

source
let max_pointer_hops : Int

#
max_section_records

source
let max_section_records : Int

#
max_udp_payload

source
let max_udp_payload : UInt16

#
negative_ttl

source
let negative_ttl : Int

#
opcode_iquery

source
let opcode_iquery : UInt16

#
opcode_notify

source
let opcode_notify : UInt16

#
opcode_query

source
let opcode_query : UInt16

#
opcode_status

source
let opcode_status : UInt16

#
opcode_update

source
let opcode_update : UInt16

#
opt_from_rr

source
fn opt_from_rr(rr : RR) -> Result[OptRR, String]

#
parse_server_addr

source
fn parse_server_addr(source : String) -> Result[ServerAddress, TransportError]

Parse an IPv4, hostname, or bracketed IPv6 DNS server address. host, [ipv6], and host:port use port 53 when omitted.

#
pretty_print_message

source
fn pretty_print_message(msg : Message) -> String

#
pretty_print_rdata

source
fn pretty_print_rdata(rdata : RData) -> String

#
pretty_print_result

source
fn pretty_print_result(result : DnsResult) -> String

#
pretty_print_result_json

source
fn pretty_print_result_json(result : DnsResult, name : String, qtype : UInt16, server : String) -> String

#
pretty_print_rr

source
fn pretty_print_rr(rr : RR) -> String

#
ptr_name_from_ipv4

source
fn ptr_name_from_ipv4(ip : Int) -> String

#
qclass_in

source
let qclass_in : UInt16

#
qtype_a

source
let qtype_a : UInt16

#
qtype_aaaa

source
let qtype_aaaa : UInt16

#
qtype_afsdb

source
let qtype_afsdb : UInt16

#
qtype_any

source
let qtype_any : UInt16

#
qtype_axfr

source
let qtype_axfr : UInt16

#
qtype_caa

source
let qtype_caa : UInt16

#
qtype_cert

source
let qtype_cert : UInt16

#
qtype_cname

source
let qtype_cname : UInt16

#
qtype_dname

source
let qtype_dname : UInt16

#
qtype_dnskey

source
let qtype_dnskey : UInt16

#
qtype_ds

source
let qtype_ds : UInt16

#
qtype_hinfo

source
let qtype_hinfo : UInt16

#
qtype_https

source
let qtype_https : UInt16

#
qtype_isdn

source
let qtype_isdn : UInt16

#
qtype_ixfr

source
let qtype_ixfr : UInt16

#
qtype_key

source
let qtype_key : UInt16

#
qtype_kx

source
let qtype_kx : UInt16

#
qtype_loc

source
let qtype_loc : UInt16

#
qtype_mb

source
let qtype_mb : UInt16

#
qtype_md

source
let qtype_md : UInt16

#
qtype_mf

source
let qtype_mf : UInt16

#
qtype_mg

source
let qtype_mg : UInt16

#
qtype_minfo

source
let qtype_minfo : UInt16

#
qtype_mr

source
let qtype_mr : UInt16

#
qtype_mx

source
let qtype_mx : UInt16

#
qtype_naptr

source
let qtype_naptr : UInt16

#
qtype_ns

source
let qtype_ns : UInt16

#
qtype_nsec

source
let qtype_nsec : UInt16

#
qtype_null

source
let qtype_null : UInt16

#
qtype_opt

source
let qtype_opt : UInt16

#
qtype_ptr

source
let qtype_ptr : UInt16

#
qtype_px

source
let qtype_px : UInt16

#
qtype_rp

source
let qtype_rp : UInt16

#
qtype_rrsig

source
let qtype_rrsig : UInt16

#
qtype_rt

source
let qtype_rt : UInt16

#
qtype_sig

source
let qtype_sig : UInt16

#
qtype_soa

source
let qtype_soa : UInt16

#
qtype_spf

source
let qtype_spf : UInt16

#
qtype_srv

source
let qtype_srv : UInt16

#
qtype_sshfp

source
let qtype_sshfp : UInt16

#
qtype_svcb

source
let qtype_svcb : UInt16

#
qtype_tlsa

source
let qtype_tlsa : UInt16

#
qtype_to_string

source
fn qtype_to_string(qtype : UInt16) -> String

#
qtype_txt

source
let qtype_txt : UInt16

#
qtype_wks

source
let qtype_wks : UInt16

#
qtype_x25

source
let qtype_x25 : UInt16

#
question_a

source
fn question_a(name : String) -> Question

#
question_aaaa

source
fn question_aaaa(name : String) -> Question

#
question_any

source
fn question_any(name : String) -> Question

#
question_clone

source
fn question_clone(q : Question) -> Question

#
question_cname

source
fn question_cname(name : String) -> Question

#
question_custom

source
fn question_custom(name : String, qtype : UInt16, qclass? : UInt16) -> Question

#
question_description

source
fn question_description(q : Question) -> String

#
question_is_internet

source
fn question_is_internet(q : Question) -> Bool

#
question_is_type

source
fn question_is_type(q : Question, qtype : UInt16) -> Bool

#
question_mx

source
fn question_mx(name : String) -> Question

#
question_ns

source
fn question_ns(name : String) -> Question

#
question_ptr

source
fn question_ptr(name : String) -> Question

#
question_soa

source
fn question_soa(name : String) -> Question

#
question_srv

source
fn question_srv(name : String) -> Question

#
question_txt

source
fn question_txt(name : String) -> Question

#
question_wire_size

source
fn question_wire_size(q : Question) -> Int

#
questions_for_types

source
fn questions_for_types(name : String, qtypes : Array[UInt16]) -> Array[Question]

#
rcode_badalg

source
let rcode_badalg : Int

#
rcode_badcookie

source
let rcode_badcookie : Int

#
rcode_badkey

source
let rcode_badkey : Int

#
rcode_badmode

source
let rcode_badmode : Int

#
rcode_badname

source
let rcode_badname : Int

#
rcode_badtime

source
let rcode_badtime : Int

#
rcode_badtrunc

source
let rcode_badtrunc : Int

#
rcode_badvers

source
let rcode_badvers : Int

#
rcode_formerr

source
let rcode_formerr : Int

#
rcode_noerror

source
let rcode_noerror : Int

#
rcode_notimp

source
let rcode_notimp : Int

#
rcode_nxdomain

source
let rcode_nxdomain : Int

#
rcode_refused

source
let rcode_refused : Int

#
rcode_servfail

source
let rcode_servfail : Int

#
rcode_to_string

source
fn rcode_to_string(rcode : Int) -> String

#
read_tcp_length

source
fn read_tcp_length(buf : Array[Byte], offset? : Int) -> Result[Int, TransportError]

#
response_has_cname

source
fn response_has_cname(msg : Message) -> Bool

#
rr_a

source
fn rr_a(name : String, ip : Int, ttl? : UInt) -> RR

#
rr_aaaa

source
fn rr_aaaa(name : String, w1 : Int, w2 : Int, w3 : Int, w4 : Int, ttl? : UInt) -> RR

#
rr_cname

source
fn rr_cname(name : String, target : String, ttl? : UInt) -> RR

#
rr_compare_ttl

source
fn rr_compare_ttl(a : RR, b : RR) -> Int

Compare two DNS TTLs using their RFC 1035 unsigned 32-bit ordering. The result is -1, 0, or 1 and never depends on subtracting values that may overflow a signed Int.

#
rr_count_by_type

source
fn rr_count_by_type(rrs : Array[RR], rtype : UInt16) -> Int

#
rr_filter_by_min_ttl

source
fn rr_filter_by_min_ttl(rrs : Array[RR], min_ttl : UInt) -> Array[RR]

#
rr_is_expired

source
fn rr_is_expired(rr : RR, current_time : Int) -> Bool

Return whether an RR's unsigned TTL has elapsed after current_time seconds. Equality is expired. Negative elapsed values are treated as being before the record was inserted.

#
rr_is_type

source
fn rr_is_type(rr : RR, rtype : UInt16) -> Bool

#
rr_mx

source
fn rr_mx(name : String, pref : Int, exchange : String, ttl? : UInt) -> RR

#
rr_new

source
fn rr_new(name : String, rtype : UInt16, rclass : UInt16, ttl : UInt, rdata : RData) -> RR

#
rr_ns

source
fn rr_ns(name : String, ns : String, ttl? : UInt) -> RR

#
rr_ptr

source
fn rr_ptr(name : String, ptr : String, ttl? : UInt) -> RR

#
rr_short_description

source
fn rr_short_description(rr : RR) -> String

#
rr_soa

source
fn rr_soa(name : String, mname : String, rname : String, serial : UInt, refresh : UInt, retry : UInt, expire : UInt, minimum : UInt, ttl? : UInt) -> RR

#
rr_srv

source
fn rr_srv(name : String, priority : UInt, weight : UInt, port : UInt, target : String, ttl? : UInt) -> RR

#
rr_txt

source
fn rr_txt(name : String, strings : Array[String], ttl? : UInt) -> RR

#
rr_type_needs_decompression

source
fn rr_type_needs_decompression(rtype : UInt16) -> Bool

#
rr_type_registry

source
fn rr_type_registry() -> Array[RrTypeInfo]

#
short_print_rdata

source
fn short_print_rdata(rdata : RData) -> String

Format RDATA for one-answer-per-line command output.

This deliberately keeps DNS names without a presentation trailing dot and leaves SOA fields space separated so scripts can compare the value with dig +short after their type-specific normalization. It is a semantic formatter, not a zone-file serializer.

#
soa_default_expire

source
let soa_default_expire : UInt

#
soa_default_minimum

source
let soa_default_minimum : UInt

#
soa_default_refresh

source
let soa_default_refresh : UInt

#
soa_default_retry

source
let soa_default_retry : UInt

#
tcp_dns_max_len

source
let tcp_dns_max_len : Int

#
tcp_dns_max_message_size

source
fn tcp_dns_max_message_size() -> Int

#
transport_error_message

source
fn transport_error_message(err : TransportError) -> String

#
validate_tcp_message

source
fn validate_tcp_message(buf : Array[Byte]) -> Bool

#
wire_check_range

source
fn wire_check_range(bytes : Array[Byte], offset : Int, length : Int) -> Result[Unit, String]

#
wire_concat

source
fn wire_concat(segments : Array[Array[Byte]]) -> Array[Byte]

#
wire_copy_range

source
fn wire_copy_range(bytes : Array[Byte], offset : Int, length : Int) -> Result[Array[Byte], String]

#
wire_get_pointer

source
fn wire_get_pointer(bytes : Array[Byte], offset : Int) -> Result[Int, String]

#
wire_get_u16

source
fn wire_get_u16(bytes : Array[Byte], offset : Int) -> Result[(UInt16, Int), String]

#
wire_get_u32

source
fn wire_get_u32(bytes : Array[Byte], offset : Int) -> Result[(UInt, Int), String]

#
wire_hex_dump

source
fn wire_hex_dump(bytes : Array[Byte], max_len? : Int) -> String

#
wire_is_pointer

source
fn wire_is_pointer(b : Byte) -> Bool

#
wire_message_size

source
fn wire_message_size(header_bytes : Array[Byte], sections : Array[Array[Byte]]) -> Int

#
wire_put_pointer

source
fn wire_put_pointer(buf : Array[Byte], offset : Int, target : Int) -> Result[Int, String]

#
wire_put_u16

source
fn wire_put_u16(buf : Array[Byte], offset : Int, val : UInt16) -> Result[Int, String]

#
wire_put_u32

source
fn wire_put_u32(buf : Array[Byte], offset : Int, val : UInt) -> Result[Int, String]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io