cmd/http/main.ha

@@ -1,53 +1,23 @@
-use getopt;
 use io;
 use log;
 use net::dial;
 use net::http;
 use net::uri;
 use os;
-use strings;
-
-const usage: [_]getopt::help = [
-	"HTTP client",
-	('H', "Name:value", "Sets an HTTP header"),
-	('X', "method", "Sets the HTTP method verb"),
-	"url"
-];
 
 export fn main() void = {
-	const client = http::newclient("Hare net::http test client");
+	const client = http::newclient("Hare test client");
 	defer http::client_finish(&client);
 
-	const cmd = getopt::parse(os::args, usage...);
+	const target = match (uri::parse(os::args[1])) {
-	defer getopt::finish(&cmd);
-
-	if (len(cmd.args) != 1) {
-		getopt::printusage(os::stderr, "http", usage)!;
-		os::exit(os::status::FAILURE);
-	};
-
-	const targ = match (uri::parse(cmd.args[0])) {
 	case let u: uri::uri =>
 		yield u;
 	case uri::invalid =>
 		log::fatal("Invalid URI");
 	};
-	defer uri::finish(&targ);
+	defer uri::finish(&target);
 
-	let req = http::new_request(&client, "GET", &targ)!;
+	const resp = match (http::get(&client, &target)) {
-	for (let i = 0z; i < len(cmd.opts); i += 1) {
-		const (opt, val) = cmd.opts[i];
-		switch (opt) {
-		case 'H' =>
-			const (name, val) = strings::cut(val, ":");
-			http::header_add(&req.header, name, val);
-		case 'X' =>
-			req.method = val;
-		case => abort();
-		};
-	};
-
-	const resp = match (http::do(&client, &req)) {
 	case let err: http::error =>
 		log::fatal("HTTP error:", http::strerror(err));
 	case let resp: http::response =>
@@ -64,12 +34,6 @@ export fn main() void = {
 		log::printfln("{}: {}", name, val);
 	};
 
-	const body = match (resp.body) {
+	const body = resp.body as *io::stream;
-	case let st: *io::stream =>
-		yield st;
-	case null =>
-		return;
-	};
 	io::copy(os::stdout, body)!;
-	io::close(body)!;
 };

cmd/httpd/main.ha

@@ -1,92 +0,0 @@
-use getopt;
-use net;
-use net::ip;
-use net::http;
-use net::dial;
-use os;
-use memio;
-use io;
-use fmt;
-use bufio;
-use strings;
-
-const usage: [_]getopt::help = [
-	"HTTP server",
-	('a', "address", "listened address (ex: 127.0.0.1:8080)")
-];
-
-export fn main() void = {
-	const cmd = getopt::parse(os::args, usage...);
-	defer getopt::finish(&cmd);
-
-	let port: u16 = 8080;
-	let ip_addr: ip::addr4 = [127, 0, 0, 1];
-
-	for (let i = 0z; i < len(cmd.opts); i += 1) {
-		const opt = cmd.opts[i];
-		switch (opt.0) {
-		case 'a' =>
-			match (dial::splitaddr(opt.1, "")) {
-			case let value: (str, u16) =>
-				ip_addr = ip::parsev4(value.0)!;
-				port = value.1;
-			case dial::invalid_address =>
-				abort("Invalid address");
-			};
-		case => abort(); // unreachable
-		};
-	};
-
-	const server = match (http::listen(ip_addr, port)) {
-	case let this: *http::server =>
-		yield this;
-	case net::error => abort("failure while listening");
-	};
-	defer http::server_finish(server);
-
-	for (true) {
-		const serv_req = match (http::serve(server)) {
-		case let this: *http::server_request =>
-			yield this;
-		case net::error => abort("failure while serving");
-		};
-		defer http::serve_finish(serv_req);
-
-		let buf = memio::dynamic();
-		defer io::close(&buf)!;
-		handlereq(&buf, &serv_req.request);
-
-		http::response_write(
-			serv_req.socket,
-			http::STATUS_OK,
-			&buf,
-			("Content-Type", "text/plain")
-		)!;
-	};
-};
-
-export fn handlereq(buf: *io::stream, request: *http::request) void = {
-	fmt::fprintfln(buf, "Method: {}", request.method)!;
-	fmt::fprintfln(buf, "Path: {}", request.target.path)!;
-	fmt::fprintfln(buf, "Fragment: {}", request.target.fragment)!;
-	fmt::fprintfln(buf, "Query: {}", request.target.query)!;
-	fmt::fprintfln(buf, "Headers: <<EOF")!;
-	http::write_header(buf, &request.header)!;
-	fmt::fprintfln(buf, "EOF")!;
-
-	match (request.body) {
-	case void => void;
-	case let body: io::handle =>
-		fmt::fprintfln(buf, "Body: <<EOF")!;
-		for (true) {
-			match (bufio::read_line(body)!) {
-			case let line: []u8 =>
-				fmt::fprintln(buf, strings::fromutf8(line)!)!;
-				break;
-			case io::EOF =>
-				break;
-			};
-		};
-		fmt::fprintfln(buf, "EOF")!;
-	};
-};

net/http/client.ha

@@ -1,5 +1,10 @@
+use errors;
+use fmt;
 use io;
+use net::ip;
 use net::uri;
+use strconv;
+use strings;
 
 export type client = struct {
 	default_header: header,
@@ -39,6 +44,76 @@ export fn client_default_transport(client: *client) *transport = {
 	return &client.default_transport;
 };
 
+fn new_request(
+	client: *client,
+	method: str,
+	target: *uri::uri,
+) (request | errors::unsupported) = {
+	let req = request {
+		method = method,
+		target = alloc(uri::dup(target)),
+		header = header_dup(&client.default_header),
+		transport = null,
+		body = void,
+	};
+	switch (req.target.scheme) {
+	case "http" =>
+		if (req.target.port == 0) {
+			req.target.port = 80;
+		};
+	case "https" =>
+		if (req.target.port == 0) {
+			req.target.port = 443;
+		};
+	case =>
+		return errors::unsupported;
+	};
+
+	let host = match (req.target.host) {
+	case let host: str =>
+		yield host;
+	case let ip: ip::addr4 =>
+		yield ip::string(ip);
+	case let ip: ip::addr6 =>
+		static let buf: [64 + 2]u8 = [0...];
+		yield fmt::bsprintf(buf, "[{}]", ip::string(ip));
+	};
+
+	if (req.target.scheme == "http" && req.target.port != 80) {
+		host = fmt::asprintf("{}:{}", host, req.target.port);
+	} else if (target.scheme == "https" && target.port != 443) {
+		host = fmt::asprintf("{}:{}", host, req.target.port);
+	} else {
+		host = strings::dup(host);
+	};
+	defer free(host);
+	header_add(&req.header, "Host", host);
+
+	return req;
+};
+
+fn new_request_body(
+	client: *client,
+	method: str,
+	target: *uri::uri,
+	body: io::handle,
+) (request | errors::unsupported) = {
+	let req = new_request(client, method, target)?;
+	req.body = body;
+
+	const offs = match (io::seek(body, 0, io::whence::CUR)) {
+	case let off: io::off =>
+		yield off;
+	case io::error =>
+		header_add(&req.header, "Transfer-Encoding", "chunked");
+		return req;
+	};
+	const ln = io::seek(body, 0, io::whence::END)!;
+	io::seek(body, offs, io::whence::SET)!;
+	header_add(&req.header, "Content-Length", strconv::ztos(ln: size));
+	return req;
+};
+
 fn uri_origin_form(target: *uri::uri) uri::uri = {
 	let target = *target;
 	target.scheme = "";

net/http/constants.ha

@@ -8,12 +8,6 @@ export def POST: str = "POST";
 export def PUT: str = "PUT";
 // HTTP "DELETE" method.
 export def DELETE: str = "DELETE";
-// HTTP "OPTIONS" method.
-export def OPTIONS: str = "OPTIONS";
-// HTTP "PATCH" method.
-export def PATCH: str = "PATCH";
-// HTTP "CONNECT" method.
-export def CONNECT: str = "CONNECT";
 
 // HTTP "Continue" response status (100).
 export def STATUS_CONTINUE: uint = 100;

net/http/do.ha

@@ -14,9 +14,6 @@ use types;
 // Performs an HTTP [[request]] with the given [[client]]. The request is
 // performed synchronously; this function blocks until the server has returned
 // the response status and all HTTP headers associated with the response.
-//
-// If the provided [[response]] has a non-null body, the user must pass it to
-// [[io::close]] before calling [[response_finish]].
 export fn do(client: *client, req: *request) (response | error) = {
 	assert(req.target.scheme == "http"); // TODO: https
 	const conn = dial::dial_uri("tcp", req.target)?;
@@ -56,21 +53,10 @@ export fn do(client: *client, req: *request) (response | error) = {
 	};
 
 	let resp = response { ... };
-	const scan = bufio::newscanner(conn, 512);
+	const scan = bufio::newscanner_static(conn, buf);
 	read_statusline(&resp, &scan)?;
 	read_header(&resp.header, &scan)?;
-
+	resp.body = new_reader(conn, &resp, &scan)?;
-	const response_complete =
-		req.method == "HEAD" ||
-		resp.status == STATUS_NO_CONTENT ||
-		resp.status == STATUS_NOT_MODIFIED ||
-		(resp.status >= 100 && resp.status < 200) ||
-		(req.method == "CONNECT" && resp.status >= 200 && resp.status < 300);
-	if (!response_complete) {
-		resp.body = new_reader(conn, &resp, &scan)?;
-	} else if (req.method != "CONNECT") {
-		io::close(conn)!;
-	};
 	return resp;
 };
 
@@ -94,51 +80,35 @@ fn read_statusline(
 	const version = match (strings::next_token(&tok)) {
 	case let ver: str =>
 		yield ver;
-	case done =>
+	case void =>
 		return protoerr;
 	};
 
 	const status = match (strings::next_token(&tok)) {
 	case let status: str =>
 		yield status;
-	case done =>
+	case void =>
 		return protoerr;
 	};
 
 	const reason = match (strings::next_token(&tok)) {
 	case let reason: str =>
 		yield reason;
-	case done =>
+	case void =>
 		return protoerr;
 	};
 
 	const (_, version) = strings::cut(version, "/");
 	const (major, minor) = strings::cut(version, ".");
-
+	resp.version = (
-	const major = match (strconv::stou(major)) {
+		strconv::stou(major)!,
-	case let u: uint =>
+		strconv::stou(minor)!,
-		yield u;
+	);
-	case =>
-		return protoerr;
-	};
-	const minor = match (strconv::stou(minor)) {
-	case let u: uint =>
-		yield u;
-	case =>
-		return protoerr;
-	};
-	resp.version = (major, minor);
 
 	if (resp.version.0 > 1) {
 		return errors::unsupported;
 	};
 
-	resp.status = match (strconv::stou(status)) {
+	resp.status = strconv::stou(status)!;
-	case let u: uint =>
-		yield u;
-	case =>
-		return protoerr;
-	};
-
 	resp.reason = strings::dup(reason);
 };

net/http/header.ha

@@ -11,7 +11,7 @@ export type header = [](str, str);
 // Adds a given HTTP header, which may be added more than once. The name should
 // be canonicalized by the caller.
 export fn header_add(head: *header, name: str, val: str) void = {
-	assert(len(name) >= 1 && len(val) >= 1);
+	assert(len(name) > 1 && len(val) > 1);
 	append(head, (strings::dup(name), strings::dup(val)));
 };
 
@@ -77,7 +77,7 @@ export fn write_header(sink: io::handle, head: *header) (size | io::error) = {
 	return z;
 };
 
-fn read_header(head: *header, scan: *bufio::scanner) (void | io::error | protoerr) = {
+fn read_header(head: *header, scan: *bufio::scanner) (void | error) = {
 	for (true) {
 		const item = match (bufio::scan_string(scan, "\r\n")) {
 		case let line: const str =>

net/http/request.ha

@@ -1,14 +1,5 @@
-use errors;
-use fmt;
 use io;
-use net::ip;
 use net::uri;
-use strconv;
-use strings;
-use bufio;
-use memio;
-use encoding::utf8;
-use types;
 
 // Stores state related to an HTTP request.
 //
@@ -42,236 +33,3 @@ export fn request_finish(req: *request) void = {
 	uri::finish(req.target);
 	free(req.target);
 };
-
-// Creates a new HTTP [[request]] using the given HTTP [[client]] defaults.
-export fn new_request(
-	client: *client,
-	method: str,
-	target: *uri::uri,
-) (request | errors::unsupported) = {
-	let req = request {
-		method = method,
-		target = alloc(uri::dup(target)),
-		header = header_dup(&client.default_header),
-		transport = null,
-		body = void,
-	};
-	switch (req.target.scheme) {
-	case "http" =>
-		if (req.target.port == 0) {
-			req.target.port = 80;
-		};
-	case "https" =>
-		if (req.target.port == 0) {
-			req.target.port = 443;
-		};
-	case =>
-		return errors::unsupported;
-	};
-
-	let host = match (req.target.host) {
-	case let host: str =>
-		yield host;
-	case let ip: ip::addr4 =>
-		yield ip::string(ip);
-	case let ip: ip::addr6 =>
-		static let buf: [64 + 2]u8 = [0...];
-		yield fmt::bsprintf(buf, "[{}]", ip::string(ip));
-	};
-
-	if (req.target.scheme == "http" && req.target.port != 80) {
-		host = fmt::asprintf("{}:{}", host, req.target.port);
-	} else if (target.scheme == "https" && target.port != 443) {
-		host = fmt::asprintf("{}:{}", host, req.target.port);
-	} else {
-		host = strings::dup(host);
-	};
-	defer free(host);
-	header_add(&req.header, "Host", host);
-	return req;
-};
-
-// Creates a new HTTP [[request]] using the given HTTP [[client]] defaults and
-// the provided request body.
-//
-// If the provided I/O handle is seekable, the Content-Length header is added
-// automatically. Otherwise, Transfer-Encoding: chunked will be used.
-export fn new_request_body(
-	client: *client,
-	method: str,
-	target: *uri::uri,
-	body: io::handle,
-) (request | errors::unsupported) = {
-	let req = new_request(client, method, target)?;
-	req.body = body;
-
-	const offs = match (io::seek(body, 0, io::whence::CUR)) {
-	case let off: io::off =>
-		yield off;
-	case io::error =>
-		header_add(&req.header, "Transfer-Encoding", "chunked");
-		return req;
-	};
-	const ln = io::seek(body, 0, io::whence::END)!;
-	io::seek(body, offs, io::whence::SET)!;
-	header_add(&req.header, "Content-Length", strconv::ztos(ln: size));
-	return req;
-};
-
-export type request_server = void;
-export type authority = void;
-
-export type request_uri = (
-	request_server |
-	authority |
-	*uri::uri |
-	str |
-);
-
-export type request_line = struct {
-	method: str,
-	uri: request_uri,
-	version: version,
-};
-
-export fn request_parse(file: io::handle) (request | protoerr | io::error) = {
-	const scan = bufio::newscanner(file, types::SIZE_MAX);
-	defer bufio::finish(&scan);
-
-	const req_line = request_line_parse(&scan)?;
-	defer request_line_finish(&req_line);
-
-	let header: header = [];
-	read_header(&header, &scan)?;
-
-	const target = match (req_line.uri) {
-	case let uri: request_server => return errors::unsupported;
-	case let uri: authority => return errors::unsupported;
-	case let uri: *uri::uri => yield uri;
-	case let path: str =>
-		const uri = fmt::asprintf("http:{}", path);
-		defer free(uri);
-		yield alloc(uri::parse(uri)!);
-	};
-
-	const length: (void | size) = void;
-	const head_length = header_get(&header, "Content-Length");
-	if ("" != head_length) {
-		match (strconv::stoz(head_length)) {
-		case let s: size => length = s;
-		case strconv::invalid => return protoerr;
-		case strconv::overflow => return protoerr;
-		};
-	};
-
-	let body: (io::handle | void) = void;
-	if (length is size) {
-		const limit = io::limitreader(&scan, length as size);
-		let _body = alloc(memio::dynamic());
-		io::copy(_body, &limit)!;
-		io::seek(_body, 0, io::whence::SET)!;
-		body = _body;
-	};
-
-	return request {
-		method = req_line.method,
-		target = target,
-		header = header,
-		body = body,
-		...
-	};
-};
-
-export fn parsed_request_finish(request: *request) void = {
-	uri::finish(request.target);
-	free(request.target);
-
-	match (request.body) {
-	case void => yield;
-	case let body: io::handle =>
-		io::close(body)!;
-		free(body: *memio::stream);
-	};
-
-	header_free(&request.header);
-};
-
-export fn request_line_parse(scan: *bufio::scanner) (request_line | protoerr | io::error) = {
-	const line = match (bufio::scan_string(scan, "\r\n")) {
-	case let line: const str =>
-		yield line;
-	case let err: io::error =>
-		return err;
-	case utf8::invalid =>
-		return protoerr;
-	case io::EOF =>
-		return protoerr;
-	};
-
-	const tok = strings::tokenize(line, " ");
-
-	const method = match (strings::next_token(&tok)) {
-	case let method: str =>
-		yield strings::dup(method);
-	case done =>
-		return protoerr;
-	};
-
-	const uri: request_uri = match (strings::next_token(&tok)) {
-	case let req_uri: str =>
-		if ("*" == req_uri) {
-			yield request_server;
-		};
-
-		yield match (uri::parse(req_uri)) {
-		case let uri: uri::uri => yield alloc(uri);
-		case => yield strings::dup(req_uri); // as path
-		};
-	case done =>
-		return protoerr;
-	};
-
-	const version = match (strings::next_token(&tok)) {
-	case let ver: str =>
-		yield ver;
-	case done =>
-		return protoerr;
-	};
-
-	const (_, version) = strings::cut(version, "/");
-	const (major, minor) = strings::cut(version, ".");
-
-	const major = match (strconv::stou(major)) {
-	case let u: uint =>
-		yield u;
-	case =>
-		return protoerr;
-	};
-	const minor = match (strconv::stou(minor)) {
-	case let u: uint =>
-		yield u;
-	case =>
-		return protoerr;
-	};
-
-	if (major > 1) {
-		return errors::unsupported;
-	};
-
-	if (uri is request_server && method != OPTIONS) {
-		return protoerr;
-	};
-
-	return request_line {
-		method = method,
-		uri = uri,
-		version = (major, minor),
-	};
-};
-
-export fn request_line_finish(line: *request_line) void = {
-	match (line.uri) {
-	case let path: str => free(path);
-	case => yield;
-	};
-};

net/http/response.ha

@@ -1,14 +1,10 @@
 use io;
 use os;
-use fmt;
-use strconv;
-
-export type version = (uint, uint);
 
 // Stores state related to an HTTP response.
 export type response = struct {
 	// HTTP protocol version (major, minor)
-	version: version,
+	version: (uint, uint),
 	// The HTTP status for this request as an integer.
 	status: uint,
 	// The HTTP status reason phrase.
@@ -19,45 +15,9 @@ export type response = struct {
 	body: nullable *io::stream,
 };
 
-// Frees state associated with an HTTP [[response]]. If the response has a
+// Frees state associated with an HTTP [[response]].
-// non-null body, the user must call [[io::close]] prior to calling this
-// function.
 export fn response_finish(resp: *response) void = {
 	header_free(&resp.header);
 	free(resp.reason);
 	free(resp.body);
 };
-
-export fn response_write(
-	rw: io::handle,
-	status: uint,
-	body: (void | io::handle),
-	header: (str, str)...
-) (void | io::error) = {
-	fmt::fprintfln(rw, "HTTP/1.1 {} {}", status, status_reason(status))?;
-
-	let header = header_dup(&header);
-	defer header_free(&header);
-
-	match (body) {
-	case void => void;
-	case let body: io::handle =>
-		match (io::tell(body)) {
-		case io::error => void;
-		case let off: io::off =>
-			header_add(&header, "Content-Length", strconv::i64tos(off));
-			io::seek(body, 0, io::whence::SET)!;
-			body = &io::limitreader(body, off: size);
-		};
-	};
-
-	write_header(rw, &header)?;
-
-	fmt::fprintln(rw)!;
-
-	match (body) {
-	case void => void;
-	case let body: io::handle =>
-		io::copy(rw, body)!;
-	};
-};

net/http/server.ha

@@ -1,43 +0,0 @@
-use net;
-use net::ip;
-use net::tcp;
-
-export type server = struct {
-	socket: net::socket,
-};
-
-export type server_request = struct {
-	socket: net::socket,
-	request: request,
-};
-
-export fn listen(ip: ip::addr, port: u16) (*server | net::error) = {
-	return alloc(server {
-		socket = tcp::listen(ip, port)?,
-	});
-};
-
-export fn server_finish(server: *server) void = {
-	net::close(server.socket)!;
-	free(server);
-};
-
-export fn accept(server: *server) (net::socket | net::error) = {
-	return net::accept(server.socket)?;
-};
-
-export fn serve(server: *server) (*server_request | net::error) = {
-	const socket = accept(server)?;
-	const request = request_parse(socket)!;
-
-	return alloc(server_request {
-		request = request,
-		socket = socket,
-	});
-};
-
-export fn serve_finish(serv_req: *server_request) void = {
-	parsed_request_finish(&serv_req.request);
-	net::close(serv_req.socket)!;
-	free(serv_req);
-};

net/http/transport.ha

@@ -50,7 +50,7 @@ export type transport = struct {
 };
 
 fn new_reader(
-	conn: io::file,
+	conn: io::handle,
 	resp: *response,
 	scan: *bufio::scanner,
 ) (*io::stream | errors::unsupported | protoerr) = {
@@ -68,7 +68,8 @@ fn new_reader(
 				return protoerr;
 			};
 		};
-		return new_identity_reader(conn, scan, length);
+		const remain = bufio::scan_buffer(scan);
+		return new_identity_reader(conn, remain, length);
 	};
 
 	// TODO: Figure out the semantics for closing the stream
@@ -80,8 +81,13 @@ fn new_reader(
 	let stream: io::handle = conn;
 	let buffer: []u8 = bufio::scan_buffer(scan);
 	const iter = strings::tokenize(te, ",");
-	for (const tok => strings::next_token(&iter)) {
+	for (true) {
-		const te = strings::trim(tok);
+		const te = match (strings::next_token(&iter)) {
+		case let tok: str =>
+			yield strings::trim(tok);
+		case void =>
+			break;
+		};
 
 		// XXX: We could add lzw support if someone added it to
 		// hare-compress
@@ -109,32 +115,33 @@ fn new_reader(
 
 type identity_reader = struct {
 	vtable: io::stream,
-	conn: io::file,
+	conn: io::handle,
-	scan: *bufio::scanner,
+	buffer: [os::BUFSZ]u8,
-	src: io::limitstream,
+	pending: size,
+	length: size,
 };
 
 const identity_reader_vtable = io::vtable {
 	reader = &identity_read,
-	closer = &identity_close,
 	...
 };
 
 // Creates a new reader that reads data until the response's Content-Length is
 // reached; i.e. the null Transport-Encoding.
 fn new_identity_reader(
-	conn: io::file,
+	conn: io::handle,
-	scan: *bufio::scanner,
+	buffer: []u8,
 	content_length: size,
 ) *io::stream = {
-	const scan = alloc(*scan);
+	let rd = alloc(identity_reader {
-	return alloc(identity_reader {
 		vtable = &identity_reader_vtable,
 		conn = conn,
-		scan = scan,
+		length = content_length,
-		src = io::limitreader(scan, content_length),
 		...
 	});
+	rd.buffer[..len(buffer)] = buffer[..];
+	rd.pending = len(buffer);
+	return rd;
 };
 
 fn identity_read(
@@ -143,20 +150,34 @@ fn identity_read(
 ) (size | io::EOF | io::error) = {
 	let rd = s: *identity_reader;
 	assert(rd.vtable == &identity_reader_vtable);
-	return io::read(&rd.src, buf)?;
-};
 
-fn identity_close(s: *io::stream) (void | io::error) = {
+	if (rd.length <= 0) {
-	let rd = s: *identity_reader;
+		return io::EOF;
-	assert(rd.vtable == &identity_reader_vtable);
+	};
 
-	// Flush the remainder of the response in case the caller did not read
+	if (rd.pending == 0) {
-	// it out entirely
+		let nread = rd.length;
-	io::copy(io::empty, &rd.src)?;
+		if (nread > len(rd.buffer)) {
+			nread = len(rd.buffer);
+		};
 
-	bufio::finish(rd.scan);
+		match (io::read(rd.conn, rd.buffer[..nread])?) {
-	free(rd.scan);
+		case let n: size =>
-	io::close(rd.conn)?;
+			rd.pending = n;
+		case io::EOF =>
+			return io::EOF;
+		};
+	};
+
+	let n = len(buf);
+	if (n > rd.pending) {
+		n = rd.pending;
+	};
+	buf[..n] = rd.buffer[..n];
+	rd.buffer[..len(rd.buffer) - n] = rd.buffer[n..];
+	rd.pending -= n;
+	rd.length -= n;
+	return n;
 };
 
 type chunk_state = enum {
@@ -241,7 +262,7 @@ fn chunked_read(
 			return errors::invalid;
 		};
 
-		match (strconv::stoz(ln, strconv::base::HEX)) {
+		match (strconv::stozb(ln, strconv::base::HEX)) {
 		case let z: size =>
 			rd.length = z;
 		case =>
@@ -293,4 +314,6 @@ fn chunked_read(
 		rd.pending -= 2;
 		rd.state = chunk_state::HEADER;
 	};
+
+	abort(); // Unreachable
 };