#include "i.h"

typedef struct NGchanitem NGchanitem;
typedef struct ImageCache ImageCache;

// Item sent allong ngchan
struct NGchanitem {
	int			req;
	ByteSource*	bs;
	Netconn*		nc;
	Channel*		anschan;
};

// In-memory cache of CImages
struct ImageCache
{
	CImage*	imhd;		// head (LRU) of cache chain (linked through CImage.next)
	CImage*	imtl;			// tail MRU) of cache chain
	int		n;			// size of chain
	int		memused;	// current total of image mem used by cached images
	int		memlimit;		// keep memused less than this
	int		nlimit;		// keep n less than this
};

// Some constants
enum {
	NCTimeout = 100000,	// free NC slot after 100 seconds
	UBufsize = 40960,		// initial buffer size for unknown lengths
	UEBufsize = 1024,		// initial buffer size for unknown lengths, error responses
	Maxnthreads = 10,		// max allowed config.nthreads
};

Rune crlf[] = L"\r\n";
Rune  sptab[] =  L" \t";

// globals
int			bytesourceid = 0;	// for allocating bytesource ids
int			netconnid = 0;		// for allocating netconn ids
int			dbg;				// config.dbg['d']
int			warn;			// dbg || config.dbg['w']
int			dbgev;			// config.dbg['e']
int			dbgproto;			// are we debugging netget protocol?
int			aborting;			// in the process of aborting a get
Netconn**	netconns;			// array of netconns
int			nnetconns;		// current number of slots in netconns
Channel*		ngchan;			// Channel of NGchanitem
Channel*		reqanschan;		// Channel of ByteSource*
Channel*		abortanschan;		// Channel of ByteSource*
Config		config;
ResourceState	startres;
ImageCache	imcache;

// Track HTTP methods in i.h
// (upper-case, since that's required in HTTP requests)
Rune* hmeth[] = { L"GET", L"POST" };

// Track media types in charon.h
// keep in alphabetical order
Rune* mnames[] = {
	L"application/msword",
	L"application/octet-stream",
	L"application/pdf",
	L"application/postscript",
	L"application/rtf",
	L"application/vnd.framemaker",
	L"application/vnd.ms-excel",
	L"application/vnd.ms-powerpoint",
	L"application/x-unknown",
	L"audio/32kadpcm",
	L"audio/basic",
	L"image/cgm",
	L"image/g3fax",
	L"image/gif",
	L"image/ief",
	L"image/jpeg",
	L"image/png",
	L"image/tiff",
	L"image/x-bit",
	L"image/x-bit2",
	L"image/x-bitmulti",
	L"image/x-xbitmap",
	L"model/vrml",
	L"multipart/digest",
	L"multipart/mixed",
	L"text/css",
	L"text/enriched",
	L"text/html",
	L"text/javascript",
	L"text/plain",
	L"text/richtext",
	L"text/sgml",
	L"text/tab-separated-values",
	L"text/xml",
	L"video/mpeg",
	L"video/quicktime"
};

// Track Charsets in i.h
//(cf rfc1945 for other names, those we don't bother handling)
Rune* chsetnames[] = {
	L"unknown", L"us-ascii", L"iso-8859-1", L"unicode-1-1-utf-8", L"unicode-1-1"
};

// Track Netconn states in i.h
Rune* ncstatenames[] = {
	L"free", L"idle", L"connect", L"gethdr", L"getdata",
	L"done", L"err"
};

// Track major status values in i.h
Rune* hsnames[] = {
	L"none", L"information", L"ok", L"redirect", L"request error", L"server error"
};

// File extension to Media type lookup table
// (keep sorted on file extension)
static StringInt fileexttable[] = {
	{L"ai", ApplPostscript},
	{L"au", AudioBasic},
	{L"bit", ImageXBit},
	{L"bit2", ImageXBit2},
	{L"bitm", ImageXBitmulti},
	{L"eps", ApplPostscript},
	{L"gif", ImageGif},
	{L"htm", TextHtml},
	{L"html", TextHtml},
	{L"jpe", ImageJpeg},
	{L"jpeg", ImageJpeg},
	{L"jpg", ImageJpeg},
	{L"pdf", ApplPdf},
	{L"ps", ApplPostscript},
	{L"text", TextPlain},
	{L"tif", ImageTiff},
	{L"tiff", ImageTiff},
	{L"txt", TextPlain}
};
#define NFILEEXTS (sizeof(fileexttable)/sizeof(StringInt))

// Beginning of a JPEG file
static uchar jpmagic[] = {0xFF, 0xD8, 0xFF, 0xE0,
		0, 0, 'J', 'F', 'I', 'F', 0};

// Color lookup table
static StringInt color_tab[] = {
	{L"aqua", 0x00FFFF},
	{L"black", Black},
	{L"blue", Blue},
	{L"fuchsia", 0xFF00FF},
	{L"gray", 0x808080},
	{L"green", 0x008000},
	{L"lime", 0x00FF00},
	{L"maroon", 0x800000},
	{L"navy", Navy},
	{L"olive", 0x808000},
	{L"purple", 0x800080},
	{L"red", Red},
	{L"silver", 0xC0C0C0},
	{L"teal", 0x008080},
	{L"white", White},
	{L"yellow", 0xFFFF00}
};
#define NCOLORS (sizeof(color_tab)/sizeof(StringInt))

// track Error codes in i.h
static Rune* errphrases[] = {
	L"(no error)",
	L"Stopped",
	L"Unsupported scheme",
	L"Unexpected HTTP answer code",
	L"Redirect loop",
	L"Can't get file status",
	L"Read error",
	L"Write error",
	L"Unexpected end of file",
	L"Couldn't connect",
	L"FTP protocol error",
	L"FTP login failed",
	L"HTTP protocol error",
	L"Authorization failed",
	L"Unsupported image type",
	L"Not enough memory",
	L"Image encoding is bad"
};
#define NERRPHRASES (sizeof(errphrases)/sizeof(Rune*))

static StringInt 		*targetmap;
static int			targetmapsize;
static int			ntargets;
static void			runnetconn(void *arg);
static int			strhash(Rune* s);
static Transport*	gettransport(int scheme);
static Netconn*		newnetconn(int id);
static void			makefree(Netconn* nc);
static ByteSource*	newbytesource(void);
static void			imcacheinit(void);
static void			setconfig(int argc, char** argv);
static int			setopt(Rune* key, int keylen, Rune* val, int vallen);
static void			targetmapinit(void);
static int			rnhandler(void* ureg, char* note);
static void			sendprocintr(int pid);
static int			countrefgo(void);


// Initialize Chutils globals
void
iutilsinit(int argc, char** argv)
{
	startres = curresstate();

	// Setconfig needs urlinit() to have been done.
	// Rest of inits are done after setconfig, in case their
	// actions depend on configuration settings.
	// guiinit() is done in i.c.
	urlinit();
	setconfig(argc, argv);
	transportinit();
	lexinit();
	buildinit();
	layoutinit();
	imginit();
	eventinit();
	imcacheinit();
	targetmapinit();
	gcinit();
	threadnotify(rnhandler, 1);
	aborting = 0;
	nnetconns = 10;
	netconns = emallocz(sizeof(Netconn)*nnetconns);
	dbgproto = config.dbg['p'];
	dbg = config.dbg['d'];
	warn = config.dbg['w'];
	dbgev = config.dbg['e'];
	ngchan = chancreate(sizeof(NGchanitem), 0);
	reqanschan = chancreate(sizeof(ByteSource*), 0);
	abortanschan = chancreate(sizeof(ByteSource*), 0);
	if(ngchan == nil || reqanschan == nil || abortanschan == nil)
		fatalerror("can't create channels");
}

// Make a ByteSource for given request, and make sure
// that it is on the queue of some Netconn.
// If don't have a transport for the request's scheme,
// the returned bs will have err set.
ByteSource*
startreq(ReqInfo* req)
{
	ByteSource*	bs;
	ByteSource*	bsans;
	NGchanitem	ngi;

	bs = newbytesource();
	bs->req = req;
	bs->refgo = 1;
	bs->refnc = 1;
	if(config.showprogress)
		sendprogress(bs->id, Pstart, 0, req->url->url);
	ngi.req = NGstartreq;
	ngi.bs = bs;
	ngi.nc = nil;
	ngi.anschan = reqanschan;
	if(send(ngchan, &ngi) < 0)
		finish();
	if(recv(reqanschan, &bsans) < 0)
		finish();
	return bs;
}

// Wait for some ByteSource to
// have a state change that go hasn't seen yet.
// There's a race between go doing a freebs
// and netconn returning a statechange;
// fix that race by only returning bs's that
// still have refgo == 1.
ByteSource*
waitreq(void)
{
	ByteSource*	bs;
	NGchanitem	ngi;

	ngi.req = NGwaitreq;
	do {
		ngi.bs = nil;
		ngi.nc = nil;
		ngi.anschan = reqanschan;
		if(send(ngchan, &ngi) < 0)
			finish();
		if(recv(reqanschan, &bs) < 0)
			finish();
		if(bs == nil)
			return nil;
	} while(bs->refgo == 0);
	return bs;
}

// Notify netget that goproc is finished with bs.
// See waitreq comment about waitfreq/freebs race.
void
freebs(ByteSource* bs)
{
	NGchanitem	ngi;

	bs->refgo = 0;
	ngi.req = NGfreebs;
	ngi.bs = bs;
	ngi.nc = nil;
	ngi.anschan = reqanschan;
	if(send(ngchan, &ngi) < 0)
		finish();
	if(recv(reqanschan, &bs) < 0)
		finish();
}

// Tell netget to abort all gets.
// This involves sending interrupts to any runnetconns that
// may be stuck in I/O.
// All bs's will then be returned to waitreq with an "aborted"
// error, after which this function can return.
void
abortgo(void)
{
	NGchanitem	ngi;

	if(dbg)
		trace("abort go\n");

	ngi.req = NGabort;
	ngi.bs = nil;
	ngi.nc = nil;
	ngi.anschan = abortanschan;

	if(send(ngchan, &ngi) < 0)
		finish();
	if(recv(abortanschan, nil) < 0)
		finish();
}

int
forkrunnetconn(Netconn *nc, void **rncargs)
{
	int id;

	assert(nc->rnpid == 0 && nc->rntid == 0);
	if(config.nthreads > 0)
		id = proccreate(runnetconn, (void*)rncargs, STACKSIZE);
	else
		id = threadcreate(runnetconn, (void*)rncargs, STACKSIZE);
	if(id < 0)
		return -1;
	nc->rntid = id;
	return 0;
}

// This runs as a separate thread.
// It acts as a monitor to synchronize access to the Netconn data
// structures, as a dispatcher to start runnetconn's as needed to
// process work on Netconn queues, and as a notifier to let goproc
// know when any ByteSources have advanced their state.
void
netget(void* arg)
{
	int	msg;
	int	n;
	int	i;
	int	toldgo;
	ByteSource*	bs;
	ByteSource*	bsnil;
	Netconn*	nc;
	Channel*	c;
	Channel*	pendingc;
	int	waitpending;
	int	maxconn;
	Netconn*	x;
	int	minqlen;
	Rune*	sport;
	int	port;
	int	freen;
	int	scheme;
	Rune*	host;
	int	err;
	int	totlen;
	ByteSource*	sendtopending;
	NGchanitem	ngi;
	Transport*	tpt;
	int		gncs[Maxnthreads];
	void*	rncargs[2];

	USED(arg);
	waitpending = 0;
	maxconn = config.nthreads;
	if(maxconn < 1)
		maxconn = 1;
	if(maxconn > Maxnthreads)
		maxconn = Maxnthreads;
	for(n = 0; n < nnetconns; n++)
		netconns[n] = newnetconn(n);
	bsnil = nil;
	pendingc = nil;
	sendtopending = nil;
	toldgo = 0;
	while(1) {
    mainloop_start:
		if(aborting) {
			if(toldgo && countrefgo() == 0) {
				if(send(abortanschan, nil) < 0)
					finish();
				aborting = 0;
			}
		}
		if(recv(ngchan, &ngi) < 0)
			finish();
		msg = ngi.req;
		bs = ngi.bs;
		nc = ngi.nc;
		c = ngi.anschan;
		switch(msg) {
		case NGstartreq:
			// bs has req filled in, and is otherwise in its initial state.
			// Find a suitable Netconn and add bs to its queue of work,
			// then send nil along c to let goproc continue.

			if(dbgproto)
				trace("Startreq BS=%d for %U\n", bs->id, bs->req->url);
			scheme = bs->req->url->scheme;
			host = Strndup(bs->req->url->host, bs->req->url->nhost);
			err = 0;
			tpt = nil;
			if(aborting)
				err = ERRaborted;
			else if(scheme < 0 || scheme >= TRANSMAX || transports[scheme] == nil)
				err = ERRunsupscheme;
			else 
				tpt = transports[scheme];
			if(err)
				bs->err = err;
			else {
				sport = Strndup(bs->req->url->port, bs->req->url->nport);
				if(sport == nil)
					port = (tpt->defaultport)(scheme);
				else
					port = Strtol(sport, nil, 10);
				i = 0;
				freen = -1;
				for(n = 0; n < nnetconns && (i < maxconn || freen == -1); n++) {
					nc = netconns[n];
					if(nc->state == NCfree) {
						if(freen == -1)
							freen = n;
					}
					else if(!Strcmp(nc->host, host) && nc->port == port
							&& nc->scheme == scheme && i < maxconn) {
						gncs[i++] = n;
					}
				}
				if(i < maxconn) {
					//  use a new netconn for this bs
					if(freen == -1) {
						// need to make netconns bigger
						netconns = (Netconn**)erealloc(netconns, (freen + 10) * sizeof(Netconn*));
						for(i = nnetconns; i < nnetconns+10; i++)
							netconns[i] = newnetconn(i);
						freen = nnetconns;
						nnetconns += 10;
					}
					nc = netconns[freen];
					nc->rnpid = 0;
					nc->rntid = 0;
					nc->host = host;
					nc->port = port;
					nc->scheme = scheme;
					nc->qlen = 0;
					nc->ngcur = 0;
					nc->gocur = 0;
					nc->reqsent = 0;
					nc->pipeline = 0;
					nc->connected = 0;
				}
				else {
					// use existing netconn with fewest outstanding requests
					nc = netconns[gncs[0]];
					if(maxconn > 1) {
						minqlen = nc->qlen - nc->gocur;
						for(i = 1; i < maxconn; i++) {
							x = netconns[gncs[i]];
							if(x->qlen - x->gocur < minqlen) {
								nc = x;
								minqlen = x->qlen - x->gocur;
							}
						}
					}
				}
				if(nc->qlen == nc->qalloclen) {
					// need to make queue bigger
					nc->queue = (ByteSource**)erealloc(nc->queue, (nc->qalloclen + 10) * sizeof(ByteSource*));
					nc->qalloclen += 10;
				}
				nc->queue[nc->qlen++] = bs;
				bs->net = nc;
				if(dbgproto)
					trace("Chose NC=%d for BS %d, qlen=%d\n", nc->id, bs->id, nc->qlen);
				if(nc->state == NCfree || nc->state == NCidle) {
					if(nc->connected) {
						nc->state = NCgethdr;
						if(dbgproto)
							trace("NC %d: starting runnetconn in gethdr state\n", nc->id);
					}
					else {
						nc->state = NCconnect;
						if(dbgproto)
							trace("NC %d: starting runnetconn in connect state\n", nc->id);
					}
					rncargs[0] = nc;
					rncargs[1] = tpt;
					if(forkrunnetconn(nc, rncargs) < 0){
						trace("Can't start runnetconn!\n");
						return;
					}
				}
			}
			if(send(c, &bsnil) < 0)
				finish();
			break;

		case NGwaitreq:
			// goproc wants to be notified when some ByteSource
			// changes to a state that the goproc hasn't seen yet.
			// Send such a ByteSource along return channel c.

			if(dbgproto)
				trace("Waitreq\n");
			assert(!waitpending);
			if(aborting) {
				if(dbgproto)
					trace("Send <abort> to waitreq\n");
				send(c, &bsnil);
				toldgo = 1;
				goto mainloop_start;
			}
			for(n = 0; n < nnetconns; n++) {
				nc = netconns[n];
				if(nc->state == NCfree)
					continue;
				if(nc->gocur < nc->qlen) {
					bs = nc->queue[nc->gocur];
					if(!bs->refgo)
						continue;
					if(bs->err ||
					   (bs->hdr != nil && !bs->seenhdr) ||
					   (bs->edata > bs->lim) || (nc->gocur < nc->ngcur)) {
						if(dbgproto)
							trace("Send BS %d to waitreq\n", bs->id);
						if(send(c, &bs) < 0)
							finish();
						goto mainloop_start;
					}
				}
			}
			if(dbgproto)
				trace("Waitpending\n");
			waitpending = 1;
			pendingc = c;
			break;

		case NGfreebs:
			if(dbgproto)
				trace("Freebs BS=%d\n", bs->id);
			nc = bs->net;
			if(bs->refnc == 0) {
				if(nc != nil)
					nc->queue[nc->gocur] = nil;
			}
			if(nc != nil) {
				// can be nil if no transport was found
				nc->gocur++;
				if(dbgproto)
					trace("NC %d: gocur=%d, ngcur=%d, qlen=%d\n",
						nc->id, nc->gocur, nc->ngcur, nc->qlen);
				if(nc->gocur == nc->qlen && nc->ngcur == nc->qlen) {
					if(!nc->connected)
						makefree(nc);
				}
			}
			if(send(c, &bsnil) < 0)
				finish();
			break;

		case NGstatechg:
			// Some runnetconn is telling us tht it changed the
			// state of nc.  Send a nil along c to let it continue.

			if(dbgproto)
				trace("Statechg NC=%d, state=%S\n", nc->id, ncstatenames[nc->state]);
			sendtopending = nil;
			if(!aborting && waitpending && nc->gocur < nc->qlen) {
				bs = nc->queue[nc->gocur];
				if(dbgproto) {
					totlen = 0;
					if(bs->hdr != nil)
						totlen = bs->hdr->length;
					trace("BS %d: havehdr=%d seenhdr=%d edata=%d lim=%d, length=%d\n",
						 bs->id, bs->hdr != nil, bs->seenhdr, bs->edata, bs->lim, totlen);
					if(bs->err)
						trace("   err=%S\n", errphrase(bs->err));
				}
				if(bs->refgo &&
				   (bs->err ||
				   (bs->hdr != nil && !bs->seenhdr) ||
				   (bs->edata > bs->lim)))
					sendtopending = bs;
			}
			if(nc->state == NCdone || nc->state == NCerr) {
				if(dbgproto)
					trace("NC %d: runnetconn finishing\n", nc->id);
if(nc->ngcur >= nc->qlen) {
trace("NC %d has ngcur=%d, qlen=%d\n", nc->id, nc->ngcur, nc->qlen);
}
				assert(nc->ngcur < nc->qlen);
				bs = nc->queue[nc->ngcur];
				bs->refnc = 0;
				if(bs->refgo == 0)
					nc->queue[nc->ngcur] = nil;
				nc->ngcur++;
				if(dbgproto)
					trace("NC %d: ngcur=%d\n", nc->id, nc->ngcur);
				nc->state = NCidle;
				nc->rnpid = 0;
				nc->rntid = 0;
				if(dbgproto)
					trace("NC %d: idle\n", nc->id);
				if(aborting) {
					/* free ByteSources! */
					makefree(nc);
				}
				else if(nc->ngcur < nc->qlen) {
					if(nc->connected) {
						nc->state = NCgethdr;
						if(dbgproto)
							trace("NC %d: starting runnetconn in gethdr state\n", nc->id);
					}
					else {
						nc->state = NCconnect;
						if(dbgproto)
							trace("NC %d: starting runnetconn in connect state\n", nc->id);
					}
					rncargs[0] = nc;
					rncargs[1] = transports[nc->scheme];
					if(forkrunnetconn(nc, rncargs) < 0){
						trace("Can't start runnetconn!\n");
						return;
					}
				}
				else if(!nc->connected)
					makefree(nc);
			}
if(dbgproto)
	trace("Send reply to chan 0x%p\n", c);
			send(c, &bsnil);
if(dbgproto)
	trace("done sending reply to chan 0x%p\n", c);
			if(sendtopending != nil) {
				if(dbgproto)
					trace("Send BS %d to pending waitreq\n", bs->id);
				send(pendingc, &sendtopending);
				waitpending = 0;
			}
			break;
		case NGabort:
			if(dbgproto)
				trace("NGabort received\n");
			aborting = 1;
			if(waitpending) {
				if(dbgproto)
					trace("Send <abort> to pending waitreq\n");
				send(pendingc, &bsnil);
				waitpending = 0;
				toldgo = 1;
			}
			else
				toldgo = !countrefgo();
			for(n = 0; n < nnetconns; n++) {
				nc = netconns[n];
				if(nc->rntid != 0) {
					if(config.nthreads != 0)
						sendprocintr(nc->rnpid);
					/* else we can't interrupt */
				}
			}
			break;
		}
	}
}

// Return number of ByteSources in netget queues
// that have refgo
static int
countrefgo(void)
{
	int ans, i, n;
	Netconn*	nc;
	ByteSource* bs;

	ans = 0;
	for(n = 0; n < nnetconns; n++) {
		nc = netconns[n];
		if(nc->state != NCfree) {
			for(i = 0; i < nc->qlen; i++) {
				bs = nc->queue[i];
				if(bs == nil)
					continue;
				if(bs->refgo)
					ans++;
			}
		}
	}
	return ans;
}

static void
sendprocintr(int pid)
{
	int fd;
	char buf[100];

	if(dbgproto)
		trace("proc %d sending rnintr to proc %d\n", getpid(), pid);
	sprint(buf, "/proc/%d/note", pid);
	fd = open(buf, OWRITE);
	if(fd >= 0) {
		write(fd, "rnintr", 6);
		close(fd);
	}
}

static int
rnhandler(void* ureg, char* note)
{
	USED(ureg);
	if(strncmp(note, "rnintr", 6) == 0) {
		if(dbgproto)
			trace("proc %d got rnintr\n", getpid());
		return 1;
	}
	return 0;
}

// A separate proc, to handle ngcur request of transport.
// The arguments should be: {Netconn*, Transport*}.
// If config.nthreads == 0, it is run as thread rather than proc
// (for debugging).
static void
runnetconn(void* arg)
{
	Netconn*	nc;
	Transport*	tpt;
	int	totlen;
	Channel*	ach;
	ByteSource*	bs;
	ByteSource*	bsans;
	NGchanitem	ngi;
	void**	args;

	if(config.nthreads != 0)
		meminit(GRnet);
	args = (void**)arg;
	nc = (Netconn*)args[0];
	nc->rnpid = getpid();
	tpt = (Transport*)args[1];
	ach = chancreate(sizeof(ByteSource*), 0);
	assert(nc->ngcur < nc->qlen);
	bs = nc->queue[nc->ngcur];
	ngi.req = NGstatechg;
	ngi.bs = nil;
	ngi.nc = nc;
	ngi.anschan = ach;
	bs->data = nil;

	if(nc->state == NCconnect) {
		(tpt->connect)(nc, bs);
		if(bs->err || aborting)
			goto finished;
		nc->state = NCgethdr;
	}
	assert(nc->state == NCgethdr && nc->connected);
	if(config.showprogress)
		sendprogress(bs->id, Pconnected, 0, nil);

	// Write enough requests so that nc->ngcur header
	//will be next to be retrieved
	while(nc->reqsent < nc->qlen) {
		(tpt->writereq)(nc, nc->queue[nc->reqsent]);
		if(aborting)
			goto finished;
		if(nc->queue[nc->reqsent]->err) {
			if(nc->reqsent > nc->ngcur) {
				nc->queue[nc->reqsent]->err = 0;
				break;
			}
			else
				goto finished;
		}
		nc->reqsent++;
		if(nc->reqsent >= nc->ngcur + 1 || !nc->pipeline)
			break;
	}
	assert(nc->reqsent > nc->ngcur);

	// Get the header
	(tpt->gethdr)(nc, bs);
	if(bs->err || aborting)
		goto finished;
	assert(bs->hdr != nil);
	if(config.showprogress)
		sendprogress(bs->id, Phavehdr, 0, nil);

	totlen = bs->hdr->length;
	if(totlen > 0) {
		nc->state = NCgetdata;
		if(send(ngchan, &ngi) == -1)
			goto cleanup;
		if(recv(ach, &bsans) == -1)
			goto cleanup;
		bs->data = (uchar*)emalloc(totlen);
		bs->dalloclen = totlen;
		while(bs->edata < totlen) {
			(tpt->getdata)(nc, bs);
			if(bs->err || aborting)
				goto finished;
			if(config.showprogress)
				sendprogress(bs->id, Phavedata, 100*bs->edata/totlen, nil);
			if(send(ngchan, &ngi) == -1)
				goto cleanup;
			if(recv(ach, &bsans) == -1)
				goto cleanup;
		}
	}
	else if(totlen == -1) {
		// Unknown length.
		// To simplify consumer semantics, we want bs->data to
		// not change underfoot, so for now, simply accumlate
		// everything before telling consumer about a state change.
		//
		// Report progress percentage based on current totlen (wrong
		// of course, but at least shows trend)
		if(bs->hdr->code == HCOk || bs->hdr->code == HCOkNonAuthoritative)
			totlen = UBufsize;
		else
			totlen = UEBufsize;
		nc->state = NCgetdata;
		bs->hdr->length = 100000000;	// avoid BS free during following loop
		if(send(ngchan, &ngi) == -1)
			goto cleanup;
		if(recv(ach, &bsans) == -1)
			goto cleanup;
		bs->data = (uchar*)emalloc(totlen);
		bs->dalloclen = totlen;
		while(1) {
			(tpt->getdata)(nc, bs);
			if(aborting)
				goto finished;
			if(config.showprogress)
				sendprogress(bs->id, Phavedata, 100*bs->edata/totlen, nil);
			if(bs->err) {
				// assume EOF
				bs->data = (uchar*)erealloc(bs->data, bs->edata);
				bs->dalloclen = bs->edata;
				bs->err = 0;
				bs->hdr->length = bs->edata;
				nc->connected = 0;
				break;
			}
			if(bs->edata == totlen) {
				totlen *= 2;
				bs->data = (uchar*)erealloc(bs->data, totlen);
				bs->dalloclen = totlen;
			}
		}
	}
	nc->state = NCdone;
	if(config.showprogress)
		sendprogress(bs->id, Phavedata, 100, nil);

finished:
	if(aborting)
		bs->err = ERRaborted;
	if(bs->err) {
		nc->state = NCerr;
		nc->connected = 0;
		/*
		 * If we're aborting, then the event loop is stuck in abortgo
		 * waiting for us to finish.  Don't update the progress meter,
		 * since that requires having the event loop.
		 */
		if(!aborting && config.showprogress)
			sendprogress(bs->id, Perr, 0, errphrase(bs->err));
	}
	if(send(ngchan, &ngi) == -1)
		goto cleanup;
	recv(ach, &bsans);
	if(dbgproto)
		trace("runnetconn in proc %d exiting\n", getpid());
	threadexits("");

cleanup:
	if(aborting)
		goto finished;
	if(dbgproto)
		trace("runnetconn in proc %d exiting\n", getpid());
	threadexits("");
}

// Allocate a new Netconn, set its id and all other fields to "unused" state
static Netconn*
newnetconn(int id)
{
	Netconn* nc;

	nc = (Netconn*)emalloc(sizeof(Netconn));
	nc->id = id;
	nc->qalloclen = 10;
	nc->queue = (ByteSource**)emalloc(nc->qalloclen*sizeof(ByteSource*));
	makefree(nc);
	return nc;
}

// Reset the fields of nc so that it is free to service another connection to anywhere.
static void
makefree(Netconn* nc)
{
	if(dbgproto)
		trace("NC %d: free\n", nc->id);
	nc->state = NCfree;
	nc->rnpid = 0;
	nc->host = nil;
	nc->port = 0;
	nc->dfd = -1;
	nc->cfd = -1;
	nc->qlen = 0;
	nc->gocur = 0;
	nc->ngcur = 0;
	nc->reqsent = 0;
	nc->pipeline = 0;
	nc->connected = 0;
	nc->tstate = 0;
	nc->tn1 = 0;
	nc->tn2 = 0;
	nc->tbuf = nil;
	nc->tbuflen = 0;
	memset(nc->queue, 0, nc->qalloclen*sizeof(ByteSource*));
}

// Allocate a new ByteSource, and set its fields to initial state.
static ByteSource*
newbytesource(void)
{
	ByteSource* bs;

	bs = (ByteSource*)emallocz(sizeof(ByteSource));
	bs->id = bytesourceid++;
	return bs;
}

// Return an ByteSource that is completely filled, from string s.
ByteSource*
newstringbytesource(Rune* s)
{
	ByteSource* bs;
	Header* hdr;
	uchar* a;
	int n;

	n = Strlen(s);
	a = (uchar*)emalloc(n*sizeof(Rune));
	memmove(a, s, n*sizeof(Rune));
	hdr = newheader();
	hdr->code = HCOk;
	hdr->length = n;
	hdr->mtype = TextHtml;
	hdr->chset = Unicode;
	bs = newbytesource();
	bs->hdr = hdr;
	bs->data = a;
	bs->dalloclen = n*sizeof(Rune);
	bs->edata = bs->dalloclen;
	bs->refgo = 1;
	bs->seenhdr = 1;
	return bs;
}

// Allocate a new ReqInfo structure, fill it in, and return.
ReqInfo*
newreqinfo(ParsedUrl* url, int method, uchar* body, int bodylen, Rune* auth, int target)
{
	ReqInfo* r;

	r = (ReqInfo*)emalloc(sizeof(ReqInfo));
	r->url = url;
	r->method = method;
	r->body = body;
	r->bodylen = bodylen;
	r->auth = auth;
	r->target = target;
	return r;
}

// Allocate a new MaskedImage, with im for the image field.
MaskedImage*
newmaskedimage(Image* im)
{
	MaskedImage* m;

	m = (MaskedImage*)emallocz(sizeof(MaskedImage));
	m->im = im;
	return m;
}

// Allocate a new CImage, with the give src, width, and height.
// Start with a reference count of 1.
CImage*
newcimage(ParsedUrl* src, int width, int height)
{
	CImage* c;

	c = (CImage*)emalloc(sizeof(CImage));
	c->src = src;
	c->actual = nil;
	if(src != nil)
		c->imhash = strhash(src->host) + strhash(src->path);
	else
		c->imhash = 0;
	c->width = width;
	c->height = height;
	c->refcnt = 1;
	c->next = nil;
	c->mims = nil;
	c->mimslen = 0;
	return c;
}

// Decrement the refcnt, and free when it reaches 0.
void
freecimage(CImage* c)
{
	int i;
	MaskedImage* m;

	if(--c->refcnt <= 0) {
		if(c->mims != nil) {
			for(i = 0; i < c->mimslen; i++) {
				m = c->mims[i];
				if(m->im != nil)
					freeimage(m->im);
				if(m->mask != nil)
					freeimage(m->mask);
			}
		}
	}
}

// Return true if Cimages a and b represent the same image.
// As well as matching the src urls, the specified widths and heights must match too.
// (Widths and heights are specified if at least one of those is not zero.)
int
cimagematch(CImage* a, CImage* b)
{
	if(a->imhash == b->imhash) {
		if(urlequal(a->src, b->src)) {
			return (a->width == 0 || b->width == 0 || a->width == b->width) &&
				(a->height == 0 || b->height == 0 || a->height == b->height);
			// (above is not quite enough: should also check that don't have
			// situation where one has width set, not height, and the other has reverse,
			// but it is unusual for an image to have a spec in only one dimension anyway)
		}
	}
	return 0;
}

// Return approximate number of bytes due to Images in ci
int
cimagebytes(CImage* ci)
{
	int tot, i;
	MaskedImage* mim;
	Image* dim;

	tot = 0;
	for(i = 0; i < ci->mimslen; i++) {
		mim = ci->mims[i];
		dim = mim->im;
		if(dim != nil)
			tot += ((dim->r.max.x-dim->r.min.x)>>(3-log2[dim->depth])) *
					(dim->r.max.y-dim->r.min.y);
		dim = mim->mask;
		if(dim != nil)
			tot += ((dim->r.max.x-dim->r.min.x)>>(3-log2[dim->depth])) *
					(dim->r.max.y-dim->r.min.y);
	}
	return tot;
}

// Call this after initial windows have been made,
// so that resetlimits() will exclude the images for those
// windows from the available memory.
static void
imcacheinit(void)
{
	memset(&imcache, 0, sizeof(imcache));
	imcacheresetlimits();
}

// Call resetlimits when amount of non-image-cache image
// memory might have changed significantly (e.g., on main window resize).
void
imcacheresetlimits(void)
{
	int avail;
	ResourceState rs;

	rs = curresstate();
	avail = rs.memavail;
	avail = 6*avail/10;	// allow 40% slop for nonimage data and other applications
	imcache.memlimit = config.imagecachemem;
	if(imcache.memlimit > avail)
		imcache.memlimit = avail;
	imcache.nlimit = config.imagecachenum;
	imcacheneed(0);	// if resized, perhaps need to shed some images
}

// Look for a CImage matching ci, and if found, move it
// to the tail position (i.e., MRU)
CImage*
imcachelook(CImage* ci)
{
	CImage*	ans;
	CImage*	prev;
	CImage*	i;

	ans = nil;
	prev = nil;
	for(i = imcache.imhd; i != nil; i = i->next) {
		if(cimagematch(i, ci)) {
			if(imcache.imtl != i) {
				if(prev != nil)
					prev->next = i->next;
				else
					imcache.imhd = i->next;
				i->next = nil;
				imcache.imtl->next = i;
				imcache.imtl = i;
			}
			ans = i;
			break;
		}
		prev = i;
	}
	return ans;
}

// Call this to add ci as MRU of cache chain (should only call if
// it is known that a ci with same image isn't already there).
// Update imcache.memused.
// Assume imcacheneed has been called to ensure that neither
// memlimit nor nlimit will be exceeded.
void
imcacheadd(CImage* ci)
{
	ci->next = nil;
	if(imcache.imhd == nil)
		imcache.imhd = ci;
	else
		imcache.imtl->next = ci;
	imcache.imtl = ci;
	imcache.memused += cimagebytes(ci);
	imcache.n++;
}

// Delete least-recently-used image in image cache
// and update memused and n.
void
imcachedeletelru(void)
{
	CImage*	ci;

	ci = imcache.imhd;
	if(ci != nil) {
		imcache.imhd = ci->next;
		if(imcache.imhd == nil) {
			imcache.imtl = nil;
			imcache.memused = 0;
		}
		else
			imcache.memused -= cimagebytes(ci);
		freecimage(ci);
		imcache.n--;
	}
}

void
imcacheclear(void)
{
	while(imcache.imhd != nil)
		imcachedeletelru();
}

int
imcacheneed(int nbytes)
{
	while(imcache.n >=imcache.nlimit || imcache.memused + nbytes > imcache.memlimit) {
		if(imcache.imhd == nil)
			return 0;
		imcachedeletelru();
	}
	return 1;
}

// Return new Header with default values for fields
Header*
newheader(void)
{
	Header* h;

	h = (Header*)emalloc(sizeof(Header));
	h->code = HCOk;
	h->actual = nil;
	h->base = nil;
	h->location = nil;
	h->length = -1;
	h->mtype = UnknownType;
	h->chset = UnknownCharset;
	h->msg = nil;
	h->refresh = nil;
	h->chal = nil;
	h->warn = nil;
	return h;
}

// Set the mtype (and possibly chset) fields of h based on (in order):
//	first bytes of file, if unambigous
//	file name extension
//	first bytes of file, even if ambigous (guess)
//	if all else fails, then leave as UnknownType.
// If it's a text type, also set the chset.
// (HTTP Transport will try to use Content-Type first, and call this if that
// doesn't work; other Transports will have to rely on this "guessing" function.)
void
setmediatype(Header* h, Rune* name, uchar* first, int firstlen)
{
	int	n;
	int	mt;
	int	i;
	Rune*	s;
	int	val;
	Rune*	ext;
	Rune*	file;
	uchar	b;
	int	nctl;
	int	ntophalf;

	n = firstlen;
	mt = UnknownType;
	for(i = 0; i < n; i++)
		if(!isspace(first[i]))
			break;
	if(n - i >= 6) {
		s = toStr(first, 6, US_Ascii);
		if(!Strcmp(s, L"<html>") || !Strcmp(s, L"<head>") || !Strcmp(s, L"<title")) {
			h->mtype = TextHtml;
		}
		else if(!Strcmp(s, L"<!doct")) {
				mt = TextHtml;
		}
		else if(!Strcmp(s, L"gif87a") || !Strcmp(s, L"gif89a")) {
			if(i == 0)
				mt = ImageGif;
		}
		else if(!Strcmp(s, L"#defin")) {
			h->mtype = ImageXXBitmap;
		}
		if(h->mtype == UnknownType) {
			if(i == 0 && n >= sizeof(jpmagic)) {
				for(; i < sizeof(jpmagic); i++)
					if(jpmagic[i] > (uchar)0 && first[i] != jpmagic[i])
						break;
				if(i == sizeof(jpmagic))
					mt = ImageJpeg;
			}
		}
	}
	if(mt == UnknownType && name != nil) {
		// Try file name extension
		file = Strrclass(name, L"/");
		if(file == nil)
			file = name;
		else
			file++;
		if(*file != 0) {
			ext = Strrclass(file, L".");
			if(ext != nil) {
				ext++;
				if(lookup(fileexttable, NFILEEXTS, ext, Strlen(ext), &val))
					mt = val;
			}
		}
	}
	if(mt == UnknownType || (mt >= TextHtml && mt <= TextSgml)) {
		// Try file statistics
		nctl = 0;
		ntophalf = 0;
		if(n > 1024)
			n = 1024;
		for(i = 0; i < n; i++) {
			b = first[i];
			if(iscntrl(b))
				nctl++;
			if(b >= 128)
				ntophalf++;
		}
		if(nctl < n/100 && ntophalf < n/10) {
			if(mt == UnknownType)
				mt = TextPlain;
			if(ntophalf == 0)
				h->chset = US_Ascii;
			else
				h->chset = ISO_8859_1;
		}
		else if(mt == UnknownType) {
			if(n == 0) {
				mt = TextHtml;
				h->chset = ISO_8859_1;
			}
			else
				mt = ApplOctets;
		}
		else
			h->chset = ISO_8859_1;
	}
	h->mtype = mt;
}

void
printheader(Header* h)
{
	Rune*	mtype;
	Rune*	chset;

	mtype = L"?";
	if(h->mtype >= 0 && h->mtype < NMEDIATYPES)
		mtype = mnames[h->mtype];
	chset = L"?";
	if(h->chset >= 0 && h->chset < NCHARSETS)
		chset = chsetnames[h->chset];
	trace("code=%d (%S) length=%d mtype=%S chset=%S\n",
			h->code, hcphrase(h->code), h->length, mtype, chset);
	if(h->base != nil)
		trace("  base=%U\n", h->base);
	if(h->location != nil)
		trace("  location=%U\n", h->location);
	if(h->refresh != nil)
		trace("  refresh=%S\n", h->refresh);
	if(h->chal != nil)
		trace("  chal=%S\n", h->chal);
	if(h->warn != nil)
		trace("  warn=%S\n", h->warn);
}


#define PAGESIZE 4096
ResourceState
curresstate(void)
{
	int n;
	static int fd = -1;
	char* p;
	ResourceState r;
	uchar buf[SMALLBUFSIZE];

	r.ms = (int)cputime();
	r.mem = 1*1024*1024;
	r.memavail = 10*1024*1024;
	if(fd < 0)
		fd = open("/dev/swap", OREAD);
	if(fd >= 0) {
		seek(fd, 0, 0);
		n = read(fd, buf, (sizeof buf) - 1);
		if(n > 3) {
			buf[n] = 0;
			r.mem = strtol((char*)buf, &p, 10) * PAGESIZE;
			if(p != nil && *p == '/') {
				r.memavail = strtol((char*)(p+1), &p, 10) * PAGESIZE;
			}
		}
	}
	return r;
}

ResourceState
resstatesince(ResourceState rnew, ResourceState rold)
{
	ResourceState r;

	r.ms = rnew.ms - rold.ms;
	r.mem = rnew.mem - rold.mem;
	r.memavail = rnew.memavail - rold.memavail;
	return r;
}

void
resstateprint(ResourceState r, char* msg)
{
	int d, dms;

	d = r.ms/1000;
	dms = r.ms % 1000;
	trace("%s:\n\ttime: %d.%#.3ds; memory: %dK, available memory %dK\n",
				msg, d, dms, r.mem/1024, r.memavail/1024);
}

// Decide what to do based on Header and whether this is
// for the main entity or not, and the number of redirections-so-far.
// Return value is "use"; other return values put in *perror, *pchallenge, and *predir.
// Action to do is:
//	If use==1, use the entity else drain its byte source.
//	If *perror != nil, mesg was put in progress bar
//	If (pchallenge != nil, get auth info and make new request with auth
//	Else if *predir != nil, make a new request with redir for url
//
// (if challenge or redir is non-nil, use will be 0)
int
hdraction(ByteSource* bs, int ismain, int nredirs,
					int* perror, Rune** pchallenge, ParsedUrl** predir)
{
	int	use;
	int	error;
	Rune*	challenge;
	ParsedUrl*	redir;
	Header*	h;
	int	code;

	use = 1;
	error = 0;
	challenge = nil;
	redir = nil;
	h = bs->hdr;
	assert(h != nil);
	bs->seenhdr = 1;
	code = h->code;
	switch(code/100) {
	case HSOk:
		if(code != HCOk)
			error = ERRunexphscode;
		break;
	case HSRedirect:
		if(h->location != nil) {
			redir = h->location;
			if(redir->scheme == NOSCHEME)
				redir = makeabsoluteurl(redir, h->base);
			if(dbg)
				trace("redirect %U to %U\n", h->actual, redir);
			if(nredirs >= Maxredir) {
				redir = nil;
				error = ERRredirloop;
			}
			else
				use = 0;
		}
		break;
	case HSError:
		if(code == HCUnauthorized && h->chal != nil) {
			challenge = h->chal;
			use = 0;
		}
		else {
			error = code;
			use = ismain;
		}
		break;
	case HSServererr:
		error = code;
		use = ismain;
		break;
	default:
		error = ERRunexphscode;
		use = 0;
		break;
	}
	if(error && config.showprogress)
		sendprogress(bs->id, Perr, 0, errphrase(error));
	*perror = error;
	*pchallenge = challenge;
	*predir = redir;
	return use;
}

void
sendprogress(int bsid, int state, int pcnt, Rune* s)
{
	EV prog;

	prog.tag = EVprogresstag;
	prog.genframeid = -1;	// TODO: pass in correct frameid
	prog.u.progress.bsid = bsid;
	prog.u.progress.state = state;
	prog.u.progress.pcnt = pcnt;
	prog.u.progress.s = s;
	send(evchan, &prog);
}

// Read a line up to and including cr/lf (be tolerant and allowing missing cr).
// Look first in buf[*pbstart:*pbend], and if that isn't sufficient to get whole line,
// refill buf from fd as needed.
// Since most of the time the needed line will be in the passed buffer, we sometimes
// return pointers into that buffer.  We only allocated the answer if the line straddles
// buffer reads.
//
// Return values:
//	getline returns 1 if got eof, else 0.
//	*pans points to line, *panslen points to its length (not including cr/lf).
//	*pbstart and *pbend are updated to new valid portion of buf (after cr/lf).
int
getline(int fd, uchar* buf, int bufsize, int* pbstart, int* pbend,
	uchar** pans, int* panslen)
{
	int	i, k, eof, bstart, bend;
	int	anslen, lastlen;
	uchar*	ans;
	uchar*	last;

	ans = nil;
	anslen = 0;
	eof = 0;
	bstart = *pbstart;
	bend = *pbend;
	while(1) {
		for(i = bstart; i < bend; i++) {
			if(buf[i] == '\n') {
				k = i;
				if(k > bstart && buf[k - 1] == '\r')
					k--;
				last = buf+bstart;
				lastlen = k-bstart;
				bstart = i + 1;
				goto mainloop_done;
			}
		}
		k = bend-bstart;
		if(k > 0) {
			if(anslen > 0)
				ans = (uchar*)erealloc(ans, anslen+k);
			else
				ans = (uchar*)emalloc(k);
			memmove(ans+anslen, buf+bstart, k);
			anslen += k;
		}
		last = nil;
		lastlen = 0;
		bstart = 0;
		bend = read(fd, buf, bufsize);
		if(bend <= 0) {
			eof = 1;
			bend = 0;
			break;
		}
	}
   mainloop_done:
	if(anslen == 0) {
		ans = last;
		anslen = lastlen;
	}
	else {
		if(lastlen > 0) {
			ans = (uchar*)erealloc(ans, anslen+lastlen);
			memmove(ans+anslen, last, lastlen);
			anslen += lastlen;
		}
	}
	*pans = ans;
	*panslen = anslen;
	*pbstart = bstart;
	*pbend = bend;
//trace("*pans=%d, *panslen=%d, *pbstart=%d, *pbend=%d, eof=%d\n", ans, anslen, bstart, bend, eof);
//if(anslen > 0) { write(1, ans, anslen); trace("\n"); }
	return eof;
}

// Look (linearly) through a for s[0:slen] (case insensitive); return its index if found, else -1.
int
Strlookup(Rune** a, int n, Rune* s, int slen)
{
	int	i;

	for(i = 0; i < n; i++)
		if(!Strncmpci(s, slen, a[i]))
			return i;
	return -1;
}

// Return string representation of HTTP code.
// Note: returned values are constants, and should not be freed.
Rune*
hcphrase(int code)
{
	Rune*	ans;

	switch(code) {
	case HCContinue:
		ans = L"Continue";
		break;
	case HCSwitchProto:
		ans = L"Switching Protcols";
		break;
	case HCOk:
		ans = L"Ok";
		break;
	case HCCreated:
		ans = L"Created";
		break;
	case HCAccepted:
		ans = L"Accepted";
		break;
	case HCOkNonAuthoritative:
		ans = L"Non-Authoratative Information";
		break;
	case HCNoContent:
		ans = L"No content";
		break;
	case HCResetContent:
		ans = L"Reset content";
		break;
	case HCPartialContent:
		ans = L"Partial content";
		break;
	case HCMultipleChoices:
		ans = L"Multiple choices";
		break;
	case HCMovedPerm:
		ans = L"Moved permanently";
		break;
	case HCMovedTemp:
		ans = L"Moved temporarily";
		break;
	case HCSeeOther:
		ans = L"See other";
		break;
	case HCNotModified:
		ans = L"Not modified";
		break;
	case HCUseProxy:
		ans = L"Use proxy";
		break;
	case HCBadRequest:
		ans = L"Bad request";
		break;
	case HCUnauthorized:
		ans = L"Unauthorized";
		break;
	case HCPaymentRequired:
		ans = L"Payment required";
		break;
	case HCForbidden:
		ans = L"Forbidden";
		break;
	case HCNotFound:
		ans = L"Not found";
		break;
	case HCMethodNotAllowed:
		ans = L"Method not allowed";
		break;
	case HCNotAcceptable:
		ans = L"Not Acceptable";
		break;
	case HCProxyAuthRequired:
		ans = L"Proxy authentication required";
		break;
	case HCRequestTimeout:
		ans = L"Request timed-out";
		break;
	case HCConflict:
		ans = L"Conflict";
		break;
	case HCGone:
		ans = L"Gone";
		break;
	case HCLengthRequired:
		ans = L"Length required";
		break;
	case HCPreconditionFailed:
		ans = L"Precondition failed";
		break;
	case HCRequestTooLarge:
		ans = L"Request entity too large";
		break;
	case HCRequestURITooLarge:
		ans = L"Request-URI too large";
		break;
	case HCUnsupportedMedia:
		ans = L"Unsupported media type";
		break;
	case HCRangeInvalid:
		ans = L"Requested range not valid";
		break;
	case HCExpectFailed:
		ans = L"Expectation failed";
		break;
	case HCServerError:
		ans = L"Internal server error";
		break;
	case HCNotImplemented:
		ans = L"Not implemented";
		break;
	case HCBadGateway:
		ans = L"Bad gateway";
		break;
	case HCServiceUnavailable:
		ans = L"Service unavailable";
		break;
	case HCGatewayTimeout:
		ans = L"Gateway time-out";
		break;
	case HCVersionUnsupported:
		ans = L"HTTP version not supported";
		break;
	case HCRedirectionFailed:
		ans = L"Redirection failed";
		break;
	default:
		ans = L"Unknown code";
		break;
	}
	return ans;
}

// Error codes can be either one of the ERR... values or one of the HC... values
Rune*
errphrase(int code)
{
	if(code >=0 && code < NERRPHRASES)
		return errphrases[code];
	return hcphrase(code);
}

// Make a StringInt table out of a[0:n], mapping each string
// to its index.  Check that entries are in alphabetical order.
// These tables use the real malloc(), and are never freed.
StringInt*
makestrinttab(Rune** a, int n)
{
	StringInt*	ans;
	int	i;

	ans = (StringInt*)malloc(n * sizeof(StringInt));
	for(i = 0; i < n; i++) {
		ans[i].key = a[i];
		ans[i].val = i;
		assert(i == 0 || Strcmp(a[i], a[i - 1]) >= 0);
	}
	return ans;
}

// Use targetmap array to keep track of name <-> targetid mapping.
// Use real malloc(), and never free
static void
targetmapinit(void)
{
	targetmapsize = 10;
	targetmap = (StringInt*)malloc(targetmapsize*sizeof(StringInt));
	memset(targetmap, 0, targetmapsize*sizeof(StringInt));
	targetmap[0].key = L"_top";
	targetmap[0].val = FTtop;
	targetmap[1].key = L"_self";
	targetmap[1].val = FTself;
	targetmap[2].key = L"_parent";
	targetmap[2].val = FTparent;
	targetmap[3].key = L"_blank";
	targetmap[3].val = FTblank;
	ntargets = 4;
}

int
targetid(Rune* s)
{
	int i;
	int n;

	n = Strlen(s);
	if(n == 0)
		return FTself;
	for(i = 0; i < ntargets; i++)
		if(Strcmp(s, targetmap[i].key) == 0)
			return targetmap[i].val;
	if(i >= targetmapsize) {
		targetmapsize += 10;
		targetmap = (StringInt*)realloc(targetmap, targetmapsize*sizeof(StringInt));
	}
	targetmap[i].key = (Rune*)malloc((n+1)*sizeof(Rune));
	memmove(targetmap[i].key, s, (n+1)*sizeof(Rune));
	targetmap[i].val = i;
	ntargets++;
	return i;
}

Rune*
targetname(int targid)
{
	int i;

	for(i = 0; i < ntargets; i++)
		if(targetmap[i].val == targid)
			return targetmap[i].key;
	return L"?";
}

// Use logtime when only care about time stamps
void
logtime(char* msg, int data)
{
	trace("%s: %d %d\n", msg, (int)cputime() - startres.ms, data);
}

// Convert HTML color spec to RGB value, returning dflt if can't.
// Argument is supposed to be a valid HTML color, or "".
// Return the RGB value of the color, using dflt if s
// is nil or an invalid color.
int
color(Rune* s, int dflt)
{
	int v;
	Rune* rest;

	if(s == nil)
		return dflt;
	if(lookup(color_tab, NCOLORS, s, Strlen(s), &v))
		return v;
	if(s[0] == '#')
		s++;
	v = Strtol(s, &rest, 16);
	if(*rest == 0)
		return v;
	return dflt;
}

static int
strhash(Rune* s)
{
	int	hash;
	enum { prime = 8388617 };

	hash = 0;
	if(s != nil) {
		while(*s != 0)
			hash = ((hash%prime) << 7) + *s++;
	}
	return hash;
}

// Set up config global to defaults, then try to read user-specifiic
// config data from /usr/<username>/lib/iconfig, then try to
// override from command line arguments.
static void
setconfig(int argc, char** argv)
{
	Rune*	user;
	int	fd;
	int	n;
	Rune*	line;
	int		linelen;
	Rune*	key;
	int		keylen;
	Rune*	val;
	int		vallen;
	int	i;
	int	j;
	uchar*	aline;
	int		alinelen;
	int	eof;
	int	cfgio;
	Rune*	a;
	Rune*	b;
	char*	s;
	uchar	buf[BIGBUFSIZE];

	config.userdir = Strdup(L"/");
	config.starturl = makeurl(L"file:/lib/i/start.html", 0);
	config.homeurl = copyurl(config.starturl);
	config.httpproxy = nil;
	config.defaultwidth = 800;
	config.defaultheight = 800;
	config.x = 0;
	config.y = 0;
	config.nocache = 0;
	config.maxstale = 0;
	config.imagelvl = ImgFull;
	config.imagecachenum = 60;
	config.imagecachemem = 100000000;
	config.docookies = 0;
	config.doscripts = 0;
	config.saveauthinfo = 0;
	config.showprogress = 1;
	config.usecci = 0;
	config.httpminor = 0;
	config.agentname = Strdup(L"i/2.0 (Plan 9)");
	config.nthreads = 1;
	config.dbgfile = nil;
	user = nil;
	fd = open("/dev/user", OREAD);
	if(fd != -1) {
		n = read(fd, buf, sizeof(buf));
		if(n > 0)
			user = toStr(buf, n, UTF_8);
		close(fd);
	}
	if(user != nil) {
		config.userdir = Strdup3(L"/usr/", user, L"/lib");
		snprint((char*)buf, sizeof(buf), "%S/iconfig", config.userdir);
		cfgio = open((char*)buf, OREAD);
		if(cfgio != -1) {
			i = 0;
			j = 0;
			while(1) {
				eof = getline(cfgio, buf, sizeof(buf), &i, &j, &aline, &alinelen);
				if(eof)
					break;
				if(alinelen == 0)
					continue;
				line = toStr(aline, alinelen, UTF_8);
				linelen = Strlen(line);
				if(alinelen > 0 && line[0] != '#') {
					splitl(line, linelen, L" \t=", &key, &keylen, &val, &vallen);
					if(keylen != 0) {
						if(vallen != 0) {
							a = Strnclass(val, L"^ \t=", vallen);
							if(a == nil)
								vallen = 0;
							else {
								vallen -= (a-val);
								val = a;
								a = Strnclass(val, L"#\r\n", vallen);
								if(a != nil)
									vallen = a-val;
							}
						}
						if(!setopt(key, keylen, val, vallen))
							trace("couldn't set option from line '%S'\n", line);
					}
				}
			}
			close(cfgio);
		}
	}
	argc--;
	argv++;
	while(argc > 0) {
		s = argv[0];
		if(*s == 0)
			continue;
		else if(s[0] == '-') {
			a = toStr((uchar*)(s+1), strlen(s+1), UTF_8);
			b = nil;
			if(argc > 1) {
				b = toStr((uchar*)argv[1], strlen(argv[1]), UTF_8);
				if(b[0] != '-') {
					argc--;
					argv++;
				}
			}
			if(!setopt(a, Strlen(a), b, Strlen(b)))
				trace("couldn't set option from arg '%s'\n", s);
		}
		else {
			if(argc == 1) {
				a = toStr((uchar*)s, strlen(s), UTF_8);
				if(!setopt(L"starturl", 8, a, Strlen(a)))
					trace("couldn't set starturl from arg '%s'\n", s);
			}
			else
				trace("ignoring unknown option %s\n", s);
		}
		argc--;
		argv++;
	}
}

static int
setopt(Rune* key, int keylen, Rune* val, int vallen)
{
	int	ok;
	int	v;
	int	c;
	int	i;
	Rune*	s;

	ok = 1;
	if(vallen == 0) {
		s = nil;
		v = 1;
	}
	else {
		s = Strndup(val, vallen);
		v = Strtol(s, nil, 0);
	}
	if(!Strncmpci(key, keylen, L"userdir")) {
		config.userdir = Strdup(s);
	}
	else if(!Strncmpci(key, keylen, L"starturl")) {
		if(vallen != 0) {
			config.starturl = makeurl(s, 1);
			assert(config.starturl != nil);
		}
		else
			ok = 0;
	}
	else if(!Strncmpci(key, keylen, L"homeurl")) {
		if(vallen != 0) {
			config.homeurl = makeurl(s, 1);
		}
		else
			ok = 0;
	}
	else if(!Strncmpci(key, keylen, L"httpproxy")) {
		if(vallen != 0) {
			config.httpproxy = makeurl(s, 1);
		}
		else
			config.httpproxy = nil;
	}
	else if(!Strncmpci(key, keylen, L"defaultwidth") || !Strncmpci(key, keylen, L"width")) {
		if(v > 200)
			config.defaultwidth = v;
		else
			ok = 0;
	}
	else if(!Strncmpci(key, keylen, L"defaultheight") || !Strncmpci(key, keylen, L"height")) {
		if(v > 100)
			config.defaultheight = v;
		else
			ok = 0;
	}
	else if(!Strncmpci(key, keylen, L"x")) {
		config.x = v;
	}
	else if(!Strncmpci(key, keylen, L"y")) {
		config.y = v;
	}
	else if(!Strncmpci(key, keylen, L"nocache")) {
		config.nocache = v;
	}
	else if(!Strncmpci(key, keylen, L"maxstale")) {
		config.maxstale = v;
	}
	else if(!Strncmpci(key, keylen, L"imagelvl")) {
		config.imagelvl = v;
	}
	else if(!Strncmpci(key, keylen, L"imagecachenum")) {
		config.imagecachenum = v;
	}
	else if(!Strncmpci(key, keylen, L"imagecachemem")) {
		config.imagecachemem = v;
	}
	else if(!Strncmpci(key, keylen, L"docookies")) {
		config.docookies = v;
	}
	else if(!Strncmpci(key, keylen, L"doscripts")) {
		config.doscripts = v;
	}
	else if(!Strncmpci(key, keylen, L"saveauthinfo")) {
		config.saveauthinfo = v;
	}
	else if(!Strncmpci(key, keylen, L"showprogress")) {
		config.showprogress = v;
	}
	else if(!Strncmpci(key, keylen, L"usecci")){
		config.usecci = v;
	}
	else if(!Strncmpci(key, keylen, L"http")) {
		if(!Strncmpci(val, vallen, L"1.1"))
			config.httpminor = 1;
		else
			config.httpminor = 0;
	}
	else if(!Strncmpci(key, keylen, L"agentname")) {
		config.agentname = Strdup(s);
	}
	else if(!Strncmpci(key, keylen, L"nthreads")) {
		config.nthreads = v;
	}
	else if(!Strncmpci(key, keylen, L"dbgfile")) {
		config.dbgfile = Strdup(s);
	}
	else if(!Strncmpci(key, keylen, L"dbg")) {
		for(i = 0; i < vallen; i++) {
			c = val[i];
			if(c < sizeof(config.dbg))
				config.dbg[c]++;
			else {
				ok = 0;
				break;
			}
		}
	}
	else
		ok = 0;
	return ok;
}