// Cliente de prueba: manda un mensaje desde un puerto de origen elegido y espera la respuesta.
//   demux_client <tcp|udp|udp-connect> <ip> <puerto> <puerto_origen> <mensaje> [espera_s]
// Con espera_s, la conexión se queda abierta ese tiempo después de la respuesta.
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

#define REPLY_WAIT_S 2

int main(int argc, char *argv[]) {
    if (argc != 6 && argc != 7) {
        fprintf(stderr, "uso: %s <tcp|udp|udp-connect> <ip> <puerto> <puerto_origen> <mensaje> [espera_s]\n",
                argv[0]);
        return EXIT_FAILURE;
    }
    int is_tcp = strcmp(argv[1], "tcp") == 0;
    int is_connected = is_tcp || strcmp(argv[1], "udp-connect") == 0;
    if (!is_tcp && !is_connected && strcmp(argv[1], "udp") != 0) {
        fprintf(stderr, "protocolo no válido: %s\n", argv[1]);
        return EXIT_FAILURE;
    }
    int port = atoi(argv[3]);
    int source_port = atoi(argv[4]);
    if (port <= 0 || port > 65535 || source_port <= 0 || source_port > 65535) {
        fprintf(stderr, "puerto fuera de rango\n");
        return EXIT_FAILURE;
    }
    struct sockaddr_in remote;
    memset(&remote, 0, sizeof remote);
    remote.sin_family = AF_INET;
    remote.sin_port = htons((uint16_t)port);
    if (inet_pton(AF_INET, argv[2], &remote.sin_addr) != 1) {
        fprintf(stderr, "dirección no válida: %s\n", argv[2]);
        return EXIT_FAILURE;
    }

    int fd = socket(AF_INET, is_tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
    if (fd == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    int yes = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) == -1) {
        perror("setsockopt");
        return EXIT_FAILURE;
    }
    struct timeval wait = {.tv_sec = REPLY_WAIT_S};
    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &wait, sizeof wait) == -1) {
        perror("setsockopt");
        return EXIT_FAILURE;
    }
    struct sockaddr_in local;
    memset(&local, 0, sizeof local);
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    local.sin_port = htons((uint16_t)source_port);
    if (bind(fd, (struct sockaddr *)&local, sizeof local) == -1) {
        perror("bind");
        return EXIT_FAILURE;
    }
    if (is_connected && connect(fd, (struct sockaddr *)&remote, sizeof remote) == -1) {
        perror("connect");
        return EXIT_FAILURE;
    }
    size_t length = strlen(argv[5]);
    ssize_t sent = is_connected
        ? send(fd, argv[5], length, 0)
        : sendto(fd, argv[5], length, 0, (struct sockaddr *)&remote, sizeof remote);
    if (sent == -1) {
        perror("send");
        return EXIT_FAILURE;
    }
    char reply[256];
    ssize_t got = recv(fd, reply, sizeof reply - 1, 0);
    if (got == -1) {
        perror("recv");
        return EXIT_FAILURE;
    }
    reply[got] = '\0';
    printf("%s\n", reply);
    if (fflush(stdout) == EOF) {
        perror("fflush");
    }
    if (argc == 7) {
        unsigned rest = (unsigned)atoi(argv[6]);
        while (rest > 0) {
            rest = sleep(rest);
        }
    }
    if (close(fd) == -1) {
        perror("close");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

#!/usr/bin/env python3
"""Los pasos del ensayo: cargar sus arreglos, cortar enlaces y volverlos a subir.

    python3 ensayo.py arreglos          carga lab/*.conf en los routers
    python3 ensayo.py corta <a> <b>     baja el enlace entre dos nodos
    python3 ensayo.py sube <a> <b>      lo vuelve a subir
    python3 ensayo.py enlaces           lista los enlaces

Cortar con `ip link set down` hace que los dos extremos se enteren al instante: BGP cierra
la sesión sin esperar a su hold timer. Es lo que se ve cuando se desconecta un cable.
"""
import os
import subprocess
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
ANSWERS = os.path.join(HERE, "solution")
if not os.path.isdir(ANSWERS):
    ANSWERS = os.path.join(HERE, "lab")
PREFIX = "clab-w09-ensayo-"
FIXED_ROUTERS = ["e1", "e2", "e3", "t2"]
LINKS = {
    ("t1", "t2"): ("eth1", "eth1"),
    ("t1", "e1"): ("eth2", "eth1"),
    ("t1", "e2"): ("eth3", "eth1"),
    ("t1", "e3"): ("eth4", "eth1"),
    ("t2", "e2"): ("eth2", "eth2"),
    ("t2", "e3"): ("eth3", "eth2"),
    ("t2", "e4"): ("eth4", "eth1"),
    ("e3", "e4"): ("eth3", "eth2"),
}


def run(*args):
    done = subprocess.run(args, capture_output=True, text=True, timeout=60)
    if done.returncode != 0:
        raise SystemExit(f"falló {' '.join(args)}:\n{done.stdout}{done.stderr}")
    return done.stdout


def set_link(a, b, state):
    if (a, b) in LINKS:
        interface_a, interface_b = LINKS[a, b]
    elif (b, a) in LINKS:
        interface_b, interface_a = LINKS[b, a]
    else:
        raise SystemExit(f"no hay un enlace entre {a} y {b}: python3 ensayo.py enlaces")
    run("docker", "exec", PREFIX + a, "ip", "link", "set", interface_a, state)
    run("docker", "exec", PREFIX + b, "ip", "link", "set", interface_b, state)


def answer_is_ready(router):
    with open(os.path.join(ANSWERS, f"{router}.conf"), encoding="utf-8") as file:
        return "TODO" not in file.read()


def load_fixes():
    for router in FIXED_ROUTERS:
        if not answer_is_ready(router):
            print(f"{router}: lab/{router}.conf todavía tiene su TODO, no lo cargo")
            continue
        path = os.path.join(ANSWERS, f"{router}.conf")
        run("docker", "cp", path, f"{PREFIX}{router}:/tmp/arreglo.conf")
        run("docker", "exec", PREFIX + router, "vtysh", "-f", "/tmp/arreglo.conf")
        # Un filtro de entrada cambiado no se aplica solo a lo que ya se recibió.
        run("docker", "exec", PREFIX + router, "vtysh", "-c", "clear bgp ipv4 unicast * soft in")
        print(f"{router}: arreglo cargado")


def main():
    if len(sys.argv) == 2 and sys.argv[1] == "arreglos":
        load_fixes()
    elif len(sys.argv) == 2 and sys.argv[1] == "enlaces":
        for a, b in LINKS:
            print(f"{a} {b}")
    elif len(sys.argv) == 4 and sys.argv[1] in ("corta", "sube"):
        set_link(sys.argv[2], sys.argv[3], "down" if sys.argv[1] == "corta" else "up")
    else:
        print(__doc__)


if __name__ == "__main__":
    main()

"""Ayudas de las pruebas de la semana 9: levantar topologías y correr comandos."""
import os
import subprocess
import time
import unittest

HERE = os.path.dirname(os.path.abspath(__file__))
# La solución no se publica. Sin ella, las pruebas usan lo que ustedes escriben en lab/.
ANSWERS = os.path.join(HERE, "solution")
if not os.path.isdir(ANSWERS):
    ANSWERS = os.path.join(HERE, "lab")


def answer_path(name):
    """Devuelve la ruta de un archivo del laboratorio, o salta si sigue con el TODO."""
    path = os.path.join(ANSWERS, name)
    with open(path, encoding="utf-8") as file:
        if "TODO" in file.read():
            raise unittest.SkipTest(f"falta completar lab/{name}")
    return path


def run(args, timeout=240, stdin=None):
    return subprocess.run(args, capture_output=True, text=True, timeout=timeout, stdin=stdin)


class Lab:
    """Una topología de Containerlab que se levanta y se destruye desde las pruebas."""

    def __init__(self, folder, name, network):
        self.folder = os.path.join(HERE, folder)
        self.topology = f"{folder}.clab.yml"
        self.prefix = f"clab-{name}-"
        self.network = network

    def deploy(self):
        done = subprocess.run(
            ["containerlab", "deploy", "-t", self.topology, "--reconfigure"],
            cwd=self.folder, capture_output=True, text=True, timeout=300)
        if done.returncode != 0:
            raise RuntimeError(done.stdout + done.stderr)

    def destroy(self):
        subprocess.run(["containerlab", "destroy", "-t", self.topology, "--cleanup"],
                       cwd=self.folder, capture_output=True, text=True, timeout=300)
        subprocess.run(["docker", "network", "rm", self.network], capture_output=True, text=True)

    def sh(self, node, *command, timeout=60):
        """Corre un comando en un nodo y devuelve el resultado completo."""
        return run(["docker", "exec", self.prefix + node, *command], timeout=timeout)

    def out(self, node, *command, timeout=60):
        """Corre un comando en un nodo y devuelve stdout y stderr juntos."""
        done = self.sh(node, *command, timeout=timeout)
        return done.stdout + done.stderr

    def daemon(self, node, command):
        """Deja un comando corriendo en segundo plano dentro de un nodo."""
        run(["docker", "exec", "-d", self.prefix + node, "sh", "-c", command])

    def vtysh(self, node, command):
        return self.out(node, "vtysh", "-c", command)


def wait_until(predicate, seconds=30, step=0.5):
    """Espera a que una condición se cumpla; devuelve si se cumplió."""
    deadline = time.monotonic() + seconds
    while time.monotonic() < deadline:
        if predicate():
            return True
        time.sleep(step)
    return predicate()

#!/usr/bin/env python3
"""Construye la entrega confiable paso a paso, con un solo paquete en vuelo.

    python3 rdt_sim.py                     lista los escenarios
    python3 rdt_sim.py <escenario>         corre uno y muestra el diagrama de tiempo
    python3 rdt_sim.py todos               corre todos

Es un simulador: no hay red ni sockets. El canal sigue un guion que dice qué le pasa a cada
transmisión, en orden. Así, un error ocurre siempre en el mismo lugar y se puede razonar.
Cada versión del protocolo agrega un solo mecanismo a la anterior:

    v1    canal perfecto: se envía y ya
    v2    errores de bits: checksum, ACK y NAK
    v2.1  ACK o NAK dañados: un bit de secuencia en los datos
    v2.2  lo mismo sin NAK: el ACK dice qué número confirma
    v3    pérdidas: un temporizador
"""
import heapq
import sys
from dataclasses import dataclass, field

ONE_WAY_MS = 10
TIMEOUT_MS = 30
LATE_EXTRA_MS = 25  # lo que se atrasa un paquete con el resultado "tarde"


@dataclass
class Packet:
    kind: str  # DATA, ACK o NAK
    seq: int | None = None
    payload: str | None = None
    corrupt: bool = False

    def label(self):
        text = self.kind
        if self.seq is not None:
            text += f" {self.seq}"
        if self.payload is not None:
            text += f' "{self.payload}"'
        return text


@dataclass
class Result:
    version: str
    trace: list = field(default_factory=list)
    delivered: list = field(default_factory=list)
    finished: bool = False
    transmissions: int = 0


class Simulation:
    """El emisor y el receptor de una versión, unidos por un canal con guion."""

    def __init__(self, version, messages, script=()):
        self.version = version
        self.messages = list(messages)
        self.script = list(script)
        self.result = Result(version)
        self.events = []
        self.order = 0
        self.now = 0
        self.index = 0  # próximo mensaje por confirmar
        self.send_seq = 0
        self.expected_seq = 0
        self.timer_generation = 0

    @property
    def uses_seq(self):
        return self.version in ("v2.1", "v2.2", "v3")

    # El canal --------------------------------------------------------------------------
    def schedule(self, delay, action, *args):
        heapq.heappush(self.events, (self.now + delay, self.order, action, args))
        self.order += 1

    def log(self, side, text):
        self.result.trace.append((self.now, side, text))

    def transmit(self, side, packet, is_retransmission=False):
        outcome = self.script.pop(0) if self.script else "ok"
        self.result.transmissions += 1
        note = {"ok": "", "corrupt": "  [el canal daña bits]", "lost": "  [el canal lo pierde]",
                "late": "  [llega tarde]"}[outcome]
        again = " (otra vez)" if is_retransmission else ""
        self.log(side, f"envía {packet.label()}{again}{note}")
        if outcome == "lost":
            return
        delay = ONE_WAY_MS + (LATE_EXTRA_MS if outcome == "late" else 0)
        if outcome == "corrupt":
            packet = Packet(packet.kind, packet.seq, packet.payload, corrupt=True)
        handler = self.at_receiver if side == "emisor" else self.at_sender
        self.schedule(delay, handler, packet)

    # El emisor -------------------------------------------------------------------------
    def data_packet(self):
        seq = self.send_seq if self.uses_seq else None
        return Packet("DATA", seq, self.messages[self.index])

    def send_current(self, is_retransmission=False):
        self.transmit("emisor", self.data_packet(), is_retransmission)
        if self.version == "v3":
            self.timer_generation += 1
            self.schedule(TIMEOUT_MS, self.on_timeout, self.timer_generation)

    def advance(self):
        self.timer_generation += 1  # apaga el temporizador
        self.index += 1
        self.send_seq ^= 1
        if self.index < len(self.messages):
            self.send_current()
        else:
            self.result.finished = True
            self.log("emisor", "terminó: todo confirmado")

    def on_timeout(self, generation):
        if generation != self.timer_generation or self.result.finished:
            return
        self.log("emisor", "vence el temporizador")
        self.send_current(is_retransmission=True)

    def at_sender(self, packet):
        if self.result.finished:
            self.log("emisor", f"recibe {packet.label()}: ya terminó, lo ignora")
            return
        if packet.corrupt:
            if self.version == "v3":
                self.log("emisor", "recibe una respuesta dañada: la ignora y espera al temporizador")
            else:
                self.log("emisor", "recibe una respuesta dañada: no sabe qué era, repite")
                self.send_current(is_retransmission=True)
            return
        if packet.kind == "NAK":
            self.log("emisor", f"recibe {packet.label()}: repite")
            self.send_current(is_retransmission=True)
        elif self.version in ("v2.2", "v3") and packet.seq != self.send_seq:
            if self.version == "v3":
                self.log("emisor", f"recibe {packet.label()}: es de un paquete viejo, la ignora")
            else:
                self.log("emisor", f"recibe {packet.label()}: esperaba ACK {self.send_seq}, repite")
                self.send_current(is_retransmission=True)
        else:
            self.log("emisor", f"recibe {packet.label()}")
            self.advance()

    # El receptor -----------------------------------------------------------------------
    def deliver(self, packet):
        text = "?!?" if packet.corrupt else packet.payload
        self.result.delivered.append(text)
        return text

    def reply(self, kind, seq=None):
        self.transmit("receptor", Packet(kind, seq))

    def at_receiver(self, packet):
        version = self.version
        if version == "v1":
            # Sin checksum, el receptor no se entera de que los bits llegaron dañados.
            self.log("receptor", f'recibe y entrega "{self.deliver(packet)}"')
            self.schedule(1, self.next_without_reply)
            return
        if packet.corrupt:
            if version in ("v2", "v2.1"):
                self.log("receptor", "recibe datos dañados")
                self.reply("NAK")
            else:
                self.log("receptor", "recibe datos dañados: confirma el último bueno")
                self.reply("ACK", self.expected_seq ^ 1)
            return
        if version == "v2":
            self.log("receptor", f'recibe y entrega "{self.deliver(packet)}"')
            self.reply("ACK")
            return
        if packet.seq == self.expected_seq:
            self.log("receptor", f'recibe {packet.seq} y entrega "{self.deliver(packet)}"')
            self.expected_seq ^= 1
            self.reply("ACK", None if version == "v2.1" else packet.seq)
        else:
            self.log("receptor", f"recibe {packet.seq}: duplicado, no lo entrega")
            self.reply("ACK", None if version == "v2.1" else packet.seq)

    def next_without_reply(self):
        self.index += 1
        if self.index < len(self.messages):
            self.send_current()
        else:
            self.result.finished = True
            self.log("emisor", "terminó")

    # La simulación ---------------------------------------------------------------------
    def run(self):
        self.send_current()
        while self.events:
            self.now, _, action, args = heapq.heappop(self.events)
            action(*args)
        if not self.result.finished:
            self.log("emisor", "se quedó esperando para siempre: nada en camino, ningún temporizador")
        return self.result


# nombre: (versión, guion del canal, qué muestra)
MESSAGES = ["a", "b", "c"]
SCENARIOS = {
    "v1-perfecto": ("v1", [], "v1 sobre un canal perfecto: funciona"),
    "v1-errores": ("v1", ["ok", "corrupt"], "v1 con un error de bits: entrega basura sin enterarse"),
    "v2-datos": ("v2", ["ok", "ok", "corrupt"], "v2 con un dato dañado: el NAK lo arregla"),
    "v2-ack": ("v2", ["ok", "corrupt"], "v2 con un ACK dañado: el emisor repite y se duplica"),
    "v21-ack": ("v2.1", ["ok", "corrupt"], "v2.1 con un ACK dañado: el bit de secuencia lo arregla"),
    "v22-datos": ("v2.2", ["ok", "ok", "corrupt"], "v2.2 con un dato dañado: un ACK repetido hace de NAK"),
    "v22-perdida": ("v2.2", ["ok", "ok", "lost"], "v2.2 con una pérdida: se queda esperando para siempre"),
    "v3-dato": ("v3", ["ok", "ok", "lost"], "v3 con un dato perdido: el temporizador lo repite"),
    "v3-ack": ("v3", ["ok", "lost"], "v3 con un ACK perdido: repite, y el receptor reconoce el duplicado"),
    "v3-tarde": ("v3", ["ok", "late"], "v3 con un ACK tarde: retransmisión innecesaria, pero correcta"),
    "v3-sin-seq": ("v3-sin-seq", ["ok", "lost"], "temporizador sin números de secuencia: se duplica"),
}


class NoSeqSimulation(Simulation):
    """El temporizador de v3 sin el bit de secuencia, para ver por qué hace falta el bit."""

    @property
    def uses_seq(self):
        return False

    def __init__(self, messages, script=()):
        super().__init__("v3", messages, script)

    def at_receiver(self, packet):
        self.log("receptor", f'recibe y entrega "{self.deliver(packet)}"')
        self.reply("ACK")

    def at_sender(self, packet):
        if self.result.finished:
            self.log("emisor", f"recibe {packet.label()}: ya terminó, lo ignora")
            return
        self.log("emisor", f"recibe {packet.label()}")
        self.advance()


def run_scenario(name):
    version, script, _ = SCENARIOS[name]
    if version == "v3-sin-seq":
        return NoSeqSimulation(MESSAGES, script).run()
    return Simulation(version, MESSAGES, script).run()


def print_result(name):
    result = run_scenario(name)
    print(f"--- {name}: {SCENARIOS[name][2]}")
    for when, side, text in result.trace:
        print(f"{when:5d} ms  {side:<9}{text}")
    verdict = "correcto" if result.delivered == MESSAGES and result.finished else "INCORRECTO"
    print(f"entregado: {' '.join(result.delivered)}   ({verdict}, "
          f"{result.transmissions} transmisiones)")


def main():
    if len(sys.argv) == 2 and sys.argv[1] == "todos":
        for name in SCENARIOS:
            print_result(name)
            print()
    elif len(sys.argv) == 2 and sys.argv[1] in SCENARIOS:
        print_result(sys.argv[1])
    else:
        for name, (_, _, description) in SCENARIOS.items():
            print(f"{name:<13}{description}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""¿Cuántos números de secuencia hacen falta para una ventana? Lo revisa caso por caso.

    python3 seq_space.py [hasta_N]

El receptor está esperando el paquete r. Sin confirmaciones todavía, el emisor puede estar
retrocedido hasta r - W, de modo que por la red pueden llegar copias de r - W ... r - 1. Hay
ambigüedad si alguna de esas copias viejas lleva el mismo número que un paquete que el
receptor aceptaría como nuevo: solo r en Go-Back-N, y r ... r + W - 1 en Selective Repeat.

Supone que la red no guarda un paquete más viejo que una ventana: es lo que TCP resuelve
limitando el tiempo de vida máximo de un segmento.
"""
import sys


def conflicts(protocol, modulus, window):
    """Los números que se pueden confundir, tomando r = window para no tener negativos."""
    r = window
    old = {index % modulus for index in range(r - window, r)}
    accepted = {r % modulus} if protocol == "gbn" else {(r + i) % modulus for i in range(window)}
    return sorted(old & accepted)


def is_safe(protocol, modulus, window):
    return not conflicts(protocol, modulus, window)


def largest_safe_window(protocol, modulus):
    return max(window for window in range(1, modulus + 1) if is_safe(protocol, modulus, window))


def main():
    limit = int(sys.argv[1]) if len(sys.argv) > 1 else 16
    print(f"{'números':>8}{'bits':>6}{'GBN: W máx':>12}{'SR: W máx':>11}")
    modulus = 2
    while modulus <= limit:
        print(f"{modulus:>8}{modulus.bit_length() - 1:>6}{largest_safe_window('gbn', modulus):>12}"
              f"{largest_safe_window('sr', modulus):>11}")
        modulus *= 2
    print()
    for protocol, modulus, window in [("sr", 4, 2), ("sr", 4, 3), ("gbn", 4, 3), ("gbn", 4, 4)]:
        clash = conflicts(protocol, modulus, window)
        text = f"se confunden {clash}" if clash else "sin ambigüedad"
        print(f"{protocol}, {modulus} números, ventana {window}: {text}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""El tablero del hackathon: quién alcanza a quién, y qué sesiones BGP no están arriba.

    python3 tablero.py [archivo_de_equipos]        por omisión, ensayo/equipos.txt

El archivo tiene una línea por equipo: nombre, contenedor y dirección. Cada celda es un
ping desde la dirección de la fila hacia la de la columna: que dé "ok" exige que el camino
exista en los dos sentidos.
"""
import json
import os
import subprocess
import sys
from concurrent.futures import ThreadPoolExecutor

HERE = os.path.dirname(os.path.abspath(__file__))
DEFAULT_TEAMS = os.path.join(HERE, "ensayo", "equipos.txt")


def read_teams(path=DEFAULT_TEAMS):
    teams = []
    with open(path, encoding="utf-8") as file:
        for line in file:
            line = line.split("#")[0].strip()
            if line:
                name, container, address = line.split()
                teams.append((name, container, address))
    return teams


def can_reach(source, target):
    command = ["docker", "exec", source[1], "ping", "-c", "2", "-W", "1", "-I", source[2], target[2]]
    return subprocess.run(command, capture_output=True, text=True, timeout=30).returncode == 0


def reachability(teams):
    """Devuelve {(origen, destino): True o False} para cada par de equipos distintos."""
    pairs = [(a, b) for a in teams for b in teams if a is not b]
    with ThreadPoolExecutor(max_workers=32) as pool:
        results = list(pool.map(lambda pair: can_reach(*pair), pairs))
    return {(a[0], b[0]): good for (a, b), good in zip(pairs, results)}


def sessions_down(teams):
    """Devuelve las sesiones BGP que no están en Established: (equipo, vecino, estado)."""
    down = []
    for name, container, _ in teams:
        done = subprocess.run(["docker", "exec", container, "vtysh", "-c", "show bgp summary json"],
                              capture_output=True, text=True, timeout=30)
        try:
            summary = json.loads(done.stdout)
        except json.JSONDecodeError:
            down.append((name, "?", "sin respuesta de vtysh"))
            continue
        peers = summary.get("ipv4Unicast", {}).get("peers", {})
        for address, peer in peers.items():
            if peer.get("state") != "Established":
                down.append((name, address, peer.get("state", "?")))
    return down


def render(teams, matrix):
    names = [team[0] for team in teams]
    width = max(len(name) for name in names) + 2
    lines = [" " * width + "".join(f"{name:>{width}}" for name in names)]
    for row in names:
        cells = ["-" if row == column else ("ok" if matrix[row, column] else "X")
                 for column in names]
        lines.append(f"{row:<{width}}" + "".join(f"{cell:>{width}}" for cell in cells))
    good = sum(matrix.values())
    lines.append(f"{good} de {len(matrix)} pares se alcanzan")
    return "\n".join(lines)


def main():
    path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_TEAMS
    teams = read_teams(path)
    print(render(teams, reachability(teams)))
    down = sessions_down(teams)
    print("sesiones BGP que no están arriba:" if down else "todas las sesiones BGP están arriba")
    for name, address, state in down:
        print(f"  {name}: vecino {address}, {state}")


if __name__ == "__main__":
    main()

// Servidor TCP que muestra qué socket atiende cada conexión.
//   tcp_demux <puerto>
// El socket que escucha nunca recibe datos: cada conexión aceptada tiene el suyo.
#include <arpa/inet.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

#define MAX_CONNECTIONS 16
#define MAX_MESSAGE 1500

static void describe_peer(int fd, char *text, size_t size) {
    struct sockaddr_in peer;
    socklen_t len = sizeof peer;
    char ip[INET_ADDRSTRLEN] = "?";
    if (getpeername(fd, (struct sockaddr *)&peer, &len) == -1) {
        perror("getpeername");
        snprintf(text, size, "?");
        return;
    }
    if (inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof ip) == NULL) {
        perror("inet_ntop");
    }
    snprintf(text, size, "%s:%u", ip, ntohs(peer.sin_port));
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "uso: %s <puerto>\n", argv[0]);
        return EXIT_FAILURE;
    }
    int port = atoi(argv[1]);
    if (port <= 0 || port > 65535) {
        fprintf(stderr, "puerto no válido: %s\n", argv[1]);
        return EXIT_FAILURE;
    }
    if (setvbuf(stdout, NULL, _IOLBF, 0) != 0) {
        perror("setvbuf");
    }
    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    int yes = 1;
    if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) == -1) {
        perror("setsockopt");
        return EXIT_FAILURE;
    }
    struct sockaddr_in local;
    memset(&local, 0, sizeof local);
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    local.sin_port = htons((uint16_t)port);
    if (bind(listener, (struct sockaddr *)&local, sizeof local) == -1) {
        perror("bind");
        return EXIT_FAILURE;
    }
    if (listen(listener, 8) == -1) {
        perror("listen");
        return EXIT_FAILURE;
    }
    printf("socket %d  escuchando en el puerto %d\n", listener, port);

    struct pollfd watched[MAX_CONNECTIONS + 1];
    watched[0] = (struct pollfd){.fd = listener, .events = POLLIN};
    nfds_t count = 1;

    for (;;) {
        if (poll(watched, count, -1) == -1) {
            perror("poll");
            return EXIT_FAILURE;
        }
        char peer[64];
        if ((watched[0].revents & POLLIN) && count <= MAX_CONNECTIONS) {
            int fd = accept(listener, NULL, NULL);
            if (fd == -1) {
                perror("accept");
            } else {
                describe_peer(fd, peer, sizeof peer);
                printf("socket %d  conexión nueva de %s\n", fd, peer);
                watched[count++] = (struct pollfd){.fd = fd, .events = POLLIN};
            }
        }
        for (nfds_t i = 1; i < count; i++) {
            if (!(watched[i].revents & (POLLIN | POLLHUP))) {
                continue;
            }
            char data[MAX_MESSAGE];
            ssize_t got = recv(watched[i].fd, data, sizeof data - 1, 0);
            if (got == -1) {
                perror("recv");
            }
            if (got <= 0) {
                if (close(watched[i].fd) == -1) {
                    perror("close");
                }
                watched[i] = watched[--count];
                i--;
                continue;
            }
            data[got] = '\0';
            describe_peer(watched[i].fd, peer, sizeof peer);
            printf("socket %d  de %s  \"%s\"\n", watched[i].fd, peer, data);
            char reply[64];
            int len = snprintf(reply, sizeof reply, "recibido en el socket %d", watched[i].fd);
            if (send(watched[i].fd, reply, (size_t)len, 0) == -1) {
                perror("send");
            }
        }
    }
}

#!/usr/bin/env python3
"""Un TFTP mínimo (RFC 1350), solo lectura: un protocolo real de stop-and-wait sobre UDP.

    python3 tftp_mini.py serve <carpeta> [--timeout-ms 200] [--port 69]
    python3 tftp_mini.py get <ip> <archivo> <destino> [--port 69] [--ignore-block-number]

Por cada bloque de 512 bytes el servidor espera su ACK. Si el temporizador vence, repite el
bloque. Un bloque de menos de 512 bytes indica el final. --ignore-block-number hace que el
cliente escriba todo lo que llega, sin mirar el número de bloque: sirve para ver qué pasa
sin números de secuencia.
"""
import argparse
import hashlib
import os
import socket
import struct
import threading
import time

OP_RRQ, OP_DATA, OP_ACK, OP_ERROR = 1, 3, 4, 5
BLOCK_SIZE = 512
MAX_TRIES = 40
GET_IDLE_S = 10


def send_file(path, client, timeout_s):
    """Atiende una lectura, desde un socket y un puerto nuevos, como pide el RFC 1350."""
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.connect(client)
    block_number = 0
    retransmissions = 0
    try:
        with open(path, "rb") as file:
            while True:
                data = file.read(BLOCK_SIZE)
                block_number += 1
                packet = struct.pack("!HH", OP_DATA, block_number & 0xffff) + data
                retransmissions += stop_and_wait(sock, packet, block_number & 0xffff, timeout_s)
                if len(data) < BLOCK_SIZE:
                    break
        print(f"enviado {os.path.basename(path)}: {block_number} bloques, "
              f"{retransmissions} retransmisiones", flush=True)
    except FileNotFoundError:
        sock.send(struct.pack("!HH", OP_ERROR, 1) + b"no existe\0")
    except (TimeoutError, ConnectionError) as error:
        print(f"transferencia abandonada: {error}", flush=True)
    finally:
        sock.close()


def stop_and_wait(sock, packet, block_number, timeout_s):
    """Manda un bloque y espera su ACK. Devuelve cuántas veces tuvo que repetirlo."""
    for tries in range(MAX_TRIES):
        sock.send(packet)
        deadline = time.monotonic() + timeout_s
        while (left := deadline - time.monotonic()) > 0:
            sock.settimeout(left)
            try:
                reply = sock.recv(64)
            except TimeoutError:
                break
            # Un ACK viejo se ignora: repetir por eso multiplicaría los bloques en la red.
            if len(reply) == 4 and struct.unpack("!HH", reply) == (OP_ACK, block_number):
                return tries
    raise TimeoutError(f"sin ACK del bloque {block_number}")


def serve(folder, port, timeout_ms):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind(("0.0.0.0", port))
    print(f"TFTP en el puerto {port}, carpeta {folder}", flush=True)
    while True:
        request, client = sock.recvfrom(1024)
        if len(request) < 4 or struct.unpack("!H", request[:2])[0] != OP_RRQ:
            continue
        name = request[2:].split(b"\0")[0].decode(errors="replace")
        path = os.path.join(folder, os.path.basename(name))
        threading.Thread(target=send_file, args=(path, client, timeout_ms / 1000),
                         daemon=True).start()


def get(server_ip, name, target, port, ignore_block_number):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.settimeout(1.0)
    request = struct.pack("!H", OP_RRQ) + name.encode() + b"\0octet\0"
    digest = hashlib.sha256()
    expected = 1
    duplicates = 0
    total = 0
    started = time.monotonic()
    last_heard = started
    sock.sendto(request, (server_ip, port))
    with open(target, "wb") as file:
        while True:
            try:
                packet, sender = sock.recvfrom(BLOCK_SIZE + 4)
            except TimeoutError:
                if time.monotonic() - last_heard > GET_IDLE_S:
                    raise SystemExit("el servidor dejó de responder") from None
                if expected == 1:
                    sock.sendto(request, (server_ip, port))
                continue
            last_heard = time.monotonic()
            opcode, block = struct.unpack("!HH", packet[:4])
            if opcode == OP_ERROR:
                raise SystemExit(f"error del servidor: {packet[4:-1].decode(errors='replace')}")
            if opcode != OP_DATA:
                continue
            is_new = block == (expected & 0xffff)
            sock.sendto(struct.pack("!HH", OP_ACK, block), sender)
            if not is_new:
                duplicates += 1
            if is_new or ignore_block_number:
                data = packet[4:]
                file.write(data)
                digest.update(data)
                total += len(data)
            if is_new:
                expected += 1
                if len(packet) - 4 < BLOCK_SIZE:
                    break
    elapsed = time.monotonic() - started
    rate = total * 8 / elapsed / 1000
    print(f"bytes={total} tiempo={elapsed:.2f}s tasa={rate:.1f} kbit/s "
          f"duplicados={duplicates} sha256={digest.hexdigest()[:16]}")


def main():
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    commands = parser.add_subparsers(dest="command", required=True)
    server = commands.add_parser("serve")
    server.add_argument("folder")
    server.add_argument("--port", type=int, default=69)
    server.add_argument("--timeout-ms", type=int, default=200)
    client = commands.add_parser("get")
    client.add_argument("server_ip")
    client.add_argument("name")
    client.add_argument("target")
    client.add_argument("--port", type=int, default=69)
    client.add_argument("--ignore-block-number", action="store_true")
    args = parser.parse_args()
    if args.command == "serve":
        serve(args.folder, args.port, args.timeout_ms)
    else:
        get(args.server_ip, args.name, args.target, args.port, args.ignore_block_number)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Calcula a mano el checksum de un datagrama UDP sobre IPv4, palabra por palabra.

    python3 udp_checksum.py <ip_origen> <ip_destino> <puerto_origen> <puerto_destino> <datos>

Sigue el RFC 768: suma de complemento a uno del pseudo-encabezado, el encabezado UDP
(con el checksum en cero) y los datos, y al final el complemento. Si el resultado da
cero, se escribe 0xffff, porque en UDP sobre IPv4 un cero quiere decir "sin checksum".
"""
import argparse
import ipaddress
import struct

PROTO_UDP = 17


def pseudo_header(source, destination, udp_length):
    return (ipaddress.IPv4Address(source).packed + ipaddress.IPv4Address(destination).packed
            + struct.pack("!BBH", 0, PROTO_UDP, udp_length))


def words(data):
    """Parte en palabras de 16 bits. Si el largo es impar, completa con un byte en cero."""
    if len(data) % 2:
        data += b"\0"
    return [int.from_bytes(data[i:i + 2], "big") for i in range(0, len(data), 2)]


def ones_complement_sum(values):
    total = sum(values)
    while total > 0xffff:
        total = (total & 0xffff) + (total >> 16)
    return total


def udp_checksum(source, destination, source_port, destination_port, payload):
    length = 8 + len(payload)
    data = (pseudo_header(source, destination, length)
            + struct.pack("!HHHH", source_port, destination_port, length, 0) + payload)
    result = ~ones_complement_sum(words(data)) & 0xffff
    return result if result != 0 else 0xffff


def explain(source, destination, source_port, destination_port, payload):
    """Devuelve la cuenta como texto, en líneas."""
    length = 8 + len(payload)
    parts = [("pseudo-encabezado", pseudo_header(source, destination, length)),
             ("encabezado UDP", struct.pack("!HHHH", source_port, destination_port, length, 0)),
             ("datos", payload)]
    lines = []
    all_words = []
    for name, data in parts:
        block = words(data)
        all_words += block
        lines.append(f"{name:<18} " + " ".join(f"{word:04x}" for word in block))
    total = sum(all_words)
    lines.append(f"{'suma':<18} {total:x}")
    folded = ones_complement_sum(all_words)
    if total != folded:
        lines.append(f"{'con acarreos':<18} {folded:04x}")
    lines.append(f"{'complemento':<18} {~folded & 0xffff:04x}")
    lines.append(f"{'checksum':<18} "
                 f"{udp_checksum(source, destination, source_port, destination_port, payload):04x}")
    return lines


def main():
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("source")
    parser.add_argument("destination")
    parser.add_argument("source_port", type=int)
    parser.add_argument("destination_port", type=int)
    parser.add_argument("payload")
    args = parser.parse_args()
    print("\n".join(explain(args.source, args.destination, args.source_port,
                            args.destination_port, args.payload.encode())))


if __name__ == "__main__":
    main()