/*
    MiddleMan filtering proxy server
    Copyright (C) 2002  Jason McLaughlin

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include "proto.h"
#include "pages.h"

/*
parse <templates> section from xml config file
*/
TEMPLATES *templates_load(TEMPLATES * templates, XML_LIST * xml_list)
{
	TEMPLATES *templates_tmp = templates;
	struct TEMPLATE_LIST *template_list = NULL;

	if (templates_tmp == NULL) {
		templates_tmp = xmalloc(sizeof(TEMPLATES));
		templates_tmp->template_list = NULL;
		templates_tmp->path = NULL;
		templates_tmp->id = 0;

		templates = templates_tmp;

		pthread_rwlock_init(&templates_tmp->lock, NULL);
	} else
		template_list = templates_tmp->template_list;

	while ((xml_list = xml_section(xml_list, "<templates>"))) {
		XML_LIST_LOOP(xml_list, "<templates>") {
			XML_LIST_CMP(xml_list, "<template>") {
				template_list = template_list_new(template_list);
				template_list->id = templates->id++;

				if (templates_tmp->template_list == NULL)
					templates_tmp->template_list = template_list;
				XML_LIST_LOOP(xml_list, "<template>") {
					XML_LIST_CMP(xml_list, "<enabled>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE) {
							if (!strcasecmp(xml_list->item, "false"))
								template_list->enabled = FALSE;
							else
								template_list->enabled = TRUE;
						}
					}
					XML_LIST_CMP(xml_list, "<comment>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, xml_list->item, NULL, NULL, NULL, NULL, NULL);
					}
					XML_LIST_CMP(xml_list, "<name>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, NULL, xml_list->item, NULL, NULL, NULL, NULL);
					}
					XML_LIST_CMP(xml_list, "<file>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, NULL, NULL, xml_list->item, NULL, NULL, NULL);
					}
					XML_LIST_CMP(xml_list, "<type>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, NULL, NULL, NULL, xml_list->item, NULL, NULL);
					}
					XML_LIST_CMP(xml_list, "<mime>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, NULL, NULL, NULL, NULL, xml_list->item, NULL);
					}
					XML_LIST_CMP(xml_list, "<code>") {
						xml_list = xml_list->next;
						if (xml_list->type == XML_VALUE)
							template_list_insert(template_list, NULL, NULL, NULL, NULL, NULL, xml_list->item);
					}
				}
			}
			XML_LIST_CMP(xml_list, "<path>") {
				xml_list = xml_list->next;
				if (xml_list->type == XML_VALUE) {
					FREE_AND_NULL(templates_tmp->path);
					templates_tmp->path = xstrdup(xml_list->item);
				}
			}
		}
	}

	return templates;
}

XML_LIST *templates_xml(TEMPLATES * templates, XML_LIST * xml_list)
{
	char *ptr, buf[16];
	struct TEMPLATE_LIST *tl;

	if (templates == NULL)
		return xml_list;

	pthread_rwlock_rdlock(&templates->lock);

	xml_list = xml_list_add(xml_list, "<templates>", XML_TAG);

	if (templates->path != NULL) {
		xml_list = xml_list_add(xml_list, "<path>", XML_TAG);
		ptr = string_to_xml(templates->path);
		xml_list = xml_list_add(xml_list, ptr, XML_VALUE);
		xfree(ptr);
		xml_list = xml_list_add(xml_list, "</path>", XML_TAG);
	}

	for (tl = templates->template_list; tl; tl = tl->next) {
		xml_list = xml_list_add(xml_list, "<template>", XML_TAG);

		xml_list = xml_list_add(xml_list, "<enabled>", XML_TAG);
		xml_list = xml_list_add(xml_list, (tl->enabled == TRUE) ? "true" : "false", XML_VALUE);
		xml_list = xml_list_add(xml_list, "</enabled>", XML_TAG);

		if (tl->comment != NULL) {
			xml_list = xml_list_add(xml_list, "<comment>", XML_TAG);
			ptr = string_to_xml(tl->comment);
			xml_list = xml_list_add(xml_list, ptr, XML_VALUE);
			xfree(ptr);
			xml_list = xml_list_add(xml_list, "</comment>", XML_TAG);
		}

		if (tl->name != NULL) {
			xml_list = xml_list_add(xml_list, "<name>", XML_TAG);
			ptr = string_to_xml(tl->name);
			xml_list = xml_list_add(xml_list, ptr, XML_VALUE);
			xfree(ptr);
			xml_list = xml_list_add(xml_list, "</name>", XML_TAG);
		}

		if (tl->file != NULL) {
			xml_list = xml_list_add(xml_list, "<file>", XML_TAG);
			ptr = string_to_xml(tl->file);
			xml_list = xml_list_add(xml_list, ptr, XML_VALUE);
			xfree(ptr);
			xml_list = xml_list_add(xml_list, "</file>", XML_TAG);
		}

		if (tl->mime != NULL) {
			xml_list = xml_list_add(xml_list, "<mime>", XML_TAG);
			ptr = string_to_xml(tl->mime);
			xml_list = xml_list_add(xml_list, ptr, XML_VALUE);
			xfree(ptr);
			xml_list = xml_list_add(xml_list, "</mime>", XML_TAG);
		}

		if (tl->code != -1) {
			xml_list = xml_list_add(xml_list, "<code>", XML_TAG);
			snprintf(buf, sizeof(buf), "%d", tl->code);
			xml_list = xml_list_add(xml_list, buf, XML_VALUE);
			xml_list = xml_list_add(xml_list, "</code>", XML_TAG);
		}

		xml_list = xml_list_add(xml_list, "<type>", XML_TAG);
		xml_list = xml_list_add(xml_list, (tl->type == TEMPLATE_FILE) ? "file" : "executable", XML_VALUE);
		xml_list = xml_list_add(xml_list, "</type>", XML_TAG);

		xml_list = xml_list_add(xml_list, "</template>", XML_TAG);

	}

	xml_list = xml_list_add(xml_list, "</templates>", XML_TAG);

	pthread_rwlock_unlock(&templates->lock);

	return xml_list;
}

void template_list_insert(struct TEMPLATE_LIST *x, char *a, char *b, char *c, char *d, char *e, char *f)
{
	if (a != NULL) {
		FREE_AND_NULL(x->comment);

		if (strcmp(a, ""))
			x->comment = xstrdup(a);
	}
	if (b != NULL) {
		FREE_AND_NULL(x->name);

		if (strcmp(b, ""))
			x->name = xstrdup(b);
	}
	if (c != NULL) {
		FREE_AND_NULL(x->file);

		if (strcmp(c, ""))
			x->file = xstrdup(c);
	}
	if (d != NULL) {
		if (!strcasecmp(d, "file"))
			x->type = TEMPLATE_FILE;
		else if (!strcasecmp(d, "executable"))
			x->type = TEMPLATE_EXECUTABLE;
	}
	if (e != NULL) {
		FREE_AND_NULL(x->mime);

		if (strcmp(e, ""))
			x->mime = xstrdup(e);
	}
	if (f != NULL) {
		x->code = -1;

		if (strcmp(f, ""))
			x->code = atoi(f);
	}
}

struct TEMPLATE_LIST *template_list_new(struct TEMPLATE_LIST *x)
{
	if (x == NULL) {
		x = xmalloc(sizeof(struct TEMPLATE_LIST));
		x->prev = NULL;
	} else {
		while (x->next != NULL)
			x = x->next;
		x->next = xmalloc(sizeof(struct TEMPLATE_LIST));
		x->next->prev = x;
		x = x->next;
	}
	x->enabled = TRUE;
	x->comment = NULL;
	x->code = -1;
	x->next = NULL;
	x->name = NULL;
	x->file = NULL;
	x->type = TEMPLATE_FILE;
	x->mime = NULL;

	return x;
}

struct TEMPLATE_LIST *template_list_delete(struct TEMPLATE_LIST *x)
{
	struct TEMPLATE_LIST *start = x;

	while (start->prev != NULL)
		start = start->prev;

	if (x->next != NULL)
		x->next->prev = x->prev;
	if (x->prev != NULL)
		x->prev->next = x->next;
	else
		start = start->next;

	FREE_AND_NULL(x->comment);
	FREE_AND_NULL(x->name);
	FREE_AND_NULL(x->file);
	FREE_AND_NULL(x->mime);

	xfree(x);

	return start;
}

/*
free templates structure
*/
void templates_free(TEMPLATES * templates)
{
	if (!templates)
		return;

	templates_list_free(templates->template_list);

	if (templates->path != NULL)
		xfree(templates->path);

	pthread_rwlock_destroy(&templates->lock);

	xfree(templates);
}

void templates_list_free(struct TEMPLATE_LIST *tl)
{
	struct TEMPLATE_LIST *tmp;

	while (tl != NULL) {
		tmp = tl->next;

		FREE_AND_NULL(tl->comment);
		FREE_AND_NULL(tl->name);
		FREE_AND_NULL(tl->file);
		FREE_AND_NULL(tl->mime);

		xfree(tl);
		tl = tmp;
	}
}

/*
load a template from a file, and place in a buffer
*/
FILEBUF *template_get(TEMPLATES * templates, CONNECTION * connection, char *name)
{
	int i = 0, x = -1;
	char buf[256];
	struct TEMPLATE_LIST *template_list = NULL;
	FILEBUF *ret = NULL;

	pthread_rwlock_rdlock(&templates->lock);
	template_list = templates->template_list;

	while (template_list != NULL) {
		/* search through templates from config file first */
		if (template_list->name != NULL) {
			if (template_list->enabled == TRUE && !strcasecmp(template_list->name, name))
				break;
		}

		template_list = template_list->next;
	}

	if (template_list == NULL || template_list->file == NULL) {
		/* no matching template in config file, search through compiled-in templates */
		while (PAGES[i].name != NULL) {
			if (!strcasecmp(PAGES[i].name, name)) {
				x = i;
				break;
			}
			i++;
		}

		/* nope, nothing... oh well */
		if (x == -1)
			goto out;

		i = (PAGES[x].len != -1) ? PAGES[x].len : strlen(PAGES[x].content);
		ret = filebuf_new();

		ret->size = i;
		ret->data = xmalloc(i);
		memcpy(ret->data, PAGES[x].content, i);
		ret->type = xstrdup(PAGES[x].mime);
	} else if (template_list->type == TEMPLATE_FILE) {
		if (template_list->file[0] != '/' && templates->path != NULL)
			snprintf(buf, sizeof(buf), "%s/%s", templates->path, template_list->file);
		else
			snprintf(buf, sizeof(buf), "%s", template_list->file);

		ret = filebuf_new();

		filebuf_read(ret, buf);

		if (template_list->mime != NULL)
			ret->type = xstrdup(template_list->mime);
	} else if (template_list->type == TEMPLATE_EXECUTABLE) {
		ret = external_exec(connection, template_list->file, NULL, EXTERNAL_PIPE);
		if (template_list->mime != NULL && ret != NULL) {
			if (!strcasecmp(template_list->mime, "STDIN"))
				ret->type = external_getmime(ret);
			else
				ret->type = xstrdup(template_list->mime);
		}
	}

	if (ret != NULL && (ret->type == NULL || !strncasecmp(ret->type, "text/", 5))) {
		/* replace variables with actual value, or just remove if value is unknown */
		/* note: these can't be escaped... I should fix that */
		string_replace(ret, "$HTTP_METHOD", (connection->header != NULL) ? connection->header->method : NULL);
		string_replace(ret, "$HTTP_HOST", (connection->header != NULL) ? connection->header->host : NULL);
		string_replace(ret, "$HTTP_FILE", (connection->header != NULL) ? connection->header->file : NULL);
		snprintf(buf, sizeof(buf), "%d", (connection->header != NULL) ? connection->header->port : 0);
		string_replace(ret, "$HTTP_PORT", buf);

		string_replace(ret, "$IP", connection->ip);
	}

	if (template_list != NULL && ret != NULL)
		ret->code = template_list->code;

      out:
	pthread_rwlock_unlock(&templates->lock);

	return ret;
}

/*
send a template with http headers and proper mime type to web browser
*/
int template_send(TEMPLATES * templates, char *template, CONNECTION * connection, int error)
{
	FILEBUF *filebuf = NULL;
	HEADER *header;

	filebuf = template_get(templates, connection, template);

	if (!filebuf)
		return FALSE;

	header = header_new();
	header->type = HTTP_RESP;
	header->code = (filebuf->code != -1) ? filebuf->code : error;
	header->content_length = filebuf->size;
	header->content_type = (filebuf->type != NULL) ? xstrdup(filebuf->type) : xstrdup("text/plain");

	header_send(header, connection, CLIENT, HEADER_RESP);
	http_header_free(header);

	/* don't actually send anything if this is a HEAD request */
	if (connection->header == NULL || strcasecmp(connection->header->method, "HEAD"))
		net_filebuf_send(filebuf, connection, CLIENT);

	putlog(MMLOG_TEMPLATE, "sent %s", template);

	filebuf_free(filebuf);

	return TRUE;
}