"""A minimal DNS TXT lookup, because the standard library has none.
The nsite gateway binds a custom domain to a site through a TXT record at
`_nsite.<domain>`. `socket` can resolve A/AAAA, not TXT, and pulling in a
DNS library for one record type is not worth a dependency: this is a single
UDP query (RFC 1035, with the RFC 1123 TCP fallback when the answer is
truncated), to the resolvers `/etc/resolv.conf` names, following CNAMEs in
the answer section.
Returned strings are the TXT character-strings of one record joined, one
entry per record, decoded as UTF-8 with errors replaced. The caller decides
what a value means.
"""
from __future__ import annotations
import os
import random
import socket
import struct
from typing import Callable, Optional, Sequence
TYPE_TXT = 16
TYPE_CNAME = 5
CLASS_IN = 1
MAX_LABEL = 63
MAX_NAME = 253
Resolver = Callable[[str], list[str]]
[docs]class DnsError(Exception):
"""The lookup could not be completed (network, malformed answer)."""
[docs]def system_nameservers(path: str = '/etc/resolv.conf') -> list[str]:
out: list[str] = []
try:
with open(path, encoding='utf-8', errors='replace') as f:
for line in f:
parts = line.split()
if len(parts) >= 2 and parts[0] == 'nameserver':
out.append(parts[1])
except OSError:
pass
return out or ['127.0.0.53', '1.1.1.1']
def _encode_name(name: str) -> bytes:
name = name.rstrip('.')
if len(name) > MAX_NAME:
raise DnsError('name too long')
out = b''
for label in name.split('.'):
raw = label.encode('idna') if label else b''
if not raw or len(raw) > MAX_LABEL:
raise DnsError('bad label in %r' % name)
out += bytes([len(raw)]) + raw
return out + b'\x00'
def _read_name(msg: bytes, off: int, depth: int = 0) -> tuple[str, int]:
labels: list[str] = []
jumped_to: Optional[int] = None
while True:
if off >= len(msg):
raise DnsError('truncated name')
ln = msg[off]
if ln & 0xC0 == 0xC0:
if depth > 8:
raise DnsError('pointer loop')
ptr = struct.unpack('!H', msg[off:off + 2])[0] & 0x3FFF
name, _ = _read_name(msg, ptr, depth + 1)
labels.append(name)
return '.'.join(x for x in labels if x), (jumped_to if jumped_to is not None else off + 2)
off += 1
if ln == 0:
return '.'.join(labels), off
labels.append(msg[off:off + ln].decode('ascii', errors='replace'))
off += ln
def _query(name: str, server: str, timeout: float, tcp: bool = False) -> bytes:
qid = random.randrange(0, 1 << 16)
header = struct.pack('!HHHHHH', qid, 0x0100, 1, 0, 0, 0) # RD set
q = header + _encode_name(name) + struct.pack('!HH', TYPE_TXT, CLASS_IN)
fam = socket.AF_INET6 if ':' in server else socket.AF_INET
if tcp:
with socket.socket(fam, socket.SOCK_STREAM) as s:
s.settimeout(timeout)
s.connect((server, 53))
s.sendall(struct.pack('!H', len(q)) + q)
ln = s.recv(2)
if len(ln) < 2:
raise DnsError('short tcp answer')
want = struct.unpack('!H', ln)[0]
buf = b''
while len(buf) < want:
chunk = s.recv(want - len(buf))
if not chunk:
break
buf += chunk
resp = buf
else:
with socket.socket(fam, socket.SOCK_DGRAM) as s:
s.settimeout(timeout)
s.sendto(q, (server, 53))
resp, _ = s.recvfrom(4096)
if len(resp) < 12 or struct.unpack('!H', resp[:2])[0] != qid:
raise DnsError('answer id mismatch')
return resp
def _parse_txt(resp: bytes, name: str) -> list[str]:
_, flags, qd, an, _, _ = struct.unpack('!HHHHHH', resp[:12])
rcode = flags & 0xF
if rcode == 3:
return [] # NXDOMAIN: no such name, not an error
if rcode != 0:
raise DnsError('rcode %d' % rcode)
if flags & 0x0200:
raise _Truncated()
off = 12
for _ in range(qd):
_, off = _read_name(resp, off)
off += 4
wanted = {name.rstrip('.').lower()}
out: list[str] = []
for _ in range(an):
rname, off = _read_name(resp, off)
rtype, _, _, rdlen = struct.unpack('!HHIH', resp[off:off + 10])
off += 10
rdata = resp[off:off + rdlen]
off += rdlen
if rname.lower() not in wanted:
continue
if rtype == TYPE_CNAME:
target, _ = _read_name(resp, off - rdlen)
wanted.add(target.lower())
elif rtype == TYPE_TXT:
i, parts = 0, []
while i < len(rdata):
ln = rdata[i]
parts.append(rdata[i + 1:i + 1 + ln])
i += 1 + ln
out.append(b''.join(parts).decode('utf-8', errors='replace'))
return out
class _Truncated(Exception):
pass
[docs]def lookup_txt(name: str, servers: Optional[Sequence[str]] = None, timeout: float = 3.0) -> list[str]:
"""TXT records at `name`. Empty list = the name has none (incl. NXDOMAIN).
Raises DnsError when no resolver answered usably."""
servers = list(servers) if servers else system_nameservers()
if os.environ.get('FLEETMESH_DNS_SERVERS'):
servers = os.environ['FLEETMESH_DNS_SERVERS'].split(',')
last: Optional[Exception] = None
for server in servers:
try:
try:
return _parse_txt(_query(name, server, timeout), name)
except _Truncated:
return _parse_txt(_query(name, server, timeout, tcp=True), name)
except (OSError, DnsError, struct.error) as e:
last = e
continue
raise DnsError('no resolver answered for %s: %s' % (name, last))