diff --git a/src/libhttpd/parse.c b/src/libhttpd/parse.c
new file mode 100644
index 0000000..5fd4092
--- /dev/null
+++ b/src/libhttpd/parse.c
@@ -0,0 +1,1057 @@
+#include <u.h>
+#include <libc.h>
+#include <bin.h>
+#include <httpd.h>
+#include "escape.h"
+
+typedef struct Hlex	Hlex;
+typedef struct MimeHead	MimeHead;
+
+enum
+{
+	/*
+	 * tokens
+	 */
+	Word	= 1,
+	QString,
+};
+
+#define UlongMax	4294967295UL
+
+struct Hlex
+{
+	int	tok;
+	int	eoh;
+	int	eol;			/* end of header line encountered? */
+	uchar	*hstart;		/* start of header */
+	jmp_buf	jmp;			/* jmp here to parse header */
+	char	wordval[HMaxWord];
+	HConnect *c;
+};
+
+struct MimeHead
+{
+	char	*name;
+	void	(*parse)(Hlex*, char*);
+	uchar	seen;
+	uchar	ignore;
+};
+
+static void	mimeaccept(Hlex*, char*);
+static void	mimeacceptchar(Hlex*, char*);
+static void	mimeacceptenc(Hlex*, char*);
+static void	mimeacceptlang(Hlex*, char*);
+static void	mimeagent(Hlex*, char*);
+static void	mimeauthorization(Hlex*, char*);
+static void	mimeconnection(Hlex*, char*);
+static void	mimecontlen(Hlex*, char*);
+static void	mimeexpect(Hlex*, char*);
+static void	mimefresh(Hlex*, char*);
+static void	mimefrom(Hlex*, char*);
+static void	mimehost(Hlex*, char*);
+static void	mimeifrange(Hlex*, char*);
+static void	mimeignore(Hlex*, char*);
+static void	mimematch(Hlex*, char*);
+static void	mimemodified(Hlex*, char*);
+static void	mimenomatch(Hlex*, char*);
+static void	mimerange(Hlex*, char*);
+static void	mimetransenc(Hlex*, char*);
+static void	mimeunmodified(Hlex*, char*);
+
+/*
+ * headers seen also include
+ * allow  cache-control chargeto
+ * content-encoding content-language content-location content-md5 content-range content-type
+ * date etag expires forwarded last-modified max-forwards pragma
+ * proxy-agent proxy-authorization proxy-connection
+ * ua-color ua-cpu ua-os ua-pixels
+ * upgrade via x-afs-tokens x-serial-number
+ */
+static MimeHead	mimehead[] =
+{
+	{"accept",		mimeaccept},
+	{"accept-charset",	mimeacceptchar},
+	{"accept-encoding",	mimeacceptenc},
+	{"accept-language",	mimeacceptlang},
+	{"authorization",	mimeauthorization},
+	{"connection",		mimeconnection},
+	{"content-length",	mimecontlen},
+	{"expect",		mimeexpect},
+	{"fresh",		mimefresh},
+	{"from",		mimefrom},
+	{"host",		mimehost},
+	{"if-match",		mimematch},
+	{"if-modified-since",	mimemodified},
+	{"if-none-match",	mimenomatch},
+	{"if-range",		mimeifrange},
+	{"if-unmodified-since",	mimeunmodified},
+	{"range",		mimerange},
+	{"transfer-encoding",	mimetransenc},
+	{"user-agent",		mimeagent},
+};
+
+char*		hmydomain;
+char*		hversion = "HTTP/1.1";
+
+static	void	lexhead(Hlex*);
+static	void	parsejump(Hlex*, char*);
+static	int	getc(Hlex*);
+static	void	ungetc(Hlex*);
+static	int	wordcr(Hlex*);
+static	int	wordnl(Hlex*);
+static	void	word(Hlex*, char*);
+static	int	lex1(Hlex*, int);
+static	int	lex(Hlex*);
+static	int	lexbase64(Hlex*);
+static	ulong	digtoul(char *s, char **e);
+
+/*
+ * flush an clean up junk from a request
+ */
+void
+hreqcleanup(HConnect *c)
+{
+	int i;
+
+	hxferenc(&c->hout, 0);
+	memset(&c->req, 0, sizeof(c->req));
+	memset(&c->head, 0, sizeof(c->head));
+	c->hpos = c->header;
+	c->hstop = c->header;
+	binfree(&c->bin);
+	for(i = 0; i < nelem(mimehead); i++){
+		mimehead[i].seen = 0;
+		mimehead[i].ignore = 0;
+	}
+}
+
+/*
+ * list of tokens
+ * if the client is HTTP/1.0,
+ * ignore headers which match one of the tokens.
+ * restarts parsing if necessary.
+ */
+static void
+mimeconnection(Hlex *h, char *unused)
+{
+	char *u, *p;
+	int reparse, i;
+
+	reparse = 0;
+	for(;;){
+		while(lex(h) != Word)
+			if(h->tok != ',')
+				goto breakout;
+
+		if(cistrcmp(h->wordval, "keep-alive") == 0)
+			h->c->head.persist = 1;
+		else if(cistrcmp(h->wordval, "close") == 0)
+			h->c->head.closeit = 1;
+		else if(!http11(h->c)){
+			for(i = 0; i < nelem(mimehead); i++){
+				if(cistrcmp(mimehead[i].name, h->wordval) == 0){
+					reparse = mimehead[i].seen && !mimehead[i].ignore;
+					mimehead[i].ignore = 1;
+					if(cistrcmp(mimehead[i].name, "authorization") == 0){
+						h->c->head.authuser = nil;
+						h->c->head.authpass = nil;
+					}
+				}
+			}
+		}
+
+		if(lex(h) != ',')
+			break;
+	}
+
+breakout:;
+	/*
+	 * if need to ignore headers we've already parsed,
+	 * reset & start over.  need to save authorization
+	 * info because it's written over when parsed.
+	 */
+	if(reparse){
+		u = h->c->head.authuser;
+		p = h->c->head.authpass;
+		memset(&h->c->head, 0, sizeof(h->c->head));
+		h->c->head.authuser = u;
+		h->c->head.authpass = p;
+
+		h->c->hpos = h->hstart;
+		longjmp(h->jmp, 1);
+	}
+}
+
+int
+hparseheaders(HConnect *c, int timeout)
+{
+	Hlex h;
+
+	c->head.fresh_thresh = 0;
+	c->head.fresh_have = 0;
+	c->head.persist = 0;
+	if(c->req.vermaj == 0){
+		c->head.host = hmydomain;
+		return 1;
+	}
+
+	memset(&h, 0, sizeof(h));
+	h.c = c;
+	alarm(timeout);
+	if(!hgethead(c, 1))
+		return -1;
+	alarm(0);
+	h.hstart = c->hpos;
+
+	if(setjmp(h.jmp) == -1)
+		return -1;
+
+	h.eol = 0;
+	h.eoh = 0;
+	h.tok = '\n';
+	while(lex(&h) != '\n'){
+		if(h.tok == Word && lex(&h) == ':')
+			parsejump(&h, hstrdup(c, h.wordval));
+		while(h.tok != '\n')
+			lex(&h);
+		h.eol = h.eoh;
+	}
+
+	if(http11(c)){
+		/*
+		 * according to the http/1.1 spec,
+		 * these rules must be followed
+		 */
+		if(c->head.host == nil){
+			hfail(c, HBadReq, nil);
+			return -1;
+		}
+		if(c->req.urihost != nil)
+			c->head.host = c->req.urihost;
+		/*
+		 * also need to check host is actually this one
+		 */
+	}else if(c->head.host == nil)
+		c->head.host = hmydomain;
+	return 1;
+}
+
+/*
+ * mimeparams	: | mimeparams ";" mimepara
+ * mimeparam	: token "=" token | token "=" qstring
+ */
+static HSPairs*
+mimeparams(Hlex *h)
+{
+	HSPairs *p;
+	char *s;
+
+	p = nil;
+	for(;;){
+		if(lex(h) != Word)
+			break;
+		s = hstrdup(h->c, h->wordval);
+		if(lex(h) != Word && h->tok != QString)
+			break;
+		p = hmkspairs(h->c, s, hstrdup(h->c, h->wordval), p);
+	}
+	return hrevspairs(p);
+}
+
+/*
+ * mimehfields	: mimehfield | mimehfields commas mimehfield
+ * mimehfield	: token mimeparams
+ * commas	: "," | commas ","
+ */
+static HFields*
+mimehfields(Hlex *h)
+{
+	HFields *f;
+
+	f = nil;
+	for(;;){
+		while(lex(h) != Word)
+			if(h->tok != ',')
+				goto breakout;
+
+		f = hmkhfields(h->c, hstrdup(h->c, h->wordval), nil, f);
+
+		if(lex(h) == ';')
+			f->params = mimeparams(h);
+		if(h->tok != ',')
+			break;
+	}
+breakout:;
+	return hrevhfields(f);
+}
+
+/*
+ * parse a list of acceptable types, encodings, languages, etc.
+ */
+static HContent*
+mimeok(Hlex *h, char *name, int multipart, HContent *head)
+{
+	char *generic, *specific, *s;
+	float v;
+
+	/*
+	 * each type is separated by one or more commas
+	 */
+	while(lex(h) != Word)
+		if(h->tok != ',')
+			return head;
+
+	generic = hstrdup(h->c, h->wordval);
+	lex(h);
+	if(h->tok == '/' || multipart){
+		/*
+		 * at one time, IE5 improperly said '*' for single types
+		 */
+		if(h->tok != '/')
+			return nil;
+		if(lex(h) != Word)
+			return head;
+		specific = hstrdup(h->c, h->wordval);
+		if(!multipart && strcmp(specific, "*") != 0)
+			return head;
+		lex(h);
+	}else
+		specific = nil;
+	head = hmkcontent(h->c, generic, specific, head);
+
+	for(;;){
+		switch(h->tok){
+		case ';':
+			/*
+			 * should make a list of these params
+			 * for accept, they fall into two classes:
+			 *	up to a q=..., they modify the media type.
+			 *	afterwards, they acceptance criteria
+			 */
+			if(lex(h) == Word){
+				s = hstrdup(h->c, h->wordval);
+				if(lex(h) != '=' || lex(h) != Word && h->tok != QString)
+					return head;
+				v = strtod(h->wordval, nil);
+				if(strcmp(s, "q") == 0)
+					head->q = v;
+				else if(strcmp(s, "mxb") == 0)
+					head->mxb = v;
+			}
+			break;
+		case ',':
+			return  mimeok(h, name, multipart, head);
+		default:
+			return head;
+		}
+		lex(h);
+	}
+	return head;
+}
+
+/*
+ * parse a list of entity tags
+ * 1#entity-tag
+ * entity-tag = [weak] opaque-tag
+ * weak = "W/"
+ * opaque-tag = quoted-string
+ */
+static HETag*
+mimeetag(Hlex *h, HETag *head)
+{
+	HETag *e;
+	int weak;
+
+	for(;;){
+		while(lex(h) != Word && h->tok != QString)
+			if(h->tok != ',')
+				return head;
+
+		weak = 0;
+		if(h->tok == Word && strcmp(h->wordval, "*") != 0){
+			if(strcmp(h->wordval, "W") != 0)
+				return head;
+			if(lex(h) != '/' || lex(h) != QString)
+				return head;
+			weak = 1;
+		}
+
+		e = halloc(h->c, sizeof(HETag));
+		e->etag = hstrdup(h->c, h->wordval);
+		e->weak = weak;
+		e->next = head;
+		head = e;
+
+		if(lex(h) != ',')
+			return head;
+	}
+	return head;
+}
+
+/*
+ * ranges-specifier = byte-ranges-specifier
+ * byte-ranges-specifier = "bytes" "=" byte-range-set
+ * byte-range-set = 1#(byte-range-spec|suffix-byte-range-spec)
+ * byte-range-spec = byte-pos "-" [byte-pos]
+ * byte-pos = 1*DIGIT
+ * suffix-byte-range-spec = "-" suffix-length
+ * suffix-length = 1*DIGIT
+ *
+ * syntactically invalid range specifiers cause the
+ * entire header field to be ignored.
+ * it is syntactically incorrect for the second byte pos
+ * to be smaller than the first byte pos
+ */
+static HRange*
+mimeranges(Hlex *h, HRange *head)
+{
+	HRange *r, *rh, *tail;
+	char *w;
+	ulong start, stop;
+	int suf;
+
+	if(lex(h) != Word || strcmp(h->wordval, "bytes") != 0 || lex(h) != '=')
+		return head;
+
+	rh = nil;
+	tail = nil;
+	for(;;){
+		while(lex(h) != Word){
+			if(h->tok != ','){
+				if(h->tok == '\n')
+					goto breakout;
+				return head;
+			}
+		}
+
+		w = h->wordval;
+		start = 0;
+		suf = 1;
+		if(w[0] != '-'){
+			suf = 0;
+			start = digtoul(w, &w);
+			if(w[0] != '-')
+				return head;
+		}
+		w++;
+		stop = ~0UL;
+		if(w[0] != '\0'){
+			stop = digtoul(w, &w);
+			if(w[0] != '\0')
+				return head;
+			if(!suf && stop < start)
+				return head;
+		}
+
+		r = halloc(h->c, sizeof(HRange));
+		r->suffix = suf;
+		r->start = start;
+		r->stop = stop;
+		r->next = nil;
+		if(rh == nil)
+			rh = r;
+		else
+			tail->next = r;
+		tail = r;
+
+		if(lex(h) != ','){
+			if(h->tok == '\n')
+				break;
+			return head;
+		}
+	}
+breakout:;
+
+	if(head == nil)
+		return rh;
+
+	for(tail = head; tail->next != nil; tail = tail->next)
+		;
+	tail->next = rh;
+	return head;
+}
+
+static void
+mimeaccept(Hlex *h, char *name)
+{
+	h->c->head.oktype = mimeok(h, name, 1, h->c->head.oktype);
+}
+
+static void
+mimeacceptchar(Hlex *h, char *name)
+{
+	h->c->head.okchar = mimeok(h, name, 0, h->c->head.okchar);
+}
+
+static void
+mimeacceptenc(Hlex *h, char *name)
+{
+	h->c->head.okencode = mimeok(h, name, 0, h->c->head.okencode);
+}
+
+static void
+mimeacceptlang(Hlex *h, char *name)
+{
+	h->c->head.oklang = mimeok(h, name, 0, h->c->head.oklang);
+}
+
+static void
+mimemodified(Hlex *h, char *unused)
+{
+	lexhead(h);
+	h->c->head.ifmodsince = hdate2sec(h->wordval);
+}
+
+static void
+mimeunmodified(Hlex *h, char *unused)
+{
+	lexhead(h);
+	h->c->head.ifunmodsince = hdate2sec(h->wordval);
+}
+
+static void
+mimematch(Hlex *h, char *unused)
+{
+	h->c->head.ifmatch = mimeetag(h, h->c->head.ifmatch);
+}
+
+static void
+mimenomatch(Hlex *h, char *unused)
+{
+	h->c->head.ifnomatch = mimeetag(h, h->c->head.ifnomatch);
+}
+
+/*
+ * argument is either etag or date
+ */
+static void
+mimeifrange(Hlex *h, char *unused)
+{
+	int c, d, et;
+
+	et = 0;
+	c = getc(h);
+	while(c == ' ' || c == '\t')
+		c = getc(h);
+	if(c == '"')
+		et = 1;
+	else if(c == 'W'){
+		d = getc(h);
+		if(d == '/')
+			et = 1;
+		ungetc(h);
+	}
+	ungetc(h);
+	if(et){
+		h->c->head.ifrangeetag = mimeetag(h, h->c->head.ifrangeetag);
+	}else{
+		lexhead(h);
+		h->c->head.ifrangedate = hdate2sec(h->wordval);
+	}
+}
+
+static void
+mimerange(Hlex *h, char *unused)
+{
+	h->c->head.range = mimeranges(h, h->c->head.range);
+}
+
+/*
+ * note: netscape and ie through versions 4.7 and 4
+ * support only basic authorization, so that is all that is supported here
+ *
+ * "Authorization" ":" "Basic" base64-user-pass
+ * where base64-user-pass is the base64 encoding of
+ * username ":" password
+ */
+static void
+mimeauthorization(Hlex *h, char *unused)
+{
+	char *up, *p;
+	int n;
+
+	if(lex(h) != Word || cistrcmp(h->wordval, "basic") != 0)
+		return;
+
+	n = lexbase64(h);
+	if(!n)
+		return;
+
+	/*
+	 * wipe out source for password, so it won't be logged.
+	 * it is replaced by a single =,
+	 * which is valid base64, but not ok for an auth reponse.
+	 * therefore future parses of the header field will not overwrite
+	 * authuser and authpass.
+	 */
+	memmove(h->c->hpos - (n - 1), h->c->hpos, h->c->hstop - h->c->hpos);
+	h->c->hstop -= n - 1;
+	*h->c->hstop = '\0';
+	h->c->hpos -= n - 1;
+	h->c->hpos[-1] = '=';
+
+	up = halloc(h->c, n + 1);
+	n = dec64((uchar*)up, n, h->wordval, n);
+	up[n] = '\0';
+	p = strchr(up, ':');
+	if(p != nil){
+		*p++ = '\0';
+		h->c->head.authuser = hstrdup(h->c, up);
+		h->c->head.authpass = hstrdup(h->c, p);
+	}
+}
+
+static void
+mimeagent(Hlex *h, char *unused)
+{
+	lexhead(h);
+	h->c->head.client = hstrdup(h->c, h->wordval);
+}
+
+static void
+mimefrom(Hlex *h, char *unused)
+{
+	lexhead(h);
+}
+
+static void
+mimehost(Hlex *h, char *unused)
+{
+	char *hd;
+
+	lexhead(h);
+	for(hd = h->wordval; *hd == ' ' || *hd == '\t'; hd++)
+		;
+	h->c->head.host = hlower(hstrdup(h->c, hd));
+}
+
+/*
+ * if present, implies that a message body follows the headers
+ * "content-length" ":" digits
+ */
+static void
+mimecontlen(Hlex *h, char *unused)
+{
+	char *e;
+	ulong v;
+
+	if(lex(h) != Word)
+		return;
+	e = h->wordval;
+	v = digtoul(e, &e);
+	if(v == ~0UL || *e != '\0')
+		return;
+	h->c->head.contlen = v;
+}
+
+/*
+ * mimexpect	: "expect" ":" expects
+ * expects	: | expects "," expect
+ * expect	: "100-continue" | token | token "=" token expectparams | token "=" qstring expectparams
+ * expectparams	: ";" token | ";" token "=" token | token "=" qstring
+ * for now, we merely parse "100-continue" or anything else.
+ */
+static void
+mimeexpect(Hlex *h, char *unused)
+{
+	if(lex(h) != Word || cistrcmp(h->wordval, "100-continue") != 0 || lex(h) != '\n')
+		h->c->head.expectother = 1;
+	h->c->head.expectcont = 1;
+}
+
+static void
+mimetransenc(Hlex *h, char *unused)
+{
+	h->c->head.transenc = mimehfields(h);
+}
+
+static void
+mimefresh(Hlex *h, char *unused)
+{
+	char *s;
+
+	lexhead(h);
+	for(s = h->wordval; *s && (*s==' ' || *s=='\t'); s++)
+		;
+	if(strncmp(s, "pathstat/", 9) == 0)
+		h->c->head.fresh_thresh = atoi(s+9);
+	else if(strncmp(s, "have/", 5) == 0)
+		h->c->head.fresh_have = atoi(s+5);
+}
+
+static void
+mimeignore(Hlex *h, char *unused)
+{
+	lexhead(h);
+}
+
+static void
+parsejump(Hlex *h, char *k)
+{
+	int l, r, m;
+
+	l = 1;
+	r = nelem(mimehead) - 1;
+	while(l <= r){
+		m = (r + l) >> 1;
+		if(cistrcmp(mimehead[m].name, k) <= 0)
+			l = m + 1;
+		else
+			r = m - 1;
+	}
+	m = l - 1;
+	if(cistrcmp(mimehead[m].name, k) == 0 && !mimehead[m].ignore){
+		mimehead[m].seen = 1;
+		(*mimehead[m].parse)(h, k);
+	}else
+		mimeignore(h, k);
+}
+
+static int
+lex(Hlex *h)
+{
+	return h->tok = lex1(h, 0);
+}
+
+static int
+lexbase64(Hlex *h)
+{
+	int c, n;
+
+	n = 0;
+	lex1(h, 1);
+
+	while((c = getc(h)) >= 0){
+		if(!(c >= 'A' && c <= 'Z'
+		|| c >= 'a' && c <= 'z'
+		|| c >= '0' && c <= '9'
+		|| c == '+' || c == '/')){
+			ungetc(h);
+			break;
+		}
+
+		if(n < HMaxWord-1)
+			h->wordval[n++] = c;
+	}
+	h->wordval[n] = '\0';
+	return n;
+}
+
+/*
+ * rfc 822/rfc 1521 lexical analyzer
+ */
+static int
+lex1(Hlex *h, int skipwhite)
+{
+	int level, c;
+
+	if(h->eol)
+		return '\n';
+
+top:
+	c = getc(h);
+	switch(c){
+	case '(':
+		level = 1;
+		while((c = getc(h)) >= 0){
+			if(c == '\\'){
+				c = getc(h);
+				if(c < 0)
+					return '\n';
+				continue;
+			}
+			if(c == '(')
+				level++;
+			else if(c == ')' && --level == 0)
+				break;
+			else if(c == '\n'){
+				c = getc(h);
+				if(c < 0)
+					return '\n';
+				if(c == ')' && --level == 0)
+					break;
+				if(c != ' ' && c != '\t'){
+					ungetc(h);
+					return '\n';
+				}
+			}
+		}
+		goto top;
+
+	case ' ': case '\t':
+		goto top;
+
+	case '\r':
+		c = getc(h);
+		if(c != '\n'){
+			ungetc(h);
+			goto top;
+		}
+
+	case '\n':
+		if(h->tok == '\n'){
+			h->eol = 1;
+			h->eoh = 1;
+			return '\n';
+		}
+		c = getc(h);
+		if(c < 0){
+			h->eol = 1;
+			return '\n';
+		}
+		if(c != ' ' && c != '\t'){
+			ungetc(h);
+			h->eol = 1;
+			return '\n';
+		}
+		goto top;
+
+	case ')':
+	case '<': case '>':
+	case '[': case ']':
+	case '@': case '/':
+	case ',': case ';': case ':': case '?': case '=':
+		if(skipwhite){
+			ungetc(h);
+			return c;
+		}
+		return c;
+
+	case '"':
+		if(skipwhite){
+			ungetc(h);
+			return c;
+		}
+		word(h, "\"");
+		getc(h);		/* skip the closing quote */
+		return QString;
+
+	default:
+		ungetc(h);
+		if(skipwhite)
+			return c;
+		word(h, "\"(){}<>@,;:/[]?=\r\n \t");
+		if(h->wordval[0] == '\0'){
+			h->c->head.closeit = 1;
+			hfail(h->c, HSyntax);
+			longjmp(h->jmp, -1);
+		}
+		return Word;
+	}
+	goto top;
+	return 0;
+}
+
+/*
+ * return the rest of an rfc 822, including \n
+ * do not map to lower case
+ */
+static void
+lexhead(Hlex *h)
+{
+	int c, n;
+
+	n = 0;
+	while((c = getc(h)) >= 0){
+		if(c == '\r')
+			c = wordcr(h);
+		else if(c == '\n')
+			c = wordnl(h);
+		if(c == '\n')
+			break;
+		if(c == '\\'){
+			c = getc(h);
+			if(c < 0)
+				break;
+		}
+
+		if(n < HMaxWord-1)
+			h->wordval[n++] = c;
+	}
+	h->tok = '\n';
+	h->eol = 1;
+	h->wordval[n] = '\0';
+}
+
+static void
+word(Hlex *h, char *stop)
+{
+	int c, n;
+
+	n = 0;
+	while((c = getc(h)) >= 0){
+		if(c == '\r')
+			c = wordcr(h);
+		else if(c == '\n')
+			c = wordnl(h);
+		if(c == '\\'){
+			c = getc(h);
+			if(c < 0)
+				break;
+		}else if(c < 32 || strchr(stop, c) != nil){
+			ungetc(h);
+			break;
+		}
+
+		if(n < HMaxWord-1)
+			h->wordval[n++] = c;
+	}
+	h->wordval[n] = '\0';
+}
+
+static int
+wordcr(Hlex *h)
+{
+	int c;
+
+	c = getc(h);
+	if(c == '\n')
+		return wordnl(h);
+	ungetc(h);
+	return ' ';
+}
+
+static int
+wordnl(Hlex *h)
+{
+	int c;
+
+	c = getc(h);
+	if(c == ' ' || c == '\t')
+		return c;
+	ungetc(h);
+
+	return '\n';
+}
+
+static int
+getc(Hlex *h)
+{
+	if(h->eoh)
+		return -1;
+	if(h->c->hpos < h->c->hstop)
+		return *h->c->hpos++;
+	h->eoh = 1;
+	h->eol = 1;
+	return -1;
+}
+
+static void
+ungetc(Hlex *h)
+{
+	if(h->eoh)
+		return;
+	h->c->hpos--;
+}
+
+static ulong
+digtoul(char *s, char **e)
+{
+	ulong v;
+	int c, ovfl;
+
+	v = 0;
+	ovfl = 0;
+	for(;;){
+		c = *s;
+		if(c < '0' || c > '9')
+			break;
+		s++;
+		c -= '0';
+		if(v > UlongMax/10 || v == UlongMax/10 && c >= UlongMax%10)
+			ovfl = 1;
+		v = v * 10 + c;
+	}
+
+	if(e)
+		*e = s;
+	if(ovfl)
+		return UlongMax;
+	return v;
+}
+
+int
+http11(HConnect *c)
+{
+	return c->req.vermaj > 1 || c->req.vermaj == 1 && c->req.vermin > 0;
+}
+
+char*
+hmkmimeboundary(HConnect *c)
+{
+	char buf[32];
+	int i;
+
+	srand((time(0)<<16)|getpid());
+	strcpy(buf, "upas-");
+	for(i = 5; i < sizeof(buf)-1; i++)
+		buf[i] = 'a' + nrand(26);
+	buf[i] = 0;
+	return hstrdup(c, buf);
+}
+
+HSPairs*
+hmkspairs(HConnect *c, char *s, char *t, HSPairs *next)
+{
+	HSPairs *sp;
+
+	sp = halloc(c, sizeof *sp);
+	sp->s = s;
+	sp->t = t;
+	sp->next = next;
+	return sp;
+}
+
+HSPairs*
+hrevspairs(HSPairs *sp)
+{
+	HSPairs *last, *next;
+
+	last = nil;
+	for(; sp != nil; sp = next){
+		next = sp->next;
+		sp->next = last;
+		last = sp;
+	}
+	return last;
+}
+
+HFields*
+hmkhfields(HConnect *c, char *s, HSPairs *p, HFields *next)
+{
+	HFields *hf;
+
+	hf = halloc(c, sizeof *hf);
+	hf->s = s;
+	hf->params = p;
+	hf->next = next;
+	return hf;
+}
+
+HFields*
+hrevhfields(HFields *hf)
+{
+	HFields *last, *next;
+
+	last = nil;
+	for(; hf != nil; hf = next){
+		next = hf->next;
+		hf->next = last;
+		last = hf;
+	}
+	return last;
+}
+
+HContent*
+hmkcontent(HConnect *c, char *generic, char *specific, HContent *next)
+{
+	HContent *ct;
+
+	ct = halloc(c, sizeof(HContent));
+	ct->generic = generic;
+	ct->specific = specific;
+	ct->next = next;
+	ct->q = 1;
+	ct->mxb = 0;
+	return ct;
+}