Chunking.java

package org.prevayler.foundation;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.EOFException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class Chunking {

	private static final String ASCII = "US-ASCII";
	private static final byte[] CRLF = new byte[] {'\r', '\n'};
	private static final String SIZE = "0|[1-9A-F][0-9A-F]{0,6}|[1-7][0-9A-F]{7}";
	private static final String TOKEN = "[^\u0000-\u0020()<>@,;:\\\\\"/\\[\\]?={}\u007F-\uFFFF]+";
	private static final String HEADER = "(" + SIZE + ")(;" + TOKEN + "=" + TOKEN + ")*\r\n";
	private static final Pattern TOKEN_PATTERN = Pattern.compile(TOKEN);
	private static final Pattern HEADER_PATTERN = Pattern.compile(HEADER);

	private static boolean validToken(String token) {
		return TOKEN_PATTERN.matcher(token).matches();
	}

	public static void writeChunk(OutputStream stream, Chunk chunk) throws IOException {
		stream.write(Integer.toHexString(chunk.getBytes().length).toUpperCase().getBytes(ASCII));
		Iterator iterator = chunk.getParameters().entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry entry = (Map.Entry) iterator.next();
			String name = (String) entry.getKey();
			String value = (String) entry.getValue();
			if (!validToken(name)) {
				throw new IOException("Invalid parameter name '" + name + "'");
			}
			if (!validToken(value)) {
				throw new IOException("Invalid parameter value '" + value + "'");
			}
			stream.write(';');
			stream.write(name.getBytes(ASCII));
			stream.write('=');
			stream.write(value.getBytes(ASCII));
		}
		stream.write(CRLF);
		stream.write(chunk.getBytes());
		stream.write(CRLF);
	}

	public static Chunk readChunk(InputStream stream) throws IOException {
		String header = readLine(stream);

		if (header == null) {
			return null;
		}

		if (!HEADER_PATTERN.matcher(header).matches()) {
			throw new IOException("Chunk header corrupted");
		}

		StringTokenizer tokenizer = new StringTokenizer(header, ";=\r\n");

		int size = Integer.parseInt(tokenizer.nextToken(), 16);

		Map parameters = new LinkedHashMap();
		while (tokenizer.hasMoreTokens()) {
			String name = tokenizer.nextToken();
			String value = tokenizer.nextToken();
			parameters.put(name, value);
		}

		byte[] bytes = new byte[size];
		int total = 0;
		while (total < size) {
			int read = stream.read(bytes, total, size - total);
			if (read == -1) {
				throw new EOFException("Unexpected end of stream in chunk data");
			}
			total += read;
		}

		int cr = stream.read();
		int lf = stream.read();
		if (cr == -1 || cr == '\r' && lf == -1) {
			throw new EOFException("Unexpected end of stream in chunk trailer");
		} else if (cr != '\r' || lf != '\n') {
			throw new IOException("Chunk trailer corrupted");
		}

		return new Chunk(bytes, parameters);
	}

	private static String readLine(InputStream stream) throws IOException {
		ByteArrayOutputStream header = new ByteArrayOutputStream();
		while (true) {
			int b = stream.read();
			if (b == -1) {
				if (header.size() == 0) {
					return null;
				} else {
					throw new EOFException("Unexpected end of stream in chunk header");
				}
			}
			header.write(b);
			if (b == '\n') {
				return header.toString(ASCII);
			}
		}
	}

}