xref: /plan9/sys/src/libhttpd/hio.c (revision e02f7f02bd837384880240d3ead0b1c0930eacbe)

#include <u.h>
#include <libc.h>
#include <httpd.h>

static	char	hstates[] = "nrewE";
static	char	hxfers[] = " x";
static int _hflush(Hio*, int, int);

int
hinit(Hio *h, int fd, int mode)
{
	if(fd == -1 || mode != Hread && mode != Hwrite)
		return -1;
	h->hh = nil;
	h->fd = fd;
	h->seek = 0;
	h->state = mode;
	h->start = h->buf + 16;		/* leave space for chunk length */
	h->stop = h->pos = h->start;
	if(mode == Hread){
		h->bodylen = ~0UL;
		*h->pos = '\0';
	}else
		h->stop = h->start + Hsize;
	return 0;
}

int
hiserror(Hio *h)
{
	return h->state == Herr;
}

int
hgetc(Hio *h)
{
	uchar *p;

	p = h->pos;
	if(p < h->stop){
		h->pos = p + 1;
		return *p;
	}
	p -= UTFmax;
	if(p < h->start)
		p = h->start;
	if(!hreadbuf(h, p) || h->pos == h->stop)
		return -1;
	return *h->pos++;
}

int
hungetc(Hio *h)
{
	if(h->state == Hend)
		h->state = Hread;
	else if(h->state == Hread)
		h->pos--;
	if(h->pos < h->start || h->state != Hread){
		h->state = Herr;
		h->pos = h->stop;
		return -1;
	}
	return 0;
}

/*
 * fill the buffer, saving contents from vsave onwards.
 * nothing is saved if vsave is nil.
 * returns the beginning of the buffer.
 *
 * understands message body sizes and chunked transfer encoding
 */
void *
hreadbuf(Hio *h, void *vsave)
{
	Hio *hh;
	uchar *save;
	int c, in, cpy, dpos;

	save = vsave;
	if(save && (save < h->start || save > h->stop)
	|| h->state != Hread && h->state != Hend){
		h->state = Herr;
		h->pos = h->stop;
		return nil;
	}

	dpos = 0;
	if(save && h->pos > save)
		dpos = h->pos - save;
	cpy = 0;
	if(save){
		cpy = h->stop - save;
		memmove(h->start, save, cpy);
	}
	h->seek += h->stop - h->start - cpy;
	h->pos = h->start + dpos;

	in = Hsize - cpy;
	if(h->state == Hend)
		in = 0;
	else if(in > h->bodylen)
		in = h->bodylen;

	/*
	 * for chunked encoding, fill buffer,
	 * then read in new chunk length and wipe out that line
	 */
	hh = h->hh;
	if(hh != nil){
		if(!in && h->xferenc && h->state != Hend){
			if(h->xferenc == 2){
				c = hgetc(hh);
				if(c == '\r')
					c = hgetc(hh);
				if(c != '\n'){
					h->pos = h->stop;
					h->state = Herr;
					return nil;
				}
			}
			h->xferenc = 2;
			in = 0;
			while((c = hgetc(hh)) != '\n'){
				if(c >= '0' && c <= '9')
					c -= '0';
				else if(c >= 'a' && c <= 'f')
					c -= 'a' - 10;
				else if(c >= 'A' && c <= 'F')
					c -= 'A' - 10;
				else
					break;
				in = in * 16 + c;
			}
			while(c != '\n'){
				if(c < 0){
					h->pos = h->stop;
					h->state = Herr;
					return nil;
				}
				c = hgetc(hh);
			}
			h->bodylen = in;

			in = Hsize - cpy;
			if(in > h->bodylen)
				in = h->bodylen;
		}
		if(in){
			while(hh->pos + in > hh->stop){
				if(hreadbuf(hh, hh->pos) == nil){
					h->pos = h->stop;
					h->state = Herr;
					return nil;
				}
			}
			memmove(h->start + cpy, hh->pos, in);
			hh->pos += in;
		}
	}else if(in){
		if((in = read(h->fd, h->start + cpy, in)) < 0){
			h->state = Herr;
			h->pos = h->stop;
			return nil;
		}
	}
	if(in == 0)
		h->state = Hend;

	h->bodylen -= in;

	h->stop = h->start + cpy + in;
	*h->stop = '\0';
	if(h->pos == h->stop)
		return nil;
	return h->start;
}

int
hbuflen(Hio *h, void *p)
{
	return h->stop - (uchar*)p;
}

/*
 * prepare to receive a message body
 * len is the content length (~0 => unspecified)
 * te is the transfer encoding
 * returns < 0 if setup failed
 */
Hio*
hbodypush(Hio *hh, ulong len, HFields *te)
{
	Hio *h;
	int xe;

	if(hh->state != Hread)
		return nil;
	xe = 0;
	if(te != nil){
		if(te->params != nil || te->next != nil)
			return nil;
		if(cistrcmp(te->s, "chunked") == 0){
			xe = 1;
			len = 0;
		}else if(cistrcmp(te->s, "identity") == 0){
			;
		}else
			return nil;
	}

	h = malloc(sizeof *h);
	if(h == nil)
		return nil;

	h->hh = hh;
	h->fd = -1;
	h->seek = 0;
	h->state = Hread;
	h->xferenc = xe;
	h->start = h->buf + 16;		/* leave space for chunk length */
	h->stop = h->pos = h->start;
	*h->pos = '\0';
	h->bodylen = len;
	return h;
}

/*
 * dump the state of the io buffer into a string
 */
char *
hunload(Hio *h)
{
	uchar *p, *t, *stop, *buf;
	int ne, n, c;

	stop = h->stop;
	ne = 0;
	for(p = h->pos; p < stop; p++){
		c = *p;
		if(c == 0x80)
			ne++;
	}
	p = h->pos;

	n = (stop - p) + ne + 3;
	buf = mallocz(n, 1);
	if(buf == nil)
		return nil;
	buf[0] = hstates[h->state];
	buf[1] = hxfers[h->xferenc];

	t = &buf[2];
	for(; p < stop; p++){
		c = *p;
		if(c == 0 || c == 0x80){
			*t++ = 0x80;
			if(c == 0x80)
				*t++ = 0x80;
		}else
			*t++ = c;
	}
	*t++ = '\0';
	if(t != buf + n)
		return nil;
	return (char*)buf;
}

/*
 * read the io buffer state from a string
 */
int
hload(Hio *h, char *buf)
{
	uchar *p, *t, *stop;
	char *s;
	int c;

	s = strchr(hstates, buf[0]);
	if(s == nil)
		return -1;
	h->state = s - hstates;

	s = strchr(hxfers, buf[1]);
	if(s == nil)
		return -1;
	h->xferenc = s - hxfers;

	t = h->start;
	stop = t + Hsize;
	for(p = (uchar*)&buf[2]; c = *p; p++){
		if(c == 0x80){
			if(p[1] != 0x80)
				c = 0;
			else
				p++;
		}
		*t++ = c;
		if(t >= stop)
			return -1;
	}
	*t = '\0';
	h->pos = h->start;
	h->stop = t;
	h->seek = 0;
	return 0;
}

void
hclose(Hio *h)
{
	if(h->fd >= 0){
		if(h->state == Hwrite)
			hxferenc(h, 0);
		close(h->fd);
	}
	h->stop = h->pos = nil;
	h->fd = -1;
}

/*
 * flush the buffer and possibly change encoding modes
 */
int
hxferenc(Hio *h, int on)
{
	if(h->xferenc && !on && h->pos != h->start)
		hflush(h);
	if(_hflush(h, 1, 0) < 0)
		return -1;
	h->xferenc = !!on;
	return 0;
}

int
hputc(Hio *h, int c)
{
	uchar *p;

	p = h->pos;
	if(p < h->stop){
		h->pos = p + 1;
		return *p = c;
	}
	if(hflush(h) < 0)
		return -1;
	return *h->pos++ = c;
}

static int
fmthflush(Fmt *f)
{
	Hio *h;

	h = f->farg;
	h->pos = f->to;
	if(hflush(h) < 0)
		return 0;
	f->stop = h->stop;
	f->to = h->pos;
	f->start = h->pos;
	return 1;
}

int
hvprint(Hio *h, char *fmt, va_list args)
{
	int n;
	Fmt f;

	f.runes = 0;
	f.stop = h->stop;
	f.to = h->pos;
	f.start = h->pos;
	f.flush = fmthflush;
	f.farg = h;
	f.nfmt = 0;
//	fmtlocaleinit(&f, nil, nil, nil);
	n = fmtvprint(&f, fmt, args);
	h->pos = f.to;
	return n;
}

int
hprint(Hio *h, char *fmt, ...)
{
	int n;
	va_list arg;

	va_start(arg, fmt);
	n = hvprint(h, fmt, arg);
	va_end(arg);
	return n;
}

static int
_hflush(Hio *h, int force, int dolength)
{
	uchar *s;
	int w;

	if(h == nil)
		return -1;
	if(h->state != Hwrite){
		h->state = Herr;
		h->stop = h->pos;
		return -1;
	}
	s = h->start;
	w = h->pos - s;
	if(w == 0 && !force)
		return 0;
	if(h->xferenc){
		*--s = '\n';
		*--s = '\r';
		do{
			*--s = "0123456789abcdef"[w & 0xf];
			w >>= 4;
		}while(w);
		h->pos[0] = '\r';
		h->pos[1] = '\n';
		w = &h->pos[2] - s;
	}
	if(dolength)
		fprint(h->fd, "Content-Length: %d\r\n\r\n", w);
	if(write(h->fd, s, w) != w){
		h->state = Herr;
		h->stop = h->pos;
		return -1;
	}
	h->seek += w;
	h->pos = h->start;
	return 0;
}

int
hflush(Hio *h)
{
	return _hflush(h, 0, 0);
}

int
hlflush(Hio* h)
{
	return _hflush(h, 0, 1);
}

int
hwrite(Hio *h, void *vbuf, int len)
{
	uchar *buf;
	int n, m;

	buf = vbuf;
	n = len;
	if(n < 0 || h->state != Hwrite){
		h->state = Herr;
		h->stop = h->pos;
		return -1;
	}
	if(h->pos + n >= h->stop){
		if(h->start != h->pos)
			if(hflush(h) < 0)
				return -1;
		while(h->pos + n >= h->stop){
			m = h->stop - h->pos;
			if(h->xferenc){
				memmove(h->pos, buf, m);
				h->pos += m;
				if(hflush(h) < 0)
					return -1;
			}else{
				if(write(h->fd, buf, m) != m){
					h->state = Herr;
					h->stop = h->pos;
					return -1;
				}
				h->seek += m;
			}
			n -= m;
			buf += m;
		}
	}
	memmove(h->pos, buf, n);
	h->pos += n;
	return len;
}