/*  MasqMail
    Copyright (C) 1999-2001 Oliver Kurth
    Copyright (C) 2010  markus schnalke <meillo@marmaro.de>

    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.
*/

#ifndef PARSE_TEST
#include "masqmail.h"
#endif

/* This is really dangerous. I hope that I was careful enough,
   but maybe there is some malformed address possible that causes
   this to segfault or be caught in endless loops.

   If you find something like that, PLEASE mail the string to me
   (no matter how idiotic it is), so that I can debug that.
   Those things really should not happen.
*/

static gchar *specials = "()<>@,;:\\\".[]`";

char *parse_error = NULL;

static gchar*
skip_comment(gchar * p)
{

#ifdef PARSE_TEST
	g_print("skip_comment: %s\n", p);
#endif

	p++;
	while (*p && *p != ')') {
		p++;
		if (*p == '(') {
			p = skip_comment(p);
		}
	}
	p++;

	return p;
}

static gboolean
read_word(gchar * p, gchar ** b, gchar ** e)
{
#ifdef PARSE_TEST
	g_print("read_word: %s\n", p);
#endif
	/* eat leading spaces */
	while (*p && isspace(*p)) {
		p++;
	}

	*b = p;
	/*  b = &p; */
	if (*p == '\"') {
		/* quoted-string */
		p++;
		while (*p && (*p != '\"')) {
			p++;
		}
		p++;
	} else {
		/* atom */
		while (*p && !strchr(specials, *p) && !iscntrl(*p) && !isspace(*p)) {
			p++;
		}
	}
	*e = p;
	return TRUE;
}

static gboolean
read_word_with_dots(gchar * p, gchar ** b, gchar ** e)
{
	gchar *b0 = p;

#ifdef PARSE_TEST
	g_print("read_word_with_dots: %s\n", p);
#endif
	while (TRUE) {
		if (!read_word(p, b, e)) {
			return FALSE;
		}
		p = *e;
		if (*p != '.') {
			break;
		}
		p++;
	}
	*b = b0;
	*e = p;
	return TRUE;
}

static gboolean
read_domain(gchar * p, gchar ** b, gchar ** e)
{
#ifdef PARSE_TEST
	g_print("read_domain: %s\n", p);
#endif
	*b = p;
	if (*p != '[') {
		while (isalnum(*p) || (*p == '-') || (*p == '.')) {
			p++;
		}
	} else {
		p++;
		while (isalpha(*p) || (*p == '.')) {
			p++;
		}
		if (*p != ']') {
			parse_error = g_strdup_printf("']' expected at end of literal address %s", *b);
			return FALSE;
		}
		p++;
	}
	*e = p;
	return TRUE;
}

gboolean
parse_address_rfc822(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,
                     gchar** domain_end, gchar** address_end)
{
	gint angle_brackets = 0;

	gchar *p = string;
	gchar *b, *e;

	*local_begin = *local_end = NULL;
	*domain_begin = *domain_end = NULL;

	/* might be some memory left from previous call: */
	if (parse_error) {
		g_free(parse_error);
		parse_error = NULL;
	}

	/* leading spaces and angle brackets */
	while (*p && (isspace(*p) || (*p == '<'))) {
		if (*p == '<') {
			angle_brackets++;
		}
		p++;
	}

	if (!*p) {
		return FALSE;
	}

	while (TRUE) {
		if (!read_word_with_dots(p, &b, &e)) {
			return FALSE;
		}

		p = e;
#ifdef PARSE_TEST
		g_print("after read_word_with_dots: %s\n", p);
#endif
		/* eat white spaces and comments */
		while ((*p && (isspace(*p))) || (*p == '(')) {
			if (*p == '(') {
				if (!(p = skip_comment(p))) {
					parse_error = g_strdup("missing right bracket ')'");
					return FALSE;
				}
			} else {
				p++;
			}
		}
		/* we now have a non-space char that is not
		   the beginning of a comment */

		if (*p == '@' || *p == ',') {
			/* the last word was the local_part of an addr-spec */
			*local_begin = b;
			*local_end = e;
#ifdef PARSE_TEST
			g_print("found local part: %s\n", *local_begin);
#endif
			if (*p == '@') {
				p++;	/* skip @ */
				/* now the domain */
				if (!read_domain(p, &b, &e)) {
					return FALSE;
				}
				p = e;
				*domain_begin = b;
				*domain_end = e;
			} else {
				/* unqualified? */
				/* something like `To: alice, bob' with -t */
				*domain_begin = *domain_end = NULL;
			}
			break;

		} else if (*p == '<') {
			/* addr-spec follows */
			while (isspace(*p) || (*p == '<')) {
				if (*p == '<') {
					angle_brackets++;
				}
				p++;
			}
			if (!read_word_with_dots(p, &b, &e)) {
				return FALSE;
			}
			p = e;
			*local_begin = b;
			*local_end = e;
#ifdef PARSE_TEST
			g_print("found local part: %s\n", *local_begin);
#endif
			if (*p == '@') {
				p++;
				if (!read_domain(p, &b, &e)) {
					return FALSE;
				}
				p = e;
				*domain_begin = b;
				*domain_end = e;
			} else {
				/* may be unqualified address */
				*domain_begin = *domain_end = NULL;
			}
			break;

		} else if (!*p || *p == '>') {
			*local_begin = b;
			*local_end = e;
#ifdef PARSE_TEST
			g_print("found local part: %s\n", *local_begin);
#endif
			*domain_begin = *domain_end = NULL;
			break;

		} else if (strchr(specials, *p) || iscntrl(*p) || isspace(*p)) {
			parse_error = g_strdup_printf("unexpected character: %c", *p);
#ifdef PARSE_TEST
			g_print("unexpected character: %c", *p);
#endif
			return FALSE;
		}
	}

	/* trailing spaces and angle brackets */
#ifdef PARSE_TEST
	g_print("down counting trailing '>'\n");
#endif
	while (*p && (isspace(*p) || (*p == '>'))) {
		if (*p == '>') {
			angle_brackets--;
		}
		p++;
	}

	*address_end = p;

	if (angle_brackets > 0) {
		parse_error = g_strdup("missing '>' at end of string");
		return FALSE;
	} else if (angle_brackets < 0) {
		parse_error = g_strdup("superfluous '>' at end of string");
		return FALSE;
	}

	/* we successfully parsed the address */
	return TRUE;
}

gboolean
parse_address_rfc821(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,
                     gchar** domain_end, gchar** address_end)
{
	gint angle_brackets = 0;

	gchar *p = string;
	gchar *b, *e;

	*local_begin = *local_end = NULL;
	*domain_begin = *domain_end = NULL;

	/* might be some memory left from previous call: */
	if (parse_error != NULL) {
		g_free(parse_error);
		parse_error = NULL;
	}

	/* leading spaces and angle brackets */
	while (*p && (isspace(*p) || (*p == '<'))) {
		if (*p == '<') {
			angle_brackets++;
		}
		p++;
	}

	if (!*p) {
		return FALSE;
	}

	while (TRUE) {
		if (!read_word_with_dots(p, &b, &e)) {
			return FALSE;
		}

		p = e;
#ifdef PARSE_TEST
		g_print("after read_word_with_dots: %s\n", p);
#endif
		*local_begin = b;
		*local_end = e;
#ifdef PARSE_TEST
		g_print("found local part: %s\n", *local_begin);
		g_print("local_end = %s\n", *local_end);
#endif
		if (!(*p) || isspace(*p) || (*p == '>')) {
			/* unqualified ? */
			domain_begin = domain_end = NULL;
			break;
		} else if (*p == '@') {
			p++;
			if (read_domain(p, &b, &e)) {
				p = e;
				*domain_begin = b;
				*domain_end = e;
			}
			break;
		} else {
			parse_error = g_strdup_printf ("unexpected character after local part '%c'", *p);
			return FALSE;
		}
	}

	/* trailing spaces and angle brackets */
#ifdef PARSE_TEST
	g_print("down counting trailing '>'\n");
#endif
	while (*p && (isspace(*p) || (*p == '>'))) {
		if (*p == '>') {
			angle_brackets--;
		}
		p++;
	}
	*address_end = p;

	if (angle_brackets > 0) {
		parse_error = g_strdup("missing '>' at end of string");
		return FALSE;
	} else if (angle_brackets < 0) {
		parse_error = g_strdup("superfluous '>' at end of string");
		return FALSE;
	}

	/* we successfully parsed the address */
	return TRUE;
}

/*
  allocate address, reading from string.
  On failure, returns NULL.
  after call, end contains a pointer to the end of the parsed string
  end may be NULL, if we are not interested.

  parses both rfc 821 and rfc 822 addresses, depending on flag is_rfc821
*/
address*
_create_address(gchar * string, gchar ** end, gboolean is_rfc821)
{
	gchar *loc_beg, *loc_end;
	gchar *dom_beg, *dom_end;
	gchar *addr_end;
	gboolean ret;

	/* TODO: what about (string == NULL)? */
	if (string && (string[0] == '\0')) {
		address *addr = g_malloc(sizeof(address));
		addr->address = g_strdup("");
		addr->local_part = g_strdup("");
		/* 'NULL' address (failure notice),
		   "" makes sure it will not be qualified with a hostname */
		addr->domain = g_strdup("");
		return addr;
	}

	if (is_rfc821) {
		ret = parse_address_rfc821(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end);
	} else {
		ret = parse_address_rfc822(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end);
	}
	if (!ret) {
		return NULL;
	}

	address *addr = g_malloc(sizeof(address));
	gchar *p = addr_end;

	memset(addr, 0, sizeof(address));

	if (loc_beg[0] == '|') {
		parse_error = g_strdup("no pipe allowed for RFC 822/821 address");
		return NULL;
	}

	while (*p && (*p != ',')) {
		p++;
	}
	addr->address = g_strndup(string, p - string);
	addr->local_part = g_strndup(loc_beg, loc_end - loc_beg);

#ifdef PARSE_TEST
	g_print("addr->local_part = %s\n", addr->local_part);
#endif

	if (dom_beg != NULL) {
		addr->domain = g_strndup(dom_beg, dom_end - dom_beg);
	} else if (addr->local_part[0] == '\0') {
		/* 'NULL' address (failure notice),
		   "" makes sure it will not be qualified with a hostname */
		addr->domain = g_strdup("");
	} else {
		addr->domain = NULL;
	}

	if (end) {
		*end = p;
	}

#ifndef PARSE_TEST
	addr_unmark_delivered(addr);
#endif

	return addr;
}

address*
create_address_rfc822(gchar * string, gchar ** end)
{
	return _create_address(string, end, FALSE);
}

address*
create_address_rfc821(gchar * string, gchar ** end)
{
	return _create_address(string, end, TRUE);
}

GList*
addr_list_append_rfc822(GList * addr_list, gchar * string, gchar * domain)
{
	gchar *p = string;
	gchar *end;

	while (*p) {
#ifdef PARSE_TEST
		g_print("string: %s\n", p);
#endif

		address *addr = _create_address(p, &end, FALSE);
		if (!addr) {
			break;
		}

#ifdef PARSE_TEST
		g_print("addr: %s (%s<@>%s)", addr->address, addr->local_part, addr->domain);
#endif
		if (domain && !addr->domain) {
			addr->domain = g_strdup(domain);
		}
#ifdef PARSE_TEST
		g_print(" (%s<@>%s)\n", addr->local_part, addr->domain);
#endif

		addr_list = g_list_append(addr_list, addr);
		p = end;

		while (*p == ',' || isspace(*p)) {
			p++;
		}
	}
	return addr_list;
}