HTTP 요청 프레이밍

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public final class MixedHttpBodyReader {
    static byte[] read(InputStream input, int contentLength) throws Exception {
        var reader = new BufferedReader(new InputStreamReader(
                input,
                StandardCharsets.US_ASCII));
        while (!reader.readLine().isEmpty()) {
            // 헤더를 문자 버퍼에 미리 읽을 수 있다.
        }
        return input.readNBytes(contentLength);
    }

    public static void main(String[] args) {
        System.out.println("compile-only mixed buffering counterexample");
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public final class BoundedHttpRequestReader {
    private static final int MAX_LINE = 4_096;
    private static final int MAX_HEAD = 16_384;
    private static final int MAX_BODY = 1_048_576;

    record Request(String method, String target, String version,
                   Map<String, List<String>> headers, byte[] body) {
        Request {
            headers = Map.copyOf(headers);
            body = body.clone();
        }
    }

    static Request read(InputStream input) throws Exception {
        String start = readLine(input);
        if (start == null || start.isEmpty()) {
            throw new EOFException("request line missing");
        }
        String[] parts = start.split(" ", -1);
        if (parts.length != 3) {
            throw new IllegalArgumentException("invalid request line");
        }

        int headBytes = start.length() + 2;
        Map<String, List<String>> headers = new LinkedHashMap<>();
        while (true) {
            String line = readLine(input);
            if (line == null) {
                throw new EOFException("headers truncated");
            }
            headBytes += line.length() + 2;
            if (headBytes > MAX_HEAD) {
                throw new IllegalArgumentException("headers too large");
            }
            if (line.isEmpty()) {
                break;
            }
            int colon = line.indexOf(':');
            if (colon <= 0) {
                throw new IllegalArgumentException("invalid header");
            }
            String name = line.substring(0, colon)
                    .trim().toLowerCase(Locale.ROOT);
            String value = line.substring(colon + 1).trim();
            headers.computeIfAbsent(name, ignored -> new ArrayList<>())
                    .add(value);
        }

        if (headers.containsKey("transfer-encoding")) {
            throw new IllegalArgumentException(
                    "transfer coding requires chunk decoder");
        }
        int length = contentLength(headers.get("content-length"));
        byte[] body = input.readNBytes(length);
        if (body.length != length) {
            throw new EOFException("body truncated");
        }

        Map<String, List<String>> frozen = new LinkedHashMap<>();
        headers.forEach((name, values) ->
                frozen.put(name, List.copyOf(values)));
        return new Request(parts[0], parts[1], parts[2], frozen, body);
    }

    private static int contentLength(List<String> values) {
        if (values == null) {
            return 0;
        }
        if (values.size() != 1) {
            throw new IllegalArgumentException("repeated content-length");
        }
        long parsed;
        try {
            parsed = Long.parseLong(values.getFirst());
        } catch (NumberFormatException error) {
            throw new IllegalArgumentException("invalid content-length", error);
        }
        if (parsed < 0 || parsed > MAX_BODY) {
            throw new IllegalArgumentException("body length out of range");
        }
        return Math.toIntExact(parsed);
    }

    static String readLine(InputStream input) throws Exception {
        var bytes = new ByteArrayOutputStream();
        while (bytes.size() <= MAX_LINE) {
            int value = input.read();
            if (value == -1) {
                return bytes.size() == 0
                        ? null
                        : throwTruncatedLine();
            }
            if (value == '\r') {
                if (input.read() != '\n') {
                    throw new IllegalArgumentException("CR without LF");
                }
                return bytes.toString(StandardCharsets.US_ASCII);
            }
            if (value == '\n') {
                throw new IllegalArgumentException("bare LF");
            }
            bytes.write(value);
        }
        throw new IllegalArgumentException("line too long");
    }

    private static String throwTruncatedLine() throws EOFException {
        throw new EOFException("line truncated");
    }

    public static void main(String[] args) throws Exception {
        byte[] body = "한글".getBytes(StandardCharsets.UTF_8);
        String head = "POST /notes HTTP/1.1\r\n"
                + "Host: local\r\n"
                + "Content-Type: text/plain; charset=UTF-8\r\n"
                + "Content-Length: " + body.length + "\r\n"
                + "\r\n";
        var wire = new ByteArrayOutputStream();
        wire.writeBytes(head.getBytes(StandardCharsets.US_ASCII));
        wire.writeBytes(body);

        Request request = read(new ByteArrayInputStream(wire.toByteArray()));
        System.out.println(request.method() + " " + request.target());
        System.out.println(new String(request.body(), StandardCharsets.UTF_8));
        System.out.println(request.headers().keySet());
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

public final class ChunkedBodyDecoder {
    private static final int MAX_LINE = 1_024;
    private static final int MAX_BODY = 1_048_576;

    static byte[] read(InputStream input) throws Exception {
        var body = new ByteArrayOutputStream();
        while (true) {
            String sizeLine = readLine(input);
            if (sizeLine == null || sizeLine.isEmpty()) {
                throw new EOFException("chunk size missing");
            }
            if (sizeLine.indexOf(';') >= 0) {
                throw new IllegalArgumentException(
                        "chunk extensions are not supported");
            }
            int size;
            try {
                size = Integer.parseInt(sizeLine, 16);
            } catch (NumberFormatException error) {
                throw new IllegalArgumentException("invalid chunk size", error);
            }
            if (size < 0 || body.size() + (long) size > MAX_BODY) {
                throw new IllegalArgumentException("chunked body too large");
            }
            if (size == 0) {
                String trailerEnd = readLine(input);
                if (!"".equals(trailerEnd)) {
                    throw new IllegalArgumentException(
                            "trailers are not supported");
                }
                return body.toByteArray();
            }

            byte[] chunk = input.readNBytes(size);
            if (chunk.length != size) {
                throw new EOFException("chunk data truncated");
            }
            body.writeBytes(chunk);
            expectCrlf(input);
        }
    }

    private static void expectCrlf(InputStream input) throws Exception {
        if (input.read() != '\r' || input.read() != '\n') {
            throw new IllegalArgumentException("chunk CRLF missing");
        }
    }

    private static String readLine(InputStream input) throws Exception {
        var bytes = new ByteArrayOutputStream();
        while (bytes.size() <= MAX_LINE) {
            int value = input.read();
            if (value == -1) {
                return bytes.size() == 0 ? null : failLine();
            }
            if (value == '\r') {
                if (input.read() != '\n') {
                    throw new IllegalArgumentException("invalid line end");
                }
                return bytes.toString(StandardCharsets.US_ASCII);
            }
            if (value == '\n') {
                throw new IllegalArgumentException("bare LF");
            }
            bytes.write(value);
        }
        throw new IllegalArgumentException("chunk line too long");
    }

    private static String failLine() throws EOFException {
        throw new EOFException("chunk line truncated");
    }

    public static void main(String[] args) throws Exception {
        String wire = "4\r\nWiki\r\n"
                + "5\r\npedia\r\n"
                + "7\r\n 한글\r\n"
                + "0\r\n\r\n";
        byte[] body = read(new ByteArrayInputStream(
                wire.getBytes(StandardCharsets.UTF_8)));
        System.out.println(new String(body, StandardCharsets.UTF_8));
        System.out.println("bytes=" + body.length);
    }
}