TCP, UDP e IP

import net from "node:net";
import readline from "node:readline";

const servidor = net.createServer((conexao) => {
  conexao.setTimeout(30_000); // fecha conexões ociosas
  conexao.on("timeout", () => conexao.destroy());

  // O readline acumula os bytes e entrega uma linha completa por vez
  const linhas = readline.createInterface({ input: conexao });

  linhas.on("line", (mensagem) => {
    if (mensagem.length > 1024) {
      conexao.end("ERRO mensagem longa demais\n");
      return;
    }
    conexao.write(`OK ${mensagem.toUpperCase()}\n`);
  });

  conexao.on("error", () => conexao.destroy());
});

servidor.listen(9000);

import asyncio

TAMANHO_MAXIMO = 1024


async def atender(leitor: asyncio.StreamReader, escritor: asyncio.StreamWriter):
    try:
        while True:
            # readline acumula os bytes até a quebra de linha
            linha = await asyncio.wait_for(leitor.readline(), timeout=30)
            if not linha:
                break  # o cliente fechou a conexão
            mensagem = linha.decode().rstrip("\n")
            escritor.write(f"OK {mensagem.upper()}\n".encode())
            await escritor.drain()
    except (asyncio.TimeoutError, asyncio.LimitOverrunError, ValueError):
        pass  # ociosa demais ou linha longa demais
    finally:
        escritor.close()


async def main():
    # limit: tamanho máximo de uma linha no buffer de leitura
    servidor = await asyncio.start_server(atender, port=9000, limit=TAMANHO_MAXIMO)
    async with servidor:
        await servidor.serve_forever()


asyncio.run(main())

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"strings"
	"time"
)

func atender(conexao net.Conn) {
	defer conexao.Close()

	leitor := bufio.NewScanner(conexao)
	leitor.Buffer(make([]byte, 1024), 1024) // tamanho máximo de uma linha

	for {
		conexao.SetReadDeadline(time.Now().Add(30 * time.Second))
		if !leitor.Scan() {
			return // fim da conexão, ociosidade ou linha longa demais
		}
		mensagem := leitor.Text()
		fmt.Fprintf(conexao, "OK %s\n", strings.ToUpper(mensagem))
	}
}

func main() {
	ouvinte, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatal(err)
	}
	for {
		conexao, err := ouvinte.Accept()
		if err != nil {
			continue
		}
		go atender(conexao) // uma goroutine por conexão
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class ServidorDeLinhas {
    public static void main(String[] args) throws IOException {
        try (var servidor = new ServerSocket(9000)) {
            while (true) {
                Socket conexao = servidor.accept();
                Thread.startVirtualThread(() -> atender(conexao)); // uma thread virtual por conexão
            }
        }
    }

    static void atender(Socket conexao) {
        try (conexao;
             var leitor = new BufferedReader(
                 new InputStreamReader(conexao.getInputStream(), StandardCharsets.UTF_8));
             var escritor = new PrintWriter(conexao.getOutputStream(), true, StandardCharsets.UTF_8)) {

            conexao.setSoTimeout(30_000); // tempo limite de leitura
            String mensagem;
            // readLine acumula os bytes até a quebra de linha
            while ((mensagem = leitor.readLine()) != null) {
                if (mensagem.length() > 1024) {
                    escritor.println("ERRO mensagem longa demais");
                    return;
                }
                escritor.println("OK " + mensagem.toUpperCase());
            }
        } catch (IOException e) {
            // ociosa demais ou conexão interrompida
        }
    }
}

using System.Net;
using System.Net.Sockets;
using System.Text;

var ouvinte = new TcpListener(IPAddress.Any, 9000);
ouvinte.Start();

while (true)
{
    var conexao = await ouvinte.AcceptTcpClientAsync();
    _ = Atender(conexao); // uma tarefa por conexão
}

static async Task Atender(TcpClient conexao)
{
    using (conexao)
    {
        var fluxo = conexao.GetStream();
        using var leitor = new StreamReader(fluxo, Encoding.UTF8);
        using var escritor = new StreamWriter(fluxo, Encoding.UTF8) { AutoFlush = true };

        try
        {
            while (true)
            {
                using var tempo = new CancellationTokenSource(TimeSpan.FromSeconds(30));
                // ReadLineAsync acumula os bytes até a quebra de linha
                var mensagem = await leitor.ReadLineAsync(tempo.Token);
                if (mensagem is null) break; // o cliente fechou
                if (mensagem.Length > 1024)
                {
                    await escritor.WriteLineAsync("ERRO mensagem longa demais");
                    break;
                }
                await escritor.WriteLineAsync($"OK {mensagem.ToUpperInvariant()}");
            }
        }
        catch (Exception e) when (e is OperationCanceledException or IOException)
        {
            // ociosa demais ou conexão interrompida
        }
    }
}