/* Copyright (c) 2002-2018 Pigeonhole authors, see the included COPYING file
 */

/* NOTE: much of the functionality implemented here should eventually appear
 * somewhere in Dovecot itself.
 */

#include "lib.h"
#include "str.h"
#include "unichar.h"

#include "rfc2822.h"

#include "message-header-encode.h"

#include <stdio.h>
#include <ctype.h>

bool rfc2822_header_field_name_verify
(const char *field_name, unsigned int len)
{
	const char *p = field_name;
	const char *pend = p + len;

	/* field-name   =   1*ftext
	 * ftext        =   %d33-57 /               ; Any character except
	 *                  %d59-126                ;  controls, SP, and
	 *                                          ;  ":".
	 */

	while ( p < pend ) {
		if ( *p < 33 || *p == ':' )
			return FALSE;

		p++;
	}

	return TRUE;
}

bool rfc2822_header_field_body_verify
(const char *field_body, unsigned int len, bool allow_crlf, bool allow_utf8)
{
	const unsigned char *p = (const unsigned char *)field_body;
	const unsigned char *pend = p + len;
	bool is8bit = FALSE;

	/* RFC5322:
	 *
	 * unstructured    =  (*([FWS] VCHAR) *WSP)
	 * VCHAR           =  %x21-7E
	 * FWS             =  ([*WSP CRLF] 1*WSP) /   ; Folding white space
	 * WSP             =  SP / HTAB               ; White space
	 */

	while ( p < pend ) {
		if ( *p < 0x20 ) {
			if ( (*p == '\r' || *p == '\n') ) {
				if ( !allow_crlf )
					return FALSE;
			} else if ( *p != '\t' ) {
				return FALSE;
			}
		}

		if ( !is8bit && *p > 127 ) {
			if ( !allow_utf8 )
				return FALSE;

			is8bit = TRUE;
		}

		p++;
	}

	if ( is8bit && !uni_utf8_str_is_valid(field_body) ) {
		return FALSE;
	}

	return TRUE;
}

/*
 *
 */

const char *rfc2822_header_field_name_sanitize(const char *name)
{
	char *result = t_strdup_noconst(name);
	char *p;

	/* Make the whole name lower case ... */
	result = str_lcase(result);

	/* ... except for the first letter and those that follow '-' */
	p = result;
	*p = i_toupper(*p);
	while ( *p != '\0' ) {
		if ( *p == '-' ) {
			p++;

			if ( *p != '\0' )
				*p = i_toupper(*p);

			continue;
		}

		p++;
	}

	return result;
}

/*
 * Message construction
 */

/* FIXME: This should be collected into a Dovecot API for composing internet
 * mail messages.
 */

unsigned int rfc2822_header_append
(string_t *header, const char *name, const char *body, bool crlf,
	uoff_t *body_offset_r)
{
	static const unsigned int max_line = 80;

	const char *bp = body;  /* Pointer */
	const char *sp = body;  /* Start pointer */
	const char *wp = NULL;  /* Whitespace pointer */
	const char *nlp = NULL; /* New-line pointer */
	unsigned int line_len = strlen(name);
	unsigned int lines = 0;

	/* Write header field name first */
	str_append(header, name);
	str_append(header, ": ");

	if ( body_offset_r != NULL )
		*body_offset_r = str_len(header);

	line_len +=  2;

	/* Add field body; fold it if necessary and account for existing folding */
	while ( *bp != '\0' ) {
		bool ws_first = TRUE;

		while ( *bp != '\0' && nlp == NULL &&
			(wp == NULL || line_len < max_line) ) {
			if ( *bp == ' ' || *bp == '\t' ) {
				if (ws_first)
					wp = bp;
				ws_first = FALSE;
			} else if ( *bp == '\r' || *bp == '\n' ) {
				if (ws_first)
					nlp = bp;
				else
					nlp = wp;
				break;
			} else {
				ws_first = TRUE;
			}

			bp++; line_len++;
		}

		if ( *bp == '\0' ) break;

		/* Existing newline ? */
		if ( nlp != NULL ) {			
			/* Replace any consecutive newline and whitespace for
			   consistency */
			while ( *bp == ' ' || *bp == '\t' || *bp == '\r' || *bp == '\n' )
				bp++;

			str_append_data(header, sp, nlp-sp);

			if ( crlf )
				str_append(header, "\r\n");
			else
				str_append(header, "\n");

			while ( *bp == ' ' || *bp == '\t' )
				bp++;
			if ( *bp != '\0' ) {
				/* Continued line; replace leading whitespace with single TAB */
				str_append_c(header, '\t');
			}

			sp = bp;
		} else {
			/* Insert newline at last whitespace within the max_line limit */
			i_assert(wp >= sp);
			str_append_data(header, sp, wp-sp);

			/* Force continued line; drop any existing whitespace */
			while ( *wp == ' ' || *wp == '\t' )
				wp++;

			if ( crlf )
				str_append(header, "\r\n");
			else
				str_append(header, "\n");

			/* Insert single TAB instead of the original whitespace */
			str_append_c(header, '\t');

			sp = wp;
			if (sp > bp)
				bp = sp;
		}

		lines++;

		line_len = bp - sp;
		wp = NULL;
		nlp = NULL;
	}

	if ( bp != sp || lines == 0 ) {
		str_append_data(header, sp, bp-sp);
		if ( crlf )
			str_append(header, "\r\n");
		else
			str_append(header, "\n");
		lines++;
	}

	return lines;
}

void rfc2822_header_printf
(string_t *header, const char *name, const char *fmt, ...)
{
	const char *body;
	va_list args;

	va_start(args, fmt);
	body = t_strdup_vprintf(fmt, args);
	va_end(args);

	rfc2822_header_write(header, name, body);
}

void rfc2822_header_utf8_printf
(string_t *header, const char *name, const char *fmt, ...)
{
	string_t *body = t_str_new(256);
	va_list args;

	va_start(args, fmt);
	message_header_encode(t_strdup_vprintf(fmt, args), body);
	va_end(args);

	rfc2822_header_write(header, name, str_c(body));
}


void rfc2822_header_write_address(string_t *header,
	const char *name, const char *address)
{
	bool has_8bit = FALSE;
	const char *p;

	for (p = address; *p != '\0'; p++) {
		if ((*p & 0x80) != 0)
			has_8bit = TRUE;
	}

	if (!has_8bit) {
		rfc2822_header_write(header, name, address);
	} else {
		string_t *body = t_str_new(256);
		message_header_encode(address, body);
		rfc2822_header_write(header, name, str_c(body));
	}
}