// El constructor CONNECTA. Si torna, ja estas connectat.
// Si no pot, llanca excepcio i l'objecte no arriba a existir mai.
Socket socket = new Socket("localhost", 9090);

import java.io.IOException;
import java.net.ConnectException;
import java.net.Socket;
import java.net.UnknownHostException;

try (Socket socket = new Socket("localhost", 9090)) {

    System.out.println("Connectat a   : " + socket.getInetAddress().getHostAddress());
    System.out.println("Port remot    : " + socket.getPort());
    System.out.println("Adreca local  : " + socket.getLocalAddress().getHostAddress());
    System.out.println("Port local    : " + socket.getLocalPort());

} catch (UnknownHostException e) {
    // Fallada al pas 1: el nom no s'ha pogut resoldre.
    System.err.println("No existeix l'equip: " + e.getMessage());
} catch (ConnectException e) {
    // Fallada al pas 3: la maquina ha respost RST. No hi ha ningu escoltant.
    System.err.println("Connexio rebutjada: no hi ha servidor en aquest port");
} catch (IOException e) {
    // Qualsevol altra fallada de xarxa.
    System.err.println("Fallada de xarxa: " + e.getMessage());
}

Connectat a   : 127.0.0.1
Port remot    : 9090
Adreca local  : 127.0.0.1
Port local    : 51422

import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;

// 1. Es crea el socket SENSE connectar (constructor sense arguments).
Socket socket = new Socket();

// 2. Es descriu el desti amb un InetSocketAddress: parell (host, port).
InetSocketAddress desti = new InetSocketAddress("192.168.1.50", 9090);

// 3. Es connecta amb temps limit explicit en milisegons.
try {
    socket.connect(desti, 3000);        // 3 segons com a maxim
} catch (SocketTimeoutException e) {
    // El termini s'ha esgotat: la maquina no ha respost al SYN.
    // Fallada TRANSITORIA: pot tenir sentit reintentar.
    System.err.println("El servidor no respon en 3 s");
}

// Resol el nom ARA. Si no resol, isUnresolved() sera true
// (compte: NO llanca excepcio aqui; la llancara connect()).
InetSocketAddress a = new InetSocketAddress("servidor.nexussoftware.local", 9090);

// No resol res: deixa el nom tal qual perque el resolgui
// qui connecti (util amb proxies SOCKS, que resolen ells).
InetSocketAddress b = InetSocketAddress.createUnresolved("servidor.local", 9090);

// Amb una InetAddress ja resolta, sense consultar DNS.
InetSocketAddress c = new InetSocketAddress(InetAddress.getLoopbackAddress(), 9090);

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress("localhost", 9090), 3000);
    socket.setSoTimeout(10_000);

    // SORTIDA: el teu text -> caracters -> bytes UTF-8 -> xarxa
    //   PrintWriter        dona println() i format
    //   BufferedWriter     acumula per no fer una escriptura de xarxa per caracter
    //   OutputStreamWriter es el PONT caracters -> bytes, amb charset explicit
    PrintWriter escriptor = new PrintWriter(
            new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)),
            true);                      // <-- autoFlush: buida a cada println()

    // ENTRADA: xarxa -> bytes UTF-8 -> caracters -> linies
    BufferedReader lector = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));

    String salutacio = lector.readLine();       // "200 BIBLIOTECH BTCP/1"
    System.out.println("S: " + salutacio);

    escriptor.println("CONSULTA 978-0000000001");
    System.out.println("C: CONSULTA 978-0000000001");

    String resposta = lector.readLine();        // "200 OK 978-...|Java Eficac|LLIBRE|true"
    System.out.println("S: " + resposta);

    escriptor.println("SORTIR");
    System.out.println("S: " + lector.readLine());   // "221 ADEU"
}

// CLIENT TRENCAT - no el copiis, es l'exemple del que NO s'ha de fer.
try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress("localhost", 9090), 3000);

    PrintWriter escriptor = new PrintWriter(
            new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)));
    //          ^^^^^ falta el "true" de l'autoFlush

    BufferedReader lector = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));

    escriptor.println("CONSULTA 978-0000000001");  // Es queda a la MEMORIA INTERMEDIA.

    String resposta = lector.readLine();           // <-- ES BLOQUEJA AQUI PER SEMPRE
    System.out.println(resposta);
}

// FORMA 1 (recomanada per a protocols de linia): autoFlush a PrintWriter.
// El segon argument true fa que println(), printf() i format()
// buidin automaticament. COMPTE: print() SENSE salt de linia NO buida.
PrintWriter escriptor = new PrintWriter(
        new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)),
        true);
escriptor.println("CONSULTA 978-0000000001");   // s'envia sol

// FORMA 2: buidatge explicit. Obligatoria si escrius amb print() sense salt,
// o si el protocol fa servir \r\n i escrius el terminador a ma.
escriptor.print("CONSULTA 978-0000000001\n");
escriptor.flush();                               // <-- imprescindible

// FORMA 3: BufferedWriter directe, que a mes SI que llanca IOException.
BufferedWriter bw = new BufferedWriter(
        new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8));
bw.write("CONSULTA 978-0000000001");
bw.write('\n');
bw.flush();

// El que fa el client:
escriptor.println("CONSULTA 111");
escriptor.println("LLISTA");

// El que pot llegir el servidor amb un read() sobre bytes crus:
//   Cas A: "CONSULTA 111\nLLISTA\n"   (els dos missatges junts)
//   Cas B: "CONSULTA 111\n"           despres "LLISTA\n"   (un i un)
//   Cas C: "CONSU"                    despres "LTA 111\nLLI"  despres "STA\n"

String linia;
while ((linia = lector.readLine()) != null) {
    // Aqui 'linia' es SEMPRE un missatge complet del protocol.
    // readLine() ja ha resolt el trossejat per tu.
    processar(linia);
}
// Sortim del bucle quan readLine() retorna null:
// l'altre extrem ha tancat el seu costat de la connexio.

// Longitud previa: primer quants bytes venen, despres els bytes.
byte[] dades = ressenya.getBytes(StandardCharsets.UTF_8);
sortidaDades.writeInt(dades.length);     // 4 bytes en big-endian
sortidaDades.write(dades);               // les dades, sense restriccions
sortidaDades.flush();

// En llegir:
int longitud = entradaDades.readInt();
if (longitud < 0 || longitud > MAXIM_PERMES) {
    // IMPRESCINDIBLE: si no, un client malicios demana un array de 2 GB
    // i provoca un OutOfMemoryError amb 4 bytes de peticio.
    throw new ProtocolException("Longitud declarada invalida: " + longitud);
}
byte[] dades = entradaDades.readNBytes(longitud);
String ressenya = new String(dades, StandardCharsets.UTF_8);

try (Socket socket = new Socket()) {
    socket.connect(desti, 3000);
    // ... conversa ...
}   // socket.close() garantit, tambe si salta una excepcio

// INNECESSARI i a mes enganyos: dona a entendre que son recursos
// independents quan en realitat els tres son el mateix socket.
try (Socket socket = new Socket();
     PrintWriter escriptor = new PrintWriter(...);
     BufferedReader lector = new BufferedReader(...)) {

// Client que puja un fitxer al servidor i despres espera el resum.
try (Socket socket = new Socket()) {
    socket.connect(desti, 3000);

    // 1. Enviar el contingut complet.
    try (OutputStream sortida = socket.getOutputStream()) {
        // COMPTE: aquest try-with-resources tancaria el socket sencer. Malament.
    }
}

try (Socket socket = new Socket()) {
    socket.connect(desti, 3000);

    // 1. Enviar tot el contingut i BUIDAR.
    OutputStream sortida = socket.getOutputStream();
    Files.copy(Path.of("cataleg.csv"), sortida);
    sortida.flush();

    // 2. Dir "he acabat de parlar" SENSE tancar la connexio.
    //    El servidor veura fi de flux i sabra que pot processar.
    socket.shutdownOutput();

    // 3. Continuar escoltant: el sentit de lectura continua obert.
    BufferedReader lector = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
    String resum;
    while ((resum = lector.readLine()) != null) {
        System.out.println("S: " + resum);
    }
}   // ara si, tancament complet

socket.setSoTimeout(10_000);       // 10 segons per lectura

try {
    String linia = lector.readLine();
    if (linia == null) {
        System.out.println("L'altre extrem ha tancat ordenadament");
    } else {
        processar(linia);
    }
} catch (SocketTimeoutException e) {
    // Han passat 10 s sense arribar ni un sol byte.
    // MOLT IMPORTANT: el socket CONTINUA VALID. Es pot reintentar la lectura.
    System.out.println("Sense dades en 10 s; el socket continua utilitzable");
}

socket.setSoTimeout(1000);          // sondeig cada segon
while (!Thread.currentThread().isInterrupted() && executant) {
    try {
        String linia = lector.readLine();
        if (linia == null) {
            break;                  // l'altre ha tancat
        }
        processar(linia);
    } catch (SocketTimeoutException e) {
        // Un segon sense dades: aprofitem per comprovar
        // el marcador de cancellacio del modul 8 i tornem a esperar.
        continue;
    }
}

Sense TCP_NODELAY, protocol interactiu:

  Client: envia "CONSULTA 111\n"  (13 bytes)  --> surt de seguida (no hi ha res pendent)
  Servidor: rep, processa, respon
  Client: envia "LLISTA\n"        (7 bytes)   --> ESPERA: hi ha un enviament sense confirmar
          ...                                     fins a 200 ms de retard artificial

socket.setTcpNoDelay(true);     // true = SENSE algorisme de Nagle = enviar ja

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.excepcio.BiblioTechException;

import java.io.IOException;
import java.net.ConnectException;
import java.net.NoRouteToHostException;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Tradueix les excepcions de xarxa a excepcions del domini de BiblioTech
 * i decideix si la fallada es transitoria (mereix reintent) o permanent.
 * Aquesta es la FRONTERA D'ERRORS de 06-07 aplicada a la xarxa.
 */
public final class TraductorErrorsXarxa {

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

    private TraductorErrorsXarxa() {
    }

    /** Resultat de classificar una fallada de xarxa. */
    public record Classificacio(String missatgeUsuari, boolean transitori) {
    }

    public static Classificacio classificar(IOException e, String desti) {
        if (e instanceof UnknownHostException) {
            LOG.severe("Nom no resoluble: " + desti);
            return new Classificacio(
                    "No es troba el servidor de cataleg. Revisa la configuracio.", false);
        }
        if (e instanceof ConnectException) {
            // Compte amb l'ordre: ConnectException es subclasse de SocketException,
            // aixi que s'ha de comprovar ABANS.
            LOG.severe("Connexio rebutjada per " + desti + ": el servidor no esta arrencat");
            return new Classificacio(
                    "El servidor de cataleg no esta disponible.", false);
        }
        if (e instanceof SocketTimeoutException) {
            LOG.warning("Temps esgotat amb " + desti);
            return new Classificacio(
                    "El servidor de cataleg triga massa a respondre.", true);
        }
        if (e instanceof NoRouteToHostException) {
            LOG.severe("Sense ruta cap a " + desti);
            return new Classificacio(
                    "No hi ha connexio amb la xarxa del servidor.", false);
        }
        if (e instanceof SocketException) {
            // "Connection reset", "Broken pipe" i similars.
            LOG.warning("Connexio trencada amb " + desti + ": " + e.getMessage());
            return new Classificacio(
                    "S'ha perdut la connexio amb el cataleg.", true);
        }
        LOG.log(Level.SEVERE, "Fallada de xarxa no classificada amb " + desti, e);
        return new Classificacio("Error de comunicacio amb el cataleg.", false);
    }

    /** Converteix la fallada en l'excepcio de domini, conservant la causa. */
    public static BiblioTechException traduir(IOException e, String desti) {
        Classificacio c = classificar(e, desti);
        return new BiblioTechException(c.missatgeUsuari(), e);
    }
}

package com.nexussoftware.bibliotech.xarxa;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * Variant binaria de l'enviament d'una fitxa de material.
 * Es fa servir quan el volum importa mes que la llegibilitat.
 */
public final class ProtocolBinari {

    /** Limit defensiu: cap camp de text legitim no passa d'aixo. */
    private static final int MAXIM_TEXT = 4096;

    private ProtocolBinari() {
    }

    public static void enviarFitxa(Socket socket, String isbn, String titol,
                                   int pagines, boolean disponible) throws IOException {
        // Fem servir memoria intermedia: sense BufferedOutputStream, cada writeInt
        // seria potencialment una operacio de xarxa independent.
        DataOutputStream sortida = new DataOutputStream(
                new BufferedOutputStream(socket.getOutputStream()));

        escriureText(sortida, isbn);        // longitud (int) + bytes UTF-8
        escriureText(sortida, titol);
        sortida.writeInt(pagines);          // 4 bytes, big-endian
        sortida.writeBoolean(disponible);   // 1 byte
        sortida.flush();                    // imprescindible, com sempre
    }

    public static String rebreTitol(Socket socket) throws IOException {
        DataInputStream entrada = new DataInputStream(
                new BufferedInputStream(socket.getInputStream()));

        String isbn = llegirText(entrada);
        String titol = llegirText(entrada);
        int pagines = entrada.readInt();
        boolean disponible = entrada.readBoolean();

        return titol + " (" + isbn + ", " + pagines + " pag., "
                + (disponible ? "disponible" : "prestat") + ")";
    }

    /** Escriu un text amb longitud previa: 4 bytes de mida + bytes UTF-8. */
    private static void escriureText(DataOutputStream sortida, String text)
            throws IOException {
        byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
        sortida.writeInt(bytes.length);
        sortida.write(bytes);
    }

    /** Llegeix un text amb longitud previa, VALIDANT la longitud declarada. */
    private static String llegirText(DataInputStream entrada) throws IOException {
        int longitud = entrada.readInt();

        // Sense aquesta comprovacio, un client malicios envia l'int 2_000_000_000
        // i provoquem un OutOfMemoryError amb una peticio de 4 bytes.
        if (longitud < 0 || longitud > MAXIM_TEXT) {
            throw new IOException("Longitud de text invalida: " + longitud);
        }

        // readNBytes llegeix EXACTAMENT n bytes o llanca EOFException si el
        // flux acaba abans. Un read(byte[]) sol podria llegir-ne menys
        // i deixar-te amb dades incompletes sense assabentar-te'n: error classic.
        byte[] bytes = entrada.readNBytes(longitud);
        if (bytes.length < longitud) {
            throw new java.io.EOFException("Flux acabat a mitja text");
        }
        return new String(bytes, StandardCharsets.UTF_8);
    }
}

// TEMPTADOR I PERILLOS. No facis aixo en un servidor de xarxa.
ObjectOutputStream sortida = new ObjectOutputStream(socket.getOutputStream());
sortida.writeObject(llibre);
sortida.flush();

// I a l'altre costat:
ObjectInputStream entrada = new ObjectInputStream(socket.getInputStream());
Llibre llibre = (Llibre) entrada.readObject();   // <-- AQUI HI HA EL FORAT

ObjectInputStream entrada = new ObjectInputStream(socket.getInputStream());
// Llista blanca estricta: nomes aquestes classes, maxim 1000 objectes,
// maxim 100 KB, profunditat maxima 10. Tota la resta, rebutjat.
entrada.setObjectInputFilter(ObjectInputFilter.Config.createFilter(
        "com.nexussoftware.bibliotech.domini.Llibre;"
        + "java.lang.String;"
        + "maxdepth=10;maxarray=1000;maxbytes=102400;"
        + "!*"));         // el !* final rebutja tot el que no esta llistat

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.excepcio.BiblioTechException;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Client del protocol BTCP/1 de BiblioTech.
 *
 * Parla amb el servidor de cataleg definit a 09-01 i implementat a 09-03.
 * Implementa AutoCloseable: s'acomiada amb SORTIR i tanca el socket.
 *
 * NO es segur per a diversos fils: un socket es una conversa, i dos fils
 * escrivint alhora entrellacarien les seves peticions. Un fil, un client.
 */
public class ClientCataleg implements AutoCloseable {

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

    private static final int LIMIT_CONNEXIO_MS = 3_000;
    private static final int LIMIT_LECTURA_MS = 10_000;
    private static final String VERSIO_ESPERADA = "BTCP/1";
    /** Sostre de linies d'una resposta multiple: defensa contra un servidor hostil. */
    private static final int MAXIM_LINIES = 10_000;

    private final String host;
    private final int port;

    private Socket socket;
    private BufferedReader lector;
    private PrintWriter escriptor;

    public ClientCataleg(String host, int port) {
        this.host = host;
        this.port = port;
    }

    /** Fitxa d'un material tal com la retorna el protocol. */
    public record FitxaXarxa(String isbn, String titol, String tipus, boolean disponible) {

        /** Converteix una linia "isbn|titol|tipus|disponible" en una fitxa. */
        static FitxaXarxa desdeLinia(String linia) throws BiblioTechException {
            // -1 a split conserva els camps buits del final;
            // sense ell, "111|Titol|LLIBRE|" donaria 3 camps en lloc de 4.
            String[] camps = linia.split("\\|", -1);
            if (camps.length != 4) {
                throw new BiblioTechException(
                        "Resposta del servidor amb format invalid: " + linia);
            }
            return new FitxaXarxa(camps[0], camps[1], camps[2],
                    Boolean.parseBoolean(camps[3]));
        }
    }

    // ---------------------------------------------------------------
    // Connexio
    // ---------------------------------------------------------------

    /** Connecta i verifica la salutacio del servidor. */
    public void connectar() throws BiblioTechException {
        try {
            socket = new Socket();

            // Protocol interactiu de missatges curts: sense Nagle.
            socket.setTcpNoDelay(true);

            // Temps limit de CONNEXIO: mai el constructor que connecta.
            socket.connect(new InetSocketAddress(host, port), LIMIT_CONNEXIO_MS);

            // Temps limit de LECTURA: diferent de l'anterior, i igual d'obligatori.
            socket.setSoTimeout(LIMIT_LECTURA_MS);

            // La pila de fluxos del modul 7, amb charset EXPLICIT en tots dos sentits.
            escriptor = new PrintWriter(
                    new BufferedWriter(
                            new OutputStreamWriter(socket.getOutputStream(),
                                    StandardCharsets.UTF_8)),
                    true);      // autoFlush: cada println() s'envia
            lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(),
                            StandardCharsets.UTF_8));

            // El servidor parla primer: comprovem que es qui diem
            // i que parla la nostra versio abans d'enviar res.
            String salutacio = lector.readLine();
            if (salutacio == null) {
                throw new BiblioTechException(
                        "El servidor ha tancat la connexio sense saludar");
            }
            if (!salutacio.startsWith("200 ") || !salutacio.contains(VERSIO_ESPERADA)) {
                throw new BiblioTechException(
                        "Salutacio inesperada del servidor: '" + salutacio + "'");
            }
            LOG.info(() -> "Connectat al cataleg " + host + ":" + port
                    + " (" + salutacio + ")");

        } catch (IOException e) {
            tancarSocketSilenciosament();
            throw TraductorErrorsXarxa.traduir(e, host + ":" + port);
        }
    }

    // ---------------------------------------------------------------
    // Operacions del protocol
    // ---------------------------------------------------------------

    /** CONSULTA <isbn>. Retorna null si el material no existeix (404). */
    public FitxaXarxa consultar(String isbn) throws BiblioTechException {
        validarArgument(isbn, "l'ISBN");
        String resposta = intercanviar("CONSULTA " + isbn);

        if (resposta.startsWith("200 OK ")) {
            return FitxaXarxa.desdeLinia(resposta.substring("200 OK ".length()));
        }
        if (resposta.startsWith("404 ")) {
            return null;        // "no trobat" es un resultat, no un error
        }
        throw errorDeProtocol(resposta);
    }

    /** LLISTA. Retorna totes les fitxes del cataleg. */
    public List<FitxaXarxa> llistar() throws BiblioTechException {
        String capcalera = intercanviar("LLISTA");

        if (!capcalera.startsWith("201 LLISTA ")) {
            throw errorDeProtocol(capcalera);
        }

        int anunciades = enterDe(capcalera.substring("201 LLISTA ".length()).strip(), capcalera);
        if (anunciades < 0 || anunciades > MAXIM_LINIES) {
            throw new BiblioTechException(
                    "El servidor anuncia un nombre de linies fora de rang: " + anunciades);
        }

        List<FitxaXarxa> fitxes = new ArrayList<>(anunciades);
        try {
            String linia;
            while ((linia = lector.readLine()) != null) {
                if (linia.equals(".")) {
                    break;      // fi de la resposta multiple
                }
                if (fitxes.size() >= MAXIM_LINIES) {
                    throw new BiblioTechException(
                            "El servidor envia mes linies de les permeses");
                }
                fitxes.add(FitxaXarxa.desdeLinia(linia));
            }
            if (linia == null) {
                throw new BiblioTechException(
                        "El servidor ha tancat la connexio a mitja llista");
            }
        } catch (SocketTimeoutException e) {
            throw new BiblioTechException(
                    "El servidor ha deixat de respondre a mitja llista", e);
        } catch (IOException e) {
            throw TraductorErrorsXarxa.traduir(e, host + ":" + port);
        }

        // El nombre anunciat es redundant a proposit: si no quadra,
        // hi ha un problema i es millor saber-ho que ignorar-ho.
        if (fitxes.size() != anunciades) {
            LOG.warning("El servidor va anunciar " + anunciades + " linies i n'ha enviat "
                    + fitxes.size());
        }
        return fitxes;
    }

    /** PRESTAR <isbn> <empleat>. Retorna true si s'ha registrat el prestec. */
    public boolean prestar(String isbn, String empleat) throws BiblioTechException {
        validarArgument(isbn, "l'ISBN");
        validarArgument(empleat, "l'empleat");

        String resposta = intercanviar("PRESTAR " + isbn + " " + empleat);

        if (resposta.startsWith("200 ")) {
            return true;
        }
        if (resposta.startsWith("409 ") || resposta.startsWith("404 ")) {
            LOG.info(() -> "Prestec rebutjat: " + resposta);
            return false;
        }
        throw errorDeProtocol(resposta);
    }

    // ---------------------------------------------------------------
    // Nucli: enviar una linia i llegir una resposta
    // ---------------------------------------------------------------

    private String intercanviar(String peticio) throws BiblioTechException {
        if (socket == null || socket.isClosed()) {
            throw new BiblioTechException("El client no esta connectat");
        }
        try {
            // El protocol especifica \n, no el separador de la plataforma:
            // per aixo l'escrivim a ma en lloc de fer servir println(String).
            escriptor.print(peticio + "\n");
            escriptor.flush();      // OBLIGATORI: print() no dispara autoFlush

            // PrintWriter s'empassa les IOException; checkError() es l'unica
            // forma d'assabentar-se que l'escriptura ha fallat.
            if (escriptor.checkError()) {
                throw new BiblioTechException(
                        "Fallada en enviar la peticio al servidor de cataleg");
            }

            String resposta = lector.readLine();
            if (resposta == null) {
                throw new BiblioTechException(
                        "El servidor ha tancat la connexio sense respondre a: " + peticio);
            }
            LOG.fine(() -> "C: " + peticio + "  ->  S: " + resposta);
            return resposta;

        } catch (SocketTimeoutException e) {
            throw new BiblioTechException(
                    "El servidor no ha respost en " + LIMIT_LECTURA_MS + " ms", e);
        } catch (IOException e) {
            throw TraductorErrorsXarxa.traduir(e, host + ":" + port);
        }
    }

    // ---------------------------------------------------------------
    // Validacio i utilitats
    // ---------------------------------------------------------------

    /**
     * Un argument amb salt de linia trenca el protocol: injectaria
     * una peticio addicional. Validar la SORTIDA es tan important com
     * validar l'entrada.
     */
    private void validarArgument(String valor, String nom) throws BiblioTechException {
        if (valor == null || valor.isBlank()) {
            throw new BiblioTechException("Falta " + nom);
        }
        if (valor.indexOf('\n') >= 0 || valor.indexOf('\r') >= 0) {
            throw new BiblioTechException(
                    "Valor invalid per a " + nom + ": conte salts de linia");
        }
    }

    private int enterDe(String text, String context) throws BiblioTechException {
        try {
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            throw new BiblioTechException(
                    "Numero invalid a la resposta del servidor: '" + context + "'", e);
        }
    }

    private BiblioTechException errorDeProtocol(String resposta) {
        return new BiblioTechException(
                "Resposta inesperada del servidor de cataleg: " + resposta);
    }

    private void tancarSocketSilenciosament() {
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException ignorada) {
                // Tancant ja no hi ha res a salvar.
            }
        }
    }

    // ---------------------------------------------------------------
    // Tancament
    // ---------------------------------------------------------------

    @Override
    public void close() {
        if (socket == null || socket.isClosed()) {
            return;
        }
        try {
            // Comiat cortes: el servidor pot distingir un tancament
            // ordenat d'una caiguda i alliberar recursos amb tranquillitat.
            escriptor.print("SORTIR\n");
            escriptor.flush();

            // Li donem poc marge: si no contesta, tanquem igualment.
            socket.setSoTimeout(1_000);
            String adeu = lector.readLine();
            LOG.fine(() -> "Comiat del servidor: " + adeu);

        } catch (IOException e) {
            // En tancar, una fallada no canvia res: es registra i es continua.
            LOG.log(Level.FINE, "Fallada durant el comiat", e);
        } finally {
            tancarSocketSilenciosament();
            LOG.info(() -> "Connexio amb " + host + ":" + port + " tancada");
        }
    }
}

package com.nexussoftware.bibliotech.presentacio;

import com.nexussoftware.bibliotech.excepcio.BiblioTechException;
import com.nexussoftware.bibliotech.xarxa.ClientCataleg;
import com.nexussoftware.bibliotech.xarxa.ClientCataleg.FitxaXarxa;

import java.util.List;

/** Prova manual del client BTCP/1 contra un servidor. */
public class ProvaClientCataleg {

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

        // ClientCataleg es AutoCloseable: try-with-resources com sempre.
        try (ClientCataleg client = new ClientCataleg(host, port)) {
            client.connectar();

            System.out.println("--- CONSULTA d'un ISBN existent ---");
            FitxaXarxa fitxa = client.consultar("978-0000000001");
            if (fitxa == null) {
                System.out.println("No trobat");
            } else {
                System.out.printf("%s - %s [%s] %s%n",
                        fitxa.isbn(), fitxa.titol(), fitxa.tipus(),
                        fitxa.disponible() ? "disponible" : "prestat");
            }

            System.out.println();
            System.out.println("--- CONSULTA d'un ISBN inexistent ---");
            System.out.println(client.consultar("000-0000000000") == null
                    ? "No trobat (correcte)" : "Inesperat");

            System.out.println();
            System.out.println("--- LLISTA ---");
            List<FitxaXarxa> cataleg = client.llistar();
            for (FitxaXarxa f : cataleg) {
                System.out.println("  " + f.isbn() + "  " + f.titol());
            }
            System.out.println("Total: " + cataleg.size());

            System.out.println();
            System.out.println("--- PRESTAR ---");
            boolean ok = client.prestar("978-0000000002", "Diego_Alonso");
            System.out.println(ok ? "Prestec registrat" : "Prestec rebutjat");

        } catch (BiblioTechException e) {
            // Frontera d'errors: aqui ja no hi ha sockets, nomes domini.
            System.err.println("ERROR: " + e.getMessage());
            if (e.getCause() != null) {
                System.err.println("Causa tecnica: " + e.getCause());
            }
        }
    }
}

nc -l 9090

javac -d classes $(find src -name "*.java")
java -cp classes com.nexussoftware.bibliotech.presentacio.ProvaClientCataleg

TERMINAL 1 (tu, fent de servidor amb nc -l 9090)
-----------------------------------------------------
200 BIBLIOTECH BTCP/1                                   <-- TECLEGES TU (i Enter)
CONSULTA 978-0000000001                                     (l'envia el client)
200 OK 978-0000000001|Java Eficac|LLIBRE|true            <-- TECLEGES TU
CONSULTA 000-0000000000
404 NO TROBAT 000-0000000000                            <-- TECLEGES TU
LLISTA
201 LLISTA 3                                            <-- TECLEGES TU
978-0000000001|Java Eficac|LLIBRE|true                  <-- TECLEGES TU
978-0000000002|Patrons de Disseny|LLIBRE|false          <-- TECLEGES TU
978-0000000003|Refactoritzacio|LLIBRE|true              <-- TECLEGES TU
.                                                       <-- TECLEGES TU
PRESTAR 978-0000000002 Diego_Alonso
409 NO DISPONIBLE 978-0000000002                        <-- TECLEGES TU
SORTIR
221 ADEU                                                <-- TECLEGES TU

TERMINAL 2 (el client Java)
-----------------------------------------------------
--- CONSULTA d'un ISBN existent ---
978-0000000001 - Java Eficac [LLIBRE] disponible

--- CONSULTA d'un ISBN inexistent ---
No trobat (correcte)

--- LLISTA ---
  978-0000000001  Java Eficac
  978-0000000002  Patrons de Disseny
  978-0000000003  Refactoritzacio
Total: 3

--- PRESTAR ---
Prestec rebutjat

package com.nexussoftware.bibliotech.xarxa;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;

/**
 * Client d'eco que mesura la latencia d'anada i tornada.
 * Serveix per comparar l'efecte de setTcpNoDelay i per mesurar la xarxa.
 */
public class ClientEco {

    private final String host;
    private final int port;
    private final boolean senseNagle;

    public ClientEco(String host, int port, boolean senseNagle) {
        this.host = host;
        this.port = port;
        this.senseNagle = senseNagle;
    }

    /** Resultat d'una tanda de mesures. */
    public record Mesura(int enviades, int discrepancies,
                         double minMs, double mitjanaMs, double maxMs) {
    }

    public Mesura mesurar(int repeticions) throws IOException {
        try (Socket socket = new Socket()) {

            // Opcions ABANS de fer servir el socket.
            socket.setTcpNoDelay(senseNagle);
            socket.connect(new InetSocketAddress(host, port), 2_000);
            socket.setSoTimeout(5_000);

            PrintWriter escriptor = new PrintWriter(
                    new BufferedWriter(
                            new OutputStreamWriter(socket.getOutputStream(),
                                    StandardCharsets.UTF_8)),
                    true);
            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(),
                            StandardCharsets.UTF_8));

            double min = Double.MAX_VALUE;
            double max = 0;
            double suma = 0;
            int discrepancies = 0;
            int completades = 0;

            for (int i = 1; i <= repeticions; i++) {
                String missatge = "PING-" + i + "-BiblioTech";

                long t0 = System.nanoTime();
                escriptor.println(missatge);        // autoFlush: s'envia ja
                String eco = lector.readLine();     // esperem el retorn
                long t1 = System.nanoTime();

                if (eco == null) {
                    System.out.println("El servidor ha tancat rere " + completades + " ecos");
                    break;
                }

                double ms = (t1 - t0) / 1_000_000.0;
                min = Math.min(min, ms);
                max = Math.max(max, ms);
                suma += ms;
                completades++;

                // L'eco ha de ser identic: si no, hi ha un problema de
                // charset, de delimitador o de desincronitzacio del protocol.
                if (!missatge.equals(eco)) {
                    discrepancies++;
                    System.out.println("  DISCREPANCIA: he enviat '" + missatge
                            + "' i he rebut '" + eco + "'");
                }
                System.out.printf("  %2d) %.2f ms%n", i, ms);
            }

            if (completades == 0) {
                return new Mesura(0, 0, 0, 0, 0);
            }
            return new Mesura(completades, discrepancies, min, suma / completades, max);
        }
    }

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

        for (boolean senseNagle : new boolean[]{true, false}) {
            System.out.println("=== setTcpNoDelay(" + senseNagle + ") ===");
            try {
                Mesura m = new ClientEco(host, port, senseNagle).mesurar(10);
                System.out.printf(
                        "  Ecos: %d   Discrepancies: %d%n"
                        + "  min %.2f ms   mitjana %.2f ms   max %.2f ms%n%n",
                        m.enviades(), m.discrepancies(), m.minMs(), m.mitjanaMs(), m.maxMs());

            } catch (ConnectException e) {
                // No hi ha ningu escoltant: no te sentit reintentar.
                System.err.println("  No hi ha servidor d'eco a " + host + ":" + port);
                System.err.println("  Arrenca'l amb:  while true; do nc -l "
                        + port + " -c cat; done");
                return;

            } catch (SocketTimeoutException e) {
                // Transitori: la maquina no respon a temps.
                System.err.println("  Temps esgotat parlant amb " + host);

            } catch (IOException e) {
                System.err.println("  Fallada de xarxa: " + e);
            }
        }
    }
}

=== setTcpNoDelay(true) ===
   1) 1,84 ms
   2) 0,21 ms
   ...
  Ecos: 10   Discrepancies: 0
  min 0,14 ms   mitjana 0,31 ms   max 1,84 ms

package com.nexussoftware.bibliotech.xarxa;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * Detector de serveis: comprova quins ports d'un rang tenen alguna cosa escoltant.
 *
 * AVIS LEGAL I ETIC: escanejar ports de maquines alienes sense autoritzacio
 * escrita es, a molts paisos, un delicte d'acces no autoritzat a sistemes
 * informatics, i a practicament tots es motiu de bloqueig per part del
 * proveidor. Aquesta eina esta pensada UNICAMENT per a localhost i per a
 * maquines propies de Nexus Software amb autoritzacio del departament de
 * sistemes. Un escaneig genera transit i alertes en qualsevol IDS modern.
 */
public class DetectorServeis {

    /** Estat d'un port. Un enum com els de 04-07. */
    public enum Estat {
        OBERT("hi ha un servei escoltant"),
        TANCAT("la maquina respon RST: no hi ha ningu en aquest port"),
        FILTRAT("sense resposta: tallafoc que descarta, o maquina caiguda");

        private final String descripcio;

        Estat(String descripcio) {
            this.descripcio = descripcio;
        }

        public String descripcio() {
            return descripcio;
        }
    }

    private static final Map<Integer, String> SERVEIS = new HashMap<>();

    static {
        SERVEIS.put(21, "FTP");
        SERVEIS.put(22, "SSH");
        SERVEIS.put(25, "SMTP");
        SERVEIS.put(53, "DNS");
        SERVEIS.put(80, "HTTP");
        SERVEIS.put(443, "HTTPS");
        SERVEIS.put(3306, "MySQL");
        SERVEIS.put(5432, "PostgreSQL");
        SERVEIS.put(6379, "Redis");
        SERVEIS.put(8080, "HTTP alternatiu");
        SERVEIS.put(9090, "BiblioTech BTCP/1");
        SERVEIS.put(9091, "BiblioTech descobriment");
    }

    public void escanejar(String host, int inici, int fi, int limitMs) {
        System.out.printf("Escanejant %s ports %d-%d (limit %d ms)%n%n",
                host, inici, fi, limitMs);
        System.out.printf("%-8s %-10s %-24s %s%n", "PORT", "ESTAT", "SERVEI", "SALUTACIO");
        System.out.println("-".repeat(90));

        int oberts = 0, tancats = 0, filtrats = 0;

        for (int port = inici; port <= fi; port++) {
            Estat estat = provar(host, port, limitMs);

            switch (estat) {
                case OBERT -> oberts++;
                case TANCAT -> tancats++;
                case FILTRAT -> filtrats++;
            }

            // Nomes mostrem els interessants: una taula amb 65535 TANCAT
            // no ajuda ningu.
            if (estat == Estat.OBERT) {
                String salutacio = llegirSalutacio(host, port, 500);
                System.out.printf("%-8d %-10s %-24s %s%n",
                        port, estat,
                        SERVEIS.getOrDefault(port, "(desconegut)"),
                        salutacio == null ? "(no saluda)" : salutacio);
            } else if (estat == Estat.FILTRAT) {
                System.out.printf("%-8d %-10s %-24s %s%n",
                        port, estat,
                        SERVEIS.getOrDefault(port, "(desconegut)"), "");
            }
        }

        System.out.println("-".repeat(90));
        System.out.printf("Oberts: %d   Tancats: %d   Filtrats: %d%n",
                oberts, tancats, filtrats);
        for (Estat e : Estat.values()) {
            System.out.printf("  %-10s %s%n", e, e.descripcio());
        }
    }

    /** Intenta connectar i classifica el resultat pel TIPUS d'excepcio. */
    private Estat provar(String host, int port, int limitMs) {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, port), limitMs);
            return Estat.OBERT;

        } catch (SocketTimeoutException e) {
            // Ningu no ha respost al SYN: normalment un tallafoc amb politica DROP.
            return Estat.FILTRAT;

        } catch (ConnectException e) {
            // La maquina ha respost RST: es viva, pero aquell port no te servei.
            // ES INFORMACIO VALUOSA: distingeix "maquina caiguda" de "port tancat".
            return Estat.TANCAT;

        } catch (IOException e) {
            // NoRouteToHost i similars.
            return Estat.FILTRAT;
        }
    }

    /**
     * Molts protocols saluden en connectar (SMTP, FTP, SSH, BTCP/1).
     * Un temps esgotat aqui NO es una fallada: significa que el servei
     * espera que parlis tu primer (com HTTP).
     */
    private String llegirSalutacio(String host, int port, int limitMs) {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, port), limitMs);
            socket.setSoTimeout(limitMs);

            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
            String linia = lector.readLine();

            if (linia == null) {
                return null;
            }
            // Retallem: una salutacio enorme no cap a la taula, i a mes
            // no volem bolcar dades arbitraries de la xarxa a la consola.
            return linia.length() > 45 ? linia.substring(0, 45) + "..." : linia;

        } catch (IOException e) {
            return null;
        }
    }

    public static void main(String[] args) {
        DetectorServeis detector = new DetectorServeis();
        // NOMES localhost per defecte: escanejar una altra maquina requereix autoritzacio.
        detector.escanejar("localhost", 9080, 9100, 300);
    }
}

Escanejant localhost ports 9080-9100 (limit 300 ms)

PORT     ESTAT      SERVEI                   SALUTACIO
------------------------------------------------------------------------------------------
9090     OBERT      BiblioTech BTCP/1        (no saluda)
------------------------------------------------------------------------------------------
Oberts: 1   Tancats: 20   Filtrats: 0

package com.nexussoftware.bibliotech.xarxa;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.logging.Logger;

/**
 * Emissor d'un fitxer del cataleg per TCP.
 *
 * Protocol (binari, amb longitud previa):
 *   [int  ] longitud del nom en bytes UTF-8
 *   [bytes] nom
 *   [long ] mida del contingut en bytes
 *   [bytes] contingut
 *   -- shutdownOutput --
 *   [linia] resum del receptor, en text UTF-8
 */
public class EmissorFitxer {

    private static final Logger LOG = Logger.getLogger(EmissorFitxer.class.getName());
    private static final int BLOC = 8192;

    public void enviar(String host, int port, Path fitxer) throws IOException {
        if (!Files.isRegularFile(fitxer)) {
            throw new IOException("No es un fitxer: " + fitxer);
        }
        long mida = Files.size(fitxer);

        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, port), 3_000);
            socket.setSoTimeout(30_000);

            DataOutputStream sortida = new DataOutputStream(
                    new BufferedOutputStream(socket.getOutputStream()));

            // --- Capcalera: nom amb longitud previa ---
            // Enviem NOMES el nom del fitxer, mai el cami complet:
            // el receptor decideix on desar.
            byte[] nom = fitxer.getFileName().toString()
                    .getBytes(StandardCharsets.UTF_8);
            sortida.writeInt(nom.length);
            sortida.write(nom);
            sortida.writeLong(mida);

            // --- Contingut en blocs ---
            long enviats = 0;
            try (InputStream entradaFitxer =
                         new BufferedInputStream(Files.newInputStream(fitxer))) {
                byte[] bufer = new byte[BLOC];
                int llegits;
                while ((llegits = entradaFitxer.read(bufer)) != -1) {
                    // read pot retornar MENYS de BLOC: cal escriure
                    // exactament 'llegits' bytes, mai bufer.length.
                    sortida.write(bufer, 0, llegits);
                    enviats += llegits;
                }
            }
            sortida.flush();    // el buidatge de sempre, abans de tancar el sentit

            LOG.info(() -> "Enviats " + mida + " bytes de " + fitxer.getFileName());

            // --- shutdownOutput: IMPRESCINDIBLE ---
            // El receptor llegeix fins a esgotar el flux. Sense aquest tancament de mig
            // sentit, el receptor continuaria esperant mes bytes indefinidament
            // i nosaltres esperariem el seu resum: interbloqueig perfecte.
            // No podem fer servir socket.close() perque encara hem de LLEGIR.
            socket.shutdownOutput();

            // --- Resum del receptor (el sentit de lectura continua obert) ---
            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
            String resum = lector.readLine();
            System.out.println("Receptor: " + (resum == null ? "(sense resposta)" : resum));

            if (enviats != mida) {
                LOG.warning("El fitxer ha canviat de mida durant l'enviament");
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Path fitxer = Path.of(args.length > 0 ? args[0] : "cataleg.csv");
        new EmissorFitxer().enviar("localhost", 9091, fitxer);
    }
}

package com.nexussoftware.bibliotech.xarxa;

import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Receptor del fitxer. Servidor minim d'una sola connexio:
 * la versio concurrent i completa s'escriu a 09-03.
 */
public class ReceptorFitxer {

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

    private static final int MAXIM_NOM = 255;
    private static final long MAXIMA_MIDA = 10L * 1024 * 1024;     // 10 MB
    private static final Path DESTI = Path.of("rebuts");

    public void escoltar(int port) throws IOException {
        Files.createDirectories(DESTI);

        try (ServerSocket servidor = new ServerSocket(port)) {
            LOG.info(() -> "Receptor escoltant al port " + port);

            // accept() bloqueja fins que arriba una connexio i retorna
            // un Socket JA connectat. Tot el detall, a 09-03.
            try (Socket socket = servidor.accept()) {
                socket.setSoTimeout(30_000);
                LOG.info(() -> "Connexio de " + socket.getRemoteSocketAddress());
                atendre(socket);
            }
        }
    }

    private void atendre(Socket socket) throws IOException {
        DataInputStream entrada = new DataInputStream(socket.getInputStream());

        String resum;
        try {
            // --- Nom, amb longitud previa VALIDADA ---
            int longitudNom = entrada.readInt();
            if (longitudNom <= 0 || longitudNom > MAXIM_NOM) {
                throw new IOException("Longitud de nom invalida: " + longitudNom);
            }
            byte[] bytesNom = entrada.readNBytes(longitudNom);
            if (bytesNom.length < longitudNom) {
                throw new EOFException("Flux tallat llegint el nom");
            }
            String nom = new String(bytesNom, StandardCharsets.UTF_8);

            // --- Sanejament del nom: RECORREGUT DE CAMINS ---
            // Sense aixo, un emissor malicios envia "../../etc/cron.d/porta"
            // i escrivim on ell vulgui. Es una vulnerabilitat classica.
            if (nom.contains("/") || nom.contains("\\")
                    || nom.contains("..") || nom.isBlank()) {
                throw new IOException("Nom de fitxer no permes: " + nom);
            }

            // --- Mida, tambe validada ---
            long mida = entrada.readLong();
            if (mida < 0 || mida > MAXIMA_MIDA) {
                throw new IOException("Mida fora de rang: " + mida);
            }

            // --- Contingut ---
            Path desti = DESTI.resolve(nom).normalize();
            // Cinturo i tirants: comprovem que el resultat continua dins
            // del directori previst, per si alguna cosa se'ns ha escapat abans.
            if (!desti.startsWith(DESTI)) {
                throw new IOException("Cami resultant fora del directori: " + desti);
            }

            long rebuts = 0;
            try (OutputStream sortidaFitxer =
                         new BufferedOutputStream(Files.newOutputStream(desti))) {
                byte[] bufer = new byte[8192];
                int llegits;
                // Llegim fins a fi de flux: es el shutdownOutput() de l'emissor
                // el que provoca aquest -1. Sense ell, aquest bucle no acabaria.
                while ((llegits = entrada.read(bufer)) != -1) {
                    if (rebuts + llegits > mida) {
                        throw new IOException(
                                "L'emissor envia mes bytes dels anunciats");
                    }
                    sortidaFitxer.write(bufer, 0, llegits);
                    rebuts += llegits;
                }
            }

            if (rebuts != mida) {
                throw new EOFException("S'han anunciat " + mida
                        + " bytes i n'han arribat " + rebuts);
            }

            long totalRebuts = rebuts;
            LOG.info(() -> "Desat " + desti + " (" + totalRebuts + " bytes)");
            resum = "200 OK " + nom + " " + rebuts + " bytes";

        } catch (IOException e) {
            LOG.log(Level.WARNING, "Transferencia rebutjada", e);
            resum = "400 REBUTJAT " + e.getMessage();
        }

        // --- Resposta de text, amb charset explicit ---
        BufferedWriter escriptor = new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8));
        escriptor.write(resum);
        escriptor.write('\n');
        escriptor.flush();      // sense aixo, l'emissor esperaria per sempre
    }

    public static void main(String[] args) throws IOException {
        new ReceptorFitxer().escoltar(9091);
    }
}

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

# Terminal 2
java -cp classes com.nexussoftware.bibliotech.xarxa.EmissorFitxer cataleg.csv

Terminal 1:
INFO: Receptor escoltant al port 9091
INFO: Connexio de /127.0.0.1:52104
INFO: Desat rebuts/cataleg.csv (2847 bytes)

Terminal 2:
INFO: Enviats 2847 bytes de cataleg.csv
Receptor: 200 OK cataleg.csv 2847 bytes