Source code for fleetmesh_node.transport.dnstxt

"""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))