/*  MasqMail
    Copyright (C) 1999-2001 Oliver Kurth

    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 != 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) {
		while (TRUE) {
			if (read_word_with_dots(p, &b, &e)) {
				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 == '@') {
					/* 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)) {
							p = e;
							*domain_begin = b;
							*domain_end = e;
						} else
							return FALSE;
					} else {
						/* unqualified? */
						*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)) {
						p = e;
						*local_begin = b;
						*local_end = e;
#ifdef PARSE_TEST
						g_print("found local part: %s\n", *local_begin);
#endif
					} else
						return FALSE;
					if (*p == '@') {
						p++;
						if (read_domain(p, &b, &e)) {
							p = e;
							*domain_begin = b;
							*domain_end = e;
						} else
							return FALSE;
					} 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);
					return FALSE;
				}
			} else
				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) {
			if (angle_brackets > 0)
				parse_error = g_strdup("missing '>' at end of string");
			else
				parse_error = g_strdup("superfluous '>' at end of string");
			return FALSE;
		} else {
			/* we successfully parsed the address */
			return TRUE;
		}
		/* we never get here */
	}
	return FALSE;
}

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) {
		while (TRUE) {
			if (read_word_with_dots(p, &b, &e)) {
				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;
				}
			} else
				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) {
			if (angle_brackets > 0)
				parse_error = g_strdup("missing '>' at end of string");
			else
				parse_error = g_strdup("superfluous '>' at end of string");
			return FALSE;
		} else {
			/* we successfully parsed the address */
			return TRUE;
		}
		/* we never get here */
	}
	return FALSE;
}

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

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

	if (is_rfc821
	    ? parse_address_rfc821(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end)
	    : parse_address_rfc822(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end))
	{
		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)
				addr->domain = g_strdup("");  /* 'NULL' address (failure notice),
				                                 "" makes sure it will not be qualified with a hostname */
			else
				addr->domain = NULL;
		}

		if (end != NULL)
			*end = p;

#ifndef PARSE_TEST
		addr_unmark_delivered(addr);
#endif

		return addr;
	}
	return NULL;
}

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) {
		address *addr = _create_address(p, &end, FALSE);
		if (addr) {
			if (domain)
				if (addr->domain == NULL)
					addr->domain = g_strdup(domain);

			addr_list = g_list_append(addr_list, addr);
			p = end;
		} else
			break;
		while (*p == ',' || isspace(*p))
			p++;
	}
	return addr_list;
}