// Muestra cómo guarda los enteros esta máquina y qué hace htons y htonl.
#define _POSIX_C_SOURCE 200809L

#include <arpa/inet.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void print_bytes(const char *label, const void *value, size_t n) {
    const unsigned char *bytes = value;
    printf("%-22s", label);
    for (size_t i = 0; i < n; i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
}

// Parece una cabecera de 3 bytes, pero el compilador puede agregar relleno.
struct wrong_header {
    uint8_t type;
    uint16_t port;
};

int main(void) {
    uint16_t port = 9002;  // 0x232a
    uint16_t net_port = htons(port);
    uint32_t addr = 0x0A020110;  // 10.2.1.16
    uint32_t net_addr = htonl(addr);

    print_bytes("9002 en memoria:", &port, sizeof port);
    print_bytes("htons(9002):", &net_port, sizeof net_port);
    print_bytes("0x0a020110 en memoria:", &addr, sizeof addr);
    print_bytes("htonl(0x0a020110):", &net_addr, sizeof net_addr);

    // Copiar una struct a la red también copia el relleno que puso el compilador.
    printf("sizeof(struct wrong_header) = %zu, aunque sus campos suman 3\n",
           sizeof(struct wrong_header));

    // Lo correcto: definir el formato byte a byte y armarlo campo por campo.
    unsigned char wire[3];
    wire[0] = 7;
    memcpy(wire + 1, &net_port, sizeof net_port);
    print_bytes("cabecera en 3 bytes:", wire, sizeof wire);
    return EXIT_SUCCESS;
}

// Recibe de un cliente y cuenta cuánto devuelve cada recv.
//   chunk_recv [-v] [-x tamaño] <puerto>
//     -v          imprime lo que devuelve cada llamada
//     -x tamaño   usa recv_all para leer registros de tamaño fijo
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>

#define BUF_SIZE (1024 * 1024)

int main(int argc, char *argv[]) {
    bool verbose = false;
    long exact = 0;
    int opt;
    while ((opt = getopt(argc, argv, "vx:")) != -1) {
        if (opt == 'v') {
            verbose = true;
        } else if (opt == 'x') {
            exact = strtol(optarg, NULL, 10);
        } else {
            return EXIT_FAILURE;
        }
    }
    if (argc - optind != 1 || exact < 0 || exact > BUF_SIZE) {
        fprintf(stderr, "uso: %s [-v] [-x tamaño] <puerto>\n", argv[0]);
        return EXIT_FAILURE;
    }

    int listener = tcp_listen(parse_port(argv[optind]));
    if (listener == -1 || print_bound_port(listener) == -1) {
        return EXIT_FAILURE;
    }
    int conn = accept(listener, NULL, NULL);
    if (conn == -1) {
        perror("accept");
        return EXIT_FAILURE;
    }
    char *buf = malloc(BUF_SIZE);
    if (buf == NULL) {
        perror("malloc");
        return EXIT_FAILURE;
    }

    unsigned long long total = 0;
    unsigned long long bad = 0;
    long calls = 0;
    long smallest = 0;
    long largest = 0;
    for (;;) {
        ssize_t n = exact > 0 ? recv_all(conn, buf, (size_t)exact)
                              : recv(conn, buf, BUF_SIZE, 0);
        if (n == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("recv");
            return EXIT_FAILURE;
        }
        if (n == 0) {
            break;
        }
        calls++;
        if (calls == 1 || n < smallest) {
            smallest = n;
        }
        if (n > largest) {
            largest = n;
        }
        for (ssize_t i = 0; i < n; i++) {
            if ((unsigned char)buf[i] != (total + (unsigned long long)i) % 251) {
                bad++;
            }
        }
        total += (unsigned long long)n;
        if (verbose) {
            printf("%s %ld: %zd bytes\n", exact > 0 ? "registro" : "recv", calls, n);
        }
    }
    printf("%s: %ld llamadas, %llu bytes, menor %ld, mayor %ld\n",
           exact > 0 ? "recv_all" : "recv", calls, total, smallest, largest);
    printf("bytes fuera de lugar: %llu\n", bad);
    free(buf);
    close_checked(conn);
    close_checked(listener);
    return EXIT_SUCCESS;
}

// Envía por TCP varios pedazos de datos conocidos, para estudiar el stream.
//   chunk_send [-g pausa_ms] <ip> <puerto> <tamaño> <cantidad>
// Usa una dirección numérica, sin getaddrinfo, para poder compilarse de forma
// estática y correr en los nodos de la topología.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    long gap_ms = 0;
    int opt;
    while ((opt = getopt(argc, argv, "g:")) != -1) {
        if (opt != 'g') {
            return EXIT_FAILURE;
        }
        gap_ms = strtol(optarg, NULL, 10);
    }
    if (argc - optind != 4) {
        fprintf(stderr, "uso: %s [-g pausa_ms] <ip> <puerto> <tamaño> <cantidad>\n", argv[0]);
        return EXIT_FAILURE;
    }
    long size = strtol(argv[optind + 2], NULL, 10);
    long chunks = strtol(argv[optind + 3], NULL, 10);
    if (size <= 0 || chunks <= 0) {
        fprintf(stderr, "tamaño y cantidad deben ser positivos\n");
        return EXIT_FAILURE;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(parse_port(argv[optind + 1]));
    if (inet_pton(AF_INET, argv[optind], &addr.sin_addr) != 1) {
        fprintf(stderr, "dirección no válida: %s\n", argv[optind]);
        return EXIT_FAILURE;
    }

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    if (connect(fd, (struct sockaddr *)&addr, sizeof addr) == -1) {
        perror("connect");
        return EXIT_FAILURE;
    }

    char *buf = malloc((size_t)size);
    if (buf == NULL) {
        perror("malloc");
        return EXIT_FAILURE;
    }
    // El byte en la posición p del stream vale p % 251. Así el receptor puede
    // comprobar que nada se perdió, se repitió ni cambió de lugar.
    unsigned long long offset = 0;
    for (long i = 0; i < chunks; i++) {
        for (long j = 0; j < size; j++) {
            buf[j] = (char)(offset++ % 251);
        }
        if (send_all(fd, buf, (size_t)size) == -1) {
            return EXIT_FAILURE;
        }
        if (gap_ms > 0) {
            struct timespec pause = {gap_ms / 1000, (gap_ms % 1000) * 1000000L};
            if (nanosleep(&pause, NULL) == -1) {
                perror("nanosleep");
            }
        }
    }
    free(buf);
    printf("enviados: %ld llamadas a send, %llu bytes\n", chunks, offset);
    close_checked(fd);
    return EXIT_SUCCESS;
}

# Dos hosts unidos por dos caminos: r1-r2-r4 (preferido) y r1-r3-r4.
# Se usa para ver qué estado guarda cada nodo y qué sobrevive a una caída.
name: w02-fate
mgmt:
  network: redes-w02
  ipv4-subnet: 172.90.2.0/24
  ipv6-subnet: 3fff:172:90:2::/64
topology:
  defaults:
    kind: linux
    image: redes-router
  nodes:
    h1:
      binds: [build/static:/lab:ro]
      exec:
        - ip address add 10.2.1.10/24 dev eth1
        - ip route replace default via 10.2.1.1 dev eth1
    h2:
      binds: [build/static:/lab:ro]
      exec:
        - ip address add 10.2.4.10/24 dev eth1
        - ip route replace default via 10.2.4.1 dev eth1
    r1:
      binds: [r1/frr.conf:/etc/frr/frr.conf:ro]
    r2:
      binds: [r2/frr.conf:/etc/frr/frr.conf:ro]
    r3:
      binds: [r3/frr.conf:/etc/frr/frr.conf:ro]
    r4:
      binds: [r4/frr.conf:/etc/frr/frr.conf:ro]
  # MTU de 1500 bytes, como en Ethernet; Containerlab usa 9500 si no se indica.
  links:
    - {endpoints: ["h1:eth1", "r1:eth1"], mtu: 1500}
    - {endpoints: ["r1:eth2", "r2:eth1"], mtu: 1500}
    - {endpoints: ["r1:eth3", "r3:eth1"], mtu: 1500}
    - {endpoints: ["r2:eth2", "r4:eth1"], mtu: 1500}
    - {endpoints: ["r3:eth2", "r4:eth2"], mtu: 1500}
    - {endpoints: ["r4:eth3", "h2:eth1"], mtu: 1500}

// Un intermediario con una falla: copia los datos de un cliente hacia un
// servidor e intercambia un par de bytes cada cierta cantidad de bytes. Imita a
// un gateway con la memoria dañada, como el del artículo de Saltzer, Reed y Clark.
// Cada lado usa su propia conexión TCP, con su checksum y sus retransmisiones.
//   flaky_relay <puerto> <ip_destino> <puerto_destino> <cada_n_bytes>
//   Con cada_n_bytes = 0, no daña nada.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    if (argc != 5) {
        fprintf(stderr, "uso: %s <puerto> <ip_destino> <puerto_destino> <cada_n_bytes>\n",
                argv[0]);
        return EXIT_FAILURE;
    }
    long every = strtol(argv[4], NULL, 10);
    if (every < 0) {
        fprintf(stderr, "cada_n_bytes no puede ser negativo\n");
        return EXIT_FAILURE;
    }
    int listener = tcp_listen(parse_port(argv[1]));
    if (listener == -1 || print_bound_port(listener) == -1) {
        return EXIT_FAILURE;
    }
    int in = accept(listener, NULL, NULL);
    if (in == -1) {
        perror("accept");
        return EXIT_FAILURE;
    }

    struct sockaddr_in dst;
    memset(&dst, 0, sizeof dst);
    dst.sin_family = AF_INET;
    dst.sin_port = htons(parse_port(argv[3]));
    if (inet_pton(AF_INET, argv[2], &dst.sin_addr) != 1) {
        fprintf(stderr, "dirección no válida: %s\n", argv[2]);
        return EXIT_FAILURE;
    }
    int out = socket(AF_INET, SOCK_STREAM, 0);
    if (out == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    if (connect(out, (struct sockaddr *)&dst, sizeof dst) == -1) {
        perror("connect");
        return EXIT_FAILURE;
    }

    char buf[8192];
    unsigned long long total = 0, damaged = 0;
    long countdown = every;
    for (;;) {
        ssize_t n = recv(in, buf, sizeof buf, 0);
        if (n == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("recv");
            return EXIT_FAILURE;
        }
        if (n == 0) {
            break;
        }
        // Aquí los datos no están protegidos por ningún checksum de TCP.
        for (ssize_t i = 0; every > 0 && i + 1 < n; i++) {
            if (--countdown == 0) {
                char tmp = buf[i];
                buf[i] = buf[i + 1];
                buf[i + 1] = tmp;
                countdown = every;
                damaged++;
            }
        }
        if (send_all(out, buf, (size_t)n) == -1) {
            return EXIT_FAILURE;
        }
        total += (unsigned long long)n;
    }
    printf("copiados %llu bytes, %llu pares intercambiados\n", total, damaged);
    close_checked(out);
    close_checked(in);
    close_checked(listener);
    return EXIT_SUCCESS;
}

// Funciones de apoyo para sockets TCP.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int send_all(int fd, const void *buf, size_t n) {
    const char *p = buf;
    size_t left = n;
    while (left > 0) {
        // MSG_NOSIGNAL: si el otro extremo cerró, recibimos EPIPE y no la señal
        // SIGPIPE, que por defecto mataría al proceso.
        ssize_t sent = send(fd, p, left, MSG_NOSIGNAL);
        if (sent == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("send");
            return -1;
        }
        p += sent;
        left -= (size_t)sent;
    }
    return 0;
}

ssize_t recv_all(int fd, void *buf, size_t n) {
    char *p = buf;
    size_t got = 0;
    while (got < n) {
        ssize_t r = recv(fd, p + got, n - got, 0);
        if (r == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("recv");
            return -1;
        }
        if (r == 0) {
            break;  // el otro extremo cerró
        }
        got += (size_t)r;
    }
    return (ssize_t)got;
}

int tcp_listen(uint16_t port) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        return -1;
    }
    int on = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) == -1) {
        perror("setsockopt");
        close_checked(fd);
        return -1;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);
    if (bind(fd, (struct sockaddr *)&addr, sizeof addr) == -1) {
        perror("bind");
        close_checked(fd);
        return -1;
    }
    if (listen(fd, 16) == -1) {
        perror("listen");
        close_checked(fd);
        return -1;
    }
    return fd;
}

int print_bound_port(int fd) {
    struct sockaddr_in addr;
    socklen_t len = sizeof addr;
    if (getsockname(fd, (struct sockaddr *)&addr, &len) == -1) {
        perror("getsockname");
        return -1;
    }
    printf("escuchando en el puerto %u\n", ntohs(addr.sin_port));
    fflush(stdout);
    return 0;
}

uint16_t parse_port(const char *text) {
    char *end;
    errno = 0;
    long value = strtol(text, &end, 10);
    if (errno != 0 || *end != '\0' || end == text || value < 0 || value > 65535) {
        fprintf(stderr, "puerto no válido: %s\n", text);
        exit(EXIT_FAILURE);
    }
    return (uint16_t)value;
}

void close_checked(int fd) {
    if (close(fd) == -1) {
        perror("close");
    }
}

// Funciones de apoyo para sockets TCP que usan varios programas de la semana.
#ifndef IO_UTIL_H
#define IO_UTIL_H

#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>

// Envía los n bytes aunque send escriba menos. Devuelve 0, o -1 si hay error.
int send_all(int fd, const void *buf, size_t n);

// Lee hasta completar n bytes. Devuelve n, un número menor si el otro extremo
// cerró antes de completarlos, o -1 si hay error.
ssize_t recv_all(int fd, void *buf, size_t n);

// socket + SO_REUSEADDR + bind + listen en todas las interfaces. Con el puerto
// 0, el sistema elige uno libre. Devuelve el descriptor, o -1 si hay error.
int tcp_listen(uint16_t port);

// Imprime "escuchando en el puerto N": útil cuando el puerto pedido fue 0.
int print_bound_port(int fd);

// Convierte un argumento a puerto (0-65535). Termina el programa si no es válido.
uint16_t parse_port(const char *text);

// close que informa el error.
void close_checked(int fd);

#endif

"""Apoyo para las pruebas: lanza servidores y recuerda sus procesos.

El contenedor del curso comparte la red y los procesos con la máquina. Por eso
las pruebas piden el puerto 0, leen el que eligió el sistema y solo matan a los
procesos que ellas mismas lanzaron.
"""
import re
import socket
import subprocess
import threading
import time
import unittest
from pathlib import Path

HERE = Path(__file__).resolve().parent
BUILD = HERE / "build"


def free_port(kind=socket.SOCK_STREAM):
    """Un puerto libre en este momento, para los programas que no aceptan 0."""
    with socket.socket(socket.AF_INET, kind) as s:
        s.bind(("127.0.0.1", 0))
        return s.getsockname()[1]


def connect(port, timeout=5.0):
    s = socket.create_connection(("127.0.0.1", port), timeout=timeout)
    s.settimeout(timeout)
    return s


def recv_line(sock):
    data = b""
    while not data.endswith(b"\n"):
        chunk = sock.recv(1)
        if not chunk:
            break
        data += chunk
    return data.decode()


def recv_until_close(sock):
    data = b""
    while True:
        chunk = sock.recv(65536)
        if not chunk:
            return data
        data += chunk


class Server:
    """Un servidor en segundo plano. Reúne su salida para poder revisarla."""

    def __init__(self, path, *args):
        self.process = subprocess.Popen(
            [str(path), *map(str, args)],
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
        )
        line = self.process.stdout.readline()
        match = re.search(r"puerto (\d+)", line)
        if match is None:
            self.process.kill()
            self.process.wait()
            self.process.stdout.close()
            raise AssertionError(f"{path} no dijo su puerto: {line!r}")
        self.port = int(match.group(1))
        self.lines = []
        self.reader = threading.Thread(target=self._read, daemon=True)
        self.reader.start()

    def _read(self):
        for line in self.process.stdout:
            self.lines.append(line.rstrip("\n"))

    def alive(self):
        return self.process.poll() is None

    def wait_output(self, pattern, timeout=5.0):
        """Espera una línea de salida que cumpla pattern y devuelve su match."""
        deadline = time.monotonic() + timeout
        while time.monotonic() < deadline:
            for line in list(self.lines):
                match = re.search(pattern, line)
                if match:
                    return match
            time.sleep(0.02)
        raise AssertionError(f"no apareció {pattern!r}; salida: {self.lines}")

    def wait(self, timeout=10.0):
        code = self.process.wait(timeout=timeout)
        self.reader.join(timeout=2)
        return code

    def stop(self):
        if self.process.poll() is None:
            self.process.kill()
        self.process.wait()
        self.reader.join(timeout=2)
        self.process.stdout.close()


class NetTestCase(unittest.TestCase):
    """Detiene al terminar cada prueba a los servidores que esta lanzó."""

    def server(self, name, *args):
        path = name if isinstance(name, Path) else BUILD / name
        server = Server(path, *args)
        self.addCleanup(server.stop)
        return server

    def connect(self, port):
        sock = connect(port)
        self.addCleanup(sock.close)
        return sock

// Muestra por qué aparece "Address already in use". Atiende a un cliente, cierra
// primero (y por eso la conexión queda en TIME_WAIT de este lado) y termina.
//   reuse_demo [-r] <puerto>      -r activa SO_REUSEADDR
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    bool reuse = false;
    int opt;
    while ((opt = getopt(argc, argv, "r")) != -1) {
        if (opt != 'r') {
            return EXIT_FAILURE;
        }
        reuse = true;
    }
    if (argc - optind != 1) {
        fprintf(stderr, "uso: %s [-r] <puerto>\n", argv[0]);
        return EXIT_FAILURE;
    }
    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    if (reuse) {
        int on = 1;
        if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) == -1) {
            perror("setsockopt");
            return EXIT_FAILURE;
        }
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(parse_port(argv[optind]));
    if (bind(listener, (struct sockaddr *)&addr, sizeof addr) == -1) {
        perror("bind");
        return EXIT_FAILURE;
    }
    if (listen(listener, 1) == -1) {
        perror("listen");
        return EXIT_FAILURE;
    }
    if (print_bound_port(listener) == -1) {
        return EXIT_FAILURE;
    }
    int conn = accept(listener, NULL, NULL);
    if (conn == -1) {
        perror("accept");
        return EXIT_FAILURE;
    }
    if (send_all(conn, "chau\n", 5) == -1) {
        return EXIT_FAILURE;
    }
    close_checked(conn);
    close_checked(listener);
    return EXIT_SUCCESS;
}

// Recibe datagramas numerados y cuenta perdidos, desordenados y repetidos.
//   seq_recv <puerto> <cantidad_esperada> <espera_ms>
// Termina cuando pasan espera_ms sin que llegue nada, después del primero.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "uso: %s <puerto> <cantidad_esperada> <espera_ms>\n", argv[0]);
        return EXIT_FAILURE;
    }
    long expected = strtol(argv[2], NULL, 10);
    long wait_ms = strtol(argv[3], NULL, 10);
    if (expected <= 0 || wait_ms <= 0) {
        fprintf(stderr, "valores fuera de rango\n");
        return EXIT_FAILURE;
    }
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(parse_port(argv[1]));
    if (bind(fd, (struct sockaddr *)&addr, sizeof addr) == -1) {
        perror("bind");
        return EXIT_FAILURE;
    }
    if (print_bound_port(fd) == -1) {
        return EXIT_FAILURE;
    }
    bool *seen = calloc((size_t)expected, sizeof *seen);
    if (seen == NULL) {
        perror("calloc");
        return EXIT_FAILURE;
    }

    long received = 0, duplicates = 0, reordered = 0, other_size = 0;
    long first_size = 0;
    long highest = -1;
    for (;;) {
        char packet[2048];
        ssize_t n = recv(fd, packet, sizeof packet, 0);
        if (n == -1) {
            if (errno == EINTR) {
                continue;
            }
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                break;
            }
            perror("recv");
            return EXIT_FAILURE;
        }
        if (received == 0 && duplicates == 0) {
            // Ya empezó el envío: desde aquí, un silencio largo significa el fin.
            struct timeval limit = {wait_ms / 1000, (wait_ms % 1000) * 1000};
            if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &limit, sizeof limit) == -1) {
                perror("setsockopt");
                return EXIT_FAILURE;
            }
            first_size = n;
        }
        if (n < (ssize_t)sizeof(uint32_t)) {
            continue;
        }
        if (n != first_size) {
            other_size++;
        }
        uint32_t net_seq;
        memcpy(&net_seq, packet, sizeof net_seq);
        long seq = (long)ntohl(net_seq);
        if (seq >= expected) {
            continue;
        }
        if (seen[seq]) {
            duplicates++;
            continue;
        }
        seen[seq] = true;
        received++;
        if (seq < highest) {
            reordered++;
        } else {
            highest = seq;
        }
    }
    printf("recibidos: %ld de %ld\n", received, expected);
    printf("perdidos: %ld\n", expected - received);
    printf("fuera de orden: %ld\n", reordered);
    printf("repetidos: %ld\n", duplicates);
    printf("tamaño de cada recv: %ld bytes, %ld distintos\n", first_size, other_size);
    free(seen);
    close_checked(fd);
    return EXIT_SUCCESS;
}

// Envía datagramas UDP numerados.
//   seq_send <ip> <puerto> <cantidad> <tamaño> <pausa_us>
// Formato: número de secuencia de 4 bytes en orden de red, y relleno.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

#define MAX_DATAGRAM 1400

int main(int argc, char *argv[]) {
    if (argc != 6) {
        fprintf(stderr, "uso: %s <ip> <puerto> <cantidad> <tamaño> <pausa_us>\n", argv[0]);
        return EXIT_FAILURE;
    }
    long count = strtol(argv[3], NULL, 10);
    long size = strtol(argv[4], NULL, 10);
    long gap_us = strtol(argv[5], NULL, 10);
    if (count <= 0 || size < 4 || size > MAX_DATAGRAM || gap_us < 0) {
        fprintf(stderr, "valores fuera de rango\n");
        return EXIT_FAILURE;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(parse_port(argv[2]));
    if (inet_pton(AF_INET, argv[1], &addr.sin_addr) != 1) {
        fprintf(stderr, "dirección no válida: %s\n", argv[1]);
        return EXIT_FAILURE;
    }
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }

    char packet[MAX_DATAGRAM];
    memset(packet, 'x', sizeof packet);
    for (long i = 0; i < count; i++) {
        uint32_t seq = htonl((uint32_t)i);
        memcpy(packet, &seq, sizeof seq);
        if (sendto(fd, packet, (size_t)size, 0,
                   (struct sockaddr *)&addr, sizeof addr) == -1) {
            perror("sendto");
            return EXIT_FAILURE;
        }
        if (gap_us > 0) {
            struct timespec pause = {gap_us / 1000000, (gap_us % 1000000) * 1000L};
            if (nanosleep(&pause, NULL) == -1) {
                perror("nanosleep");
            }
        }
    }
    printf("enviados: %ld datagramas de %ld bytes\n", count, size);
    close_checked(fd);
    return EXIT_SUCCESS;
}

// Muestra que send puede escribir menos bytes de los pedidos. Conecta un socket
// a un receptor que nunca lee, hasta que se llenan los buffers.
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.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 REQUEST (8 * 1024 * 1024)

// Una conexión por loopback; el otro extremo queda en la cola de accept.
static int connect_to_self(int listener) {
    struct sockaddr_in addr;
    socklen_t len = sizeof addr;
    if (getsockname(listener, (struct sockaddr *)&addr, &len) == -1) {
        perror("getsockname");
        return -1;
    }
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        return -1;
    }
    if (connect(fd, (struct sockaddr *)&addr, len) == -1) {
        perror("connect");
        close_checked(fd);
        return -1;
    }
    return fd;
}

static void report(const char *mode, ssize_t sent) {
    if (sent == -1) {
        printf("%s: send devuelve -1, errno = %s\n", mode, strerror(errno));
    } else {
        printf("%s: se pidieron %d bytes y send devuelve %zd\n", mode, REQUEST, sent);
    }
}

int main(void) {
    char *buf = calloc(REQUEST, 1);
    if (buf == NULL) {
        perror("calloc");
        return EXIT_FAILURE;
    }
    int listener = tcp_listen(0);
    if (listener == -1) {
        return EXIT_FAILURE;
    }

    // Caso 1: socket no bloqueante. send copia lo que cabe y regresa.
    int fd = connect_to_self(listener);
    if (fd == -1) {
        return EXIT_FAILURE;
    }
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl");
        return EXIT_FAILURE;
    }
    report("no bloqueante, 1.ª llamada", send(fd, buf, REQUEST, MSG_NOSIGNAL));
    report("no bloqueante, 2.ª llamada", send(fd, buf, REQUEST, MSG_NOSIGNAL));
    close_checked(fd);

    // Caso 2: socket bloqueante con plazo. Se agota el plazo a la mitad.
    fd = connect_to_self(listener);
    if (fd == -1) {
        return EXIT_FAILURE;
    }
    struct timeval limit = {.tv_sec = 0, .tv_usec = 200000};
    if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &limit, sizeof limit) == -1) {
        perror("setsockopt");
        return EXIT_FAILURE;
    }
    report("bloqueante con SO_SNDTIMEO", send(fd, buf, REQUEST, MSG_NOSIGNAL));
    close_checked(fd);

    close_checked(listener);
    free(buf);
    return EXIT_SUCCESS;
}

// Marcador compartido: un total que varios clientes modifican a la vez, con un
// solo hilo y poll. El protocolo es de líneas de texto:
//   SUMA <n>\n    suma n al total y responde "total <t>\n"
//   TOTAL\n       responde "total <t>\n"
//   otra cosa     responde "error\n"
//
//   tally_server <puerto>
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

#define MAX_CLIENTS 64
#define MAX_LINE 128

// Lo que el servidor recuerda de cada conexión. Con un solo hilo no hay una
// pila por cliente: la línea a medio llegar tiene que guardarse aquí.
struct client {
    char line[MAX_LINE];
    size_t used;
};

static long total = 0;

// Procesa una línea completa y deja la respuesta en reply.
static void run_command(const char *line, char *reply, size_t size) {
    long amount;
    char extra;
    if (sscanf(line, "SUMA %ld %c", &amount, &extra) == 1) {
        total += amount;
        snprintf(reply, size, "total %ld\n", total);
    } else if (strcmp(line, "TOTAL") == 0) {
        snprintf(reply, size, "total %ld\n", total);
    } else {
        snprintf(reply, size, "error\n");
    }
}

// Envía sin bloquear. Si el cliente no lee y su buffer se llenó, se le corta:
// un cliente lento no puede detener a los demás. Otra política sería guardar
// la respuesta y esperar POLLOUT. Devuelve 0, o -1 si hay que cerrar.
static int reply_to(int fd, const char *text) {
    size_t len = strlen(text);
    ssize_t sent = send(fd, text, len, MSG_DONTWAIT | MSG_NOSIGNAL);
    if (sent == -1) {
        if (errno != EAGAIN && errno != EWOULDBLOCK) {
            perror("send");
        }
        return -1;
    }
    return (size_t)sent == len ? 0 : -1;
}

// Agrega lo recibido al buffer del cliente y atiende cada línea completa.
// Devuelve 0, o -1 si hay que cerrar la conexión.
static int handle_bytes(int fd, struct client *c, const char *data, size_t n) {
    for (size_t i = 0; i < n; i++) {
        if (data[i] != '\n') {
            if (c->used == MAX_LINE - 1) {
                return -1;  // línea demasiado larga: el buffer tiene un límite
            }
            c->line[c->used++] = data[i];
            continue;
        }
        c->line[c->used] = '\0';
        c->used = 0;
        char reply[64];
        run_command(c->line, reply, sizeof reply);
        if (reply_to(fd, reply) == -1) {
            return -1;
        }
    }
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "uso: %s <puerto>\n", argv[0]);
        return EXIT_FAILURE;
    }
    int listener = tcp_listen(parse_port(argv[1]));
    if (listener == -1 || print_bound_port(listener) == -1) {
        return EXIT_FAILURE;
    }

    // fds[0] es el socket que escucha; fds[i] y clients[i] van juntos.
    struct pollfd fds[MAX_CLIENTS + 1];
    struct client clients[MAX_CLIENTS + 1];
    nfds_t count = 1;
    fds[0].fd = listener;
    fds[0].events = POLLIN;

    for (;;) {
        // Dormir hasta que algún socket tenga algo. Es el único punto de espera.
        if (poll(fds, count, -1) == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("poll");
            return EXIT_FAILURE;
        }

        // Recorremos de atrás hacia adelante: quitar un cliente mueve al último
        // a su lugar, y ese ya fue revisado.
        for (nfds_t i = count; i-- > 1;) {
            if ((fds[i].revents & (POLLIN | POLLERR | POLLHUP)) == 0) {
                continue;
            }
            char buf[512];
            ssize_t n = recv(fds[i].fd, buf, sizeof buf, 0);
            if (n == -1 && errno == EINTR) {
                continue;
            }
            if (n == -1) {
                perror("recv");
            }
            if (n <= 0 || handle_bytes(fds[i].fd, &clients[i], buf, (size_t)n) == -1) {
                close_checked(fds[i].fd);
                count--;
                fds[i] = fds[count];
                clients[i] = clients[count];
            }
        }

        // poll dijo que hay una conexión esperando en la cola de accept.
        if (fds[0].revents & POLLIN) {
            int conn = accept(listener, NULL, NULL);
            if (conn == -1) {
                perror("accept");
            } else if (count == MAX_CLIENTS + 1) {
                fprintf(stderr, "demasiados clientes\n");
                close_checked(conn);
            } else {
                fds[count].fd = conn;
                fds[count].events = POLLIN;
                fds[count].revents = 0;
                clients[count].used = 0;
                count++;
            }
        }
    }
}

// Cliente UDP de hora.
//   time_client [-c] [-w espera_ms] <host> <puerto>
//     -c   llama a connect antes de enviar
#define _POSIX_C_SOURCE 200809L

#include "io_util.h"

#include <errno.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    bool use_connect = false;
    long wait_ms = 1000;
    int opt;
    while ((opt = getopt(argc, argv, "cw:")) != -1) {
        if (opt == 'c') {
            use_connect = true;
        } else if (opt == 'w') {
            wait_ms = strtol(optarg, NULL, 10);
        } else {
            return EXIT_FAILURE;
        }
    }
    if (argc - optind != 2 || wait_ms <= 0) {
        fprintf(stderr, "uso: %s [-c] [-w espera_ms] <host> <puerto>\n", argv[0]);
        return EXIT_FAILURE;
    }

    struct addrinfo hints;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    struct addrinfo *server;
    int err = getaddrinfo(argv[optind], argv[optind + 1], &hints, &server);
    if (err != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(err));
        return EXIT_FAILURE;
    }

    int fd = socket(server->ai_family, server->ai_socktype, server->ai_protocol);
    if (fd == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }
    // UDP no avisa si algo se pierde: sin un plazo, recv podría esperar para siempre.
    struct timeval limit = {.tv_sec = wait_ms / 1000, .tv_usec = (wait_ms % 1000) * 1000};
    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &limit, sizeof limit) == -1) {
        perror("setsockopt");
        return EXIT_FAILURE;
    }

    const char request[] = "hora?";
    ssize_t sent;
    if (use_connect) {
        // connect en UDP no envía nada: fija el destino y filtra lo que llega.
        if (connect(fd, server->ai_addr, server->ai_addrlen) == -1) {
            perror("connect");
            return EXIT_FAILURE;
        }
        sent = send(fd, request, sizeof request - 1, 0);
    } else {
        sent = sendto(fd, request, sizeof request - 1, 0,
                      server->ai_addr, server->ai_addrlen);
    }
    if (sent == -1) {
        perror("send");
        return EXIT_FAILURE;
    }
    printf("enviados %zd bytes\n", sent);
    fflush(stdout);

    char reply[128];
    ssize_t n = recv(fd, reply, sizeof reply - 1, 0);
    if (n == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("sin respuesta después de %ld ms\n", wait_ms);
            freeaddrinfo(server);
            close_checked(fd);
            return 2;
        }
        perror("recv");
        return EXIT_FAILURE;
    }
    reply[n] = '\0';
    printf("hora: %s", reply);
    freeaddrinfo(server);
    close_checked(fd);
    return EXIT_SUCCESS;
}