byte[] datos = "¿DONDE ESTA BIBLIOTECH?".getBytes(StandardCharsets.UTF_8);

DatagramPacket paquete = new DatagramPacket(
        datos,                                   // el contenido
        datos.length,                            // cuantos bytes de ese array
        InetAddress.getByName("192.168.1.50"),   // a donde va
        9091);                                   // a que puerto

byte[] buffer = new byte[1024];

// Sin direccion ni puerto: los rellenara receive() con los del REMITENTE.
DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

socket.receive(paquete);        // bloquea hasta que llega algo

// Ahora el paquete SI tiene remitente, y sabemos cuantos bytes llegaron.
InetAddress remitente = paquete.getAddress();
int puertoRemitente = paquete.getPort();
int bytesRecibidos = paquete.getLength();

// Socket EFIMERO: el sistema asigna un puerto libre.
// Sirve para enviar y para recibir respuestas a lo enviado.
DatagramSocket cliente = new DatagramSocket();

// Socket atado a un puerto CONOCIDO: es lo que hace un servidor UDP.
DatagramSocket servidor = new DatagramSocket(9091);

// Atado a un puerto y a una interfaz concreta.
DatagramSocket local = new DatagramSocket(9091, InetAddress.getByName("127.0.0.1"));

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Servidor de eco UDP. Un solo hilo, un solo socket, todos los clientes.
 * No hay conexiones, no hay pool, no hay estado por cliente.
 */
public class ServidorEcoUdp implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(ServidorEcoUdp.class.getName());

    /** Tamano del buffer de recepcion. Ver el apartado 8 sobre la MTU. */
    private static final int MAXIMO_DATAGRAMA = 1400;

    private final int puerto;
    private DatagramSocket socket;
    private volatile boolean ejecutando = false;

    public ServidorEcoUdp(int puerto) {
        this.puerto = puerto;
    }

    public void ejecutar() throws SocketException {
        socket = new DatagramSocket(puerto);
        ejecutando = true;
        LOG.info(() -> "Servidor de eco UDP en el puerto " + puerto);

        // UN buffer y UN paquete, reutilizados en todo el bucle:
        // crear un array de 1400 bytes por cada paquete recibido
        // generaria basura innecesaria a miles por segundo.
        byte[] buffer = new byte[MAXIMO_DATAGRAMA];
        DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

        while (ejecutando) {
            try {
                // IMPRESCINDIBLE antes de cada receive: restaurar la longitud.
                // Si el paquete anterior tenia 20 bytes, getLength() vale 20
                // y solo se recibirian 20 bytes del siguiente. Apartado 6.
                paquete.setLength(buffer.length);

                socket.receive(paquete);        // BLOQUEA hasta que llega algo

                // getLength() -> lo que REALMENTE llego, no buffer.length.
                String texto = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);

                LOG.info(() -> "De " + paquete.getSocketAddress() + " ("
                        + paquete.getLength() + " bytes): " + texto);

                // Respondemos AL REMITENTE, que viene en el propio paquete.
                byte[] respuesta = ("ECO: " + texto).getBytes(StandardCharsets.UTF_8);
                DatagramPacket vuelta = new DatagramPacket(
                        respuesta, respuesta.length,
                        paquete.getAddress(), paquete.getPort());
                socket.send(vuelta);

            } catch (SocketException e) {
                if (!ejecutando) {
                    LOG.info("Servidor de eco UDP detenido");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallo del socket UDP", e);
                return;

            } catch (IOException e) {
                // Un fallo con UN paquete no puede tumbar el servidor.
                LOG.log(Level.WARNING, "Error procesando un datagrama", e);
            }
        }
    }

    @Override
    public void close() {
        ejecutando = false;
        if (socket != null) {
            // Cerrar el socket desbloquea el receive(), igual que cerrar
            // el ServerSocket desbloqueaba el accept() en 09-03.
            socket.close();
        }
    }

    public static void main(String[] args) throws SocketException {
        ServidorEcoUdp servidor = new ServidorEcoUdp(9095);
        Runtime.getRuntime().addShutdownHook(new Thread(servidor::close));
        servidor.ejecutar();
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;

/** Cliente de eco UDP con tiempo limite. */
public class ClienteEcoUdp {

    private static final int MAXIMO_DATAGRAMA = 1400;

    public static void main(String[] args) throws IOException {
        String host = args.length > 0 ? args[0] : "localhost";
        int puerto = args.length > 1 ? Integer.parseInt(args[1]) : 9095;

        // Socket efimero: el sistema nos da un puerto libre.
        // try-with-resources: DatagramSocket es Closeable.
        try (DatagramSocket socket = new DatagramSocket()) {

            // OBLIGATORIO. Sin esto, si la respuesta se pierde
            // -y con UDP puede perderse- el receive() no vuelve nunca.
            socket.setSoTimeout(2000);

            InetAddress destino = InetAddress.getByName(host);

            for (String mensaje : new String[]{"Hola", "BiblioTech", "Patrones de Diseño"}) {
                byte[] datos = mensaje.getBytes(StandardCharsets.UTF_8);
                socket.send(new DatagramPacket(datos, datos.length, destino, puerto));
                System.out.println("-> " + mensaje + " (" + datos.length + " bytes)");

                byte[] buffer = new byte[MAXIMO_DATAGRAMA];
                DatagramPacket respuesta = new DatagramPacket(buffer, buffer.length);
                try {
                    socket.receive(respuesta);
                    System.out.println("<- " + new String(respuesta.getData(),
                            respuesta.getOffset(), respuesta.getLength(),
                            StandardCharsets.UTF_8));
                } catch (SocketTimeoutException e) {
                    // Con UDP esto NO es un error del programa: es el
                    // funcionamiento normal cuando algo se pierde.
                    System.out.println("<- (sin respuesta en 2 s: paquete perdido"
                            + " o servidor caido)");
                }
            }
        }
    }
}

# Terminal 1
java -cp clases com.nexussoftware.bibliotech.red.ServidorEcoUdp

# Terminal 2
java -cp clases com.nexussoftware.bibliotech.red.ClienteEcoUdp

Terminal 2:
-> Hola (4 bytes)
<- ECO: Hola
-> BiblioTech (10 bytes)
<- ECO: BiblioTech
-> Patrones de Diseño (19 bytes)
<- ECO: Patrones de Diseño

echo "Hola desde nc" | nc -u -w1 localhost 9095

ECO: Hola desde nc

// CODIGO ROTO. No lo copies.
byte[] buffer = new byte[1400];
DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

while (true) {
    socket.receive(paquete);        // <-- falta setLength antes
    procesar(paquete);
}

Estado inicial:  paquete.getLength() = 1400   (el buffer entero)

1er receive:  llega "Hola" (4 bytes)
              -> receive escribe 4 bytes y pone getLength() = 4

2o receive:   el limite ahora es 4 bytes.
              Llega "BiblioTech" (10 bytes)
              -> se aceptan SOLO 4: "Bibl"
              -> los 6 restantes SE DESCARTAN SIN AVISO
              -> getLength() = 4

3er receive:  el limite sigue siendo 4. Y asi para siempre.

De /127.0.0.1:51234 (4 bytes): Hola
De /127.0.0.1:51234 (4 bytes): Bibl
De /127.0.0.1:51234 (4 bytes): Patr

// CORRECTO: restaurar la longitud ANTES de cada receive.
while (true) {
    paquete.setLength(buffer.length);       // <-- la linea que falta
    socket.receive(paquete);
    procesar(paquete);
}

// Alternativa: paquete nuevo en cada vuelta. Correcto, pero genera
// basura. En un servidor que recibe miles de paquetes por segundo,
// la reutilizacion con setLength es notablemente mejor.
while (true) {
    DatagramPacket paquete = new DatagramPacket(new byte[1400], 1400);
    socket.receive(paquete);
    procesar(paquete);
}

// CODIGO ROTO. No lo copies.
socket.receive(paquete);
String texto = new String(paquete.getData(), StandardCharsets.UTF_8);
//                        ^^^^^^^^^^^^^^^^^ el array ENTERO, 1400 bytes

Con el bug, recibiendo "Hola" y luego "Hi":

  1er mensaje: "Hola" + 1396 bytes de ceros
               -> "Hola\0\0\0\0\0\0..."  (parece funcionar, engaña)

  2o mensaje:  "Hi" + "la" (restos del anterior) + ceros
               -> "Hila\0\0\0..."   <-- ¡DATOS MEZCLADOS!

// CORRECTO: siempre offset y getLength().
String texto = new String(
        paquete.getData(),
        paquete.getOffset(),        // desde donde
        paquete.getLength(),        // cuantos bytes son validos
        StandardCharsets.UTF_8);    // charset explicito, como siempre

byte[] utiles = Arrays.copyOfRange(
        paquete.getData(),
        paquete.getOffset(),
        paquete.getOffset() + paquete.getLength());

  1500 bytes de MTU Ethernet
-   20 bytes de cabecera IPv4  (40 si es IPv6)
-    8 bytes de cabecera UDP
= 1472 bytes de datos que caben en UNA trama Ethernet

// Truco util para detectar truncamientos: pedir un byte de mas.
// Si getLength() == buffer.length, es MUY probable que llegara
// un paquete mayor y se haya truncado.
byte[] buffer = new byte[MAXIMO_DATAGRAMA + 1];
DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);
socket.receive(paquete);

if (paquete.getLength() > MAXIMO_DATAGRAMA) {
    LOG.warning("Datagrama de " + paquete.getLength()
            + " bytes: supera el maximo previsto. Descartado.");
    return;
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.HashSet;
import java.util.Set;

/**
 * Demuestra que un receptor UDP debe tolerar perdida, duplicacion y desorden.
 * El emisor envia N paquetes numerados; el receptor analiza que llego.
 */
public class DemostracionFiabilidadUdp {

    private static final int PUERTO = 9096;
    private static final int TOTAL = 20;

    /** Receptor: cuenta lo que llega y detecta huecos, duplicados y desorden. */
    static void receptor() throws IOException {
        try (DatagramSocket socket = new DatagramSocket(PUERTO)) {
            socket.setSoTimeout(3000);      // sin esto, si se pierde el ultimo,
                                            // el bucle no terminaria nunca

            byte[] buffer = new byte[512];
            DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

            Set<Integer> vistos = new HashSet<>();
            int duplicados = 0;
            int desordenados = 0;
            int ultimoVisto = -1;

            while (true) {
                paquete.setLength(buffer.length);       // error clasico 1
                try {
                    socket.receive(paquete);
                } catch (SocketTimeoutException e) {
                    break;      // 3 s sin nada: damos por terminado
                }

                String texto = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);  // error clasico 2
                int numero = Integer.parseInt(texto.substring(texto.indexOf('#') + 1));

                if (!vistos.add(numero)) {
                    // add() devuelve false si ya estaba: es un DUPLICADO.
                    duplicados++;
                    System.out.println("  DUPLICADO: #" + numero);
                    continue;
                }
                if (numero < ultimoVisto) {
                    // Ha llegado despues de uno mayor: DESORDEN.
                    desordenados++;
                    System.out.println("  DESORDENADO: #" + numero
                            + " tras #" + ultimoVisto);
                }
                ultimoVisto = Math.max(ultimoVisto, numero);
            }

            // Los que faltan son PERDIDOS.
            StringBuilder perdidos = new StringBuilder();
            for (int i = 0; i < TOTAL; i++) {
                if (!vistos.contains(i)) {
                    perdidos.append('#').append(i).append(' ');
                }
            }

            System.out.println();
            System.out.println("=== ANALISIS DE " + TOTAL + " PAQUETES ===");
            System.out.println("Recibidos unicos : " + vistos.size());
            System.out.println("Perdidos         : " + (TOTAL - vistos.size())
                    + (perdidos.length() == 0 ? "" : "  -> " + perdidos));
            System.out.println("Duplicados       : " + duplicados);
            System.out.println("Desordenados     : " + desordenados);
        }
    }

    /** Emisor: envia TOTAL paquetes numerados lo mas rapido posible. */
    static void emisor() throws IOException, InterruptedException {
        try (DatagramSocket socket = new DatagramSocket()) {
            InetAddress destino = InetAddress.getByName("localhost");

            for (int i = 0; i < TOTAL; i++) {
                byte[] datos = ("PAQUETE#" + i).getBytes(StandardCharsets.UTF_8);
                socket.send(new DatagramPacket(datos, datos.length, destino, PUERTO));
                // send() ha "tenido exito". Eso NO significa que haya llegado.
            }
            System.out.println("Enviados " + TOTAL + " paquetes");
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length > 0 && args[0].equals("emisor")) {
            emisor();
        } else {
            receptor();
        }
    }
}

=== ANALISIS DE 100000 PAQUETES ===
Recibidos unicos : 73412
Perdidos         : 26588
Duplicados       : 0
Desordenados     : 0

# Anadir 10% de perdida, 5% de duplicacion y retardo variable al bucle invertido
sudo tc qdisc add dev lo root netem loss 10% duplicate 5% delay 20ms 10ms

# ... ejecutar la prueba ...

# Quitarlo SIEMPRE al terminar
sudo tc qdisc del dev lo root

  DUPLICADO: #3
  DESORDENADO: #7 tras #8
  DUPLICADO: #11

=== ANALISIS DE 20 PAQUETES ===
Recibidos unicos : 18
Perdidos         : 2  -> #5 #14
Duplicados       : 2
Desordenados     : 1

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;

/**
 * Peticion-respuesta fiable sobre UDP: identificador, tiempo limite,
 * reintento con espera creciente y descarte de respuestas desemparejadas.
 *
 * ATENCION: si necesitas esto para todo tu trafico, usa TCP. Esto tiene
 * sentido para intercambios cortos y sueltos (como hace el DNS), no como
 * sustituto general de TCP.
 */
public class PeticionUdpFiable {

    private static final Logger LOG = Logger.getLogger(PeticionUdpFiable.class.getName());
    private static final int MAXIMO_DATAGRAMA = 1400;

    private final InetAddress destino;
    private final int puerto;
    private final int maximoIntentos;
    private final int esperaInicialMs;

    public PeticionUdpFiable(InetAddress destino, int puerto,
                             int maximoIntentos, int esperaInicialMs) {
        this.destino = destino;
        this.puerto = puerto;
        this.maximoIntentos = maximoIntentos;
        this.esperaInicialMs = esperaInicialMs;
    }

    /**
     * Envia una peticion y espera respuesta, reintentando.
     * Devuelve null si no hubo respuesta tras todos los intentos.
     *
     * Formato: "<id> <peticion>"  ->  "<id> <respuesta>"
     */
    public String pedir(String peticion) throws IOException {
        // Identificador aleatorio: emparejar respuestas Y dificultar que
        // un tercero adivine el id e inyecte una respuesta falsa.
        int id = ThreadLocalRandom.current().nextInt(1, Integer.MAX_VALUE);
        byte[] datos = (id + " " + peticion).getBytes(StandardCharsets.UTF_8);

        try (DatagramSocket socket = new DatagramSocket()) {
            // connect() en UDP no conecta: filtra. Solo aceptaremos
            // paquetes de este destino, lo que descarta inyecciones.
            socket.connect(destino, puerto);

            int espera = esperaInicialMs;
            byte[] buffer = new byte[MAXIMO_DATAGRAMA];
            DatagramPacket respuesta = new DatagramPacket(buffer, buffer.length);

            for (int intento = 1; intento <= maximoIntentos; intento++) {
                socket.send(new DatagramPacket(datos, datos.length, destino, puerto));
                socket.setSoTimeout(espera);

                // Bucle interno: pueden llegar respuestas de intentos
                // anteriores que dabamos por perdidos. Hay que descartarlas
                // y seguir esperando la nuestra dentro del mismo plazo.
                long limite = System.currentTimeMillis() + espera;
                while (System.currentTimeMillis() < limite) {
                    try {
                        respuesta.setLength(buffer.length);     // error clasico 1
                        socket.receive(respuesta);

                        String texto = new String(respuesta.getData(),
                                respuesta.getOffset(), respuesta.getLength(),
                                StandardCharsets.UTF_8);        // error clasico 2

                        int sep = texto.indexOf(' ');
                        if (sep < 0) {
                            LOG.fine("Respuesta con formato invalido; descartada");
                            continue;
                        }
                        int idRecibido = Integer.parseInt(texto.substring(0, sep));
                        if (idRecibido != id) {
                            // Respuesta de otra peticion: se descarta.
                            LOG.fine("Respuesta con id " + idRecibido
                                    + ", esperabamos " + id + "; descartada");
                            continue;
                        }
                        return texto.substring(sep + 1);        // ¡la nuestra!

                    } catch (SocketTimeoutException e) {
                        break;      // se agoto el plazo de este intento
                    } catch (NumberFormatException e) {
                        LOG.fine("Identificador no numerico; descartada");
                    }
                }

                LOG.info("Intento " + intento + "/" + maximoIntentos
                        + " sin respuesta (espera " + espera + " ms)");

                // ESPERA CRECIENTE: duplicar en cada intento. Reintentar
                // al mismo ritmo sobre una red congestionada la empeora.
                espera *= 2;
            }
            return null;    // sin respuesta tras todos los intentos
        }
    }
}

try (DatagramSocket socket = new DatagramSocket()) {
    // OBLIGATORIO. Sin esto, enviar a una direccion de difusion
    // lanza SocketException: Permission denied.
    socket.setBroadcast(true);

    byte[] datos = "¿DONDE ESTA BIBLIOTECH?".getBytes(StandardCharsets.UTF_8);
    socket.send(new DatagramPacket(datos, datos.length,
            InetAddress.getByName("255.255.255.255"), 9091));
}

try (DatagramSocket socket = new DatagramSocket(9091)) {
    byte[] buffer = new byte[1400];
    DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);
    socket.receive(paquete);        // recibe tambien las difusiones al 9091
}

socket.setTimeToLive(1);        // no sale de la red local

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.logging.Logger;

/**
 * Emisor y receptor de multidifusion para los avisos internos de BiblioTech
 * ("el catalogo se ha actualizado", "mantenimiento en 10 minutos").
 */
public class AvisosMulticast implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(AvisosMulticast.class.getName());

    /** Rango 239.x.x.x: ambito administrativo, reservado a uso privado. */
    private static final String GRUPO = "239.10.10.10";
    private static final int PUERTO = 9097;
    private static final int MAXIMO_DATAGRAMA = 1400;

    private MulticastSocket socket;
    private InetSocketAddress grupo;
    private NetworkInterface interfaz;
    private volatile boolean ejecutando = false;

    /** Se une al grupo y queda listo para recibir. */
    public void unirse() throws IOException {
        socket = new MulticastSocket(PUERTO);
        socket.setTimeToLive(1);            // no sale de la red local

        grupo = new InetSocketAddress(InetAddress.getByName(GRUPO), PUERTO);
        interfaz = elegirInterfaz();

        // API MODERNA (Java 14+): joinGroup(SocketAddress, NetworkInterface).
        // La antigua joinGroup(InetAddress) esta obsoleta porque no permite
        // indicar la interfaz, y en una maquina con Wi-Fi + Ethernet + Docker
        // el sistema casi nunca elige la que quieres.
        socket.joinGroup(grupo, interfaz);
        ejecutando = true;

        LOG.info(() -> "Unido al grupo " + GRUPO + ":" + PUERTO
                + " por la interfaz " + interfaz.getName());
    }

    /**
     * Elige una interfaz activa, no de bucle invertido y con multidifusion.
     * En produccion esto deberia ser configurable en bibliotech.properties.
     */
    private NetworkInterface elegirInterfaz() throws IOException {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface ni = interfaces.nextElement();
            if (ni.isUp() && !ni.isLoopback() && ni.supportsMulticast()) {
                return ni;
            }
        }
        // Respaldo: en una maquina sin red, el bucle invertido permite
        // al menos que emisor y receptor de la misma maquina se hablen.
        return NetworkInterface.getByName("lo");
    }

    /** Envia un aviso a todos los suscritos al grupo. */
    public void avisar(String mensaje) throws IOException {
        byte[] datos = mensaje.getBytes(StandardCharsets.UTF_8);
        if (datos.length > MAXIMO_DATAGRAMA) {
            throw new IOException("Aviso demasiado largo: " + datos.length + " bytes");
        }
        socket.send(new DatagramPacket(datos, datos.length,
                InetAddress.getByName(GRUPO), PUERTO));
        LOG.info(() -> "Aviso enviado al grupo: " + mensaje);
    }

    /** Bucle de escucha. Llamar desde un hilo propio. */
    public void escuchar(java.util.function.Consumer<String> alRecibir) {
        byte[] buffer = new byte[MAXIMO_DATAGRAMA];
        DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

        while (ejecutando) {
            try {
                paquete.setLength(buffer.length);       // error clasico 1
                socket.receive(paquete);

                String mensaje = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);   // error clasico 2

                // OJO: tambien recibimos NUESTROS PROPIOS avisos. Si molesta,
                // se desactiva con socket.setOption(StandardSocketOptions.IP_MULTICAST_LOOP, false)
                // o se filtra por remitente comparando con las direcciones locales.
                alRecibir.accept(mensaje);

            } catch (IOException e) {
                if (!ejecutando) {
                    return;     // cierre ordenado
                }
                LOG.warning("Error recibiendo aviso: " + e.getMessage());
            }
        }
    }

    @Override
    public void close() {
        ejecutando = false;
        if (socket != null) {
            try {
                socket.leaveGroup(grupo, interfaz);     // API moderna tambien aqui
            } catch (IOException e) {
                LOG.fine("Fallo abandonando el grupo: " + e.getMessage());
            }
            socket.close();     // desbloquea el receive()
        }
    }
}

BTDP/1 - BiblioTech Discovery Protocol
======================================
Transporte : UDP, difusion al puerto 9091
Codificacion : UTF-8
Tamano maximo : 512 bytes (muy por debajo de cualquier MTU)

Peticion (puesto -> difusion):
  BTDP/1 DONDE <idPeticion>

Respuesta (servidor -> remitente, unicast):
  BTDP/1 AQUI <idPeticion> <ip> <puertoTcp> <nombreServidor>

Ejemplo:
  -> BTDP/1 DONDE 748291
  <- BTDP/1 AQUI 748291 192.168.1.50 9090 bibliotech-central

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Responde a las peticiones de descubrimiento de BiblioTech.
 * Se ejecuta junto al ServidorCatalogo de 09-03, en su propio hilo.
 *
 * Un solo socket, un solo hilo, todos los puestos de la oficina:
 * asi es un servidor UDP, sin pool y sin estado por cliente.
 */
public class RespondedorDescubrimiento implements AutoCloseable, Runnable {

    private static final Logger LOG =
            Logger.getLogger(RespondedorDescubrimiento.class.getName());

    private static final int PUERTO_DESCUBRIMIENTO = 9091;
    /** 512 bytes: el limite prudente universal, el mismo que usa el DNS. */
    private static final int MAXIMO_DATAGRAMA = 512;
    private static final String VERSION = "BTDP/1";

    private final int puertoTcp;
    private final String nombreServidor;

    private DatagramSocket socket;
    private volatile boolean ejecutando = false;
    private final AtomicLong respondidas = new AtomicLong();
    private final AtomicLong descartadas = new AtomicLong();

    public RespondedorDescubrimiento(int puertoTcp, String nombreServidor) {
        this.puertoTcp = puertoTcp;
        this.nombreServidor = nombreServidor;
    }

    public void arrancar() throws SocketException {
        socket = new DatagramSocket(PUERTO_DESCUBRIMIENTO);
        ejecutando = true;
        LOG.info(() -> "Respondedor de descubrimiento en UDP:" + PUERTO_DESCUBRIMIENTO);
    }

    @Override
    public void run() {
        // Un buffer un byte mayor que el maximo, para detectar truncamientos.
        byte[] buffer = new byte[MAXIMO_DATAGRAMA + 1];
        DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

        while (ejecutando) {
            try {
                paquete.setLength(buffer.length);       // ERROR CLASICO 1
                socket.receive(paquete);

                if (paquete.getLength() > MAXIMO_DATAGRAMA) {
                    // Un datagrama mayor del previsto: sospechoso. Se descarta.
                    descartadas.incrementAndGet();
                    LOG.warning("Datagrama de " + paquete.getLength()
                            + " bytes descartado por tamano");
                    continue;
                }

                String peticion = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);   // ERROR CLASICO 2

                procesar(peticion.strip(), paquete.getAddress(), paquete.getPort());

            } catch (SocketException e) {
                if (!ejecutando) {
                    LOG.info("Respondedor de descubrimiento detenido");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallo del socket de descubrimiento", e);
                return;

            } catch (IOException e) {
                // Un paquete malo no puede tumbar el servicio.
                LOG.log(Level.WARNING, "Error procesando un descubrimiento", e);
            }
        }
    }

    private void procesar(String peticion, InetAddress remitente, int puertoRemitente) {
        // TODO lo que llega por la red es no confiable, y aqui llega de
        // CUALQUIERA de la red local, sin conexion que lo identifique.
        String[] partes = peticion.split(" ");

        if (partes.length != 3 || !partes[0].equals(VERSION)
                || !partes[1].equals("DONDE")) {
            descartadas.incrementAndGet();
            // No respondemos a lo que no entendemos: responder a paquetes
            // arbitrarios convierte este servicio en un AMPLIFICADOR para
            // ataques de denegacion de servicio reflejada.
            LOG.fine(() -> "Descubrimiento no reconocido de " + remitente);
            return;
        }

        String id = partes[2];
        if (!identificadorValido(id)) {
            descartadas.incrementAndGet();
            return;
        }

        try {
            String miIp = InetAddress.getLocalHost().getHostAddress();
            String respuesta = VERSION + " AQUI " + id + " " + miIp + " "
                    + puertoTcp + " " + nombreServidor;

            byte[] datos = respuesta.getBytes(StandardCharsets.UTF_8);

            // UNICAST al remitente: no hace falta molestar a toda la red
            // con la respuesta. La pregunta va en difusion; la respuesta, no.
            socket.send(new DatagramPacket(datos, datos.length,
                    remitente, puertoRemitente));

            respondidas.incrementAndGet();
            LOG.info(() -> "Descubrimiento respondido a " + remitente.getHostAddress()
                    + " (id " + id + ")");

        } catch (IOException e) {
            // Si el envio falla, no pasa nada grave: el cliente reintentara.
            LOG.log(Level.WARNING, "No se pudo responder al descubrimiento", e);
        }
    }

    /** Lista blanca: solo digitos, maximo 10. Nada de datos arbitrarios. */
    private boolean identificadorValido(String id) {
        if (id.isEmpty() || id.length() > 10) {
            return false;
        }
        for (int i = 0; i < id.length(); i++) {
            if (!Character.isDigit(id.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    @Override
    public void close() {
        ejecutando = false;
        if (socket != null) {
            socket.close();     // desbloquea el receive()
        }
        LOG.info(() -> "Descubrimiento: " + respondidas.get() + " respondidas, "
                + descartadas.get() + " descartadas");
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;

/**
 * Busca el servidor de BiblioTech en la red local por difusion.
 * Evita tener que configurar la IP del servidor en cada puesto.
 */
public class BuscadorServidor {

    private static final Logger LOG = Logger.getLogger(BuscadorServidor.class.getName());

    private static final int PUERTO_DESCUBRIMIENTO = 9091;
    private static final int MAXIMO_DATAGRAMA = 512;
    private static final String VERSION = "BTDP/1";
    private static final int MAXIMO_INTENTOS = 3;

    /** Lo que se descubre: donde esta el servidor. Un record de 04-07. */
    public record ServidorEncontrado(String ip, int puertoTcp, String nombre) {
    }

    /**
     * Busca el servidor. Devuelve null si nadie responde tras los reintentos.
     * @param esperaInicialMs plazo del primer intento; se duplica en cada uno.
     */
    public ServidorEncontrado buscar(int esperaInicialMs) throws IOException {
        int id = ThreadLocalRandom.current().nextInt(1, 1_000_000);
        String peticion = VERSION + " DONDE " + id;
        byte[] datos = peticion.getBytes(StandardCharsets.UTF_8);

        try (DatagramSocket socket = new DatagramSocket()) {
            // Sin esto, enviar a 255.255.255.255 lanza
            // SocketException: Permission denied.
            socket.setBroadcast(true);

            // OJO: aqui NO se puede usar connect(), porque la respuesta
            // vendra de la IP del servidor y no de la de difusion a la
            // que enviamos. connect() la filtraria y la descartariamos.

            byte[] buffer = new byte[MAXIMO_DATAGRAMA + 1];
            DatagramPacket respuesta = new DatagramPacket(buffer, buffer.length);
            InetAddress difusion = InetAddress.getByName("255.255.255.255");

            int espera = esperaInicialMs;

            for (int intento = 1; intento <= MAXIMO_INTENTOS; intento++) {
                socket.send(new DatagramPacket(datos, datos.length,
                        difusion, PUERTO_DESCUBRIMIENTO));
                LOG.info("Buscando BiblioTech en la red local (intento "
                        + intento + "/" + MAXIMO_INTENTOS + ")...");

                socket.setSoTimeout(espera);
                long limite = System.currentTimeMillis() + espera;

                while (System.currentTimeMillis() < limite) {
                    try {
                        respuesta.setLength(buffer.length);     // error clasico 1
                        socket.receive(respuesta);

                        String texto = new String(respuesta.getData(),
                                respuesta.getOffset(), respuesta.getLength(),
                                StandardCharsets.UTF_8);        // error clasico 2

                        ServidorEncontrado encontrado = analizar(texto, id);
                        if (encontrado != null) {
                            LOG.info(() -> "BiblioTech encontrado: " + encontrado);
                            return encontrado;
                        }
                        // Respuesta de otro id o mal formada: seguimos esperando.

                    } catch (SocketTimeoutException e) {
                        break;      // plazo agotado, siguiente intento
                    }
                }
                espera *= 2;        // espera creciente
            }

            LOG.warning("Ningun servidor de BiblioTech ha respondido en la red local");
            return null;
        }
    }

    /** Analiza la respuesta VALIDANDO todo: viene de un desconocido de la red. */
    private ServidorEncontrado analizar(String texto, int idEsperado) {
        String[] p = texto.strip().split(" ");
        if (p.length != 6 || !p[0].equals(VERSION) || !p[1].equals("AQUI")) {
            return null;
        }
        try {
            if (Integer.parseInt(p[2]) != idEsperado) {
                return null;    // respuesta a otra pregunta: se descarta
            }
            int puerto = Integer.parseInt(p[4]);
            if (puerto < 1 || puerto > 65535) {
                LOG.warning("Puerto invalido en la respuesta: " + puerto);
                return null;
            }
            // La IP se valida intentando interpretarla: si no es valida,
            // getByName lanzara y no nos conectaremos a nada raro.
            InetAddress.getByName(p[3]);

            return new ServidorEncontrado(p[3], puerto, p[5]);

        } catch (NumberFormatException | IOException e) {
            LOG.fine("Respuesta de descubrimiento invalida: " + texto);
            return null;
        }
    }

    public static void main(String[] args) throws IOException {
        ServidorEncontrado servidor = new BuscadorServidor().buscar(500);
        if (servidor == null) {
            System.out.println("No se encontro ningun servidor.");
            System.out.println("Configura la IP a mano en bibliotech.properties.");
        } else {
            System.out.println("Servidor: " + servidor.nombre());
            System.out.println("Conectar a " + servidor.ip() + ":" + servidor.puertoTcp());
            // Y a partir de aqui, el ClienteCatalogo de 09-02 sobre TCP.
        }
    }
}

# Terminal 1: el servidor (o el respondedor suelto)
java -cp clases com.nexussoftware.bibliotech.red.RespondedorDescubrimiento

# Terminal 2: el puesto de trabajo
java -cp clases com.nexussoftware.bibliotech.red.BuscadorServidor

Terminal 2:
INFO: Buscando BiblioTech en la red local (intento 1/3)...
INFO: BiblioTech encontrado: ServidorEncontrado[ip=192.168.1.50, puertoTcp=9090, nombre=bibliotech-central]
Servidor: bibliotech-central
Conectar a 192.168.1.50:9090

Terminal 1:
INFO: Descubrimiento respondido a 192.168.1.23 (id 748291)

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.servicio.EstadisticasBiblioTech;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Emisor de telemetria de BiblioTech.
 *
 * Envia por UDP el estado del servicio cada N segundos. Usa el
 * ScheduledExecutorService de 08-05 y NUNCA bloquea al servidor:
 * si el recolector esta caido, los datagramas se pierden y no pasa nada.
 *
 * Formato (texto de una linea, estilo StatsD):
 *   bibliotech.prestamos.activos:12|g
 *   bibliotech.consultas.total:8471|c
 */
public class EmisorTelemetria implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(EmisorTelemetria.class.getName());
    private static final int MAXIMO_DATAGRAMA = 512;

    private final String hostRecolector;
    private final int puertoRecolector;
    private final int intervaloSegundos;
    private final EstadisticasBiblioTech estadisticas;
    private final ServidorCatalogo servidor;

    private DatagramSocket socket;
    private InetAddress destino;
    private ScheduledExecutorService planificador;

    private final AtomicLong enviados = new AtomicLong();
    private final AtomicLong fallidos = new AtomicLong();

    public EmisorTelemetria(String hostRecolector, int puertoRecolector,
                            int intervaloSegundos,
                            EstadisticasBiblioTech estadisticas,
                            ServidorCatalogo servidor) {
        this.hostRecolector = hostRecolector;
        this.puertoRecolector = puertoRecolector;
        this.intervaloSegundos = intervaloSegundos;
        this.estadisticas = estadisticas;
        this.servidor = servidor;
    }

    public void arrancar() throws IOException {
        socket = new DatagramSocket();       // efimero: solo enviamos

        // El nombre se resuelve UNA VEZ al arrancar, no en cada envio:
        // una resolucion DNS cada 5 segundos es un desperdicio y ademas
        // podria bloquear el hilo del planificador.
        destino = InetAddress.getByName(hostRecolector);

        planificador = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread h = new Thread(r, "bibliotech-telemetria");
            h.setDaemon(true);      // la telemetria no debe impedir salir
            return h;
        });

        // scheduleAtFixedRate de 08-05: cada intervaloSegundos, sin acumular.
        planificador.scheduleAtFixedRate(this::emitir,
                intervaloSegundos, intervaloSegundos, TimeUnit.SECONDS);

        LOG.info(() -> "Telemetria hacia " + hostRecolector + ":" + puertoRecolector
                + " cada " + intervaloSegundos + " s");
    }

    /**
     * Envia una tanda de medidas. Se ejecuta en el hilo del planificador.
     *
     * CRITICO: este metodo NO puede lanzar nada. Una excepcion que escape
     * de una tarea de scheduleAtFixedRate CANCELA la tarea en silencio y
     * la telemetria deja de emitir sin que nadie se entere (08-05).
     */
    private void emitir() {
        try {
            enviar("bibliotech.prestamos.activos:"
                    + estadisticas.prestamosActivos() + "|g");
            enviar("bibliotech.consultas.total:"
                    + estadisticas.consultasTotales() + "|c");
            enviar("bibliotech.conexiones.activas:"
                    + servidor.conexionesActivas() + "|g");
            enviar("bibliotech.peticiones.total:"
                    + servidor.peticionesAtendidas() + "|c");

            Runtime rt = Runtime.getRuntime();
            long memoriaMb = (rt.totalMemory() - rt.freeMemory()) / (1024 * 1024);
            enviar("bibliotech.memoria.mb:" + memoriaMb + "|g");

        } catch (RuntimeException e) {
            // Se registra y se sigue: la proxima tanda lo intentara otra vez.
            LOG.log(Level.WARNING, "Fallo emitiendo telemetria", e);
        }
    }

    private void enviar(String medida) {
        byte[] datos = medida.getBytes(StandardCharsets.UTF_8);
        if (datos.length > MAXIMO_DATAGRAMA) {
            LOG.warning("Medida demasiado larga; descartada: " + medida);
            return;
        }
        try {
            socket.send(new DatagramPacket(datos, datos.length,
                    destino, puertoRecolector));
            enviados.incrementAndGet();

            // Recuerda: este "exito" NO significa que haya llegado.
            // Con UDP, send() tiene exito aunque el recolector este apagado.

        } catch (IOException e) {
            // Casi nunca ocurre. Y si ocurre, no importa: es telemetria.
            fallidos.incrementAndGet();
            LOG.fine("Datagrama de telemetria no enviado: " + e.getMessage());
        }
    }

    @Override
    public void close() {
        if (planificador != null) {
            planificador.shutdown();        // apagado en dos fases (08-05)
            try {
                if (!planificador.awaitTermination(2, TimeUnit.SECONDS)) {
                    planificador.shutdownNow();
                }
            } catch (InterruptedException e) {
                planificador.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
        if (socket != null) {
            socket.close();
        }
        LOG.info(() -> "Telemetria detenida: " + enviados.get() + " datagramas enviados, "
                + fallidos.get() + " fallidos");
    }
}

package com.nexussoftware.bibliotech.red;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.TreeMap;

/** Recolector de telemetria minimo: muestra un panel en la consola. */
public class RecolectorTelemetria {

    public static void main(String[] args) throws Exception {
        int puerto = args.length > 0 ? Integer.parseInt(args[0]) : 9098;

        try (DatagramSocket socket = new DatagramSocket(puerto)) {
            System.out.println("Recolector escuchando en UDP:" + puerto);

            byte[] buffer = new byte[512];
            DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);
            Map<String, String> panel = new TreeMap<>();    // ordenado por clave
            long recibidos = 0;

            while (true) {
                paquete.setLength(buffer.length);
                socket.receive(paquete);
                recibidos++;

                String medida = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);

                int dosPuntos = medida.indexOf(':');
                int barra = medida.indexOf('|');
                if (dosPuntos < 0 || barra < 0 || barra < dosPuntos) {
                    continue;       // medida mal formada: se ignora
                }
                panel.put(medida.substring(0, dosPuntos),
                        medida.substring(dosPuntos + 1, barra));

                // Repintamos el panel entero con cada medida.
                System.out.print("\033[H\033[2J");      // limpiar pantalla
                System.out.println("=== TELEMETRIA BIBLIOTECH ===");
                System.out.println("Datagramas recibidos: " + recibidos);
                System.out.println();
                for (Map.Entry<String, String> e : panel.entrySet()) {
                    System.out.printf("  %-38s %s%n", e.getKey(), e.getValue());
                }
            }
        }
    }
}

=== TELEMETRIA BIBLIOTECH ===
Datagramas recibidos: 145

  bibliotech.conexiones.activas          3
  bibliotech.consultas.total             8471
  bibliotech.memoria.mb                  34
  bibliotech.peticiones.total            12093
  bibliotech.prestamos.activos           12

try (ClienteCatalogo cliente = new ClienteCatalogo("192.168.1.50", 9090)) {
    cliente.conectar();                                     // saludo de 3 vias + saludo BTCP
    FichaRed ficha = cliente.consultar("978-0000000001");   // peticion + respuesta
    System.out.println(ficha.disponible());
}                                                           // SALIR + cierre de 4 mensajes

PeticionUdpFiable peticion = new PeticionUdpFiable(
        InetAddress.getByName("192.168.1.50"), 9099, 3, 300);
String respuesta = peticion.pedir("CONSULTA 978-0000000001");
if (respuesta == null) {
    System.out.println("Sin respuesta tras 3 intentos");
} else {
    System.out.println(respuesta);
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * Reflector UDP: devuelve cada datagrama tal cual, sin interpretarlo.
 * Sin estado, sin hilos, sin conexiones. Un servidor UDP en su forma pura.
 */
public class ReflectorUdp {

    public static void main(String[] args) throws IOException {
        int puerto = args.length > 0 ? Integer.parseInt(args[0]) : 9100;

        try (DatagramSocket socket = new DatagramSocket(puerto)) {
            // Buffer generoso: aceptamos hasta 1500 bytes sin truncar.
            byte[] buffer = new byte[1500];
            DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);
            long reflejados = 0;

            System.out.println("Reflector UDP en el puerto " + puerto);

            while (true) {
                paquete.setLength(buffer.length);       // error clasico 1
                socket.receive(paquete);

                // Devolvemos EXACTAMENTE los bytes recibidos, ni uno mas:
                // el paquete ya trae la direccion y el puerto del remitente,
                // asi que send() lo devuelve a su origen sin tocar nada.
                socket.send(paquete);

                if (++reflejados % 1000 == 0) {
                    System.out.println("Reflejados: " + reflejados);
                }
            }
        }
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Sonda UDP: mide perdida, latencia y jitter de un enlace.
 * Envia y recibe en hilos separados, sin esperar respuesta por paquete,
 * que es como se mide de verdad un enlace.
 */
public class SondaUdp {

    private final String host;
    private final int puerto;
    private final int total;
    private final int tamanoDatagrama;
    private final int porSegundo;

    // Estado compartido entre el hilo emisor y el receptor.
    private final long[] latenciasUs;
    private final Set<Integer> recibidos = new HashSet<>();
    private volatile int duplicados = 0;
    private volatile int desordenados = 0;
    private volatile int recibidosTotal = 0;

    public SondaUdp(String host, int puerto, int total,
                    int tamanoDatagrama, int porSegundo) {
        this.host = host;
        this.puerto = puerto;
        this.total = total;
        this.tamanoDatagrama = Math.max(tamanoDatagrama, 16);   // cabecera minima
        this.porSegundo = porSegundo;
        this.latenciasUs = new long[total];
    }

    public void medir() throws IOException, InterruptedException {
        try (DatagramSocket socket = new DatagramSocket()) {
            socket.setSoTimeout(2000);
            InetAddress destino = InetAddress.getByName(host);

            CountDownLatch emisionTerminada = new CountDownLatch(1);

            // --- Hilo receptor ---
            // Recibe en paralelo al envio: asi la medida no incluye
            // el tiempo de "esperar mi turno para enviar el siguiente".
            Thread receptor = new Thread(() -> recibir(socket, emisionTerminada),
                    "sonda-receptor");
            receptor.start();

            // --- Emisor, en este hilo ---
            long intervaloNs = 1_000_000_000L / porSegundo;
            long siguiente = System.nanoTime();

            for (int i = 0; i < total; i++) {
                // Cabecera binaria: numero de secuencia + marca de tiempo.
                // ByteBuffer usa big-endian por defecto: el orden de red.
                ByteBuffer bb = ByteBuffer.allocate(tamanoDatagrama);
                bb.putInt(i);
                bb.putLong(System.nanoTime());
                // El resto del datagrama es relleno hasta el tamano pedido.

                socket.send(new DatagramPacket(bb.array(), tamanoDatagrama,
                        destino, puerto));

                // Ritmo controlado: sin esto saturariamos el buffer del
                // receptor y mediriamos nuestra propia saturacion, no la red.
                siguiente += intervaloNs;
                long esperaNs = siguiente - System.nanoTime();
                if (esperaNs > 0) {
                    TimeUnit.NANOSECONDS.sleep(esperaNs);
                }
            }

            emisionTerminada.countDown();
            // Margen para que lleguen las ultimas respuestas en vuelo.
            receptor.join(3000);
            socket.close();     // desbloquea el receive del receptor

            informe();
        }
    }

    private void recibir(DatagramSocket socket, CountDownLatch emisionTerminada) {
        byte[] buffer = new byte[1500];
        DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);
        int ultimo = -1;

        while (true) {
            try {
                paquete.setLength(buffer.length);
                socket.receive(paquete);
                long ahora = System.nanoTime();

                if (paquete.getLength() < 12) {
                    continue;       // no cabe ni la cabecera: se ignora
                }

                ByteBuffer bb = ByteBuffer.wrap(paquete.getData(),
                        paquete.getOffset(), paquete.getLength());
                int secuencia = bb.getInt();
                long enviado = bb.getLong();

                if (secuencia < 0 || secuencia >= total) {
                    continue;       // secuencia fuera de rango: paquete ajeno
                }

                synchronized (recibidos) {
                    if (!recibidos.add(secuencia)) {
                        duplicados++;
                        continue;
                    }
                }
                if (secuencia < ultimo) {
                    desordenados++;
                }
                ultimo = Math.max(ultimo, secuencia);

                latenciasUs[secuencia] = (ahora - enviado) / 1000;
                recibidosTotal++;

            } catch (SocketTimeoutException e) {
                // Dos segundos sin nada. Si la emision ya termino, paramos.
                if (emisionTerminada.getCount() == 0) {
                    return;
                }
            } catch (IOException e) {
                return;     // socket cerrado: fin
            }
        }
    }

    private void informe() {
        // Solo las latencias de los paquetes que efectivamente llegaron.
        long[] validas = new long[recibidosTotal];
        int j = 0;
        for (int i = 0; i < total && j < validas.length; i++) {
            if (latenciasUs[i] > 0) {
                validas[j++] = latenciasUs[i];
            }
        }
        validas = Arrays.copyOf(validas, j);

        if (validas.length == 0) {
            System.out.println("No se recibio ninguna respuesta.");
            return;
        }

        // Jitter: variacion media entre latencias CONSECUTIVAS. Se calcula
        // ANTES de ordenar, porque depende del orden temporal.
        double sumaJitter = 0;
        for (int i = 1; i < validas.length; i++) {
            sumaJitter += Math.abs(validas[i] - validas[i - 1]);
        }
        double jitterUs = validas.length > 1 ? sumaJitter / (validas.length - 1) : 0;

        long suma = 0;
        for (long v : validas) {
            suma += v;
        }
        long[] ordenadas = validas.clone();
        Arrays.sort(ordenadas);

        double perdida = 100.0 * (total - recibidosTotal) / total;

        System.out.println();
        System.out.println("=== SONDA UDP: " + host + ":" + puerto + " ===");
        System.out.printf("%-24s %d bytes%n", "Tamano de datagrama", tamanoDatagrama);
        System.out.printf("%-24s %d/s%n", "Ritmo", porSegundo);
        System.out.println();
        System.out.printf("%-24s %d%n", "Enviados", total);
        System.out.printf("%-24s %d%n", "Recibidos", recibidosTotal);
        System.out.printf("%-24s %d (%.2f%%)%n", "Perdidos",
                total - recibidosTotal, perdida);
        System.out.printf("%-24s %d%n", "Duplicados", duplicados);
        System.out.printf("%-24s %d%n", "Desordenados", desordenados);
        System.out.println();
        System.out.println("--- LATENCIA (ms) ---");
        System.out.printf("%-24s %.3f%n", "Minima", ordenadas[0] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Media",
                (suma / (double) validas.length) / 1000.0);
        System.out.printf("%-24s %.3f%n", "Mediana",
                ordenadas[ordenadas.length / 2] / 1000.0);
        System.out.printf("%-24s %.3f%n", "p95",
                ordenadas[(int) (ordenadas.length * 0.95)] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Maxima",
                ordenadas[ordenadas.length - 1] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Jitter medio", jitterUs / 1000.0);
    }

    public static void main(String[] args) throws Exception {
        String host = args.length > 0 ? args[0] : "localhost";
        int puerto = args.length > 1 ? Integer.parseInt(args[1]) : 9100;

        for (int tamano : new int[]{64, 512, 1400}) {
            new SondaUdp(host, puerto, 1000, tamano, 500).medir();
            Thread.sleep(500);
        }
    }
}

=== SONDA UDP: localhost:9100 ===
Tamano de datagrama      64 bytes
Ritmo                    500/s

Enviados                 1000
Recibidos                1000
Perdidos                 0 (0,00%)
Duplicados               0
Desordenados             0

--- LATENCIA (ms) ---
Minima                   0,041
Media                    0,078
Mediana                  0,069
p95                      0,142
Maxima                   1,884
Jitter medio             0,031

package com.nexussoftware.bibliotech.red;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.StandardSocketOptions;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.logging.Logger;

/**
 * Chat interno de Nexus Software sobre multidifusion. Sin servidor central:
 * todos son iguales, todos emiten al grupo y todos reciben de el.
 */
public class ChatBiblioTech implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(ChatBiblioTech.class.getName());

    /** Rango 239.x.x.x: ambito administrativo, uso privado. */
    private static final String GRUPO = "239.10.10.20";
    private static final int PUERTO = 9099;
    private static final int MAXIMO_DATAGRAMA = 1400;
    private static final int MAXIMO_MENSAJE = 500;

    private final String usuario;
    private final long arranque = System.currentTimeMillis();

    private MulticastSocket socket;
    private InetSocketAddress grupo;
    private NetworkInterface interfaz;
    private volatile boolean ejecutando = false;

    public ChatBiblioTech(String usuario) {
        this.usuario = usuario;
    }

    public void arrancar() throws IOException {
        socket = new MulticastSocket(PUERTO);
        socket.setTimeToLive(1);        // no sale de la red local

        // FILTRADO DE MENSAJES PROPIOS - Opcion elegida.
        //
        // Hay dos formas:
        //   (a) IP_MULTICAST_LOOP = false: el sistema no nos devuelve
        //       nuestros propios envios. Es limpia y no cuesta nada, PERO
        //       tambien impide que DOS INSTANCIAS EN LA MISMA MAQUINA se
        //       vean entre si, porque el filtro es por maquina, no por socket.
        //   (b) Comparar el remitente con las direcciones locales y filtrar
        //       en el codigo. Mas trabajo, pero permite probar con tres
        //       instancias en el mismo ordenador.
        //
        // Elegimos (b) porque el enunciado pide poder probar con tres
        // instancias locales, y ademas es el comportamiento que se quiere
        // en un chat: si abro dos ventanas, quiero ver las dos.
        socket.setOption(StandardSocketOptions.IP_MULTICAST_LOOP, true);

        grupo = new InetSocketAddress(InetAddress.getByName(GRUPO), PUERTO);
        interfaz = elegirInterfaz();

        // API moderna (Java 14+): con NetworkInterface explicita.
        socket.joinGroup(grupo, interfaz);
        ejecutando = true;

        LOG.info(() -> "Unido a " + GRUPO + ":" + PUERTO
                + " por " + interfaz.getName());
    }

    private NetworkInterface elegirInterfaz() throws IOException {
        Enumeration<NetworkInterface> nis = NetworkInterface.getNetworkInterfaces();
        NetworkInterface respaldo = null;
        while (nis.hasMoreElements()) {
            NetworkInterface ni = nis.nextElement();
            if (!ni.isUp() || !ni.supportsMulticast()) {
                continue;
            }
            if (!ni.isLoopback()) {
                return ni;      // preferimos una interfaz real
            }
            respaldo = ni;      // el bucle invertido sirve para pruebas locales
        }
        if (respaldo == null) {
            throw new IOException("No hay ninguna interfaz con multidifusion");
        }
        return respaldo;
    }

    /** Bucle de recepcion. Se ejecuta en su propio hilo. */
    private void recibir() {
        byte[] buffer = new byte[MAXIMO_DATAGRAMA];
        DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

        while (ejecutando) {
            try {
                paquete.setLength(buffer.length);       // error clasico 1
                socket.receive(paquete);

                // Filtro (b): descartamos lo que enviamos nosotros mismos.
                if (esNuestro(paquete.getAddress(), paquete.getPort())) {
                    continue;
                }

                String mensaje = new String(paquete.getData(), paquete.getOffset(),
                        paquete.getLength(), StandardCharsets.UTF_8);  // error clasico 2

                // TODO lo que llega por el grupo viene de un desconocido.
                if (mensaje.length() > MAXIMO_MENSAJE) {
                    LOG.warning("Mensaje demasiado largo descartado");
                    continue;
                }
                System.out.println(sanear(mensaje));

            } catch (IOException e) {
                if (!ejecutando) {
                    return;     // cierre ordenado
                }
                LOG.warning("Error recibiendo: " + e.getMessage());
            }
        }
    }

    /**
     * Un paquete es nuestro si viene de una direccion local Y de nuestro
     * puerto de origen. Comparar solo la direccion no bastaria: filtraria
     * tambien los mensajes de las otras instancias de la misma maquina.
     */
    private boolean esNuestro(InetAddress remitente, int puertoRemitente) {
        if (puertoRemitente != socket.getLocalPort()) {
            return false;
        }
        try {
            Enumeration<InetAddress> propias = interfaz.getInetAddresses();
            while (propias.hasMoreElements()) {
                if (propias.nextElement().equals(remitente)) {
                    return true;
                }
            }
        } catch (Exception e) {
            // Si no podemos comprobarlo, preferimos mostrar de mas que de menos.
            return false;
        }
        return false;
    }

    public void enviar(String texto) throws IOException {
        long marca = (System.currentTimeMillis() - arranque) / 1000;
        String mensaje = String.format("[%3ds] %-14s %s", marca, usuario, texto);

        byte[] datos = mensaje.getBytes(StandardCharsets.UTF_8);
        if (datos.length > MAXIMO_DATAGRAMA) {
            System.out.println("(mensaje demasiado largo, no enviado)");
            return;
        }
        socket.send(new DatagramPacket(datos, datos.length,
                InetAddress.getByName(GRUPO), PUERTO));
    }

    /**
     * Sanea antes de imprimir en consola: un mensaje del grupo puede
     * contener secuencias de escape ANSI que manipulen el terminal
     * de quien lo lea (borrar la pantalla, mover el cursor, colores).
     */
    private String sanear(String texto) {
        StringBuilder sb = new StringBuilder(texto.length());
        for (int i = 0; i < texto.length(); i++) {
            char c = texto.charAt(i);
            sb.append(Character.isISOControl(c) && c != '\t' ? '?' : c);
        }
        return sb.toString();
    }

    @Override
    public void close() {
        if (!ejecutando) {
            return;
        }
        try {
            enviar("*** se ha marchado ***");
        } catch (IOException ignorada) {
            // Nos vamos igual.
        }
        ejecutando = false;
        try {
            socket.leaveGroup(grupo, interfaz);
        } catch (IOException e) {
            LOG.fine("Fallo abandonando el grupo: " + e.getMessage());
        }
        socket.close();     // desbloquea el receive()
    }

    public static void main(String[] args) throws IOException {
        String usuario = args.length > 0 ? args[0] : "Anonimo";

        ChatBiblioTech chat = new ChatBiblioTech(usuario);
        chat.arrancar();

        Thread receptor = new Thread(chat::recibir, "chat-receptor");
        receptor.setDaemon(true);
        receptor.start();

        Runtime.getRuntime().addShutdownHook(new Thread(chat::close));

        chat.enviar("*** se ha unido ***");
        System.out.println("Chat de BiblioTech. Escribe /salir para terminar.");

        try (BufferedReader teclado = new BufferedReader(
                new InputStreamReader(System.in, StandardCharsets.UTF_8))) {
            String linea;
            while ((linea = teclado.readLine()) != null) {
                if (linea.equals("/salir")) {
                    break;
                }
                if (!linea.isBlank()) {
                    chat.enviar(linea);
                }
            }
        }
        chat.close();
    }
}

java -cp clases com.nexussoftware.bibliotech.red.ChatBiblioTech "Marta Ruiz"
java -cp clases com.nexussoftware.bibliotech.red.ChatBiblioTech "Diego Alonso"
java -cp clases com.nexussoftware.bibliotech.red.ChatBiblioTech "Nuria Vidal"

Terminal de Marta:
Chat de BiblioTech. Escribe /salir para terminar.
[  2s] Diego Alonso   *** se ha unido ***
[  5s] Nuria Vidal    *** se ha unido ***
¿Alguien tiene Java Efectivo?
[ 12s] Diego Alonso   Lo tengo yo, lo devuelvo manana
[ 18s] Nuria Vidal    *** se ha marchado ***

package com.nexussoftware.bibliotech.red;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;

/**
 * Transferencia fiable de fichero sobre UDP con parada y espera.
 *
 * Formato de cada datagrama de datos:
 *   [int    ] numero de secuencia
 *   [byte   ] 1 si es el ultimo bloque, 0 si no
 *   [int    ] longitud de los datos
 *   [bytes  ] datos
 *
 * Formato de la confirmacion:
 *   [int    ] numero de secuencia confirmado
 */
public class EnvioFiableUdp {

    private static final Logger LOG = Logger.getLogger(EnvioFiableUdp.class.getName());

    private static final int DATOS_POR_BLOQUE = 1024;
    private static final int CABECERA = 4 + 1 + 4;      // int + byte + int
    private static final int MAXIMO_INTENTOS = 5;
    private static final int ESPERA_INICIAL_MS = 200;

    /** Porcentaje de datagramas que se descartan a proposito, para probar. */
    private final int perdidaSimulada;

    private int retransmisiones = 0;

    public EnvioFiableUdp(int perdidaSimulada) {
        this.perdidaSimulada = perdidaSimulada;
    }

    public void enviar(String host, int puerto, Path fichero) throws IOException {
        long tamano = Files.size(fichero);
        long inicio = System.currentTimeMillis();

        try (DatagramSocket socket = new DatagramSocket();
             InputStream entrada = Files.newInputStream(fichero)) {

            InetAddress destino = InetAddress.getByName(host);
            // connect() filtra: solo aceptamos confirmaciones de este destino.
            socket.connect(destino, puerto);

            byte[] bloque = new byte[DATOS_POR_BLOQUE];
            byte[] bufferAck = new byte[16];
            DatagramPacket ack = new DatagramPacket(bufferAck, bufferAck.length);

            int secuencia = 0;
            long enviadosBytes = 0;
            long sumaComprobacion = 0;

            while (true) {
                int leidos = entrada.read(bloque);
                boolean ultimo = false;

                if (leidos == -1) {
                    // Fin del fichero: enviamos un bloque vacio marcado
                    // como ultimo, para que el receptor sepa que ha terminado.
                    leidos = 0;
                    ultimo = true;
                } else {
                    // Miramos si queda algo mas sin consumirlo:
                    // available() es orientativo, asi que marcamos el
                    // ultimo con un bloque vacio final. Mas simple y seguro.
                    for (int i = 0; i < leidos; i++) {
                        sumaComprobacion += bloque[i] & 0xFF;
                    }
                    enviadosBytes += leidos;
                }

                byte[] datagrama = construir(secuencia, ultimo, bloque, leidos);

                if (!enviarConConfirmacion(socket, destino, puerto,
                        datagrama, secuencia, ack, bufferAck)) {
                    throw new IOException("El receptor no confirma el bloque "
                            + secuencia + " tras " + MAXIMO_INTENTOS + " intentos");
                }

                if (ultimo) {
                    break;
                }
                secuencia++;
            }

            long ms = System.currentTimeMillis() - inicio;
            System.out.println();
            System.out.println("=== TRANSFERENCIA COMPLETADA ===");
            System.out.printf("%-26s %s%n", "Fichero", fichero.getFileName());
            System.out.printf("%-26s %d%n", "Bytes", enviadosBytes);
            System.out.printf("%-26s %d%n", "Bloques", secuencia + 1);
            System.out.printf("%-26s %d%n", "Retransmisiones", retransmisiones);
            System.out.printf("%-26s %d%%%n", "Perdida simulada", perdidaSimulada);
            System.out.printf("%-26s %d ms%n", "Tiempo", ms);
            System.out.printf("%-26s %d%n", "Suma de comprobacion", sumaComprobacion);
            System.out.printf("%-26s %.1f KB/s%n", "Velocidad",
                    ms == 0 ? 0 : enviadosBytes / 1024.0 / (ms / 1000.0));
        }
    }

    /** Construye el datagrama con su cabecera binaria en big-endian. */
    private byte[] construir(int secuencia, boolean ultimo, byte[] datos, int longitud)
            throws IOException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream(CABECERA + longitud);
        DataOutputStream salida = new DataOutputStream(bytes);
        salida.writeInt(secuencia);
        salida.writeBoolean(ultimo);
        salida.writeInt(longitud);
        salida.write(datos, 0, longitud);
        salida.flush();
        return bytes.toByteArray();
    }

    /** Envia y espera confirmacion, reintentando con espera creciente. */
    private boolean enviarConConfirmacion(DatagramSocket socket, InetAddress destino,
                                          int puerto, byte[] datagrama, int secuencia,
                                          DatagramPacket ack, byte[] bufferAck)
            throws IOException {

        int espera = ESPERA_INICIAL_MS;

        for (int intento = 1; intento <= MAXIMO_INTENTOS; intento++) {
            if (intento > 1) {
                retransmisiones++;
            }

            // --- PERDIDA SIMULADA ---
            // Se descarta el datagrama ANTES de enviarlo, para probar que
            // el mecanismo de reintento funciona sin necesitar una red mala.
            if (ThreadLocalRandom.current().nextInt(100) >= perdidaSimulada) {
                socket.send(new DatagramPacket(datagrama, datagrama.length,
                        destino, puerto));
            } else {
                LOG.fine("Perdida simulada del bloque " + secuencia);
            }

            socket.setSoTimeout(espera);
            long limite = System.currentTimeMillis() + espera;

            while (System.currentTimeMillis() < limite) {
                try {
                    ack.setLength(bufferAck.length);        // error clasico 1
                    socket.receive(ack);

                    if (ack.getLength() < 4) {
                        continue;
                    }
                    int confirmado = ByteBuffer.wrap(ack.getData(),
                            ack.getOffset(), ack.getLength()).getInt();

                    if (confirmado == secuencia) {
                        return true;
                    }
                    // Confirmacion de un bloque anterior (llego tarde):
                    // se descarta y se sigue esperando la nuestra.
                    LOG.fine("Confirmacion desfasada: " + confirmado
                            + ", esperabamos " + secuencia);

                } catch (SocketTimeoutException e) {
                    break;      // plazo agotado: siguiente intento
                }
            }
            espera *= 2;        // espera creciente
        }
        return false;
    }

    public static void main(String[] args) throws IOException {
        Path fichero = Path.of(args.length > 0 ? args[0] : "catalogo.csv");
        int perdida = args.length > 1 ? Integer.parseInt(args[1]) : 20;
        new EnvioFiableUdp(perdida).enviar("localhost", 9101, fichero);
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.logging.Logger;

/** Receptor de la transferencia fiable sobre UDP. */
public class RecepcionFiableUdp {

    private static final Logger LOG = Logger.getLogger(RecepcionFiableUdp.class.getName());

    private static final int DATOS_POR_BLOQUE = 1024;
    private static final int CABECERA = 4 + 1 + 4;
    private static final int MAXIMO_DATAGRAMA = CABECERA + DATOS_POR_BLOQUE;

    public void recibir(int puerto, Path destino) throws IOException {
        Files.createDirectories(destino.getParent() == null
                ? Path.of(".") : destino.getParent());

        try (DatagramSocket socket = new DatagramSocket(puerto);
             OutputStream salida = Files.newOutputStream(destino)) {

            System.out.println("Esperando fichero en UDP:" + puerto);
            socket.setSoTimeout(30_000);        // abandonamos si nadie envia

            byte[] buffer = new byte[MAXIMO_DATAGRAMA + 1];
            DatagramPacket paquete = new DatagramPacket(buffer, buffer.length);

            int esperado = 0;
            int duplicados = 0;
            long bytes = 0;
            long sumaComprobacion = 0;
            long inicio = System.currentTimeMillis();

            while (true) {
                paquete.setLength(buffer.length);       // error clasico 1
                socket.receive(paquete);

                if (paquete.getLength() < CABECERA
                        || paquete.getLength() > MAXIMO_DATAGRAMA) {
                    LOG.warning("Datagrama de tamano invalido descartado");
                    continue;
                }

                ByteBuffer bb = ByteBuffer.wrap(paquete.getData(),
                        paquete.getOffset(), paquete.getLength());
                int secuencia = bb.getInt();
                boolean ultimo = bb.get() != 0;
                int longitud = bb.getInt();

                // VALIDACION: la longitud viene de la red. Sin esto,
                // un emisor malicioso provoca una excepcion o algo peor.
                if (longitud < 0 || longitud > DATOS_POR_BLOQUE
                        || longitud > bb.remaining()) {
                    LOG.warning("Longitud declarada invalida: " + longitud);
                    continue;
                }

                if (secuencia < esperado) {
                    // DUPLICADO: nuestra confirmacion anterior se perdio y
                    // el emisor reenvio. Hay que RECONFIRMAR pero NO escribir
                    // los datos otra vez, o el fichero saldria corrupto.
                    duplicados++;
                    confirmar(socket, paquete, secuencia);
                    continue;
                }
                if (secuencia > esperado) {
                    // Con parada y espera esto no deberia ocurrir: significa
                    // que perdimos un bloque intermedio. No confirmamos, y el
                    // emisor reenviara el que falta.
                    LOG.warning("Bloque " + secuencia + " fuera de orden; "
                            + "esperabamos " + esperado);
                    continue;
                }

                // Bloque correcto y en orden: se escribe.
                byte[] datos = new byte[longitud];
                bb.get(datos);
                salida.write(datos);
                for (byte b : datos) {
                    sumaComprobacion += b & 0xFF;
                }
                bytes += longitud;

                confirmar(socket, paquete, secuencia);
                esperado++;

                if (ultimo) {
                    salida.flush();
                    long ms = System.currentTimeMillis() - inicio;
                    System.out.println();
                    System.out.println("=== RECEPCION COMPLETADA ===");
                    System.out.printf("%-26s %s%n", "Guardado en", destino);
                    System.out.printf("%-26s %d%n", "Bytes", bytes);
                    System.out.printf("%-26s %d%n", "Bloques", esperado);
                    System.out.printf("%-26s %d%n", "Duplicados detectados", duplicados);
                    System.out.printf("%-26s %d ms%n", "Tiempo", ms);
                    System.out.printf("%-26s %d%n", "Suma de comprobacion",
                            sumaComprobacion);
                    return;
                }
            }
        }
    }

    private void confirmar(DatagramSocket socket, DatagramPacket original, int secuencia)
            throws IOException {
        byte[] ack = ByteBuffer.allocate(4).putInt(secuencia).array();
        // Se responde AL REMITENTE, que viene en el paquete original.
        socket.send(new DatagramPacket(ack, ack.length,
                original.getAddress(), original.getPort()));
    }

    public static void main(String[] args) throws IOException {
        new RecepcionFiableUdp().recibir(9101, Path.of("recibidos", "catalogo.csv"));
    }
}

Terminal 1 (receptor):
Esperando fichero en UDP:9101

=== RECEPCION COMPLETADA ===
Guardado en                recibidos/catalogo.csv
Bytes                      2847
Bloques                    4
Duplicados detectados      1
Tiempo                     834 ms
Suma de comprobacion       291476

Terminal 2 (emisor):
=== TRANSFERENCIA COMPLETADA ===
Fichero                    catalogo.csv
Bytes                      2847
Bloques                    4
Retransmisiones            3
Perdida simulada           20%
Tiempo                     841 ms
Suma de comprobacion       291476

try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress(host, puerto), 3000);
    Files.copy(fichero, socket.getOutputStream());
    socket.shutdownOutput();
}