// dns_ask: arma a mano una pregunta de DNS, la manda por UDP y muestra el encabezado y las
// respuestas de tipo A. Sirve para ver el formato del RFC 1035 sin ninguna biblioteca.
//   uso: dns_ask <IPv4 del servidor> <nombre> [--norecurse]
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/random.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

enum { HEADER_SIZE = 12, MAX_MESSAGE = 512, MAX_JUMPS = 32, TYPE_A = 1, CLASS_IN = 1 };

static uint16_t read_u16(const uint8_t *from) {
    return (uint16_t)((from[0] << 8) | from[1]);
}

static void write_u16(uint8_t *to, uint16_t value) {
    to[0] = (uint8_t)(value >> 8);
    to[1] = (uint8_t)(value & 0xFF);
}

// Escribe "www.uni.test" como 3www3uni4test0. Devuelve los bytes usados, o -1 si no cabe.
static int encode_name(const char *name, uint8_t *out, size_t room) {
    size_t used = 0;
    while (*name != '\0') {
        const char *dot = strchr(name, '.');
        size_t size = dot != NULL ? (size_t)(dot - name) : strlen(name);
        if (size == 0 || size > 63 || used + size + 2 > room) {
            return -1;
        }
        out[used++] = (uint8_t)size;
        memcpy(out + used, name, size);
        used += size;
        name += size;
        if (*name == '.') {
            name++;
        }
    }
    if (used + 1 > room) {
        return -1;
    }
    out[used++] = 0;
    return (int)used;
}

// Se salta un nombre y devuelve dónde sigue. Un puntero ocupa 2 bytes y termina el nombre.
static int skip_name(const uint8_t *message, int length, int offset) {
    while (offset < length) {
        uint8_t size = message[offset];
        if ((size & 0xC0) == 0xC0) {
            return offset + 2 <= length ? offset + 2 : -1;
        }
        if ((size & 0xC0) != 0) {
            return -1;
        }
        if (size == 0) {
            return offset + 1;
        }
        offset += 1 + size;
    }
    return -1;
}

// Imprime un nombre, siguiendo punteros. Solo se aceptan punteros hacia atrás.
static int print_name(const uint8_t *message, int length, int offset) {
    int jumps = 0;
    while (offset < length) {
        uint8_t size = message[offset];
        if ((size & 0xC0) == 0xC0) {
            if (offset + 2 > length || ++jumps > MAX_JUMPS) {
                return -1;
            }
            int target = ((size & 0x3F) << 8) | message[offset + 1];
            if (target >= offset) {
                return -1;
            }
            offset = target;
        } else if ((size & 0xC0) != 0) {
            return -1;
        } else if (size == 0) {
            return 0;
        } else {
            if (offset + 1 + size > length) {
                return -1;
            }
            printf("%.*s.", size, (const char *)message + offset + 1);
            offset += 1 + size;
        }
    }
    return -1;
}

static int print_reply(const uint8_t *reply, int length, uint16_t id) {
    if (length < HEADER_SIZE) {
        fprintf(stderr, "dns_ask: respuesta más corta que el encabezado\n");
        return -1;
    }
    if (read_u16(reply) != id) {
        fprintf(stderr, "dns_ask: el ID no coincide; se descarta\n");
        return -1;
    }
    uint16_t flags = read_u16(reply + 2);
    uint16_t questions = read_u16(reply + 4);
    uint16_t answers = read_u16(reply + 6);
    printf("id=%u qr=%d aa=%d tc=%d rd=%d ra=%d rcode=%d\n", id, (flags >> 15) & 1, (flags >> 10) & 1,
           (flags >> 9) & 1, (flags >> 8) & 1, (flags >> 7) & 1, flags & 0xF);
    printf("preguntas=%u respuestas=%u autoridad=%u adicionales=%u\n", questions, answers,
           read_u16(reply + 8), read_u16(reply + 10));

    int offset = HEADER_SIZE;
    for (int i = 0; i < questions; i++) {
        offset = skip_name(reply, length, offset);
        if (offset < 0 || offset + 4 > length) {
            fprintf(stderr, "dns_ask: pregunta mal formada\n");
            return -1;
        }
        offset += 4;
    }
    for (int i = 0; i < answers; i++) {
        int name_at = offset;
        offset = skip_name(reply, length, offset);
        if (offset < 0 || offset + 10 > length) {
            fprintf(stderr, "dns_ask: respuesta mal formada\n");
            return -1;
        }
        uint16_t type = read_u16(reply + offset);
        uint32_t ttl = ((uint32_t)read_u16(reply + offset + 4) << 16) | read_u16(reply + offset + 6);
        uint16_t size = read_u16(reply + offset + 8);
        offset += 10;
        if (offset + size > length) {
            fprintf(stderr, "dns_ask: datos cortados\n");
            return -1;
        }
        if (type == TYPE_A && size == 4) {
            char text[INET_ADDRSTRLEN];
            if (inet_ntop(AF_INET, reply + offset, text, sizeof text) == NULL) {
                perror("inet_ntop");
                return -1;
            }
            if (print_name(reply, length, name_at) < 0) {
                fprintf(stderr, "dns_ask: nombre mal formado\n");
                return -1;
            }
            printf(" ttl=%u A %s\n", ttl, text);
        }
        offset += size;
    }
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc < 3 || argc > 4 || (argc == 4 && strcmp(argv[3], "--norecurse") != 0)) {
        fprintf(stderr, "uso: %s <IPv4 del servidor> <nombre> [--norecurse]\n", argv[0]);
        return 2;
    }
    struct sockaddr_in server = {.sin_family = AF_INET, .sin_port = htons(53)};
    if (inet_pton(AF_INET, argv[1], &server.sin_addr) != 1) {
        fprintf(stderr, "dns_ask: dirección inválida: %s\n", argv[1]);
        return 2;
    }

    uint16_t id;
    if (getrandom(&id, sizeof id, 0) != (ssize_t)sizeof id) {
        perror("getrandom");
        return 1;
    }

    // Nunca se copia una struct a la red: cada campo se escribe en orden de red.
    uint8_t query[MAX_MESSAGE] = {0};
    write_u16(query, id);
    write_u16(query + 2, argc == 4 ? 0x0000 : 0x0100);  // RD pide recursión
    write_u16(query + 4, 1);                            // una pregunta
    int name_size = encode_name(argv[2], query + HEADER_SIZE, sizeof query - HEADER_SIZE - 4);
    if (name_size < 0) {
        fprintf(stderr, "dns_ask: nombre inválido: %s\n", argv[2]);
        return 2;
    }
    write_u16(query + HEADER_SIZE + name_size, TYPE_A);
    write_u16(query + HEADER_SIZE + name_size + 2, CLASS_IN);
    size_t query_size = (size_t)(HEADER_SIZE + name_size + 4);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket");
        return 1;
    }
    struct timeval timeout = {.tv_sec = 2};
    if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout) < 0) {
        perror("setsockopt");
        close(sock);
        return 1;
    }
    // Con connect, el kernel solo nos entrega datagramas que vengan de ese servidor.
    if (connect(sock, (struct sockaddr *)&server, sizeof server) < 0) {
        perror("connect");
        close(sock);
        return 1;
    }
    if (send(sock, query, query_size, 0) != (ssize_t)query_size) {
        perror("send");
        close(sock);
        return 1;
    }
    uint8_t reply[MAX_MESSAGE];
    ssize_t got = recv(sock, reply, sizeof reply, 0);
    if (got < 0) {
        fprintf(stderr, "dns_ask: sin respuesta: %s\n", strerror(errno));
        close(sock);
        return 1;
    }
    if (close(sock) < 0) {
        perror("close");
        return 1;
    }
    return print_reply(reply, (int)got, id) == 0 ? 0 : 1;
}

#!/usr/bin/env python3
"""Servidor autoritativo mínimo: responde por una zona, por UDP y por TCP.

    python3 dns_auth.py <dirección> <archivo de zona>

Sirve para ver la jerarquía de DNS en una red propia. No es un servidor para usar en serio.
"""
import socket
import struct
import sys
import threading

import dns_wire as w

UDP_LIMIT = 512  # sin EDNS, una respuesta por UDP no pasa de aquí (RFC 1035)


def parse_rdata(rtype, fields):
    if rtype == "MX":
        return int(fields[0]), w.normalize(fields[1])
    if rtype in ("NS", "CNAME"):
        return w.normalize(fields[0])
    if rtype == "SOA":
        return (w.normalize(fields[0]), w.normalize(fields[1]), *(int(field) for field in fields[2:7]))
    if rtype == "TXT":
        text = " ".join(fields).strip('"')
        # Una forma corta de escribir un registro enorme, para ver el truncamiento.
        if text.startswith("repetir:"):
            _tag, count, unit = text.split(":", 2)
            return unit * int(count)
        return text
    return fields[0]


def load_zone(path):
    """Lee una zona: `nombre ttl tipo datos`, un registro por línea y nombres completos."""
    records = []
    with open(path, encoding="utf-8") as file:
        for line in file:
            line = line.split(";", 1)[0].strip()
            if not line:
                continue
            name, ttl, rtype, *fields = line.split()
            records.append(w.Record(w.normalize(name), w.TYPES[rtype], int(ttl), parse_rdata(rtype, fields)))
    soa = [record for record in records if record.rtype == w.TYPES["SOA"]]
    if len(soa) != 1:
        raise ValueError(f"{path}: una zona lleva exactamente un SOA")
    return soa[0].name, records


class Zone:
    def __init__(self, origin, records):
        self.origin = origin
        self.records = records
        self.soa = next(record for record in records if record.rtype == w.TYPES["SOA"])

    def find(self, name, rtype=None):
        return [record for record in self.records
                if record.name == name and (rtype is None or record.rtype == rtype)]

    def name_exists(self, name):
        # Un nombre intermedio, sin registros propios, también existe (RFC 1034, sección 4.3.2).
        return any(record.name == name or record.name.endswith("." + name) for record in self.records)

    def delegation_for(self, name):
        """Devuelve los NS del corte de zona más alto por encima de name, si hay uno."""
        labels = name.rstrip(".").split(".")
        for start in range(len(labels) - 1, -1, -1):
            candidate = ".".join(labels[start:]) + "."
            if candidate == self.origin or not w.in_bailiwick(candidate, self.origin):
                continue
            servers = self.find(candidate, w.TYPES["NS"])
            if servers:
                return servers
        return []

    def glue_for(self, hosts):
        glue = []
        for host in hosts:
            glue += self.find(host, w.TYPES["A"]) + self.find(host, w.TYPES["AAAA"])
        return glue

    def negative(self, reply, rcode):
        # El SOA va en authority: su MINIMUM limita cuánto se recuerda la respuesta negativa.
        ttl = min(self.soa.ttl, self.soa.data[6])
        reply.authority.append(w.Record(self.soa.name, self.soa.rtype, ttl, self.soa.data))
        reply.flags = (reply.flags & ~0xF) | rcode

    def answer(self, reply, name, rtype):
        if not w.in_bailiwick(name, self.origin):
            reply.flags |= w.REFUSED
            return
        servers = self.delegation_for(name)
        if servers:
            # Referral: "yo no sé, pregúntele a estos". No es autoritativa (AA = 0).
            reply.authority += servers
            reply.additional += self.glue_for(record.data for record in servers)
            return
        reply.flags |= w.FLAG_AA
        seen = set()
        while True:
            exact = self.find(name, rtype)
            if exact:
                reply.answer += exact
                break
            alias = self.find(name, w.TYPES["CNAME"])
            if alias and name not in seen:
                seen.add(name)
                reply.answer += alias
                name = alias[0].data
                if not w.in_bailiwick(name, self.origin):
                    return  # el destino es de otra zona: lo sigue el resolver
                continue
            if not reply.answer:
                self.negative(reply, w.NOERROR if self.name_exists(name) else w.NXDOMAIN)
            return
        if rtype == w.TYPES["MX"]:
            reply.additional += self.glue_for(record.data[1] for record in exact)
        elif rtype == w.TYPES["NS"]:
            reply.additional += self.glue_for(record.data for record in exact)


def respond(zone, data, limit):
    """Devuelve la respuesta a un mensaje recibido, o None si no se puede ni contestar."""
    try:
        query = w.decode(data)
    except w.WireError:
        return None, "mensaje mal formado"
    reply = w.Message(query.msg_id, w.FLAG_QR | (query.flags & w.FLAG_RD), question=query.question[:1])
    if len(query.question) != 1:
        reply.flags |= w.FORMERR
        return w.encode(reply), "sin una pregunta"
    name, rtype = query.question[0]
    zone.answer(reply, w.normalize(name), rtype)
    raw = w.encode(reply)
    summary = (f"{w.normalize(name)} {w.TYPE_NAMES.get(rtype, rtype)} -> {w.RCODE_NAMES[reply.rcode]}"
               f" an={len(reply.answer)} ns={len(reply.authority)} ar={len(reply.additional)}")
    if limit and len(raw) > limit:
        # No cabe: mandamos solo la pregunta con TC = 1, y el cliente repite por TCP.
        short = w.Message(query.msg_id, reply.flags | w.FLAG_TC, question=reply.question)
        return w.encode(short), summary + f" TC ({len(raw)} bytes)"
    return raw, summary


def log(transport, peer, msg_id, summary):
    print(f"{transport} {peer[0]}:{peer[1]} id={msg_id} {summary}", flush=True)


def serve_udp(zone, address):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((address, 53))
    while True:
        data, peer = sock.recvfrom(4096)
        raw, summary = respond(zone, data, UDP_LIMIT)
        msg_id = struct.unpack_from("!H", data)[0] if len(data) >= 2 else 0
        log("udp", peer, msg_id, summary)
        if raw is not None:
            sock.sendto(raw, peer)


def read_exact(conn, count):
    data = b""
    while len(data) < count:
        chunk = conn.recv(count - len(data))
        if not chunk:
            return None
        data += chunk
    return data


def serve_tcp_client(zone, conn, peer):
    # Por TCP cada mensaje lleva delante su largo en 2 bytes: un stream no conserva límites.
    with conn:
        conn.settimeout(5)
        try:
            while True:
                head = read_exact(conn, 2)
                if head is None:
                    return
                data = read_exact(conn, struct.unpack("!H", head)[0])
                if data is None:
                    return
                raw, summary = respond(zone, data, None)
                log("tcp", peer, struct.unpack_from("!H", data)[0] if len(data) >= 2 else 0, summary)
                if raw is None:
                    return
                conn.sendall(struct.pack("!H", len(raw)) + raw)
        except OSError:
            return


def serve_tcp(zone, address):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind((address, 53))
    sock.listen(16)
    while True:
        conn, peer = sock.accept()
        threading.Thread(target=serve_tcp_client, args=(zone, conn, peer), daemon=True).start()


def main():
    if len(sys.argv) != 3:
        sys.exit("uso: dns_auth.py <dirección> <archivo de zona>")
    zone = Zone(*load_zone(sys.argv[2]))
    print(f"autoritativo de {zone.origin} en {sys.argv[1]}: {len(zone.records)} registros", flush=True)
    threading.Thread(target=serve_tcp, args=(zone, sys.argv[1]), daemon=True).start()
    serve_udp(zone, sys.argv[1])


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Resolver recursivo mínimo, con cache: parte de la raíz y baja por las delegaciones.

    python3 dns_resolver.py <dirección> <dirección de la raíz>
"""
import math
import secrets
import socket
import struct
import sys
import threading
import time

import dns_wire as w

MAX_STEPS = 24
QUERY_TIMEOUT = 1.0
UDP_LIMIT = 512


def acceptable_reply(reply, msg_id, question, peer, server):
    """Solo se acepta una respuesta que coincide en servidor, ID y pregunta.

    Quien quiera colar una respuesta falsa tiene que adivinar todo esto, incluido el puerto,
    que aquí revisa el kernel porque el socket está conectado al servidor.
    """
    if peer[0] != server or not reply.flags & w.FLAG_QR or reply.msg_id != msg_id:
        return False
    if len(reply.question) != 1:
        return False
    name, rtype = reply.question[0]
    return w.normalize(name) == w.normalize(question[0]) and rtype == question[1]


def usable_glue(reply, zone):
    """Se guardan solo las direcciones de nombres dentro de la zona delegada."""
    return [record for record in reply.additional
            if record.rtype in (w.TYPES["A"], w.TYPES["AAAA"]) and w.in_bailiwick(record.name, zone)]


class Cache:
    """Guarda conjuntos de registros hasta que vence su TTL."""

    def __init__(self, clock=time.monotonic):
        self.clock = clock
        self.entries = {}
        self.lock = threading.Lock()

    def put(self, name, rtype, records, ttl=None, rcode=w.NOERROR):
        ttl = min((record.ttl for record in records), default=0) if ttl is None else ttl
        if ttl > 0:
            with self.lock:
                self.entries[(name, rtype)] = (self.clock() + ttl, records, rcode)

    def get(self, name, rtype):
        """Devuelve (registros con el TTL que les queda, rcode), o None si no está o venció."""
        with self.lock:
            entry = self.entries.get((name, rtype))
            if entry is None:
                return None
            expires, records, rcode = entry
            now = self.clock()
            if expires <= now:
                del self.entries[(name, rtype)]
                return None
            left = math.ceil(expires - now)
        return [w.Record(r.name, r.rtype, left, r.data) for r in records], rcode


class Resolver:
    def __init__(self, root):
        self.root = root
        self.cache = Cache()

    def ask(self, server, name, rtype):
        """Una pregunta a un servidor, con ID nuevo y un socket (y puerto) nuevo cada vez."""
        msg_id = secrets.randbelow(65536)
        data = w.encode(w.Message(msg_id, 0, question=[(name, rtype)]))
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
            sock.settimeout(QUERY_TIMEOUT)
            sock.connect((server, 53))
            sock.send(data)
            raw = sock.recv(4096)
        reply = w.decode(raw)
        if not acceptable_reply(reply, msg_id, (name, rtype), (server, 53), server):
            raise w.WireError("respuesta que no corresponde a la pregunta")
        if reply.flags & w.FLAG_TC:
            reply = self.ask_tcp(server, name, rtype)
        return reply

    def ask_tcp(self, server, name, rtype):
        msg_id = secrets.randbelow(65536)
        data = w.encode(w.Message(msg_id, 0, question=[(name, rtype)]))
        with socket.create_connection((server, 53), timeout=QUERY_TIMEOUT * 2) as conn:
            conn.sendall(struct.pack("!H", len(data)) + data)
            with conn.makefile("rb") as stream:
                head = stream.read(2)
                if len(head) != 2:
                    raise w.WireError("TCP cerrado antes de la respuesta")
                raw = stream.read(struct.unpack("!H", head)[0])
        reply = w.decode(raw)
        if not acceptable_reply(reply, msg_id, (name, rtype), (server, 53), server):
            raise w.WireError("respuesta TCP que no corresponde a la pregunta")
        return reply

    def closest_servers(self, name):
        """Busca en cache los NS del ancestro más cercano. Sin ninguno, la raíz."""
        labels = name.rstrip(".").split(".")
        for start in range(len(labels)):
            zone = ".".join(labels[start:]) + "."
            cached = self.cache.get(zone, w.TYPES["NS"])
            if not cached:
                continue
            addresses = []
            for record in cached[0]:
                glue = self.cache.get(record.data, w.TYPES["A"])
                if glue:
                    addresses += [r.data for r in glue[0]]
            if addresses:
                return addresses
        return [self.root]

    def resolve(self, name, rtype, depth=0):
        """Devuelve (rcode, registros, authority). Sigue referrals y CNAME."""
        name = w.normalize(name)
        chain = []
        for _ in range(MAX_STEPS):
            cached = self.cache.get(name, rtype)
            if cached:
                records, rcode = cached
                return rcode, chain + records, []
            alias = self.cache.get(name, w.TYPES["CNAME"])
            if alias:
                chain += alias[0]
                name = alias[0][0].data
                continue
            step = self.iterate(name, rtype, depth)
            if step is None:
                return w.SERVFAIL, chain, []
            reply = step
            if reply.rcode == w.NXDOMAIN or (reply.rcode == w.NOERROR and not reply.answer):
                self.remember_negative(name, rtype, reply)
                return reply.rcode, chain, reply.authority
            if reply.rcode != w.NOERROR:
                return w.SERVFAIL, chain, []
            self.remember_answer(reply)
        return w.SERVFAIL, chain, []

    def iterate(self, name, rtype, depth):
        """Pregunta bajando por la jerarquía hasta tener una respuesta final."""
        servers = self.closest_servers(name)
        for _ in range(MAX_STEPS):
            reply = None
            for server in servers:
                try:
                    reply = self.ask(server, name, rtype)
                    break
                except (OSError, w.WireError) as error:
                    print(f"  {server}: {error}", flush=True)
            if reply is None:
                return None
            referral = [r for r in reply.authority if r.rtype == w.TYPES["NS"]]
            if reply.answer or reply.flags & w.FLAG_AA or not referral or reply.rcode != w.NOERROR:
                return reply
            servers = self.follow_referral(reply, referral, depth)
            if not servers:
                return None
        return None

    def follow_referral(self, reply, referral, depth):
        zone = referral[0].name
        self.cache.put(zone, w.TYPES["NS"], referral)
        glue = usable_glue(reply, zone)
        by_name = {}
        for record in glue:
            by_name.setdefault((record.name, record.rtype), []).append(record)
        for (name, rtype), records in by_name.items():
            self.cache.put(name, rtype, records)
        addresses = [record.data for record in glue if record.rtype == w.TYPES["A"]]
        if addresses or depth > 4:
            return addresses
        # Sin glue, el nombre del servidor hay que resolverlo aparte, como cualquier otro.
        for record in referral:
            rcode, records, _ = self.resolve(record.data, w.TYPES["A"], depth + 1)
            if rcode == w.NOERROR:
                addresses += [r.data for r in records if r.rtype == w.TYPES["A"]]
        return addresses

    def remember_answer(self, reply):
        groups = {}
        for record in reply.answer:
            groups.setdefault((record.name, record.rtype), []).append(record)
        for (name, rtype), records in groups.items():
            self.cache.put(name, rtype, records)

    def remember_negative(self, name, rtype, reply):
        soa = [r for r in reply.authority if r.rtype == w.TYPES["SOA"]]
        if soa:
            self.cache.put(name, rtype, [], ttl=min(soa[0].ttl, soa[0].data[6]), rcode=reply.rcode)


def build_reply(resolver, data, peer):
    """Devuelve la respuesta completa a una pregunta, o None si no se puede ni contestar."""
    try:
        query = w.decode(data)
    except w.WireError:
        return None
    reply = w.Message(query.msg_id, w.FLAG_QR | w.FLAG_RA | (query.flags & w.FLAG_RD),
                      question=query.question[:1])
    if len(query.question) != 1:
        reply.flags |= w.FORMERR
        return reply
    name, rtype = query.question[0]
    if query.flags & w.FLAG_RD:
        rcode, records, authority = resolver.resolve(name, rtype)
    else:
        # Sin recursión, un resolver solo cuenta lo que ya tiene en cache.
        cached = resolver.cache.get(w.normalize(name), rtype)
        rcode, records, authority = (cached[1], cached[0], []) if cached else (w.NOERROR, [], [])
    reply.flags |= rcode
    reply.answer = records
    reply.authority = authority
    print(f"{peer[0]}:{peer[1]} id={query.msg_id} {name} {w.TYPE_NAMES.get(rtype, rtype)}"
          f" -> {w.RCODE_NAMES[rcode]} an={len(records)}", flush=True)
    return reply


def handle_udp(resolver, sock, data, peer):
    reply = build_reply(resolver, data, peer)
    if reply is None:
        return
    raw = w.encode(reply)
    if len(raw) > UDP_LIMIT:
        raw = w.encode(w.Message(reply.msg_id, reply.flags | w.FLAG_TC, question=reply.question))
    sock.sendto(raw, peer)


def handle_tcp(resolver, conn, peer):
    with conn:
        conn.settimeout(5)
        try:
            with conn.makefile("rb") as stream:
                head = stream.read(2)
                if len(head) != 2:
                    return
                data = stream.read(struct.unpack("!H", head)[0])
            reply = build_reply(resolver, data, peer)
            if reply is not None:
                raw = w.encode(reply)
                conn.sendall(struct.pack("!H", len(raw)) + raw)
        except OSError:
            return


def serve_tcp(resolver, address):
    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listener.bind((address, 53))
    listener.listen(16)
    while True:
        conn, peer = listener.accept()
        threading.Thread(target=handle_tcp, args=(resolver, conn, peer), daemon=True).start()


def main():
    if len(sys.argv) != 3:
        sys.exit("uso: dns_resolver.py <dirección> <raíz>")
    resolver = Resolver(sys.argv[2])
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((sys.argv[1], 53))
    threading.Thread(target=serve_tcp, args=(resolver, sys.argv[1]), daemon=True).start()
    print(f"resolver en {sys.argv[1]}, raíz {sys.argv[2]}", flush=True)
    while True:
        data, peer = sock.recvfrom(4096)
        threading.Thread(target=handle_udp, args=(resolver, sock, data, peer), daemon=True).start()


if __name__ == "__main__":
    main()

"""Formato de los mensajes de DNS (RFC 1035, sección 4), byte por byte y sin bibliotecas."""
import struct
from dataclasses import dataclass, field

TYPES = {"A": 1, "NS": 2, "CNAME": 5, "SOA": 6, "MX": 15, "TXT": 16, "AAAA": 28}
TYPE_NAMES = {number: name for name, number in TYPES.items()}
CLASS_IN = 1

# Bits del segundo campo del encabezado.
FLAG_QR = 0x8000  # 1 si es respuesta
FLAG_AA = 0x0400  # respuesta autoritativa
FLAG_TC = 0x0200  # truncada: pregunte por TCP
FLAG_RD = 0x0100  # el cliente pide recursión
FLAG_RA = 0x0080  # el servidor ofrece recursión

NOERROR, FORMERR, SERVFAIL, NXDOMAIN, NOTIMP, REFUSED = range(6)
RCODE_NAMES = ["NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED"]

MAX_POINTER_JUMPS = 32


class WireError(ValueError):
    """El mensaje no respeta el formato. Nunca confiamos en lo que llega de la red."""


@dataclass
class Record:
    name: str
    rtype: int
    ttl: int
    data: object  # depende del tipo; ver encode_rdata

    def __str__(self):
        return f"{self.name} {self.ttl} IN {TYPE_NAMES.get(self.rtype, self.rtype)} {self.data}"


@dataclass
class Message:
    msg_id: int = 0
    flags: int = 0
    question: list = field(default_factory=list)  # lista de (nombre, tipo)
    answer: list = field(default_factory=list)
    authority: list = field(default_factory=list)
    additional: list = field(default_factory=list)

    @property
    def rcode(self):
        return self.flags & 0x000F


def normalize(name):
    """Los nombres no distinguen mayúsculas; los guardamos en minúsculas y con punto final."""
    name = name.lower()
    return name if name.endswith(".") else name + "."


def encode_name(name, buffer, offsets):
    """Agrega un nombre a buffer. Si ya apareció un sufijo, usa un puntero a él."""
    labels = [label for label in name.split(".") if label]
    for index, label in enumerate(labels):
        suffix = ".".join(labels[index:]).lower()
        if suffix in offsets:
            buffer += struct.pack("!H", 0xC000 | offsets[suffix])
            return
        if len(buffer) < 0x4000:
            offsets[suffix] = len(buffer)
        raw = label.encode("ascii")
        if not 1 <= len(raw) <= 63:
            raise WireError(f"etiqueta de largo inválido: {label!r}")
        buffer.append(len(raw))
        buffer += raw
    buffer.append(0)


def decode_name(data, offset):
    """Lee un nombre, siguiendo punteros. Devuelve el nombre y dónde sigue el mensaje."""
    labels = []
    end = None
    jumps = 0
    while True:
        if offset >= len(data):
            raise WireError("nombre cortado")
        size = data[offset]
        if size & 0xC0 == 0xC0:
            if offset + 1 >= len(data):
                raise WireError("puntero cortado")
            if end is None:
                end = offset + 2
            target = ((size & 0x3F) << 8) | data[offset + 1]
            # Un puntero solo puede ir hacia atrás. Eso, y el límite, evitan los ciclos.
            jumps += 1
            if target >= offset or jumps > MAX_POINTER_JUMPS:
                raise WireError("puntero inválido")
            offset = target
        elif size & 0xC0:
            raise WireError("etiqueta de tipo desconocido")
        elif size == 0:
            if end is None:
                end = offset + 1
            return (".".join(labels) + ".") if labels else ".", end
        else:
            if offset + 1 + size > len(data):
                raise WireError("etiqueta cortada")
            labels.append(data[offset + 1:offset + 1 + size].decode("ascii", "replace"))
            offset += 1 + size


def encode_ipv4(text):
    parts = [int(part) for part in text.split(".")]
    if len(parts) != 4 or not all(0 <= part <= 255 for part in parts):
        raise WireError(f"dirección inválida: {text}")
    return bytes(parts)


def encode_rdata(record, buffer, offsets):
    """Agrega los datos del registro. Deja el RDLENGTH correcto antes de ellos."""
    length_at = len(buffer)
    buffer += b"\0\0"
    kind = record.rtype
    if kind == TYPES["A"]:
        buffer += encode_ipv4(record.data)
    elif kind == TYPES["AAAA"]:
        import ipaddress
        buffer += ipaddress.IPv6Address(record.data).packed
    elif kind in (TYPES["NS"], TYPES["CNAME"]):
        encode_name(record.data, buffer, offsets)
    elif kind == TYPES["MX"]:
        preference, host = record.data
        buffer += struct.pack("!H", preference)
        encode_name(host, buffer, offsets)
    elif kind == TYPES["SOA"]:
        mname, rname, serial, refresh, retry, expire, minimum = record.data
        encode_name(mname, buffer, offsets)
        encode_name(rname, buffer, offsets)
        buffer += struct.pack("!5I", serial, refresh, retry, expire, minimum)
    elif kind == TYPES["TXT"]:
        # Un TXT es una o más cadenas de hasta 255 bytes, cada una con su largo.
        raw = record.data.encode("utf-8")
        chunks = [raw[start:start + 255] for start in range(0, len(raw), 255)] or [b""]
        for chunk in chunks:
            buffer.append(len(chunk))
            buffer += chunk
    else:
        raise WireError(f"tipo no soportado: {kind}")
    struct.pack_into("!H", buffer, length_at, len(buffer) - length_at - 2)


def encode(message):
    """Convierte un mensaje a bytes, con todos los campos en orden de red."""
    buffer = bytearray(struct.pack(
        "!6H", message.msg_id, message.flags, len(message.question), len(message.answer),
        len(message.authority), len(message.additional)))
    offsets = {}
    for name, rtype in message.question:
        encode_name(name, buffer, offsets)
        buffer += struct.pack("!2H", rtype, CLASS_IN)
    for record in message.answer + message.authority + message.additional:
        encode_name(record.name, buffer, offsets)
        buffer += struct.pack("!HHI", record.rtype, CLASS_IN, record.ttl)
        encode_rdata(record, buffer, offsets)
    return bytes(buffer)


def decode_rdata(data, offset, length, rtype):
    end = offset + length
    if rtype == TYPES["A"] and length == 4:
        return ".".join(str(byte) for byte in data[offset:end])
    if rtype == TYPES["AAAA"] and length == 16:
        import ipaddress
        return str(ipaddress.IPv6Address(data[offset:end]))
    if rtype in (TYPES["NS"], TYPES["CNAME"]):
        return decode_name(data, offset)[0]
    if rtype == TYPES["MX"] and length >= 3:
        return struct.unpack_from("!H", data, offset)[0], decode_name(data, offset + 2)[0]
    if rtype == TYPES["SOA"]:
        mname, cursor = decode_name(data, offset)
        rname, cursor = decode_name(data, cursor)
        if cursor + 20 > end:
            raise WireError("SOA cortado")
        return (mname, rname, *struct.unpack_from("!5I", data, cursor))
    if rtype == TYPES["TXT"]:
        chunks, cursor = [], offset
        while cursor < end:
            size = data[cursor]
            chunks.append(data[cursor + 1:cursor + 1 + size])
            cursor += 1 + size
        return b"".join(chunks).decode("utf-8", "replace")
    # Tipos que no entendemos (por ejemplo OPT, de EDNS): se conservan como bytes.
    return bytes(data[offset:end])


def decode_record(data, offset):
    name, offset = decode_name(data, offset)
    if offset + 10 > len(data):
        raise WireError("registro cortado")
    rtype, _rclass, ttl, length = struct.unpack_from("!HHIH", data, offset)
    offset += 10
    if offset + length > len(data):
        raise WireError("datos del registro cortados")
    return Record(normalize(name), rtype, ttl, decode_rdata(data, offset, length, rtype)), offset + length


def decode(data):
    """Convierte bytes en un mensaje. Lanza WireError si algo no cuadra."""
    if len(data) < 12:
        raise WireError("mensaje más corto que el encabezado")
    msg_id, flags, qd, an, ns, ar = struct.unpack_from("!6H", data, 0)
    message = Message(msg_id, flags)
    offset = 12
    for _ in range(qd):
        name, offset = decode_name(data, offset)
        if offset + 4 > len(data):
            raise WireError("pregunta cortada")
        rtype, _rclass = struct.unpack_from("!2H", data, offset)
        offset += 4
        message.question.append((name, rtype))
    for section, count in ((message.answer, an), (message.authority, ns), (message.additional, ar)):
        for _ in range(count):
            record, offset = decode_record(data, offset)
            section.append(record)
    return message


def in_bailiwick(name, zone):
    """¿El nombre cae dentro de la zona? Quien responde solo tiene autoridad sobre su zona."""
    name, zone = normalize(name), normalize(zone)
    return zone == "." or name == zone or name.endswith("." + zone)