Http: module {
	PATH: con "/dis/http/lib/http.dis";
	BUFIOPATH: con "/dis/http/lib/bufio.dis";

	HConn: adt {
		seq:	int;
		urlstr:	string;
		req:	ref Req;
		rsp:	ref Rsp;
		length:	big;
		sent:	big;
		received:	big;

		new:	fn(fd: ref Sys->FD): ref HConn;
		puts:	fn(nil: self ref HConn, s: string): int;
		read:	fn(nil: self ref HConn, buf: array of byte, n: int): int;
		write:	fn(nil: self ref HConn, buf: array of byte, n: int): int;
		status:	fn(nil: self ref HConn, code: int, msg: string);
		err:	fn(nil: self ref HConn, code: int, msg: string);
		close:	fn(nil: self ref HConn);
		hijack:	fn(nil: self ref HConn): (ref Sys->FD, array of byte);

		# private
		begun:	int;
		fd:	ref Sys->FD;
		bin:	ref Bufio->Iobuf;
		bout:	ref Bufio->Iobuf;
		begin:	fn(nil: self ref HConn);
	};

	Req: adt {
		method:	string;
		url:	ref Url;
		version:	string;
		hmap:	ref Headers->HeaderMap;

		parse:	fn(iob: ref Bufio->Iobuf): (ref Req, string, big, string);
		tostring:	fn(nil: self ref Req, urlstr: string, cr: int): string;
	};

	Rsp: adt {
		version:	string;
		statuscode:	int;
		statusmsg:	string;
		hmap:	ref Headers->HeaderMap;

		parse:	fn(iob: ref Bufio->Iobuf): (ref Rsp, string);
		parsestatus:	fn(s: string): (ref Rsp, string);
		tostring:	fn(nil: self ref Rsp, cr: int): string;
	};

	Url: adt {
		esctype:	int;

		scheme:	string;
		user:	string;
		host:	string;
		port:	string;
		path:	string;
		query:	string;
		fragment:	string;

		parse:	fn(s: string): (Url, string);
		relative:	fn(a, b: Url): Url;
		escape:	fn(nil: self Url): Url;
		unescape:	fn(nil: self Url): Url;
		mask:	fn(nil: self Url, mask: int): Url;
		tostring:	fn(nil: self Url): string;
	};

	UTescaped, UTpartial, UTunescaped:	con iota;
	Uscheme, Uuser, Uhost, Uport, Upath, Uquery, Ufragment:	con 1<<iota;

	Query: adt {
		params:	list of (string, string);

		parse:	fn(qstr: string): (ref Query, string);
		exists:	fn(nil: self ref Query, param: string): int;
		find:	fn(nil: self ref Query, param: string): string;
		findall:	fn(nil: self ref Query, param: string): list of string;
	};

	headers: Headers;

	init:	fn();
	loadhandler:	fn(disfile: string): Handler;
	urlencode:	fn(s, except: string): string;
	urldecode:	fn(s: string): string;
};

Handler: module {
	init:	fn(m: Http, args: list of string);
	handle:	fn(h: ref Http->HConn);
};

Headers: module {
	PATH: con "/dis/http/lib/headers.dis";

	Header: type (string, string);

	HeaderMap: adt {
		parse:	fn(nil: self ref HeaderMap, nil: ref Bufio->Iobuf): string;
		parseline:	fn(s: string): (string, string, string);
		add:	fn(nil: self ref HeaderMap, name, value: string);
		addsep:	fn(nil: self ref HeaderMap, name, value: string, sep: int);
		coalesce:	fn(nil: self ref HeaderMap, name: string, sep: int);
		exists:	fn(nil: self ref HeaderMap, name: string): int;
		find:	fn(nil: self ref HeaderMap, name: string): string;
		findsep:	fn(nil: self ref HeaderMap, name: string, sep: int): string;
		findall: fn(nil: self ref HeaderMap, name: string): list of string;
		findallsep:	fn(nil: self ref HeaderMap, name: string, sep: int): list of string;
		all:	fn(nil: self ref HeaderMap): list of Header;

		# private
		hs:	list of Header;
	};

	init:	fn();
	tostring: fn(hs: list of Header, cr: int): string;
};