byte[] dades = "ON ES BIBLIOTECH?".getBytes(StandardCharsets.UTF_8);

DatagramPacket paquet = new DatagramPacket(
        dades,                                   // el contingut
        dades.length,                            // quants bytes d'aquest array
        InetAddress.getByName("192.168.1.50"),   // on va
        9091);                                   // a quin port

byte[] buffer = new byte[1024];

// Sense adreca ni port: els omplira receive() amb els del REMITENT.
DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

socket.receive(paquet);         // bloqueja fins que arriba alguna cosa

// Ara el paquet SI que te remitent, i sabem quants bytes han arribat.
InetAddress remitent = paquet.getAddress();
int portRemitent = paquet.getPort();
int bytesRebuts = paquet.getLength();

// Socket EFIMER: el sistema assigna un port lliure.
// Serveix per enviar i per rebre respostes al que s'ha enviat.
DatagramSocket client = new DatagramSocket();

// Socket lligat a un port CONEGUT: es el que fa un servidor UDP.
DatagramSocket servidor = new DatagramSocket(9091);

// Lligat a un port i a una interficie concreta.
DatagramSocket local = new DatagramSocket(9091, InetAddress.getByName("127.0.0.1"));

package com.nexussoftware.bibliotech.xarxa;

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 d'eco UDP. Un sol fil, un sol socket, tots els clients.
 * No hi ha connexions, no hi ha pool, no hi ha estat per client.
 */
public class ServidorEcoUdp implements AutoCloseable {

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

    /** Mida de la memoria intermedia de recepcio. Veure l'apartat 8 sobre l'MTU. */
    private static final int MAXIM_DATAGRAMA = 1400;

    private final int port;
    private DatagramSocket socket;
    private volatile boolean executant = false;

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

    public void executar() throws SocketException {
        socket = new DatagramSocket(port);
        executant = true;
        LOG.info(() -> "Servidor d'eco UDP al port " + port);

        // UNA memoria intermedia i UN paquet, reutilitzats a tot el bucle:
        // crear un array de 1400 bytes per cada paquet rebut
        // generaria brossa innecessaria a milers per segon.
        byte[] buffer = new byte[MAXIM_DATAGRAMA];
        DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

        while (executant) {
            try {
                // IMPRESCINDIBLE abans de cada receive: restaurar la longitud.
                // Si el paquet anterior tenia 20 bytes, getLength() val 20
                // i nomes es rebrien 20 bytes del seguent. Apartat 6.
                paquet.setLength(buffer.length);

                socket.receive(paquet);         // BLOQUEJA fins que arriba alguna cosa

                // getLength() -> el que REALMENT ha arribat, no buffer.length.
                String text = new String(paquet.getData(), paquet.getOffset(),
                        paquet.getLength(), StandardCharsets.UTF_8);

                LOG.info(() -> "De " + paquet.getSocketAddress() + " ("
                        + paquet.getLength() + " bytes): " + text);

                // Responem AL REMITENT, que ve al mateix paquet.
                byte[] resposta = ("ECO: " + text).getBytes(StandardCharsets.UTF_8);
                DatagramPacket tornada = new DatagramPacket(
                        resposta, resposta.length,
                        paquet.getAddress(), paquet.getPort());
                socket.send(tornada);

            } catch (SocketException e) {
                if (!executant) {
                    LOG.info("Servidor d'eco UDP aturat");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallada del socket UDP", e);
                return;

            } catch (IOException e) {
                // Una fallada amb UN paquet no pot tombar el servidor.
                LOG.log(Level.WARNING, "Error processant un datagrama", e);
            }
        }
    }

    @Override
    public void close() {
        executant = false;
        if (socket != null) {
            // Tancar el socket desbloqueja el receive(), igual que tancar
            // el ServerSocket desbloquejava l'accept() a 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.executar();
    }
}

package com.nexussoftware.bibliotech.xarxa;

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;

/** Client d'eco UDP amb temps limit. */
public class ClientEcoUdp {

    private static final int MAXIM_DATAGRAMA = 1400;

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

        // Socket efimer: el sistema ens dona un port lliure.
        // try-with-resources: DatagramSocket es Closeable.
        try (DatagramSocket socket = new DatagramSocket()) {

            // OBLIGATORI. Sense aixo, si la resposta es perd
            // -i amb UDP pot perdre's- el receive() no torna mai.
            socket.setSoTimeout(2000);

            InetAddress desti = InetAddress.getByName(host);

            for (String missatge : new String[]{"Hola", "BiblioTech", "Refactorització"}) {
                byte[] dades = missatge.getBytes(StandardCharsets.UTF_8);
                socket.send(new DatagramPacket(dades, dades.length, desti, port));
                System.out.println("-> " + missatge + " (" + dades.length + " bytes)");

                byte[] buffer = new byte[MAXIM_DATAGRAMA];
                DatagramPacket resposta = new DatagramPacket(buffer, buffer.length);
                try {
                    socket.receive(resposta);
                    System.out.println("<- " + new String(resposta.getData(),
                            resposta.getOffset(), resposta.getLength(),
                            StandardCharsets.UTF_8));
                } catch (SocketTimeoutException e) {
                    // Amb UDP aixo NO es un error del programa: es el
                    // funcionament normal quan alguna cosa es perd.
                    System.out.println("<- (sense resposta en 2 s: paquet perdut"
                            + " o servidor caigut)");
                }
            }
        }
    }
}

# Terminal 1
java -cp classes com.nexussoftware.bibliotech.xarxa.ServidorEcoUdp

# Terminal 2
java -cp classes com.nexussoftware.bibliotech.xarxa.ClientEcoUdp

Terminal 2:
-> Hola (4 bytes)
<- ECO: Hola
-> BiblioTech (10 bytes)
<- ECO: BiblioTech
-> Refactorització (16 bytes)
<- ECO: Refactorització

echo "Hola des de nc" | nc -u -w1 localhost 9095

ECO: Hola des de nc

// CODI TRENCAT. No el copiis.
byte[] buffer = new byte[1400];
DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

while (true) {
    socket.receive(paquet);         // <-- falta setLength abans
    processar(paquet);
}

Estat inicial:   paquet.getLength() = 1400   (la memoria intermedia sencera)

1r receive:   arriba "Hola" (4 bytes)
              -> receive escriu 4 bytes i posa getLength() = 4

2n receive:   el limit ara es de 4 bytes.
              Arriba "BiblioTech" (10 bytes)
              -> se n'accepten NOMES 4: "Bibl"
              -> els 6 restants ES DESCARTEN SENSE AVIS
              -> getLength() = 4

3r receive:   el limit continua sent 4. I aixi per sempre.

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): Refa

// CORRECTE: restaurar la longitud ABANS de cada receive.
while (true) {
    paquet.setLength(buffer.length);        // <-- la linia que falta
    socket.receive(paquet);
    processar(paquet);
}

// Alternativa: paquet nou a cada volta. Correcte, pero genera
// brossa. En un servidor que rep milers de paquets per segon,
// la reutilitzacio amb setLength es notablement millor.
while (true) {
    DatagramPacket paquet = new DatagramPacket(new byte[1400], 1400);
    socket.receive(paquet);
    processar(paquet);
}

// CODI TRENCAT. No el copiis.
socket.receive(paquet);
String text = new String(paquet.getData(), StandardCharsets.UTF_8);
//                       ^^^^^^^^^^^^^^^^ l'array SENCER, 1400 bytes

Amb el bug, rebent "Hola" i despres "Hi":

  1r missatge: "Hola" + 1396 bytes de zeros
               -> "Hola\0\0\0\0\0\0..."  (sembla que funciona, enganya)

  2n missatge: "Hi" + "la" (restes de l'anterior) + zeros
               -> "Hila\0\0\0..."   <-- DADES BARREJADES!

// CORRECTE: sempre offset i getLength().
String text = new String(
        paquet.getData(),
        paquet.getOffset(),         // des d'on
        paquet.getLength(),         // quants bytes son valids
        StandardCharsets.UTF_8);    // charset explicit, com sempre

byte[] utils = Arrays.copyOfRange(
        paquet.getData(),
        paquet.getOffset(),
        paquet.getOffset() + paquet.getLength());

  1500 bytes d'MTU Ethernet
-   20 bytes de capcalera IPv4  (40 si es IPv6)
-    8 bytes de capcalera UDP
= 1472 bytes de dades que caben en UNA trama Ethernet

// Truc util per detectar truncaments: demanar un byte de mes.
// Si getLength() == buffer.length, es MOLT probable que hagi arribat
// un paquet mes gran i s'hagi truncat.
byte[] buffer = new byte[MAXIM_DATAGRAMA + 1];
DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
socket.receive(paquet);

if (paquet.getLength() > MAXIM_DATAGRAMA) {
    LOG.warning("Datagrama de " + paquet.getLength()
            + " bytes: supera el maxim previst. Descartat.");
    return;
}

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Demostra que un receptor UDP ha de tolerar perdua, duplicacio i desordre.
 * L'emissor envia N paquets numerats; el receptor analitza que ha arribat.
 */
public class DemostracioFiabilitatUdp {

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

    /** Receptor: compta el que arriba i detecta forats, duplicats i desordre. */
    static void receptor() throws IOException {
        try (DatagramSocket socket = new DatagramSocket(PORT)) {
            socket.setSoTimeout(3000);      // sense aixo, si es perd l'ultim,
                                            // el bucle no acabaria mai

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

            Set<Integer> vistos = new HashSet<>();
            int duplicats = 0;
            int desordenats = 0;
            int ultimVist = -1;

            while (true) {
                paquet.setLength(buffer.length);        // error classic 1
                try {
                    socket.receive(paquet);
                } catch (SocketTimeoutException e) {
                    break;      // 3 s sense res: donem per acabat
                }

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

                if (!vistos.add(numero)) {
                    // add() retorna false si ja hi era: es un DUPLICAT.
                    duplicats++;
                    System.out.println("  DUPLICAT: #" + numero);
                    continue;
                }
                if (numero < ultimVist) {
                    // Ha arribat despres d'un de mes gran: DESORDRE.
                    desordenats++;
                    System.out.println("  DESORDENAT: #" + numero
                            + " rere #" + ultimVist);
                }
                ultimVist = Math.max(ultimVist, numero);
            }

            // Els que falten son PERDUTS.
            StringBuilder perduts = new StringBuilder();
            for (int i = 0; i < TOTAL; i++) {
                if (!vistos.contains(i)) {
                    perduts.append('#').append(i).append(' ');
                }
            }

            System.out.println();
            System.out.println("=== ANALISI DE " + TOTAL + " PAQUETS ===");
            System.out.println("Rebuts unics  : " + vistos.size());
            System.out.println("Perduts       : " + (TOTAL - vistos.size())
                    + (perduts.length() == 0 ? "" : "  -> " + perduts));
            System.out.println("Duplicats     : " + duplicats);
            System.out.println("Desordenats   : " + desordenats);
        }
    }

    /** Emissor: envia TOTAL paquets numerats tan de pressa com pot. */
    static void emissor() throws IOException, InterruptedException {
        try (DatagramSocket socket = new DatagramSocket()) {
            InetAddress desti = InetAddress.getByName("localhost");

            for (int i = 0; i < TOTAL; i++) {
                byte[] dades = ("PAQUET#" + i).getBytes(StandardCharsets.UTF_8);
                socket.send(new DatagramPacket(dades, dades.length, desti, PORT));
                // send() ha "tingut exit". Aixo NO significa que hagi arribat.
            }
            System.out.println("Enviats " + TOTAL + " paquets");
        }
    }

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

=== ANALISI DE 100000 PAQUETS ===
Rebuts unics  : 73412
Perduts       : 26588
Duplicats     : 0
Desordenats   : 0

# Afegir 10% de perdua, 5% de duplicacio i retard variable al bucle invertit
sudo tc qdisc add dev lo root netem loss 10% duplicate 5% delay 20ms 10ms

# ... executar la prova ...

# Treure-ho SEMPRE en acabar
sudo tc qdisc del dev lo root

  DUPLICAT: #3
  DESORDENAT: #7 rere #8
  DUPLICAT: #11

=== ANALISI DE 20 PAQUETS ===
Rebuts unics  : 18
Perduts       : 2  -> #5 #14
Duplicats     : 2
Desordenats   : 1

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Peticio-resposta fiable sobre UDP: identificador, temps limit,
 * reintent amb espera creixent i descart de respostes desaparellades.
 *
 * ATENCIO: si necessites aixo per a tot el teu transit, fes servir TCP. Aixo te
 * sentit per a intercanvis curts i solts (com fa el DNS), no com a
 * substitut general de TCP.
 */
public class PeticioUdpFiable {

    private static final Logger LOG = Logger.getLogger(PeticioUdpFiable.class.getName());
    private static final int MAXIM_DATAGRAMA = 1400;

    private final InetAddress desti;
    private final int port;
    private final int maximIntents;
    private final int esperaInicialMs;

    public PeticioUdpFiable(InetAddress desti, int port,
                            int maximIntents, int esperaInicialMs) {
        this.desti = desti;
        this.port = port;
        this.maximIntents = maximIntents;
        this.esperaInicialMs = esperaInicialMs;
    }

    /**
     * Envia una peticio i espera resposta, reintentant.
     * Retorna null si no hi ha hagut resposta despres de tots els intents.
     *
     * Format: "<id> <peticio>"  ->  "<id> <resposta>"
     */
    public String demanar(String peticio) throws IOException {
        // Identificador aleatori: aparellar respostes I dificultar que
        // un tercer endevini l'id i injecti una resposta falsa.
        int id = ThreadLocalRandom.current().nextInt(1, Integer.MAX_VALUE);
        byte[] dades = (id + " " + peticio).getBytes(StandardCharsets.UTF_8);

        try (DatagramSocket socket = new DatagramSocket()) {
            // connect() en UDP no connecta: filtra. Nomes acceptarem
            // paquets d'aquest desti, cosa que descarta injeccions.
            socket.connect(desti, port);

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

            for (int intent = 1; intent <= maximIntents; intent++) {
                socket.send(new DatagramPacket(dades, dades.length, desti, port));
                socket.setSoTimeout(espera);

                // Bucle intern: poden arribar respostes d'intents
                // anteriors que donavem per perduts. Cal descartar-les
                // i continuar esperant la nostra dins del mateix termini.
                long limit = System.currentTimeMillis() + espera;
                while (System.currentTimeMillis() < limit) {
                    try {
                        resposta.setLength(buffer.length);      // error classic 1
                        socket.receive(resposta);

                        String text = new String(resposta.getData(),
                                resposta.getOffset(), resposta.getLength(),
                                StandardCharsets.UTF_8);        // error classic 2

                        int sep = text.indexOf(' ');
                        if (sep < 0) {
                            LOG.fine("Resposta amb format invalid; descartada");
                            continue;
                        }
                        int idRebut = Integer.parseInt(text.substring(0, sep));
                        if (idRebut != id) {
                            // Resposta d'una altra peticio: es descarta.
                            LOG.fine("Resposta amb id " + idRebut
                                    + ", esperavem " + id + "; descartada");
                            continue;
                        }
                        return text.substring(sep + 1);         // la nostra!

                    } catch (SocketTimeoutException e) {
                        break;      // s'ha esgotat el termini d'aquest intent
                    } catch (NumberFormatException e) {
                        LOG.fine("Identificador no numeric; descartada");
                    }
                }

                LOG.info("Intent " + intent + "/" + maximIntents
                        + " sense resposta (espera " + espera + " ms)");

                // ESPERA CREIXENT: duplicar a cada intent. Reintentar
                // al mateix ritme sobre una xarxa congestionada l'empitjora.
                espera *= 2;
            }
            return null;    // sense resposta despres de tots els intents
        }
    }
}

try (DatagramSocket socket = new DatagramSocket()) {
    // OBLIGATORI. Sense aixo, enviar a una adreca de difusio
    // llanca SocketException: Permission denied.
    socket.setBroadcast(true);

    byte[] dades = "ON ES BIBLIOTECH?".getBytes(StandardCharsets.UTF_8);
    socket.send(new DatagramPacket(dades, dades.length,
            InetAddress.getByName("255.255.255.255"), 9091));
}

try (DatagramSocket socket = new DatagramSocket(9091)) {
    byte[] buffer = new byte[1400];
    DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
    socket.receive(paquet);         // rep tambe les difusions al 9091
}

socket.setTimeToLive(1);        // no surt de la xarxa local

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Emissor i receptor de multidifusio per als avisos interns de BiblioTech
 * ("el cataleg s'ha actualitzat", "manteniment d'aqui a 10 minuts").
 */
public class AvisosMulticast implements AutoCloseable {

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

    /** Rang 239.x.x.x: ambit administratiu, reservat a us privat. */
    private static final String GRUP = "239.10.10.10";
    private static final int PORT = 9097;
    private static final int MAXIM_DATAGRAMA = 1400;

    private MulticastSocket socket;
    private InetSocketAddress grup;
    private NetworkInterface interficie;
    private volatile boolean executant = false;

    /** S'uneix al grup i queda a punt per rebre. */
    public void unirse() throws IOException {
        socket = new MulticastSocket(PORT);
        socket.setTimeToLive(1);            // no surt de la xarxa local

        grup = new InetSocketAddress(InetAddress.getByName(GRUP), PORT);
        interficie = triarInterficie();

        // API MODERNA (Java 14+): joinGroup(SocketAddress, NetworkInterface).
        // L'antiga joinGroup(InetAddress) esta obsoleta perque no permet
        // indicar la interficie, i en una maquina amb Wi-Fi + Ethernet + Docker
        // el sistema gairebe mai no tria la que vols.
        socket.joinGroup(grup, interficie);
        executant = true;

        LOG.info(() -> "Unit al grup " + GRUP + ":" + PORT
                + " per la interficie " + interficie.getName());
    }

    /**
     * Tria una interficie activa, no de bucle invertit i amb multidifusio.
     * En produccio aixo hauria de ser configurable a bibliotech.properties.
     */
    private NetworkInterface triarInterficie() throws IOException {
        Enumeration<NetworkInterface> interficies = NetworkInterface.getNetworkInterfaces();
        while (interficies.hasMoreElements()) {
            NetworkInterface ni = interficies.nextElement();
            if (ni.isUp() && !ni.isLoopback() && ni.supportsMulticast()) {
                return ni;
            }
        }
        // Reserva: en una maquina sense xarxa, el bucle invertit permet
        // almenys que emissor i receptor de la mateixa maquina es parlin.
        return NetworkInterface.getByName("lo");
    }

    /** Envia un avis a tots els subscrits al grup. */
    public void avisar(String missatge) throws IOException {
        byte[] dades = missatge.getBytes(StandardCharsets.UTF_8);
        if (dades.length > MAXIM_DATAGRAMA) {
            throw new IOException("Avis massa llarg: " + dades.length + " bytes");
        }
        socket.send(new DatagramPacket(dades, dades.length,
                InetAddress.getByName(GRUP), PORT));
        LOG.info(() -> "Avis enviat al grup: " + missatge);
    }

    /** Bucle d'escolta. Cridar des d'un fil propi. */
    public void escoltar(java.util.function.Consumer<String> alRebre) {
        byte[] buffer = new byte[MAXIM_DATAGRAMA];
        DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

        while (executant) {
            try {
                paquet.setLength(buffer.length);        // error classic 1
                socket.receive(paquet);

                String missatge = new String(paquet.getData(), paquet.getOffset(),
                        paquet.getLength(), StandardCharsets.UTF_8);    // error classic 2

                // COMPTE: tambe rebem els NOSTRES PROPIS avisos. Si molesta,
                // es desactiva amb socket.setOption(StandardSocketOptions.IP_MULTICAST_LOOP, false)
                // o es filtra per remitent comparant amb les adreces locals.
                alRebre.accept(missatge);

            } catch (IOException e) {
                if (!executant) {
                    return;     // tancament ordenat
                }
                LOG.warning("Error rebent l'avis: " + e.getMessage());
            }
        }
    }

    @Override
    public void close() {
        executant = false;
        if (socket != null) {
            try {
                socket.leaveGroup(grup, interficie);    // API moderna tambe aqui
            } catch (IOException e) {
                LOG.fine("Fallada abandonant el grup: " + e.getMessage());
            }
            socket.close();     // desbloqueja el receive()
        }
    }
}

BTDP/1 - BiblioTech Discovery Protocol
======================================
Transport : UDP, difusio al port 9091
Codificacio : UTF-8
Mida maxima : 512 bytes (molt per sota de qualsevol MTU)

Peticio (lloc -> difusio):
  BTDP/1 ON <idPeticio>

Resposta (servidor -> remitent, unicast):
  BTDP/1 AQUI <idPeticio> <ip> <portTcp> <nomServidor>

Exemple:
  -> BTDP/1 ON 748291
  <- BTDP/1 AQUI 748291 192.168.1.50 9090 bibliotech-central

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Respon a les peticions de descobriment de BiblioTech.
 * S'executa al costat del ServidorCataleg de 09-03, al seu propi fil.
 *
 * Un sol socket, un sol fil, tots els llocs de l'oficina:
 * aixi es un servidor UDP, sense pool i sense estat per client.
 */
public class ResponedorDescobriment implements AutoCloseable, Runnable {

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

    private static final int PORT_DESCOBRIMENT = 9091;
    /** 512 bytes: el limit prudent universal, el mateix que fa servir el DNS. */
    private static final int MAXIM_DATAGRAMA = 512;
    private static final String VERSIO = "BTDP/1";

    private final int portTcp;
    private final String nomServidor;

    private DatagramSocket socket;
    private volatile boolean executant = false;
    private final AtomicLong respostes = new AtomicLong();
    private final AtomicLong descartades = new AtomicLong();

    public ResponedorDescobriment(int portTcp, String nomServidor) {
        this.portTcp = portTcp;
        this.nomServidor = nomServidor;
    }

    public void arrencar() throws SocketException {
        socket = new DatagramSocket(PORT_DESCOBRIMENT);
        executant = true;
        LOG.info(() -> "Responedor de descobriment a UDP:" + PORT_DESCOBRIMENT);
    }

    @Override
    public void run() {
        // Una memoria intermedia un byte mes gran que el maxim, per detectar truncaments.
        byte[] buffer = new byte[MAXIM_DATAGRAMA + 1];
        DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

        while (executant) {
            try {
                paquet.setLength(buffer.length);        // ERROR CLASSIC 1
                socket.receive(paquet);

                if (paquet.getLength() > MAXIM_DATAGRAMA) {
                    // Un datagrama mes gran del previst: sospitos. Es descarta.
                    descartades.incrementAndGet();
                    LOG.warning("Datagrama de " + paquet.getLength()
                            + " bytes descartat per mida");
                    continue;
                }

                String peticio = new String(paquet.getData(), paquet.getOffset(),
                        paquet.getLength(), StandardCharsets.UTF_8);    // ERROR CLASSIC 2

                processar(peticio.strip(), paquet.getAddress(), paquet.getPort());

            } catch (SocketException e) {
                if (!executant) {
                    LOG.info("Responedor de descobriment aturat");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallada del socket de descobriment", e);
                return;

            } catch (IOException e) {
                // Un paquet dolent no pot tombar el servei.
                LOG.log(Level.WARNING, "Error processant un descobriment", e);
            }
        }
    }

    private void processar(String peticio, InetAddress remitent, int portRemitent) {
        // TOT el que arriba per la xarxa no es fiable, i aqui arriba de
        // QUALSEVOL de la xarxa local, sense connexio que l'identifiqui.
        String[] parts = peticio.split(" ");

        if (parts.length != 3 || !parts[0].equals(VERSIO)
                || !parts[1].equals("ON")) {
            descartades.incrementAndGet();
            // No responem al que no entenem: respondre a paquets
            // arbitraris converteix aquest servei en un AMPLIFICADOR per a
            // atacs de denegacio de servei reflectida.
            LOG.fine(() -> "Descobriment no reconegut de " + remitent);
            return;
        }

        String id = parts[2];
        if (!identificadorValid(id)) {
            descartades.incrementAndGet();
            return;
        }

        try {
            String laMevaIp = InetAddress.getLocalHost().getHostAddress();
            String resposta = VERSIO + " AQUI " + id + " " + laMevaIp + " "
                    + portTcp + " " + nomServidor;

            byte[] dades = resposta.getBytes(StandardCharsets.UTF_8);

            // UNICAST al remitent: no cal molestar tota la xarxa
            // amb la resposta. La pregunta va en difusio; la resposta, no.
            socket.send(new DatagramPacket(dades, dades.length,
                    remitent, portRemitent));

            respostes.incrementAndGet();
            LOG.info(() -> "Descobriment respost a " + remitent.getHostAddress()
                    + " (id " + id + ")");

        } catch (IOException e) {
            // Si l'enviament falla, no passa res greu: el client reintentara.
            LOG.log(Level.WARNING, "No s'ha pogut respondre al descobriment", e);
        }
    }

    /** Llista blanca: nomes digits, maxim 10. Res de dades arbitraries. */
    private boolean identificadorValid(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() {
        executant = false;
        if (socket != null) {
            socket.close();     // desbloqueja el receive()
        }
        LOG.info(() -> "Descobriment: " + respostes.get() + " respostes, "
                + descartades.get() + " descartades");
    }
}

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Cerca el servidor de BiblioTech a la xarxa local per difusio.
 * Evita haver de configurar la IP del servidor a cada lloc.
 */
public class CercadorServidor {

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

    private static final int PORT_DESCOBRIMENT = 9091;
    private static final int MAXIM_DATAGRAMA = 512;
    private static final String VERSIO = "BTDP/1";
    private static final int MAXIM_INTENTS = 3;

    /** El que es descobreix: on es el servidor. Un record de 04-07. */
    public record ServidorTrobat(String ip, int portTcp, String nom) {
    }

    /**
     * Cerca el servidor. Retorna null si ningu no respon despres dels reintents.
     * @param esperaInicialMs termini del primer intent; es duplica a cadascun.
     */
    public ServidorTrobat cercar(int esperaInicialMs) throws IOException {
        int id = ThreadLocalRandom.current().nextInt(1, 1_000_000);
        String peticio = VERSIO + " ON " + id;
        byte[] dades = peticio.getBytes(StandardCharsets.UTF_8);

        try (DatagramSocket socket = new DatagramSocket()) {
            // Sense aixo, enviar a 255.255.255.255 llanca
            // SocketException: Permission denied.
            socket.setBroadcast(true);

            // COMPTE: aqui NO es pot fer servir connect(), perque la resposta
            // vindra de la IP del servidor i no de la de difusio a la
            // qual enviem. connect() la filtraria i la descartariem.

            byte[] buffer = new byte[MAXIM_DATAGRAMA + 1];
            DatagramPacket resposta = new DatagramPacket(buffer, buffer.length);
            InetAddress difusio = InetAddress.getByName("255.255.255.255");

            int espera = esperaInicialMs;

            for (int intent = 1; intent <= MAXIM_INTENTS; intent++) {
                socket.send(new DatagramPacket(dades, dades.length,
                        difusio, PORT_DESCOBRIMENT));
                LOG.info("Cercant BiblioTech a la xarxa local (intent "
                        + intent + "/" + MAXIM_INTENTS + ")...");

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

                while (System.currentTimeMillis() < limit) {
                    try {
                        resposta.setLength(buffer.length);      // error classic 1
                        socket.receive(resposta);

                        String text = new String(resposta.getData(),
                                resposta.getOffset(), resposta.getLength(),
                                StandardCharsets.UTF_8);        // error classic 2

                        ServidorTrobat trobat = analitzar(text, id);
                        if (trobat != null) {
                            LOG.info(() -> "BiblioTech trobat: " + trobat);
                            return trobat;
                        }
                        // Resposta d'un altre id o mal formada: continuem esperant.

                    } catch (SocketTimeoutException e) {
                        break;      // termini esgotat, seguent intent
                    }
                }
                espera *= 2;        // espera creixent
            }

            LOG.warning("Cap servidor de BiblioTech no ha respost a la xarxa local");
            return null;
        }
    }

    /** Analitza la resposta VALIDANT-HO tot: ve d'un desconegut de la xarxa. */
    private ServidorTrobat analitzar(String text, int idEsperat) {
        String[] p = text.strip().split(" ");
        if (p.length != 6 || !p[0].equals(VERSIO) || !p[1].equals("AQUI")) {
            return null;
        }
        try {
            if (Integer.parseInt(p[2]) != idEsperat) {
                return null;    // resposta a una altra pregunta: es descarta
            }
            int port = Integer.parseInt(p[4]);
            if (port < 1 || port > 65535) {
                LOG.warning("Port invalid a la resposta: " + port);
                return null;
            }
            // La IP es valida intentant interpretar-la: si no es valida,
            // getByName llancara i no ens connectarem a res estrany.
            InetAddress.getByName(p[3]);

            return new ServidorTrobat(p[3], port, p[5]);

        } catch (NumberFormatException | IOException e) {
            LOG.fine("Resposta de descobriment invalida: " + text);
            return null;
        }
    }

    public static void main(String[] args) throws IOException {
        ServidorTrobat servidor = new CercadorServidor().cercar(500);
        if (servidor == null) {
            System.out.println("No s'ha trobat cap servidor.");
            System.out.println("Configura la IP a ma a bibliotech.properties.");
        } else {
            System.out.println("Servidor: " + servidor.nom());
            System.out.println("Connectar a " + servidor.ip() + ":" + servidor.portTcp());
            // I a partir d'aqui, el ClientCataleg de 09-02 sobre TCP.
        }
    }
}

# Terminal 1: el servidor (o el responedor sol)
java -cp classes com.nexussoftware.bibliotech.xarxa.ResponedorDescobriment

# Terminal 2: el lloc de treball
java -cp classes com.nexussoftware.bibliotech.xarxa.CercadorServidor

Terminal 2:
INFO: Cercant BiblioTech a la xarxa local (intent 1/3)...
INFO: BiblioTech trobat: ServidorTrobat[ip=192.168.1.50, portTcp=9090, nom=bibliotech-central]
Servidor: bibliotech-central
Connectar a 192.168.1.50:9090

Terminal 1:
INFO: Descobriment respost a 192.168.1.23 (id 748291)

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.servei.EstadistiquesBiblioTech;

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;

/**
 * Emissor de telemetria de BiblioTech.
 *
 * Envia per UDP l'estat del servei cada N segons. Fa servir el
 * ScheduledExecutorService de 08-05 i NO bloqueja MAI el servidor:
 * si el recolector esta caigut, els datagrames es perden i no passa res.
 *
 * Format (text d'una linia, estil StatsD):
 *   bibliotech.prestecs.actius:12|g
 *   bibliotech.consultes.total:8471|c
 */
public class EmissorTelemetria implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(EmissorTelemetria.class.getName());
    private static final int MAXIM_DATAGRAMA = 512;

    private final String hostRecolector;
    private final int portRecolector;
    private final int intervalSegons;
    private final EstadistiquesBiblioTech estadistiques;
    private final ServidorCataleg servidor;

    private DatagramSocket socket;
    private InetAddress desti;
    private ScheduledExecutorService planificador;

    private final AtomicLong enviats = new AtomicLong();
    private final AtomicLong fallits = new AtomicLong();

    public EmissorTelemetria(String hostRecolector, int portRecolector,
                             int intervalSegons,
                             EstadistiquesBiblioTech estadistiques,
                             ServidorCataleg servidor) {
        this.hostRecolector = hostRecolector;
        this.portRecolector = portRecolector;
        this.intervalSegons = intervalSegons;
        this.estadistiques = estadistiques;
        this.servidor = servidor;
    }

    public void arrencar() throws IOException {
        socket = new DatagramSocket();       // efimer: nomes enviem

        // El nom es resol UNA VEGADA en arrencar, no a cada enviament:
        // una resolucio DNS cada 5 segons es un malbaratament i a mes
        // podria bloquejar el fil del planificador.
        desti = InetAddress.getByName(hostRecolector);

        planificador = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread f = new Thread(r, "bibliotech-telemetria");
            f.setDaemon(true);      // la telemetria no ha d'impedir sortir
            return f;
        });

        // scheduleAtFixedRate de 08-05: cada intervalSegons, sense acumular.
        planificador.scheduleAtFixedRate(this::emetre,
                intervalSegons, intervalSegons, TimeUnit.SECONDS);

        LOG.info(() -> "Telemetria cap a " + hostRecolector + ":" + portRecolector
                + " cada " + intervalSegons + " s");
    }

    /**
     * Envia una tanda de mesures. S'executa al fil del planificador.
     *
     * CRITIC: aquest metode NO pot llancar res. Una excepcio que escapi
     * d'una tasca de scheduleAtFixedRate CANCELLA la tasca en silenci i
     * la telemetria deixa d'emetre sense que ningu se n'assabenti (08-05).
     */
    private void emetre() {
        try {
            enviar("bibliotech.prestecs.actius:"
                    + estadistiques.prestecsActius() + "|g");
            enviar("bibliotech.consultes.total:"
                    + estadistiques.consultesTotals() + "|c");
            enviar("bibliotech.connexions.actives:"
                    + servidor.connexionsActives() + "|g");
            enviar("bibliotech.peticions.total:"
                    + servidor.peticionsAteses() + "|c");

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

        } catch (RuntimeException e) {
            // Es registra i es continua: la tanda seguent ho tornara a intentar.
            LOG.log(Level.WARNING, "Fallada emetent telemetria", e);
        }
    }

    private void enviar(String mesura) {
        byte[] dades = mesura.getBytes(StandardCharsets.UTF_8);
        if (dades.length > MAXIM_DATAGRAMA) {
            LOG.warning("Mesura massa llarga; descartada: " + mesura);
            return;
        }
        try {
            socket.send(new DatagramPacket(dades, dades.length,
                    desti, portRecolector));
            enviats.incrementAndGet();

            // Recorda: aquest "exit" NO significa que hagi arribat.
            // Amb UDP, send() te exit encara que el recolector estigui apagat.

        } catch (IOException e) {
            // Gairebe mai no passa. I si passa, no importa: es telemetria.
            fallits.incrementAndGet();
            LOG.fine("Datagrama de telemetria no enviat: " + e.getMessage());
        }
    }

    @Override
    public void close() {
        if (planificador != null) {
            planificador.shutdown();        // aturada en dues 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 aturada: " + enviats.get() + " datagrames enviats, "
                + fallits.get() + " fallits");
    }
}

package com.nexussoftware.bibliotech.xarxa;

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

/** Recolector de telemetria minim: mostra un panell a la consola. */
public class RecolectorTelemetria {

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

        try (DatagramSocket socket = new DatagramSocket(port)) {
            System.out.println("Recolector escoltant a UDP:" + port);

            byte[] buffer = new byte[512];
            DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
            Map<String, String> panell = new TreeMap<>();   // ordenat per clau
            long rebuts = 0;

            while (true) {
                paquet.setLength(buffer.length);
                socket.receive(paquet);
                rebuts++;

                String mesura = new String(paquet.getData(), paquet.getOffset(),
                        paquet.getLength(), StandardCharsets.UTF_8);

                int dosPunts = mesura.indexOf(':');
                int barra = mesura.indexOf('|');
                if (dosPunts < 0 || barra < 0 || barra < dosPunts) {
                    continue;       // mesura mal formada: s'ignora
                }
                panell.put(mesura.substring(0, dosPunts),
                        mesura.substring(dosPunts + 1, barra));

                // Repintem el panell sencer amb cada mesura.
                System.out.print("\033[H\033[2J");      // netejar la pantalla
                System.out.println("=== TELEMETRIA BIBLIOTECH ===");
                System.out.println("Datagrames rebuts: " + rebuts);
                System.out.println();
                for (Map.Entry<String, String> e : panell.entrySet()) {
                    System.out.printf("  %-38s %s%n", e.getKey(), e.getValue());
                }
            }
        }
    }
}

=== TELEMETRIA BIBLIOTECH ===
Datagrames rebuts: 145

  bibliotech.connexions.actives          3
  bibliotech.consultes.total             8471
  bibliotech.memoria.mb                  34
  bibliotech.peticions.total             12093
  bibliotech.prestecs.actius             12

try (ClientCataleg client = new ClientCataleg("192.168.1.50", 9090)) {
    client.connectar();                                     // salutacio de 3 vies + salutacio BTCP
    FitxaXarxa fitxa = client.consultar("978-0000000001");  // peticio + resposta
    System.out.println(fitxa.disponible());
}                                                           // SORTIR + tancament de 4 missatges

PeticioUdpFiable peticio = new PeticioUdpFiable(
        InetAddress.getByName("192.168.1.50"), 9099, 3, 300);
String resposta = peticio.demanar("CONSULTA 978-0000000001");
if (resposta == null) {
    System.out.println("Sense resposta despres de 3 intents");
} else {
    System.out.println(resposta);
}

package com.nexussoftware.bibliotech.xarxa;

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

/**
 * Reflector UDP: retorna cada datagrama tal qual, sense interpretar-lo.
 * Sense estat, sense fils, sense connexions. Un servidor UDP en la forma pura.
 */
public class ReflectorUdp {

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

        try (DatagramSocket socket = new DatagramSocket(port)) {
            // Memoria intermedia generosa: acceptem fins a 1500 bytes sense truncar.
            byte[] buffer = new byte[1500];
            DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
            long reflectits = 0;

            System.out.println("Reflector UDP al port " + port);

            while (true) {
                paquet.setLength(buffer.length);        // error classic 1
                socket.receive(paquet);

                // Retornem EXACTAMENT els bytes rebuts, ni un mes:
                // el paquet ja porta l'adreca i el port del remitent,
                // aixi que send() el retorna al seu origen sense tocar res.
                socket.send(paquet);

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

package com.nexussoftware.bibliotech.xarxa;

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: mesura perdua, latencia i jitter d'un enllac.
 * Envia i rep en fils separats, sense esperar resposta per paquet,
 * que es com es mesura de veritat un enllac.
 */
public class SondaUdp {

    private final String host;
    private final int port;
    private final int total;
    private final int midaDatagrama;
    private final int perSegon;

    // Estat compartit entre el fil emissor i el receptor.
    private final long[] latenciesUs;
    private final Set<Integer> rebuts = new HashSet<>();
    private volatile int duplicats = 0;
    private volatile int desordenats = 0;
    private volatile int rebutsTotal = 0;

    public SondaUdp(String host, int port, int total,
                    int midaDatagrama, int perSegon) {
        this.host = host;
        this.port = port;
        this.total = total;
        this.midaDatagrama = Math.max(midaDatagrama, 16);       // capcalera minima
        this.perSegon = perSegon;
        this.latenciesUs = new long[total];
    }

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

            CountDownLatch emissioAcabada = new CountDownLatch(1);

            // --- Fil receptor ---
            // Rep en parallel a l'enviament: aixi la mesura no inclou
            // el temps d'"esperar el meu torn per enviar el seguent".
            Thread receptor = new Thread(() -> rebre(socket, emissioAcabada),
                    "sonda-receptor");
            receptor.start();

            // --- Emissor, en aquest fil ---
            long intervalNs = 1_000_000_000L / perSegon;
            long seguent = System.nanoTime();

            for (int i = 0; i < total; i++) {
                // Capcalera binaria: numero de sequencia + marca de temps.
                // ByteBuffer fa servir big-endian per defecte: l'ordre de xarxa.
                ByteBuffer bb = ByteBuffer.allocate(midaDatagrama);
                bb.putInt(i);
                bb.putLong(System.nanoTime());
                // La resta del datagrama es reblert fins a la mida demanada.

                socket.send(new DatagramPacket(bb.array(), midaDatagrama,
                        desti, port));

                // Ritme controlat: sense aixo saturariem la memoria intermedia
                // del receptor i mesurariem la nostra saturacio, no la xarxa.
                seguent += intervalNs;
                long esperaNs = seguent - System.nanoTime();
                if (esperaNs > 0) {
                    TimeUnit.NANOSECONDS.sleep(esperaNs);
                }
            }

            emissioAcabada.countDown();
            // Marge perque arribin les ultimes respostes en vol.
            receptor.join(3000);
            socket.close();     // desbloqueja el receive del receptor

            informe();
        }
    }

    private void rebre(DatagramSocket socket, CountDownLatch emissioAcabada) {
        byte[] buffer = new byte[1500];
        DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);
        int ultim = -1;

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

                if (paquet.getLength() < 12) {
                    continue;       // no hi cap ni la capcalera: s'ignora
                }

                ByteBuffer bb = ByteBuffer.wrap(paquet.getData(),
                        paquet.getOffset(), paquet.getLength());
                int sequencia = bb.getInt();
                long enviat = bb.getLong();

                if (sequencia < 0 || sequencia >= total) {
                    continue;       // sequencia fora de rang: paquet alie
                }

                synchronized (rebuts) {
                    if (!rebuts.add(sequencia)) {
                        duplicats++;
                        continue;
                    }
                }
                if (sequencia < ultim) {
                    desordenats++;
                }
                ultim = Math.max(ultim, sequencia);

                latenciesUs[sequencia] = (ara - enviat) / 1000;
                rebutsTotal++;

            } catch (SocketTimeoutException e) {
                // Dos segons sense res. Si l'emissio ja ha acabat, parem.
                if (emissioAcabada.getCount() == 0) {
                    return;
                }
            } catch (IOException e) {
                return;     // socket tancat: fi
            }
        }
    }

    private void informe() {
        // Nomes les latencies dels paquets que efectivament han arribat.
        long[] valides = new long[rebutsTotal];
        int j = 0;
        for (int i = 0; i < total && j < valides.length; i++) {
            if (latenciesUs[i] > 0) {
                valides[j++] = latenciesUs[i];
            }
        }
        valides = Arrays.copyOf(valides, j);

        if (valides.length == 0) {
            System.out.println("No s'ha rebut cap resposta.");
            return;
        }

        // Jitter: variacio mitjana entre latencies CONSECUTIVES. Es calcula
        // ABANS d'ordenar, perque depen de l'ordre temporal.
        double sumaJitter = 0;
        for (int i = 1; i < valides.length; i++) {
            sumaJitter += Math.abs(valides[i] - valides[i - 1]);
        }
        double jitterUs = valides.length > 1 ? sumaJitter / (valides.length - 1) : 0;

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

        double perdua = 100.0 * (total - rebutsTotal) / total;

        System.out.println();
        System.out.println("=== SONDA UDP: " + host + ":" + port + " ===");
        System.out.printf("%-24s %d bytes%n", "Mida de datagrama", midaDatagrama);
        System.out.printf("%-24s %d/s%n", "Ritme", perSegon);
        System.out.println();
        System.out.printf("%-24s %d%n", "Enviats", total);
        System.out.printf("%-24s %d%n", "Rebuts", rebutsTotal);
        System.out.printf("%-24s %d (%.2f%%)%n", "Perduts",
                total - rebutsTotal, perdua);
        System.out.printf("%-24s %d%n", "Duplicats", duplicats);
        System.out.printf("%-24s %d%n", "Desordenats", desordenats);
        System.out.println();
        System.out.println("--- LATENCIA (ms) ---");
        System.out.printf("%-24s %.3f%n", "Minima", ordenades[0] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Mitjana",
                (suma / (double) valides.length) / 1000.0);
        System.out.printf("%-24s %.3f%n", "Mediana",
                ordenades[ordenades.length / 2] / 1000.0);
        System.out.printf("%-24s %.3f%n", "p95",
                ordenades[(int) (ordenades.length * 0.95)] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Maxima",
                ordenades[ordenades.length - 1] / 1000.0);
        System.out.printf("%-24s %.3f%n", "Jitter mitja", jitterUs / 1000.0);
    }

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

        for (int mida : new int[]{64, 512, 1400}) {
            new SondaUdp(host, port, 1000, mida, 500).mesurar();
            Thread.sleep(500);
        }
    }
}

=== SONDA UDP: localhost:9100 ===
Mida de datagrama        64 bytes
Ritme                    500/s

Enviats                  1000
Rebuts                   1000
Perduts                  0 (0,00%)
Duplicats                0
Desordenats              0

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

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * Xat intern de Nexus Software sobre multidifusio. Sense servidor central:
 * tots son iguals, tots emeten al grup i tots hi reben.
 */
public class ChatBiblioTech implements AutoCloseable {

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

    /** Rang 239.x.x.x: ambit administratiu, us privat. */
    private static final String GRUP = "239.10.10.20";
    private static final int PORT = 9099;
    private static final int MAXIM_DATAGRAMA = 1400;
    private static final int MAXIM_MISSATGE = 500;

    private final String usuari;
    private final long arrencada = System.currentTimeMillis();

    private MulticastSocket socket;
    private InetSocketAddress grup;
    private NetworkInterface interficie;
    private volatile boolean executant = false;

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

    public void arrencar() throws IOException {
        socket = new MulticastSocket(PORT);
        socket.setTimeToLive(1);        // no surt de la xarxa local

        // FILTRAT DE MISSATGES PROPIS - Opcio triada.
        //
        // Hi ha dues formes:
        //   (a) IP_MULTICAST_LOOP = false: el sistema no ens retorna
        //       els nostres propis enviaments. Es neta i no costa res, PERO
        //       tambe impedeix que DUES INSTANCIES A LA MATEIXA MAQUINA es
        //       vegin entre elles, perque el filtre es per maquina, no per socket.
        //   (b) Comparar el remitent amb les adreces locals i filtrar
        //       al codi. Mes feina, pero permet provar amb tres
        //       instancies al mateix ordinador.
        //
        // Triem (b) perque l'enunciat demana poder provar amb tres
        // instancies locals, i a mes es el comportament que es vol
        // en un xat: si obro dues finestres, vull veure les dues.
        socket.setOption(StandardSocketOptions.IP_MULTICAST_LOOP, true);

        grup = new InetSocketAddress(InetAddress.getByName(GRUP), PORT);
        interficie = triarInterficie();

        // API moderna (Java 14+): amb NetworkInterface explicita.
        socket.joinGroup(grup, interficie);
        executant = true;

        LOG.info(() -> "Unit a " + GRUP + ":" + PORT
                + " per " + interficie.getName());
    }

    private NetworkInterface triarInterficie() throws IOException {
        Enumeration<NetworkInterface> nis = NetworkInterface.getNetworkInterfaces();
        NetworkInterface reserva = null;
        while (nis.hasMoreElements()) {
            NetworkInterface ni = nis.nextElement();
            if (!ni.isUp() || !ni.supportsMulticast()) {
                continue;
            }
            if (!ni.isLoopback()) {
                return ni;      // preferim una interficie real
            }
            reserva = ni;       // el bucle invertit serveix per a proves locals
        }
        if (reserva == null) {
            throw new IOException("No hi ha cap interficie amb multidifusio");
        }
        return reserva;
    }

    /** Bucle de recepcio. S'executa al seu propi fil. */
    private void rebre() {
        byte[] buffer = new byte[MAXIM_DATAGRAMA];
        DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

        while (executant) {
            try {
                paquet.setLength(buffer.length);        // error classic 1
                socket.receive(paquet);

                // Filtre (b): descartem el que enviem nosaltres mateixos.
                if (esNostre(paquet.getAddress(), paquet.getPort())) {
                    continue;
                }

                String missatge = new String(paquet.getData(), paquet.getOffset(),
                        paquet.getLength(), StandardCharsets.UTF_8);   // error classic 2

                // TOT el que arriba pel grup ve d'un desconegut.
                if (missatge.length() > MAXIM_MISSATGE) {
                    LOG.warning("Missatge massa llarg descartat");
                    continue;
                }
                System.out.println(sanejar(missatge));

            } catch (IOException e) {
                if (!executant) {
                    return;     // tancament ordenat
                }
                LOG.warning("Error rebent: " + e.getMessage());
            }
        }
    }

    /**
     * Un paquet es nostre si ve d'una adreca local I del nostre
     * port d'origen. Comparar nomes l'adreca no bastaria: filtraria
     * tambe els missatges de les altres instancies de la mateixa maquina.
     */
    private boolean esNostre(InetAddress remitent, int portRemitent) {
        if (portRemitent != socket.getLocalPort()) {
            return false;
        }
        try {
            Enumeration<InetAddress> propies = interficie.getInetAddresses();
            while (propies.hasMoreElements()) {
                if (propies.nextElement().equals(remitent)) {
                    return true;
                }
            }
        } catch (Exception e) {
            // Si no ho podem comprovar, preferim mostrar de mes que de menys.
            return false;
        }
        return false;
    }

    public void enviar(String text) throws IOException {
        long marca = (System.currentTimeMillis() - arrencada) / 1000;
        String missatge = String.format("[%3ds] %-14s %s", marca, usuari, text);

        byte[] dades = missatge.getBytes(StandardCharsets.UTF_8);
        if (dades.length > MAXIM_DATAGRAMA) {
            System.out.println("(missatge massa llarg, no enviat)");
            return;
        }
        socket.send(new DatagramPacket(dades, dades.length,
                InetAddress.getByName(GRUP), PORT));
    }

    /**
     * Saneja abans d'imprimir a consola: un missatge del grup pot
     * contenir sequencies d'escapada ANSI que manipulin el terminal
     * de qui el llegeixi (esborrar la pantalla, moure el cursor, colors).
     */
    private String sanejar(String text) {
        StringBuilder sb = new StringBuilder(text.length());
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            sb.append(Character.isISOControl(c) && c != '\t' ? '?' : c);
        }
        return sb.toString();
    }

    @Override
    public void close() {
        if (!executant) {
            return;
        }
        try {
            enviar("*** ha marxat ***");
        } catch (IOException ignorada) {
            // Marxem igualment.
        }
        executant = false;
        try {
            socket.leaveGroup(grup, interficie);
        } catch (IOException e) {
            LOG.fine("Fallada abandonant el grup: " + e.getMessage());
        }
        socket.close();     // desbloqueja el receive()
    }

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

        ChatBiblioTech xat = new ChatBiblioTech(usuari);
        xat.arrencar();

        Thread receptor = new Thread(xat::rebre, "xat-receptor");
        receptor.setDaemon(true);
        receptor.start();

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

        xat.enviar("*** s'ha unit ***");
        System.out.println("Xat de BiblioTech. Escriu /sortir per acabar.");

        try (BufferedReader teclat = new BufferedReader(
                new InputStreamReader(System.in, StandardCharsets.UTF_8))) {
            String linia;
            while ((linia = teclat.readLine()) != null) {
                if (linia.equals("/sortir")) {
                    break;
                }
                if (!linia.isBlank()) {
                    xat.enviar(linia);
                }
            }
        }
        xat.close();
    }
}

java -cp classes com.nexussoftware.bibliotech.xarxa.ChatBiblioTech "Marta Ruiz"
java -cp classes com.nexussoftware.bibliotech.xarxa.ChatBiblioTech "Diego Alonso"
java -cp classes com.nexussoftware.bibliotech.xarxa.ChatBiblioTech "Nuria Vidal"

Terminal de la Marta:
Xat de BiblioTech. Escriu /sortir per acabar.
[  2s] Diego Alonso   *** s'ha unit ***
[  5s] Nuria Vidal    *** s'ha unit ***
Algu te Java Eficac?
[ 12s] Diego Alonso   El tinc jo, el retorno dema
[ 18s] Nuria Vidal    *** ha marxat ***

package com.nexussoftware.bibliotech.xarxa;

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 fitxer sobre UDP amb parada i espera.
 *
 * Format de cada datagrama de dades:
 *   [int    ] numero de sequencia
 *   [byte   ] 1 si es l'ultim bloc, 0 si no
 *   [int    ] longitud de les dades
 *   [bytes  ] dades
 *
 * Format de la confirmacio:
 *   [int    ] numero de sequencia confirmat
 */
public class EnviamentFiableUdp {

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

    private static final int DADES_PER_BLOC = 1024;
    private static final int CAPCALERA = 4 + 1 + 4;     // int + byte + int
    private static final int MAXIM_INTENTS = 5;
    private static final int ESPERA_INICIAL_MS = 200;

    /** Percentatge de datagrames que es descarten a proposit, per provar. */
    private final int perduaSimulada;

    private int retransmissions = 0;

    public EnviamentFiableUdp(int perduaSimulada) {
        this.perduaSimulada = perduaSimulada;
    }

    public void enviar(String host, int port, Path fitxer) throws IOException {
        long mida = Files.size(fitxer);
        long inici = System.currentTimeMillis();

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

            InetAddress desti = InetAddress.getByName(host);
            // connect() filtra: nomes acceptem confirmacions d'aquest desti.
            socket.connect(desti, port);

            byte[] bloc = new byte[DADES_PER_BLOC];
            byte[] buferAck = new byte[16];
            DatagramPacket ack = new DatagramPacket(buferAck, buferAck.length);

            int sequencia = 0;
            long bytesEnviats = 0;
            long sumaComprovacio = 0;

            while (true) {
                int llegits = entrada.read(bloc);
                boolean ultim = false;

                if (llegits == -1) {
                    // Fi del fitxer: enviem un bloc buit marcat
                    // com a ultim, perque el receptor sapiga que ha acabat.
                    llegits = 0;
                    ultim = true;
                } else {
                    // Mirem si queda alguna cosa mes sense consumir-la:
                    // available() es orientatiu, aixi que marquem
                    // l'ultim amb un bloc buit final. Mes simple i segur.
                    for (int i = 0; i < llegits; i++) {
                        sumaComprovacio += bloc[i] & 0xFF;
                    }
                    bytesEnviats += llegits;
                }

                byte[] datagrama = construir(sequencia, ultim, bloc, llegits);

                if (!enviarAmbConfirmacio(socket, desti, port,
                        datagrama, sequencia, ack, buferAck)) {
                    throw new IOException("El receptor no confirma el bloc "
                            + sequencia + " despres de " + MAXIM_INTENTS + " intents");
                }

                if (ultim) {
                    break;
                }
                sequencia++;
            }

            long ms = System.currentTimeMillis() - inici;
            System.out.println();
            System.out.println("=== TRANSFERENCIA COMPLETADA ===");
            System.out.printf("%-26s %s%n", "Fitxer", fitxer.getFileName());
            System.out.printf("%-26s %d%n", "Bytes", bytesEnviats);
            System.out.printf("%-26s %d%n", "Blocs", sequencia + 1);
            System.out.printf("%-26s %d%n", "Retransmissions", retransmissions);
            System.out.printf("%-26s %d%%%n", "Perdua simulada", perduaSimulada);
            System.out.printf("%-26s %d ms%n", "Temps", ms);
            System.out.printf("%-26s %d%n", "Suma de comprovacio", sumaComprovacio);
            System.out.printf("%-26s %.1f KB/s%n", "Velocitat",
                    ms == 0 ? 0 : bytesEnviats / 1024.0 / (ms / 1000.0));
        }
    }

    /** Construeix el datagrama amb la seva capcalera binaria en big-endian. */
    private byte[] construir(int sequencia, boolean ultim, byte[] dades, int longitud)
            throws IOException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream(CAPCALERA + longitud);
        DataOutputStream sortida = new DataOutputStream(bytes);
        sortida.writeInt(sequencia);
        sortida.writeBoolean(ultim);
        sortida.writeInt(longitud);
        sortida.write(dades, 0, longitud);
        sortida.flush();
        return bytes.toByteArray();
    }

    /** Envia i espera confirmacio, reintentant amb espera creixent. */
    private boolean enviarAmbConfirmacio(DatagramSocket socket, InetAddress desti,
                                         int port, byte[] datagrama, int sequencia,
                                         DatagramPacket ack, byte[] buferAck)
            throws IOException {

        int espera = ESPERA_INICIAL_MS;

        for (int intent = 1; intent <= MAXIM_INTENTS; intent++) {
            if (intent > 1) {
                retransmissions++;
            }

            // --- PERDUA SIMULADA ---
            // Es descarta el datagrama ABANS d'enviar-lo, per provar que
            // el mecanisme de reintent funciona sense necessitar una xarxa dolenta.
            if (ThreadLocalRandom.current().nextInt(100) >= perduaSimulada) {
                socket.send(new DatagramPacket(datagrama, datagrama.length,
                        desti, port));
            } else {
                LOG.fine("Perdua simulada del bloc " + sequencia);
            }

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

            while (System.currentTimeMillis() < limit) {
                try {
                    ack.setLength(buferAck.length);         // error classic 1
                    socket.receive(ack);

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

                    if (confirmat == sequencia) {
                        return true;
                    }
                    // Confirmacio d'un bloc anterior (ha arribat tard):
                    // es descarta i es continua esperant la nostra.
                    LOG.fine("Confirmacio desfasada: " + confirmat
                            + ", esperavem " + sequencia);

                } catch (SocketTimeoutException e) {
                    break;      // termini esgotat: seguent intent
                }
            }
            espera *= 2;        // espera creixent
        }
        return false;
    }

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

package com.nexussoftware.bibliotech.xarxa;

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 RecepcioFiableUdp {

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

    private static final int DADES_PER_BLOC = 1024;
    private static final int CAPCALERA = 4 + 1 + 4;
    private static final int MAXIM_DATAGRAMA = CAPCALERA + DADES_PER_BLOC;

    public void rebre(int port, Path desti) throws IOException {
        Files.createDirectories(desti.getParent() == null
                ? Path.of(".") : desti.getParent());

        try (DatagramSocket socket = new DatagramSocket(port);
             OutputStream sortida = Files.newOutputStream(desti)) {

            System.out.println("Esperant fitxer a UDP:" + port);
            socket.setSoTimeout(30_000);        // abandonem si ningu no envia

            byte[] buffer = new byte[MAXIM_DATAGRAMA + 1];
            DatagramPacket paquet = new DatagramPacket(buffer, buffer.length);

            int esperat = 0;
            int duplicats = 0;
            long bytes = 0;
            long sumaComprovacio = 0;
            long inici = System.currentTimeMillis();

            while (true) {
                paquet.setLength(buffer.length);        // error classic 1
                socket.receive(paquet);

                if (paquet.getLength() < CAPCALERA
                        || paquet.getLength() > MAXIM_DATAGRAMA) {
                    LOG.warning("Datagrama de mida invalida descartat");
                    continue;
                }

                ByteBuffer bb = ByteBuffer.wrap(paquet.getData(),
                        paquet.getOffset(), paquet.getLength());
                int sequencia = bb.getInt();
                boolean ultim = bb.get() != 0;
                int longitud = bb.getInt();

                // VALIDACIO: la longitud ve de la xarxa. Sense aixo,
                // un emissor malicios provoca una excepcio o alguna cosa pitjor.
                if (longitud < 0 || longitud > DADES_PER_BLOC
                        || longitud > bb.remaining()) {
                    LOG.warning("Longitud declarada invalida: " + longitud);
                    continue;
                }

                if (sequencia < esperat) {
                    // DUPLICAT: la nostra confirmacio anterior s'ha perdut i
                    // l'emissor ha reenviat. Cal RECONFIRMAR pero NO escriure
                    // les dades una altra vegada, o el fitxer sortiria corrupte.
                    duplicats++;
                    confirmar(socket, paquet, sequencia);
                    continue;
                }
                if (sequencia > esperat) {
                    // Amb parada i espera aixo no hauria de passar: significa
                    // que hem perdut un bloc intermedi. No confirmem, i
                    // l'emissor reenviara el que falta.
                    LOG.warning("Bloc " + sequencia + " fora d'ordre; "
                            + "esperavem " + esperat);
                    continue;
                }

                // Bloc correcte i en ordre: s'escriu.
                byte[] dades = new byte[longitud];
                bb.get(dades);
                sortida.write(dades);
                for (byte b : dades) {
                    sumaComprovacio += b & 0xFF;
                }
                bytes += longitud;

                confirmar(socket, paquet, sequencia);
                esperat++;

                if (ultim) {
                    sortida.flush();
                    long ms = System.currentTimeMillis() - inici;
                    System.out.println();
                    System.out.println("=== RECEPCIO COMPLETADA ===");
                    System.out.printf("%-26s %s%n", "Desat a", desti);
                    System.out.printf("%-26s %d%n", "Bytes", bytes);
                    System.out.printf("%-26s %d%n", "Blocs", esperat);
                    System.out.printf("%-26s %d%n", "Duplicats detectats", duplicats);
                    System.out.printf("%-26s %d ms%n", "Temps", ms);
                    System.out.printf("%-26s %d%n", "Suma de comprovacio",
                            sumaComprovacio);
                    return;
                }
            }
        }
    }

    private void confirmar(DatagramSocket socket, DatagramPacket original, int sequencia)
            throws IOException {
        byte[] ack = ByteBuffer.allocate(4).putInt(sequencia).array();
        // Es respon AL REMITENT, que ve al paquet original.
        socket.send(new DatagramPacket(ack, ack.length,
                original.getAddress(), original.getPort()));
    }

    public static void main(String[] args) throws IOException {
        new RecepcioFiableUdp().rebre(9101, Path.of("rebuts", "cataleg.csv"));
    }
}

Terminal 1 (receptor):
Esperant fitxer a UDP:9101

=== RECEPCIO COMPLETADA ===
Desat a                    rebuts/cataleg.csv
Bytes                      2847
Blocs                      4
Duplicats detectats        1
Temps                      834 ms
Suma de comprovacio        291476

Terminal 2 (emissor):
=== TRANSFERENCIA COMPLETADA ===
Fitxer                     cataleg.csv
Bytes                      2847
Blocs                      4
Retransmissions            3
Perdua simulada            20%
Temps                      841 ms
Suma de comprovacio        291476

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