// El constructor CONECTA. Si vuelve, ya estas conectado.
// Si no puede, lanza excepcion y el objeto nunca llega a existir.
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("Conectado a       : " + socket.getInetAddress().getHostAddress());
    System.out.println("Puerto remoto     : " + socket.getPort());
    System.out.println("Direccion local   : " + socket.getLocalAddress().getHostAddress());
    System.out.println("Puerto local      : " + socket.getLocalPort());

} catch (UnknownHostException e) {
    // Fallo en el paso 1: el nombre no se pudo resolver.
    System.err.println("No existe el equipo: " + e.getMessage());
} catch (ConnectException e) {
    // Fallo en el paso 3: la maquina respondio RST. No hay nadie escuchando.
    System.err.println("Conexion rechazada: no hay servidor en ese puerto");
} catch (IOException e) {
    // Cualquier otro fallo de red.
    System.err.println("Fallo de red: " + e.getMessage());
}

Conectado a       : 127.0.0.1
Puerto remoto     : 9090
Direccion local   : 127.0.0.1
Puerto local      : 51422

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

// 1. Se crea el socket SIN conectar (constructor sin argumentos).
Socket socket = new Socket();

// 2. Se describe el destino con un InetSocketAddress: par (host, puerto).
InetSocketAddress destino = new InetSocketAddress("192.168.1.50", 9090);

// 3. Se conecta con tiempo limite explicito en milisegundos.
try {
    socket.connect(destino, 3000);      // 3 segundos como maximo
} catch (SocketTimeoutException e) {
    // El plazo se agoto: la maquina no ha respondido al SYN.
    // Fallo TRANSITORIO: puede tener sentido reintentar.
    System.err.println("El servidor no responde en 3 s");
}

// Resuelve el nombre AHORA. Si no resuelve, isUnresolved() sera true
// (ojo: NO lanza excepcion aqui; la lanzara connect()).
InetSocketAddress a = new InetSocketAddress("servidor.nexussoftware.local", 9090);

// No resuelve nada: deja el nombre tal cual para que lo resuelva
// quien conecte (util con proxies SOCKS, que resuelven ellos).
InetSocketAddress b = InetSocketAddress.createUnresolved("servidor.local", 9090);

// Con una InetAddress ya resuelta, sin 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);

    // SALIDA: tu texto -> caracteres -> bytes UTF-8 -> red
    //   PrintWriter        da println() y formato
    //   BufferedWriter     acumula para no hacer una escritura de red por caracter
    //   OutputStreamWriter es el PUENTE caracteres -> bytes, con charset explicito
    PrintWriter escritor = new PrintWriter(
            new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)),
            true);                      // <-- autoFlush: vacia en cada println()

    // ENTRADA: red -> bytes UTF-8 -> caracteres -> lineas
    BufferedReader lector = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));

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

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

    String respuesta = lector.readLine();       // "200 OK 978-...|Java Efectivo|LIBRO|true"
    System.out.println("S: " + respuesta);

    escritor.println("SALIR");
    System.out.println("S: " + lector.readLine());   // "221 ADIOS"
}

// CLIENTE ROTO - no lo copies, es el ejemplo de lo que NO hay que hacer.
try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress("localhost", 9090), 3000);

    PrintWriter escritor = new PrintWriter(
            new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)));
    //          ^^^^^ falta el "true" del autoFlush

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

    escritor.println("CONSULTA 978-0000000001");   // Se queda en el BUFFER.

    String respuesta = lector.readLine();          // <-- SE BLOQUEA AQUI PARA SIEMPRE
    System.out.println(respuesta);
}

// FORMA 1 (recomendada para protocolos de linea): autoFlush en PrintWriter.
// El segundo argumento true hace que println(), printf() y format()
// vacien automaticamente. OJO: print() SIN salto de linea NO vacia.
PrintWriter escritor = new PrintWriter(
        new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8)),
        true);
escritor.println("CONSULTA 978-0000000001");    // se envia solo

// FORMA 2: vaciado explicito. Obligatoria si escribes con print() sin salto,
// o si el protocolo usa \r\n y escribes el terminador a mano.
escritor.print("CONSULTA 978-0000000001\n");
escritor.flush();                                // <-- imprescindible

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

// Lo que hace el cliente:
escritor.println("CONSULTA 111");
escritor.println("LISTA");

// Lo que puede leer el servidor con un read() sobre bytes crudos:
//   Caso A: "CONSULTA 111\nLISTA\n"    (los dos mensajes juntos)
//   Caso B: "CONSULTA 111\n"           luego "LISTA\n"    (uno y uno)
//   Caso C: "CONSU"                    luego "LTA 111\nLIS"   luego "TA\n"

String linea;
while ((linea = lector.readLine()) != null) {
    // Aqui 'linea' es SIEMPRE un mensaje completo del protocolo.
    // readLine() ya ha resuelto el troceado por ti.
    procesar(linea);
}
// Salimos del bucle cuando readLine() devuelve null:
// el otro extremo ha cerrado su lado de la conexion.

// Longitud previa: primero cuantos bytes vienen, luego los bytes.
byte[] datos = resena.getBytes(StandardCharsets.UTF_8);
salidaDatos.writeInt(datos.length);      // 4 bytes en big-endian
salidaDatos.write(datos);                // los datos, sin restricciones
salidaDatos.flush();

// Al leer:
int longitud = entradaDatos.readInt();
if (longitud < 0 || longitud > MAXIMO_PERMITIDO) {
    // IMPRESCINDIBLE: si no, un cliente malicioso pide un array de 2 GB
    // y provoca un OutOfMemoryError con 4 bytes de peticion.
    throw new ProtocoloException("Longitud declarada invalida: " + longitud);
}
byte[] datos = entradaDatos.readNBytes(longitud);
String resena = new String(datos, StandardCharsets.UTF_8);

try (Socket socket = new Socket()) {
    socket.connect(destino, 3000);
    // ... conversacion ...
}   // socket.close() garantizado, tambien si salta una excepcion

// INNECESARIO y ademas engañoso: da a entender que son recursos
// independientes cuando en realidad los tres son el mismo socket.
try (Socket socket = new Socket();
     PrintWriter escritor = new PrintWriter(...);
     BufferedReader lector = new BufferedReader(...)) {

// Cliente que sube un fichero al servidor y luego espera el resumen.
try (Socket socket = new Socket()) {
    socket.connect(destino, 3000);

    // 1. Enviar el contenido completo.
    try (OutputStream salida = socket.getOutputStream()) {
        // OJO: este try-with-resources cerraria el socket entero. Mal.
    }
}

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

    // 1. Enviar todo el contenido y VACIAR.
    OutputStream salida = socket.getOutputStream();
    Files.copy(Path.of("catalogo.csv"), salida);
    salida.flush();

    // 2. Decir "he terminado de hablar" SIN cerrar la conexion.
    //    El servidor vera fin de flujo y sabra que puede procesar.
    socket.shutdownOutput();

    // 3. Seguir escuchando: el sentido de lectura sigue abierto.
    BufferedReader lector = new BufferedReader(
            new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
    String resumen;
    while ((resumen = lector.readLine()) != null) {
        System.out.println("S: " + resumen);
    }
}   // ahora si, cierre completo

socket.setSoTimeout(10_000);       // 10 segundos por lectura

try {
    String linea = lector.readLine();
    if (linea == null) {
        System.out.println("El otro extremo ha cerrado ordenadamente");
    } else {
        procesar(linea);
    }
} catch (SocketTimeoutException e) {
    // Han pasado 10 s sin llegar un solo byte.
    // MUY IMPORTANTE: el socket SIGUE VALIDO. Se puede reintentar la lectura.
    System.out.println("Sin datos en 10 s; el socket sigue utilizable");
}

socket.setSoTimeout(1000);          // sondeo cada segundo
while (!Thread.currentThread().isInterrupted() && ejecutando) {
    try {
        String linea = lector.readLine();
        if (linea == null) {
            break;                  // el otro cerro
        }
        procesar(linea);
    } catch (SocketTimeoutException e) {
        // Un segundo sin datos: aprovechamos para comprobar
        // la bandera de cancelacion del modulo 8 y volvemos a esperar.
        continue;
    }
}

Sin TCP_NODELAY, protocolo interactivo:

  Cliente: envia "CONSULTA 111\n"  (13 bytes)  --> sale enseguida (no hay nada pendiente)
  Servidor: recibe, procesa, responde
  Cliente: envia "LISTA\n"         (6 bytes)   --> ESPERA: hay un envio sin confirmar
           ...                                     hasta 200 ms de retardo artificial

socket.setTcpNoDelay(true);     // true = SIN algoritmo de Nagle = enviar ya

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.excepcion.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;

/**
 * Traduce las excepciones de red a excepciones del dominio de BiblioTech
 * y decide si el fallo es transitorio (merece reintento) o permanente.
 * Esta es la FRONTERA DE ERRORES de 06-07 aplicada a la red.
 */
public final class TraductorErroresRed {

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

    private TraductorErroresRed() {
    }

    /** Resultado de clasificar un fallo de red. */
    public record Clasificacion(String mensajeUsuario, boolean transitorio) {
    }

    public static Clasificacion clasificar(IOException e, String destino) {
        if (e instanceof UnknownHostException) {
            LOG.severe("Nombre no resoluble: " + destino);
            return new Clasificacion(
                    "No se encuentra el servidor de catalogo. Revisa la configuracion.", false);
        }
        if (e instanceof ConnectException) {
            // Ojo al orden: ConnectException es subclase de SocketException,
            // asi que debe comprobarse ANTES.
            LOG.severe("Conexion rechazada por " + destino + ": el servidor no esta arrancado");
            return new Clasificacion(
                    "El servidor de catalogo no esta disponible.", false);
        }
        if (e instanceof SocketTimeoutException) {
            LOG.warning("Tiempo agotado con " + destino);
            return new Clasificacion(
                    "El servidor de catalogo tarda demasiado en responder.", true);
        }
        if (e instanceof NoRouteToHostException) {
            LOG.severe("Sin ruta hacia " + destino);
            return new Clasificacion(
                    "No hay conexion con la red del servidor.", false);
        }
        if (e instanceof SocketException) {
            // "Connection reset", "Broken pipe" y similares.
            LOG.warning("Conexion rota con " + destino + ": " + e.getMessage());
            return new Clasificacion(
                    "Se ha perdido la conexion con el catalogo.", true);
        }
        LOG.log(Level.SEVERE, "Fallo de red no clasificado con " + destino, e);
        return new Clasificacion("Error de comunicacion con el catalogo.", false);
    }

    /** Convierte el fallo en la excepcion de dominio, conservando la causa. */
    public static BiblioTechException traducir(IOException e, String destino) {
        Clasificacion c = clasificar(e, destino);
        return new BiblioTechException(c.mensajeUsuario(), e);
    }
}

package com.nexussoftware.bibliotech.red;

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;

/**
 * Variante binaria del envio de una ficha de material.
 * Se usa cuando el volumen importa mas que la legibilidad.
 */
public final class ProtocoloBinario {

    /** Limite defensivo: ningun campo de texto legitimo pasa de esto. */
    private static final int MAXIMO_TEXTO = 4096;

    private ProtocoloBinario() {
    }

    public static void enviarFicha(Socket socket, String isbn, String titulo,
                                   int paginas, boolean disponible) throws IOException {
        // Bufferizamos: sin BufferedOutputStream, cada writeInt seria
        // potencialmente una operacion de red independiente.
        DataOutputStream salida = new DataOutputStream(
                new BufferedOutputStream(socket.getOutputStream()));

        escribirTexto(salida, isbn);        // longitud (int) + bytes UTF-8
        escribirTexto(salida, titulo);
        salida.writeInt(paginas);           // 4 bytes, big-endian
        salida.writeBoolean(disponible);    // 1 byte
        salida.flush();                     // imprescindible, como siempre
    }

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

        String isbn = leerTexto(entrada);
        String titulo = leerTexto(entrada);
        int paginas = entrada.readInt();
        boolean disponible = entrada.readBoolean();

        return titulo + " (" + isbn + ", " + paginas + " pag., "
                + (disponible ? "disponible" : "prestado") + ")";
    }

    /** Escribe un texto con longitud previa: 4 bytes de tamano + bytes UTF-8. */
    private static void escribirTexto(DataOutputStream salida, String texto)
            throws IOException {
        byte[] bytes = texto.getBytes(StandardCharsets.UTF_8);
        salida.writeInt(bytes.length);
        salida.write(bytes);
    }

    /** Lee un texto con longitud previa, VALIDANDO la longitud declarada. */
    private static String leerTexto(DataInputStream entrada) throws IOException {
        int longitud = entrada.readInt();

        // Sin esta comprobacion, un cliente malicioso envia el int 2_000_000_000
        // y provocamos un OutOfMemoryError con una peticion de 4 bytes.
        if (longitud < 0 || longitud > MAXIMO_TEXTO) {
            throw new IOException("Longitud de texto invalida: " + longitud);
        }

        // readNBytes lee EXACTAMENTE n bytes o lanza EOFException si el
        // flujo termina antes. Un read(byte[]) suelto podria leer menos
        // y dejarte con datos incompletos sin enterarte: error clasico.
        byte[] bytes = entrada.readNBytes(longitud);
        if (bytes.length < longitud) {
            throw new java.io.EOFException("Flujo terminado a mitad de un texto");
        }
        return new String(bytes, StandardCharsets.UTF_8);
    }
}

// TENTADOR Y PELIGROSO. No hagas esto en un servidor de red.
ObjectOutputStream salida = new ObjectOutputStream(socket.getOutputStream());
salida.writeObject(libro);
salida.flush();

// Y al otro lado:
ObjectInputStream entrada = new ObjectInputStream(socket.getInputStream());
Libro libro = (Libro) entrada.readObject();      // <-- AQUI ESTA EL AGUJERO

ObjectInputStream entrada = new ObjectInputStream(socket.getInputStream());
// Lista blanca estricta: solo estas clases, maximo 1000 objetos,
// maximo 100 KB, profundidad maxima 10. Todo lo demas, rechazado.
entrada.setObjectInputFilter(ObjectInputFilter.Config.createFilter(
        "com.nexussoftware.bibliotech.dominio.Libro;"
        + "java.lang.String;"
        + "maxdepth=10;maxarray=1000;maxbytes=102400;"
        + "!*"));         // el !* final rechaza todo lo no listado

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.excepcion.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;

/**
 * Cliente del protocolo BTCP/1 de BiblioTech.
 *
 * Habla con el servidor de catalogo definido en 09-01 e implementado en 09-03.
 * Implementa AutoCloseable: se despide con SALIR y cierra el socket.
 *
 * NO es seguro para varios hilos: un socket es una conversacion, y dos hilos
 * escribiendo a la vez entrelazarian sus peticiones. Un hilo, un cliente.
 */
public class ClienteCatalogo implements AutoCloseable {

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

    private static final int LIMITE_CONEXION_MS = 3_000;
    private static final int LIMITE_LECTURA_MS = 10_000;
    private static final String VERSION_ESPERADA = "BTCP/1";
    /** Tope de lineas de una respuesta multiple: defensa contra un servidor hostil. */
    private static final int MAXIMO_LINEAS = 10_000;

    private final String host;
    private final int puerto;

    private Socket socket;
    private BufferedReader lector;
    private PrintWriter escritor;

    public ClienteCatalogo(String host, int puerto) {
        this.host = host;
        this.puerto = puerto;
    }

    /** Ficha de un material tal como la devuelve el protocolo. */
    public record FichaRed(String isbn, String titulo, String tipo, boolean disponible) {

        /** Convierte una linea "isbn|titulo|tipo|disponible" en una ficha. */
        static FichaRed desdeLinea(String linea) throws BiblioTechException {
            // -1 en split conserva los campos vacios del final;
            // sin el, "111|Titulo|LIBRO|" daria 3 campos en vez de 4.
            String[] campos = linea.split("\\|", -1);
            if (campos.length != 4) {
                throw new BiblioTechException(
                        "Respuesta del servidor con formato invalido: " + linea);
            }
            return new FichaRed(campos[0], campos[1], campos[2],
                    Boolean.parseBoolean(campos[3]));
        }
    }

    // ---------------------------------------------------------------
    // Conexion
    // ---------------------------------------------------------------

    /** Conecta y verifica el saludo del servidor. */
    public void conectar() throws BiblioTechException {
        try {
            socket = new Socket();

            // Protocolo interactivo de mensajes cortos: sin Nagle.
            socket.setTcpNoDelay(true);

            // Tiempo limite de CONEXION: nunca el constructor que conecta.
            socket.connect(new InetSocketAddress(host, puerto), LIMITE_CONEXION_MS);

            // Tiempo limite de LECTURA: distinto del anterior, e igual de obligatorio.
            socket.setSoTimeout(LIMITE_LECTURA_MS);

            // La pila de flujos del modulo 7, con charset EXPLICITO en los dos sentidos.
            escritor = new PrintWriter(
                    new BufferedWriter(
                            new OutputStreamWriter(socket.getOutputStream(),
                                    StandardCharsets.UTF_8)),
                    true);      // autoFlush: cada println() se envia
            lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(),
                            StandardCharsets.UTF_8));

            // El servidor habla primero: comprobamos que es quien decimos
            // y que habla nuestra version antes de enviar nada.
            String saludo = lector.readLine();
            if (saludo == null) {
                throw new BiblioTechException(
                        "El servidor cerro la conexion sin saludar");
            }
            if (!saludo.startsWith("200 ") || !saludo.contains(VERSION_ESPERADA)) {
                throw new BiblioTechException(
                        "Saludo inesperado del servidor: '" + saludo + "'");
            }
            LOG.info(() -> "Conectado al catalogo " + host + ":" + puerto
                    + " (" + saludo + ")");

        } catch (IOException e) {
            cerrarSocketSilenciosamente();
            throw TraductorErroresRed.traducir(e, host + ":" + puerto);
        }
    }

    // ---------------------------------------------------------------
    // Operaciones del protocolo
    // ---------------------------------------------------------------

    /** CONSULTA <isbn>. Devuelve null si el material no existe (404). */
    public FichaRed consultar(String isbn) throws BiblioTechException {
        validarArgumento(isbn, "el ISBN");
        String respuesta = intercambiar("CONSULTA " + isbn);

        if (respuesta.startsWith("200 OK ")) {
            return FichaRed.desdeLinea(respuesta.substring("200 OK ".length()));
        }
        if (respuesta.startsWith("404 ")) {
            return null;        // "no encontrado" es un resultado, no un error
        }
        throw errorDeProtocolo(respuesta);
    }

    /** LISTA. Devuelve todas las fichas del catalogo. */
    public List<FichaRed> listar() throws BiblioTechException {
        String cabecera = intercambiar("LISTA");

        if (!cabecera.startsWith("201 LISTA ")) {
            throw errorDeProtocolo(cabecera);
        }

        int anunciadas = enteroDe(cabecera.substring("201 LISTA ".length()).strip(), cabecera);
        if (anunciadas < 0 || anunciadas > MAXIMO_LINEAS) {
            throw new BiblioTechException(
                    "El servidor anuncia un numero de lineas fuera de rango: " + anunciadas);
        }

        List<FichaRed> fichas = new ArrayList<>(anunciadas);
        try {
            String linea;
            while ((linea = lector.readLine()) != null) {
                if (linea.equals(".")) {
                    break;      // fin de la respuesta multiple
                }
                if (fichas.size() >= MAXIMO_LINEAS) {
                    throw new BiblioTechException(
                            "El servidor envia mas lineas de las permitidas");
                }
                fichas.add(FichaRed.desdeLinea(linea));
            }
            if (linea == null) {
                throw new BiblioTechException(
                        "El servidor cerro la conexion a mitad de la lista");
            }
        } catch (SocketTimeoutException e) {
            throw new BiblioTechException(
                    "El servidor dejo de responder a mitad de la lista", e);
        } catch (IOException e) {
            throw TraductorErroresRed.traducir(e, host + ":" + puerto);
        }

        // El numero anunciado es redundante a proposito: si no cuadra,
        // hay un problema y es mejor saberlo que ignorarlo.
        if (fichas.size() != anunciadas) {
            LOG.warning("El servidor anuncio " + anunciadas + " lineas y envio "
                    + fichas.size());
        }
        return fichas;
    }

    /** PRESTAR <isbn> <empleado>. Devuelve true si se registro el prestamo. */
    public boolean prestar(String isbn, String empleado) throws BiblioTechException {
        validarArgumento(isbn, "el ISBN");
        validarArgumento(empleado, "el empleado");

        String respuesta = intercambiar("PRESTAR " + isbn + " " + empleado);

        if (respuesta.startsWith("200 ")) {
            return true;
        }
        if (respuesta.startsWith("409 ") || respuesta.startsWith("404 ")) {
            LOG.info(() -> "Prestamo rechazado: " + respuesta);
            return false;
        }
        throw errorDeProtocolo(respuesta);
    }

    // ---------------------------------------------------------------
    // Nucleo: enviar una linea y leer una respuesta
    // ---------------------------------------------------------------

    private String intercambiar(String peticion) throws BiblioTechException {
        if (socket == null || socket.isClosed()) {
            throw new BiblioTechException("El cliente no esta conectado");
        }
        try {
            // El protocolo especifica \n, no el separador de la plataforma:
            // por eso lo escribimos a mano en lugar de usar println(String).
            escritor.print(peticion + "\n");
            escritor.flush();       // OBLIGATORIO: print() no dispara autoFlush

            // PrintWriter se traga las IOException; checkError() es la unica
            // forma de enterarse de que la escritura fallo.
            if (escritor.checkError()) {
                throw new BiblioTechException(
                        "Fallo al enviar la peticion al servidor de catalogo");
            }

            String respuesta = lector.readLine();
            if (respuesta == null) {
                throw new BiblioTechException(
                        "El servidor cerro la conexion sin responder a: " + peticion);
            }
            LOG.fine(() -> "C: " + peticion + "  ->  S: " + respuesta);
            return respuesta;

        } catch (SocketTimeoutException e) {
            throw new BiblioTechException(
                    "El servidor no respondio en " + LIMITE_LECTURA_MS + " ms", e);
        } catch (IOException e) {
            throw TraductorErroresRed.traducir(e, host + ":" + puerto);
        }
    }

    // ---------------------------------------------------------------
    // Validacion y utilidades
    // ---------------------------------------------------------------

    /**
     * Un argumento con salto de linea rompe el protocolo: inyectaria
     * una peticion adicional. Validar la SALIDA es tan importante como
     * validar la entrada.
     */
    private void validarArgumento(String valor, String nombre) throws BiblioTechException {
        if (valor == null || valor.isBlank()) {
            throw new BiblioTechException("Falta " + nombre);
        }
        if (valor.indexOf('\n') >= 0 || valor.indexOf('\r') >= 0) {
            throw new BiblioTechException(
                    "Valor invalido para " + nombre + ": contiene saltos de linea");
        }
    }

    private int enteroDe(String texto, String contexto) throws BiblioTechException {
        try {
            return Integer.parseInt(texto);
        } catch (NumberFormatException e) {
            throw new BiblioTechException(
                    "Numero invalido en la respuesta del servidor: '" + contexto + "'", e);
        }
    }

    private BiblioTechException errorDeProtocolo(String respuesta) {
        return new BiblioTechException(
                "Respuesta inesperada del servidor de catalogo: " + respuesta);
    }

    private void cerrarSocketSilenciosamente() {
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException ignorada) {
                // Cerrando ya no hay nada que salvar.
            }
        }
    }

    // ---------------------------------------------------------------
    // Cierre
    // ---------------------------------------------------------------

    @Override
    public void close() {
        if (socket == null || socket.isClosed()) {
            return;
        }
        try {
            // Despedida cortes: el servidor puede distinguir un cierre
            // ordenado de una caida y liberar recursos con tranquilidad.
            escritor.print("SALIR\n");
            escritor.flush();

            // Le damos poco margen: si no contesta, cerramos igual.
            socket.setSoTimeout(1_000);
            String adios = lector.readLine();
            LOG.fine(() -> "Despedida del servidor: " + adios);

        } catch (IOException e) {
            // Al cerrar, un fallo no cambia nada: se registra y se sigue.
            LOG.log(Level.FINE, "Fallo durante la despedida", e);
        } finally {
            cerrarSocketSilenciosamente();
            LOG.info(() -> "Conexion con " + host + ":" + puerto + " cerrada");
        }
    }
}

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.excepcion.BiblioTechException;
import com.nexussoftware.bibliotech.red.ClienteCatalogo;
import com.nexussoftware.bibliotech.red.ClienteCatalogo.FichaRed;

import java.util.List;

/** Prueba manual del cliente BTCP/1 contra un servidor. */
public class PruebaClienteCatalogo {

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

        // ClienteCatalogo es AutoCloseable: try-with-resources como siempre.
        try (ClienteCatalogo cliente = new ClienteCatalogo(host, puerto)) {
            cliente.conectar();

            System.out.println("--- CONSULTA de un ISBN existente ---");
            FichaRed ficha = cliente.consultar("978-0000000001");
            if (ficha == null) {
                System.out.println("No encontrado");
            } else {
                System.out.printf("%s - %s [%s] %s%n",
                        ficha.isbn(), ficha.titulo(), ficha.tipo(),
                        ficha.disponible() ? "disponible" : "prestado");
            }

            System.out.println();
            System.out.println("--- CONSULTA de un ISBN inexistente ---");
            System.out.println(cliente.consultar("000-0000000000") == null
                    ? "No encontrado (correcto)" : "Inesperado");

            System.out.println();
            System.out.println("--- LISTA ---");
            List<FichaRed> catalogo = cliente.listar();
            for (FichaRed f : catalogo) {
                System.out.println("  " + f.isbn() + "  " + f.titulo());
            }
            System.out.println("Total: " + catalogo.size());

            System.out.println();
            System.out.println("--- PRESTAR ---");
            boolean ok = cliente.prestar("978-0000000002", "Diego_Alonso");
            System.out.println(ok ? "Prestamo registrado" : "Prestamo rechazado");

        } catch (BiblioTechException e) {
            // Frontera de errores: aqui ya no hay sockets, solo dominio.
            System.err.println("ERROR: " + e.getMessage());
            if (e.getCause() != null) {
                System.err.println("Causa tecnica: " + e.getCause());
            }
        }
    }
}

nc -l 9090

javac -d clases $(find src -name "*.java")
java -cp clases com.nexussoftware.bibliotech.presentacion.PruebaClienteCatalogo

TERMINAL 1 (tu, haciendo de servidor con nc -l 9090)
-----------------------------------------------------
200 BIBLIOTECH BTCP/1                                   <-- TECLEAS TU (y Enter)
CONSULTA 978-0000000001                                     (lo envia el cliente)
200 OK 978-0000000001|Java Efectivo|LIBRO|true          <-- TECLEAS TU
CONSULTA 000-0000000000
404 NO ENCONTRADO 000-0000000000                        <-- TECLEAS TU
LISTA
201 LISTA 3                                             <-- TECLEAS TU
978-0000000001|Java Efectivo|LIBRO|true                 <-- TECLEAS TU
978-0000000002|Patrones de Diseno|LIBRO|false           <-- TECLEAS TU
978-0000000003|Refactorizacion|LIBRO|true               <-- TECLEAS TU
.                                                       <-- TECLEAS TU
PRESTAR 978-0000000002 Diego_Alonso
409 NO DISPONIBLE 978-0000000002                        <-- TECLEAS TU
SALIR
221 ADIOS                                               <-- TECLEAS TU

TERMINAL 2 (el cliente Java)
-----------------------------------------------------
--- CONSULTA de un ISBN existente ---
978-0000000001 - Java Efectivo [LIBRO] disponible

--- CONSULTA de un ISBN inexistente ---
No encontrado (correcto)

--- LISTA ---
  978-0000000001  Java Efectivo
  978-0000000002  Patrones de Diseno
  978-0000000003  Refactorizacion
Total: 3

--- PRESTAR ---
Prestamo rechazado

package com.nexussoftware.bibliotech.red;

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;

/**
 * Cliente de eco que mide la latencia de ida y vuelta.
 * Sirve para comparar el efecto de setTcpNoDelay y para medir la red.
 */
public class ClienteEco {

    private final String host;
    private final int puerto;
    private final boolean sinNagle;

    public ClienteEco(String host, int puerto, boolean sinNagle) {
        this.host = host;
        this.puerto = puerto;
        this.sinNagle = sinNagle;
    }

    /** Resultado de una tanda de medidas. */
    public record Medicion(int enviadas, int discrepancias,
                           double minMs, double mediaMs, double maxMs) {
    }

    public Medicion medir(int repeticiones) throws IOException {
        try (Socket socket = new Socket()) {

            // Opciones ANTES de usar el socket.
            socket.setTcpNoDelay(sinNagle);
            socket.connect(new InetSocketAddress(host, puerto), 2_000);
            socket.setSoTimeout(5_000);

            PrintWriter escritor = 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 discrepancias = 0;
            int completadas = 0;

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

                long t0 = System.nanoTime();
                escritor.println(mensaje);          // autoFlush: se envia ya
                String eco = lector.readLine();     // esperamos el retorno
                long t1 = System.nanoTime();

                if (eco == null) {
                    System.out.println("El servidor cerro tras " + completadas + " ecos");
                    break;
                }

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

                // El eco debe ser identico: si no, hay un problema de
                // charset, de delimitador o de desincronizacion del protocolo.
                if (!mensaje.equals(eco)) {
                    discrepancias++;
                    System.out.println("  DISCREPANCIA: envie '" + mensaje
                            + "' y recibi '" + eco + "'");
                }
                System.out.printf("  %2d) %.2f ms%n", i, ms);
            }

            if (completadas == 0) {
                return new Medicion(0, 0, 0, 0, 0);
            }
            return new Medicion(completadas, discrepancias, min, suma / completadas, max);
        }
    }

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

        for (boolean sinNagle : new boolean[]{true, false}) {
            System.out.println("=== setTcpNoDelay(" + sinNagle + ") ===");
            try {
                Medicion m = new ClienteEco(host, puerto, sinNagle).medir(10);
                System.out.printf(
                        "  Ecos: %d   Discrepancias: %d%n"
                        + "  min %.2f ms   media %.2f ms   max %.2f ms%n%n",
                        m.enviadas(), m.discrepancias(), m.minMs(), m.mediaMs(), m.maxMs());

            } catch (ConnectException e) {
                // No hay nadie escuchando: no tiene sentido reintentar.
                System.err.println("  No hay servidor de eco en " + host + ":" + puerto);
                System.err.println("  Arrancalo con:  while true; do nc -l "
                        + puerto + " -c cat; done");
                return;

            } catch (SocketTimeoutException e) {
                // Transitorio: la maquina no responde a tiempo.
                System.err.println("  Tiempo agotado hablando con " + host);

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

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

package com.nexussoftware.bibliotech.red;

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 servicios: comprueba que puertos de un rango tienen algo escuchando.
 *
 * AVISO LEGAL Y ETICO: escanear puertos de maquinas ajenas sin autorizacion
 * escrita es, en muchos paises, un delito de acceso no autorizado a sistemas
 * informaticos, y en practicamente todos es motivo de bloqueo por parte del
 * proveedor. Esta herramienta esta pensada UNICAMENTE para localhost y para
 * maquinas propias de Nexus Software con autorizacion del departamento de
 * sistemas. Un escaneo genera trafico y alertas en cualquier IDS moderno.
 */
public class DetectorServicios {

    /** Estado de un puerto. Un enum como los de 04-07. */
    public enum Estado {
        ABIERTO("hay un servicio escuchando"),
        CERRADO("la maquina responde RST: no hay nadie en ese puerto"),
        FILTRADO("sin respuesta: cortafuegos que descarta, o maquina caida");

        private final String descripcion;

        Estado(String descripcion) {
            this.descripcion = descripcion;
        }

        public String descripcion() {
            return descripcion;
        }
    }

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

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

    public void escanear(String host, int desde, int hasta, int limiteMs) {
        System.out.printf("Escaneando %s puertos %d-%d (limite %d ms)%n%n",
                host, desde, hasta, limiteMs);
        System.out.printf("%-8s %-10s %-24s %s%n", "PUERTO", "ESTADO", "SERVICIO", "SALUDO");
        System.out.println("-".repeat(90));

        int abiertos = 0, cerrados = 0, filtrados = 0;

        for (int puerto = desde; puerto <= hasta; puerto++) {
            Estado estado = probar(host, puerto, limiteMs);

            switch (estado) {
                case ABIERTO -> abiertos++;
                case CERRADO -> cerrados++;
                case FILTRADO -> filtrados++;
            }

            // Solo mostramos los interesantes: una tabla con 65535 CERRADO
            // no ayuda a nadie.
            if (estado == Estado.ABIERTO) {
                String saludo = leerSaludo(host, puerto, 500);
                System.out.printf("%-8d %-10s %-24s %s%n",
                        puerto, estado,
                        SERVICIOS.getOrDefault(puerto, "(desconocido)"),
                        saludo == null ? "(no saluda)" : saludo);
            } else if (estado == Estado.FILTRADO) {
                System.out.printf("%-8d %-10s %-24s %s%n",
                        puerto, estado,
                        SERVICIOS.getOrDefault(puerto, "(desconocido)"), "");
            }
        }

        System.out.println("-".repeat(90));
        System.out.printf("Abiertos: %d   Cerrados: %d   Filtrados: %d%n",
                abiertos, cerrados, filtrados);
        for (Estado e : Estado.values()) {
            System.out.printf("  %-10s %s%n", e, e.descripcion());
        }
    }

    /** Intenta conectar y clasifica el resultado por el TIPO de excepcion. */
    private Estado probar(String host, int puerto, int limiteMs) {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, puerto), limiteMs);
            return Estado.ABIERTO;

        } catch (SocketTimeoutException e) {
            // Nadie respondio al SYN: normalmente un cortafuegos con politica DROP.
            return Estado.FILTRADO;

        } catch (ConnectException e) {
            // La maquina respondio RST: esta viva, pero ese puerto no tiene servicio.
            // ES INFORMACION VALIOSA: distingue "maquina caida" de "puerto cerrado".
            return Estado.CERRADO;

        } catch (IOException e) {
            // NoRouteToHost y similares.
            return Estado.FILTRADO;
        }
    }

    /**
     * Muchos protocolos saludan al conectar (SMTP, FTP, SSH, BTCP/1).
     * Un tiempo agotado aqui NO es un fallo: significa que el servicio
     * espera que hables tu primero (como HTTP).
     */
    private String leerSaludo(String host, int puerto, int limiteMs) {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, puerto), limiteMs);
            socket.setSoTimeout(limiteMs);

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

            if (linea == null) {
                return null;
            }
            // Recortamos: un saludo enorme no cabe en la tabla, y ademas
            // no queremos volcar datos arbitrarios de la red en la consola.
            return linea.length() > 45 ? linea.substring(0, 45) + "..." : linea;

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

    public static void main(String[] args) {
        DetectorServicios detector = new DetectorServicios();
        // SOLO localhost por defecto: escanear otra maquina requiere autorizacion.
        detector.escanear("localhost", 9080, 9100, 300);
    }
}

Escaneando localhost puertos 9080-9100 (limite 300 ms)

PUERTO   ESTADO     SERVICIO                 SALUDO
------------------------------------------------------------------------------------------
9090     ABIERTO    BiblioTech BTCP/1        (no saluda)
------------------------------------------------------------------------------------------
Abiertos: 1   Cerrados: 20   Filtrados: 0

package com.nexussoftware.bibliotech.red;

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;

/**
 * Emisor de un fichero del catalogo por TCP.
 *
 * Protocolo (binario, con longitud previa):
 *   [int  ] longitud del nombre en bytes UTF-8
 *   [bytes] nombre
 *   [long ] tamano del contenido en bytes
 *   [bytes] contenido
 *   -- shutdownOutput --
 *   [linea] resumen del receptor, en texto UTF-8
 */
public class EmisorFichero {

    private static final Logger LOG = Logger.getLogger(EmisorFichero.class.getName());
    private static final int BLOQUE = 8192;

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

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

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

            // --- Cabecera: nombre con longitud previa ---
            // Enviamos SOLO el nombre del fichero, nunca la ruta completa:
            // el receptor decide donde guardar.
            byte[] nombre = fichero.getFileName().toString()
                    .getBytes(StandardCharsets.UTF_8);
            salida.writeInt(nombre.length);
            salida.write(nombre);
            salida.writeLong(tamano);

            // --- Contenido en bloques ---
            long enviados = 0;
            try (InputStream entradaFichero =
                         new BufferedInputStream(Files.newInputStream(fichero))) {
                byte[] bufer = new byte[BLOQUE];
                int leidos;
                while ((leidos = entradaFichero.read(bufer)) != -1) {
                    // read puede devolver MENOS de BLOQUE: hay que escribir
                    // exactamente 'leidos' bytes, nunca bufer.length.
                    salida.write(bufer, 0, leidos);
                    enviados += leidos;
                }
            }
            salida.flush();     // el flush de siempre, antes de cerrar el sentido

            LOG.info(() -> "Enviados " + tamano + " bytes de " + fichero.getFileName());

            // --- shutdownOutput: IMPRESCINDIBLE ---
            // El receptor lee hasta agotar el flujo. Sin este cierre de medio
            // sentido, el receptor seguiria esperando mas bytes indefinidamente
            // y nosotros esperariamos su resumen: interbloqueo perfecto.
            // No podemos usar socket.close() porque aun tenemos que LEER.
            socket.shutdownOutput();

            // --- Resumen del receptor (el sentido de lectura sigue abierto) ---
            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
            String resumen = lector.readLine();
            System.out.println("Receptor: " + (resumen == null ? "(sin respuesta)" : resumen));

            if (enviados != tamano) {
                LOG.warning("El fichero cambio de tamano durante el envio");
            }
        }
    }

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

package com.nexussoftware.bibliotech.red;

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 fichero. Servidor minimo de una sola conexion:
 * la version concurrente y completa se escribe en 09-03.
 */
public class ReceptorFichero {

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

    private static final int MAXIMO_NOMBRE = 255;
    private static final long MAXIMO_TAMANO = 10L * 1024 * 1024;   // 10 MB
    private static final Path DESTINO = Path.of("recibidos");

    public void escuchar(int puerto) throws IOException {
        Files.createDirectories(DESTINO);

        try (ServerSocket servidor = new ServerSocket(puerto)) {
            LOG.info(() -> "Receptor escuchando en el puerto " + puerto);

            // accept() bloquea hasta que llega una conexion y devuelve
            // un Socket YA conectado. Todo el detalle, en 09-03.
            try (Socket socket = servidor.accept()) {
                socket.setSoTimeout(30_000);
                LOG.info(() -> "Conexion de " + socket.getRemoteSocketAddress());
                atender(socket);
            }
        }
    }

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

        String resumen;
        try {
            // --- Nombre, con longitud previa VALIDADA ---
            int longitudNombre = entrada.readInt();
            if (longitudNombre <= 0 || longitudNombre > MAXIMO_NOMBRE) {
                throw new IOException("Longitud de nombre invalida: " + longitudNombre);
            }
            byte[] bytesNombre = entrada.readNBytes(longitudNombre);
            if (bytesNombre.length < longitudNombre) {
                throw new EOFException("Flujo cortado leyendo el nombre");
            }
            String nombre = new String(bytesNombre, StandardCharsets.UTF_8);

            // --- Saneado del nombre: RECORRIDO DE RUTAS ---
            // Sin esto, un emisor malicioso envia "../../etc/cron.d/puerta"
            // y escribimos donde el quiera. Es una vulnerabilidad clasica.
            if (nombre.contains("/") || nombre.contains("\\")
                    || nombre.contains("..") || nombre.isBlank()) {
                throw new IOException("Nombre de fichero no permitido: " + nombre);
            }

            // --- Tamano, tambien validado ---
            long tamano = entrada.readLong();
            if (tamano < 0 || tamano > MAXIMO_TAMANO) {
                throw new IOException("Tamano fuera de rango: " + tamano);
            }

            // --- Contenido ---
            Path destino = DESTINO.resolve(nombre).normalize();
            // Cinturon y tirantes: comprobamos que el resultado sigue dentro
            // del directorio previsto, por si algo se nos escapo antes.
            if (!destino.startsWith(DESTINO)) {
                throw new IOException("Ruta resultante fuera del directorio: " + destino);
            }

            long recibidos = 0;
            try (OutputStream salidaFichero =
                         new BufferedOutputStream(Files.newOutputStream(destino))) {
                byte[] bufer = new byte[8192];
                int leidos;
                // Leemos hasta fin de flujo: es el shutdownOutput() del emisor
                // el que provoca este -1. Sin el, este bucle no terminaria.
                while ((leidos = entrada.read(bufer)) != -1) {
                    if (recibidos + leidos > tamano) {
                        throw new IOException(
                                "El emisor envia mas bytes de los anunciados");
                    }
                    salidaFichero.write(bufer, 0, leidos);
                    recibidos += leidos;
                }
            }

            if (recibidos != tamano) {
                throw new EOFException("Se anunciaron " + tamano
                        + " bytes y llegaron " + recibidos);
            }

            long finalRecibidos = recibidos;
            LOG.info(() -> "Guardado " + destino + " (" + finalRecibidos + " bytes)");
            resumen = "200 OK " + nombre + " " + recibidos + " bytes";

        } catch (IOException e) {
            LOG.log(Level.WARNING, "Transferencia rechazada", e);
            resumen = "400 RECHAZADO " + e.getMessage();
        }

        // --- Respuesta de texto, con charset explicito ---
        BufferedWriter escritor = new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8));
        escritor.write(resumen);
        escritor.write('\n');
        escritor.flush();       // sin esto, el emisor esperaria para siempre
    }

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

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

# Terminal 2
java -cp clases com.nexussoftware.bibliotech.red.EmisorFichero catalogo.csv

Terminal 1:
INFO: Receptor escuchando en el puerto 9091
INFO: Conexion de /127.0.0.1:52104
INFO: Guardado recibidos/catalogo.csv (2847 bytes)

Terminal 2:
INFO: Enviados 2847 bytes de catalogo.csv
Receptor: 200 OK catalogo.csv 2847 bytes