Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include "httpd.h"

#include "httpsrv.h"

enum

{

	HASHSIZE = 1019,

};

typedef struct Redir	Redir;

struct Redir

{

	Redir	*next;

	char	*pat;

	char	*repl;

	uint	flags;		/* generated from repl's decorations */

};

static Redir *redirtab[HASHSIZE];

static Redir *vhosttab[HASHSIZE];

static char emptystring[1];

/* these two arrays must be kept in sync */

static char decorations[] = { Modsilent, Modperm, Modsubord, Modonly, '\0' };

static uint redirflags[] = { Redirsilent, Redirperm, Redirsubord, Redironly, };

/* replacement field decorated with redirection modifiers? */

static int

isdecorated(char *repl)

{

	return strchr(decorations, repl[0]) != nil;

}

static uint

decor2flags(char *repl)

{

	uint flags;

	char *p;

	flags = 0;

	while ((p = strchr(decorations, *repl++)) != nil)

		flags |= redirflags[p - decorations];

	return flags;

}

/* return replacement without redirection modifiers */

char *

undecorated(char *repl)

{

	while (isdecorated(repl))

		repl++;

	return repl;

}

static int

hashasu(char *key, int n)

{

        ulong h;

	h = 0;

        while(*key != 0)

                h = 65599*h + *(uchar*)key++;

        return h % n;

}

static void

insert(Redir **tab, char *pat, char *repl)

{

	Redir **l;

	Redir *srch;

	ulong hash;

	hash = hashasu(pat, HASHSIZE);

	for(l = &tab[hash]; *l; l = &(*l)->next)

		;

	*l = srch = ezalloc(sizeof(Redir));

	srch->pat = pat;

	srch->flags = decor2flags(repl);

	srch->repl = undecorated(repl);

	srch->next = 0;

}

static void

cleartab(Redir **tab)

{

	Redir *t;

	int i;

	for(i = 0; i < HASHSIZE; i++){

		while((t = tab[i]) != nil){

			tab[i] = t->next;

			free(t->pat);

			free(t->repl);

			free(t);

		}

	}

}

void

redirectinit(void)

{

	static Biobuf *b = nil;

	static Qid qid;

	char *file, *line, *s, *host, *field[3];

	static char pfx[] = "http://";

	file = "/sys/lib/httpd.rewrite";

	if(b != nil){

		if(updateQid(Bfildes(b), &qid) == 0)

			return;

		Bterm(b);

	}

	b = Bopen(file, OREAD);

	if(b == nil)

		sysfatal("can't read from %s", file);

	updateQid(Bfildes(b), &qid);

	cleartab(redirtab);

	cleartab(vhosttab);

	while((line = Brdline(b, '\n')) != nil){

		line[Blinelen(b)-1] = 0;

		s = strchr(line, '#');

		if(s != nil && (s == line || s[-1] == ' ' || s[-1] == '\t'))

			*s = '\0'; 	/* chop comment iff after whitespace */

		if(tokenize(line, field, nelem(field)) == 2){

			if(strncmp(field[0], pfx, STRLEN(pfx)) == 0 &&

			   strncmp(undecorated(field[1]), pfx, STRLEN(pfx)) != 0){

				/* url -> filename */

				host = field[0] + STRLEN(pfx);

				s = strrchr(host, '/');

				if(s)

					*s = 0;  /* chop trailing slash */

				insert(vhosttab, estrdup(host), estrdup(field[1]));

			}else{

				insert(redirtab, estrdup(field[0]), estrdup(field[1]));

			}

		}

	}

	syslog(0, HTTPLOG, "redirectinit pid=%d", getpid());

}

static Redir*

lookup(Redir **tab, char *pat, int count)

{

	Redir *srch;

	ulong hash;

	hash = hashasu(pat,HASHSIZE);

	for(srch = tab[hash]; srch != nil; srch = srch->next)

		if(strcmp(pat, srch->pat) == 0) {

			/* only exact match wanted? */

			if (!(srch->flags & Redironly) || count == 0)

				return srch;

		}

	return nil;

}

static char*

prevslash(char *p, char *s)

{

	while(--s > p)

		if(*s == '/')

			break;

	return s;

}

/*

 * find the longest match of path against the redirection table,

 * chopping off the rightmost path component until success or

 * there's nothing left.  return a copy of the replacement string

 * concatenated with a slash and the portion of the path *not* matched.

 * So a match of /who/gre/some/stuff.html matched against

 *	/who/gre	http://gremlinsrus.org

 * returns

 *	http://gremlinsrus.org/some/stuff.html

 *

 * further flags: if Redironly, match only the named page and no

 * subordinate ones.  if Redirsubord, map the named patch and any

 * subordinate ones to the same replacement URL.

 */

char*

redirect(HConnect *hc, char *path, uint *flagp)

{

	Redir *redir;

	char *s, *newpath, *repl;

	int c, n, count;

	count = 0;

	for(s = strchr(path, '\0'); s > path; s = prevslash(path, s)){

		c = *s;

		*s = '\0';

		redir = lookup(redirtab, path, count++);

		*s = c;

		if(redir != nil){

			if (flagp)

				*flagp = redir->flags;

			repl = redir->repl;

			if(redir->flags & Redirsubord)

				/* don't append s, all matches map to repl */

				s = "";

			n = strlen(repl) + strlen(s) + 2 + UTFmax;

			newpath = halloc(hc, n);

			snprint(newpath, n, "%s%s", repl, s);

			return newpath;

		}

	}

	return nil;

}

/*

 * if host is virtual, return implicit prefix for URI within webroot.

 * if not, return empty string.

 * return value should not be freed by caller.

 */

char*

masquerade(char *host)

{

	Redir *redir;

	redir = lookup(vhosttab, host, 0);

	if(redir == nil)

		return emptystring;

	return redir->repl;

}