dns

nimony/lib/std/dns.nim

const RTypeA: uint16
const RTypeNs: uint16
const RTypeCname: uint16
const RTypePtr: uint16

type Question = object
  name: string
  rtype: uint16
  rclass: uint16

type Answer = object
  name: string
  rtype: uint16
  ttl: uint32
  ip4: string
  cname: string
  raw: string

type Message = object
  id: uint16
  flags: uint16
  questions: seq[Question]
  answers: seq[Answer]

proc encodeMessage(m: Message; s: var seq[char])
Encode m for the wire, ready for a datagram. A response echoes its question verbatim and appends answers; the caller decides which of the two that is entirely by what lives in questions/answers.
proc decodeMessage(buf: openArray[char]; m: var Message): bool
Parse buf into m, following compression in every name. false for anything a resolver cannot trust. The authority and additional sections are ignored.

type Resolver = object
  hosts: ref StringTableObj not nil
  servers: seq[string]

proc initResolver(dl: Deadline): Resolver
std/dns's client: the machine's own hosts table wins over the network, which is asked at the nameservers the machine is configured with — the nameserver lines of /etc/resolv.conf on POSIX, GetNetworkParams on Windows, which has no such file. Configuration that parses partially is used partially: a broken hosts file does not take the resolver down with it. The hosts file is read through the ring (asyncio), so construction is {.passive.} and bounded by dl like everything else here.
proc query(r: var Resolver; host: string; serverIdx: int64; port: uint16; dl: Deadline): Message
One question to r.servers[serverIdx], port, and one datagram back, bounded by dl. resolve speaks port 53; the port parameter exists so a caller can aim a question at an in-process server on an ephemeral port. Parsed but uninterpreted — the caller applies resolve's rules. Raises TimeoutError when dl arrives before a reply to this question, NameNotFound for NXDOMAIN, IOError when no random id can be drawn.
The id is drawn from the OS CSPRNG, and a reply counts only if it echoes the id and the question: with a clock-derived id and nothing else checked, an off-path attacker can guess well enough to have a forged answer accepted. A datagram that fails either check is dropped and the wait for the real one goes on, so a forgery cannot even make the query fail early.
proc resolve(r: var Resolver; hostIn: string; dl: Deadline): string
The IPv4 dotted quad for hostIn: from the machine's hosts table when it is listed there, from the loopback rule when it is a localhost name, else from the first nameserver that answers. Follows CNAME chains inside the one response; raises ValueError for a name the resolver cannot look up at all, TimeoutError when the budget runs out, NameNotFound when the name is not known to the resolver or the zone it asked.
proc resolve(name: string; dl: Deadline): string
Resolve name using the process-wide default resolver. The first call reads /etc/hosts and /etc/resolv.conf; every subsequent call reuses the same table. Raises the same errors as the explicit resolve form.

type DnsQuestion = object
  req: ptr DnsRequest not nil
  name: string
  rtype: uint16
  rclass: uint16

type DnsRequest = object
  sock: ptr UdpSocket
  id: uint16
  flags: uint16
  rcode: uint16
  peer: PeerAddr
  questions: seq[DnsQuestion]
  answers: seq[Answer]
  buf: array[0..511, char]

type DnsServer = object
  sock: UdpSocket

proc newDnsServer(port: uint16; deadline: Deadline): DnsServer
A bound, unconnected UDP socket able to answer questions. port of 0 asks the kernel to pick one (boundPort unless the caller passes one). Passive, like openUdp it builds on: the socket, its flag and its bind go through the ring, so call this from a task, not a thread's top level.
proc boundPort(s: var DnsServer): uint16
proc close(s: var DnsServer)
proc next(s: var DnsServer; r: var DnsRequest; dl: Deadline): bool
The next query to arrive, decoded into r and ready to be answered. false once there will not be a next one, which is how a serve loop is told to stop:
while s.next(r): ... r.respond()
Returns false when dl arrives with no query, or when the receive fails — the same answer accept gives a listener that stops serving. Never raises. A datagram that decodes to no question is dropped and the wait goes on.
proc answer(q: DnsQuestion; name: string; rtype: uint16; ttl: uint32; data: string)
Append one answer record to the request q is part of. data is interpreted by rtype: a dotted quad for RTypeA, a dotted name for CNAME/PTR, rdata bytes verbatim for anything else — the three shapes a resolver reads back are the three this accepts.
proc respond(r: var DnsRequest; dl: Deadline)
Send the reply for r to whoever asked: every question echoed, every answer answer collected, the query's RD bit returned, rcode where a handler set it. Answers accumulate across the questions of one request, so the multi-A round-robin a resolver expects is q.answer twice in a row, not two procs for one shape.