diff -up dovecot-2.2.36/src/doveadm/doveadm-mail-fetch.c.CVE_2020_12100 dovecot-2.2.36/src/doveadm/doveadm-mail-fetch.c

--- dovecot-2.2.36/src/doveadm/doveadm-mail-fetch.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/doveadm/doveadm-mail-fetch.c	2020-08-08 13:57:49.295662113 +0200

@@ -265,6 +265,9 @@ static int fetch_text(struct fetch_cmd_c

 static int fetch_text_utf8(struct fetch_cmd_context *ctx)

 {

+	const struct message_parser_settings parser_set = {

+		.hdr_flags = MESSAGE_HEADER_PARSER_FLAG_CLEAN_ONELINE,

+	};

 	struct istream *input;

 	struct message_parser_ctx *parser;

 	struct message_decoder_context *decoder;

@@ -275,9 +278,7 @@ static int fetch_text_utf8(struct fetch_

 	if (mail_get_stream(ctx->mail, NULL, NULL, &input) < 0)

 		return -1;

-	parser = message_parser_init(pool_datastack_create(), input,

-				     MESSAGE_HEADER_PARSER_FLAG_CLEAN_ONELINE,

-				     0);

+	parser = message_parser_init(pool_datastack_create(), input, &parser_set);

 	decoder = message_decoder_init(NULL, 0);

 	while ((ret = message_parser_parse_next_block(parser, &raw_block)) > 0) {

diff -up dovecot-2.2.36/src/lib-imap/test-imap-bodystructure.c.CVE_2020_12100 dovecot-2.2.36/src/lib-imap/test-imap-bodystructure.c

--- dovecot-2.2.36/src/lib-imap/test-imap-bodystructure.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-imap/test-imap-bodystructure.c	2020-08-08 13:57:49.295662113 +0200

@@ -381,6 +381,11 @@ static const unsigned int normalize_test

 static struct message_part *

 msg_parse(pool_t pool, const char *message, bool parse_bodystructure)

 {

+	const struct message_parser_settings parser_set = {

+		.hdr_flags = MESSAGE_HEADER_PARSER_FLAG_SKIP_INITIAL_LWSP |

+			MESSAGE_HEADER_PARSER_FLAG_DROP_CR,

+		.flags = MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK,

+	};

 	struct message_parser_ctx *parser;

 	struct istream *input;

 	struct message_block block;

@@ -388,10 +393,7 @@ msg_parse(pool_t pool, const char *messa

 	int ret;

 	input = i_stream_create_from_data(message, strlen(message));

-	parser = message_parser_init(pool, input,

-			MESSAGE_HEADER_PARSER_FLAG_SKIP_INITIAL_LWSP |

-			MESSAGE_HEADER_PARSER_FLAG_DROP_CR,

-			MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK);

+	parser = message_parser_init(pool, input, &parser_set);

 	while ((ret = message_parser_parse_next_block(parser, &block)) > 0) {

 		if (parse_bodystructure) {

 			message_part_data_parse_from_header(pool, block.part,

diff -up dovecot-2.2.36/src/lib-imap/test-imap-envelope.c.CVE_2020_12100 dovecot-2.2.36/src/lib-imap/test-imap-envelope.c

--- dovecot-2.2.36/src/lib-imap/test-imap-envelope.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-imap/test-imap-envelope.c	2020-08-08 13:57:49.295662113 +0200

@@ -118,6 +118,11 @@ static const unsigned int parse_tests_co

 static struct message_part_envelope *

 msg_parse(pool_t pool, const char *message)

 {

+	const struct message_parser_settings parser_set = {

+		.hdr_flags = MESSAGE_HEADER_PARSER_FLAG_SKIP_INITIAL_LWSP |

+			MESSAGE_HEADER_PARSER_FLAG_DROP_CR,

+		.flags = MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK,

+	};

 	struct message_parser_ctx *parser;

 	struct message_part_envelope *envlp = NULL;

 	struct istream *input;

@@ -126,10 +131,7 @@ msg_parse(pool_t pool, const char *messa

 	int ret;

 	input = i_stream_create_from_data(message, strlen(message));

-	parser = message_parser_init(pool, input,

-			MESSAGE_HEADER_PARSER_FLAG_SKIP_INITIAL_LWSP |

-			MESSAGE_HEADER_PARSER_FLAG_DROP_CR,

-			MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK);

+	parser = message_parser_init(pool, input, &parser_set);

 	while ((ret = message_parser_parse_next_block(parser, &block)) > 0) {

 		i_assert(block.part->parent == NULL);

 		message_part_envelope_parse_from_header(pool, &envlp, block.hdr);

diff -up dovecot-2.2.36/src/lib-mail/istream-attachment-extractor.c.CVE_2020_12100 dovecot-2.2.36/src/lib-mail/istream-attachment-extractor.c

--- dovecot-2.2.36/src/lib-mail/istream-attachment-extractor.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-mail/istream-attachment-extractor.c	2020-08-08 13:59:10.665535546 +0200

@@ -691,6 +691,10 @@ i_stream_create_attachment_extractor(str

 				     struct istream_attachment_settings *set,

 				     void *context)

 {

+	const struct message_parser_settings parser_set = {

+		.flags = MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS |

+			MESSAGE_PARSER_FLAG_INCLUDE_BOUNDARIES,

+	};

 	struct attachment_istream *astream;

 	i_assert(set->min_size > 0);

@@ -717,9 +721,7 @@ i_stream_create_attachment_extractor(str

 	astream->istream.istream.seekable = FALSE;

 	astream->pool = pool_alloconly_create("istream attachment", 1024);

-	astream->parser = message_parser_init(astream->pool, input, 0,

-				MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS |

-				MESSAGE_PARSER_FLAG_INCLUDE_BOUNDARIES);

+	astream->parser = message_parser_init(astream->pool, input, &parser_set);

 	return i_stream_create(&astream->istream, input,

 			       i_stream_get_fd(input));

 }

diff -up dovecot-2.2.36/src/lib-mail/istream-binary-converter.c.CVE_2020_12100 dovecot-2.2.36/src/lib-mail/istream-binary-converter.c

--- dovecot-2.2.36/src/lib-mail/istream-binary-converter.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-mail/istream-binary-converter.c	2020-08-08 14:00:06.560761661 +0200

@@ -286,6 +286,10 @@ static void i_stream_binary_converter_cl

 struct istream *i_stream_create_binary_converter(struct istream *input)

 {

+	const struct message_parser_settings parser_set = {

+		.flags = MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS |

+			MESSAGE_PARSER_FLAG_INCLUDE_BOUNDARIES,

+	};

 	struct binary_converter_istream *bstream;

 	bstream = i_new(struct binary_converter_istream, 1);

@@ -299,9 +303,7 @@ struct istream *i_stream_create_binary_c

 	bstream->istream.istream.seekable = FALSE;

 	bstream->pool = pool_alloconly_create("istream binary converter", 128);

-	bstream->parser = message_parser_init(bstream->pool, input, 0,

-				MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS |

-				MESSAGE_PARSER_FLAG_INCLUDE_BOUNDARIES);

+	bstream->parser = message_parser_init(bstream->pool, input, &parser_set);

 	return i_stream_create(&bstream->istream, input,

 			       i_stream_get_fd(input));

 }

diff -up dovecot-2.2.36/src/lib-mail/Makefile.am.CVE_2020_12100 dovecot-2.2.36/src/lib-mail/Makefile.am

--- dovecot-2.2.36/src/lib-mail/Makefile.am.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-mail/Makefile.am	2020-08-08 13:57:49.296662100 +0200

@@ -27,6 +27,7 @@ libmail_la_SOURCES = \

 	message-header-parser.c \

 	message-id.c \

 	message-parser.c \

+	message-parser-from-parts.c \

 	message-part.c \

 	message-part-data.c \

 	message-part-serialize.c \

@@ -41,7 +42,8 @@ libmail_la_SOURCES = \

 	rfc822-parser.c

 noinst_HEADERS = \

-	html-entities.h

+	html-entities.h \

+	message-parser-private.h

 headers = \

 	istream-attachment-connector.h \

diff -up dovecot-2.2.36/src/lib-mail/message-parser.c.CVE_2020_12100 dovecot-2.2.36/src/lib-mail/message-parser.c

--- dovecot-2.2.36/src/lib-mail/message-parser.c.CVE_2020_12100	2018-04-30 15:52:05.000000000 +0200

+++ dovecot-2.2.36/src/lib-mail/message-parser.c	2020-08-08 14:06:41.696290855 +0200

@@ -1,53 +1,12 @@

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

 #include "lib.h"

-#include "buffer.h"

+#include "array.h"

 #include "str.h"

 #include "istream.h"

 #include "rfc822-parser.h"

 #include "rfc2231-parser.h"

-#include "message-parser.h"

-

-/* RFC-2046 requires boundaries are max. 70 chars + "--" prefix + "--" suffix.

-   We'll add a bit more just in case. */

-#define BOUNDARY_END_MAX_LEN (70 + 2 + 2 + 10)

-

-struct message_boundary {

-	struct message_boundary *next;

-

-	struct message_part *part;

-	const char *boundary;

-	size_t len;

-

-	unsigned int epilogue_found:1;

-};

-

-struct message_parser_ctx {

-	pool_t parser_pool, part_pool;

-	struct istream *input;

-	struct message_part *parts, *part;

-	const char *broken_reason;

-

-	enum message_header_parser_flags hdr_flags;

-	enum message_parser_flags flags;

-

-	const char *last_boundary;

-	struct message_boundary *boundaries;

-

-	size_t skip;

-	char last_chr;

-	unsigned int want_count;

-

-	struct message_header_parser_ctx *hdr_parser_ctx;

-	unsigned int prev_hdr_newline_size;

-

-	int (*parse_next_block)(struct message_parser_ctx *ctx,

-				struct message_block *block_r);

-

-	unsigned int part_seen_content_type:1;

-	unsigned int multipart:1;

-	unsigned int eof:1;

-};

+#include "message-parser-private.h"

 message_part_header_callback_t *null_message_part_header_callback = NULL;

@@ -57,14 +16,10 @@ static int parse_next_body_to_boundary(s

 				       struct message_block *block_r);

 static int parse_next_body_to_eof(struct message_parser_ctx *ctx,

 				  struct message_block *block_r);

-static int preparsed_parse_epilogue_init(struct message_parser_ctx *ctx,

-					 struct message_block *block_r);

-static int preparsed_parse_next_header_init(struct message_parser_ctx *ctx,

-					    struct message_block *block_r);

 static struct message_boundary *

 boundary_find(struct message_boundary *boundaries,

-	      const unsigned char *data, size_t len)

+	      const unsigned char *data, size_t len, bool trailing_dashes)

 {

 	struct message_boundary *best = NULL;

@@ -76,8 +31,18 @@ boundary_find(struct message_boundary *b

 	while (boundaries != NULL) {

 		if (boundaries->len <= len &&

 		    memcmp(boundaries->boundary, data, boundaries->len) == 0 &&

-		    (best == NULL || best->len < boundaries->len))

+		    (best == NULL || best->len < boundaries->len)) {

 			best = boundaries;

+			/* If we see "foo--", it could either mean that there

+			   is a boundary named "foo" that ends now or there's

+			   a boundary "foo--" which continues. */

+			if (best->len == len ||

+			    (best->len == len-2 && trailing_dashes)) {

+				/* This is exactly the wanted boundary. There

+				   can't be a better one. */

+				break;

+			}

+		}

 		boundaries = boundaries->next;

 	}

@@ -121,8 +86,8 @@ static void parse_body_add_block(struct

 	ctx->part->body_size.virtual_size += block->size + missing_cr_count;

 }

-static int message_parser_read_more(struct message_parser_ctx *ctx,

-				    struct message_block *block_r, bool *full_r)

+int message_parser_read_more(struct message_parser_ctx *ctx,

+			     struct message_block *block_r, bool *full_r)

 {

 	int ret;

@@ -167,19 +132,18 @@ static int message_parser_read_more(stru

 	return 1;

 }

-static struct message_part *

-message_part_append(pool_t pool, struct message_part *parent)

+static void

+message_part_append(struct message_parser_ctx *ctx)

 {

-	struct message_part *p, *part, **list;

+	struct message_part *parent = ctx->part;

+	struct message_part *part;

 	i_assert(parent != NULL);

 	i_assert((parent->flags & (MESSAGE_PART_FLAG_MULTIPART |

 				   MESSAGE_PART_FLAG_MESSAGE_RFC822)) != 0);

-	part = p_new(pool, struct message_part, 1);

+	part = p_new(ctx->part_pool, struct message_part, 1);

 	part->parent = parent;

-	for (p = parent; p != NULL; p = p->parent)

-		p->children_count++;

 	/* set child position */

 	part->physical_pos =

@@ -187,33 +151,78 @@ message_part_append(pool_t pool, struct

 		parent->body_size.physical_size +

 		parent->header_size.physical_size;

-	list = &part->parent->children;

-	while (*list != NULL)

-		list = &(*list)->next;

+	/* add to parent's linked list */

+	*ctx->next_part = part;

+	/* update the parent's end-of-linked-list pointer */

+	struct message_part **next_part = &part->next;

+	array_push_back(&ctx->next_part_stack, &next_part);

+	/* This part is now the new parent for the next message_part_append()

+	   call. Its linked list begins with the children pointer. */

+	ctx->next_part = &part->children;

+

+	ctx->part = part;

+	ctx->nested_parts_count++;

+	ctx->total_parts_count++;

+	i_assert(ctx->nested_parts_count < ctx->max_nested_mime_parts);

+	i_assert(ctx->total_parts_count <= ctx->max_total_mime_parts);

+}

+

+static void message_part_finish(struct message_parser_ctx *ctx)

+{

+	struct message_part **const *parent_next_partp;

+

+	i_assert(ctx->nested_parts_count > 0);

+	ctx->nested_parts_count--;

+

+	parent_next_partp = array_back(&ctx->next_part_stack);

+	array_pop_back(&ctx->next_part_stack);

+	ctx->next_part = *parent_next_partp;

+

+	message_size_add(&ctx->part->parent->body_size, &ctx->part->body_size);

+	message_size_add(&ctx->part->parent->body_size, &ctx->part->header_size);

+	ctx->part->parent->children_count += 1 + ctx->part->children_count;

+	ctx->part = ctx->part->parent;

+}

+

+static void message_boundary_free(struct message_boundary *b)

+{

+	i_free(b->boundary);

+	i_free(b);

+}

+

+static void

+boundary_remove_until(struct message_parser_ctx *ctx,

+		      struct message_boundary *boundary)

+{

+	while (ctx->boundaries != boundary) {

+		struct message_boundary *cur = ctx->boundaries;

-	*list = part;

-	return part;

+		i_assert(cur != NULL);

+		ctx->boundaries = cur->next;

+		message_boundary_free(cur);

+

+	}

+	ctx->boundaries = boundary;

 }

 static void parse_next_body_multipart_init(struct message_parser_ctx *ctx)

 {

 	struct message_boundary *b;

-	b = p_new(ctx->parser_pool, struct message_boundary, 1);

+	b = i_new(struct message_boundary, 1);

 	b->part = ctx->part;

 	b->boundary = ctx->last_boundary;

+	ctx->last_boundary = NULL;

 	b->len = strlen(b->boundary);

 	b->next = ctx->boundaries;

 	ctx->boundaries = b;

-

-	ctx->last_boundary = NULL;

 }

 static int parse_next_body_message_rfc822_init(struct message_parser_ctx *ctx,

 					       struct message_block *block_r)

 {

-	ctx->part = message_part_append(ctx->part_pool, ctx->part);

+	message_part_append(ctx);

 	return parse_next_header_init(ctx, block_r);

 }

@@ -238,19 +247,38 @@ boundary_line_find(struct message_parser

 		return -1;

 	}

+	if (ctx->total_parts_count >= ctx->max_total_mime_parts) {

+		/* can't add any more MIME parts. just stop trying to find

+		   more boundaries. */

+		return -1;

+	}

+

 	/* need to find the end of line */

-	if (memchr(data + 2, '\n', size - 2) == NULL &&

-	    size < BOUNDARY_END_MAX_LEN &&

+	data += 2;

+	size -= 2;

+	const unsigned char *lf_pos = memchr(data, '\n', size);

+	if (lf_pos == NULL &&

+	    size+2 < BOUNDARY_END_MAX_LEN &&

 	    !ctx->input->eof && !full) {

 		/* no LF found */

 		ctx->want_count = BOUNDARY_END_MAX_LEN;

 		return 0;

 	}

+	size_t find_size = size;

+	bool trailing_dashes = FALSE;

-	data += 2;

-	size -= 2;

+	if (lf_pos != NULL) {

+		find_size = lf_pos - data;

+		if (find_size > 0 && data[find_size-1] == '\r')

+			find_size--;

+		if (find_size > 2 && data[find_size-1] == '-' &&

+		    data[find_size-2] == '-')

+			trailing_dashes = TRUE;

+	} else if (find_size > BOUNDARY_END_MAX_LEN)

+		find_size = BOUNDARY_END_MAX_LEN;

-	*boundary_r = boundary_find(ctx->boundaries, data, size);

+	*boundary_r = boundary_find(ctx->boundaries, data, find_size,

+				    trailing_dashes);

 	if (*boundary_r == NULL)

 		return -1;

@@ -263,7 +291,7 @@ boundary_line_find(struct message_parser

 static int parse_next_mime_header_init(struct message_parser_ctx *ctx,

 				       struct message_block *block_r)

 {

-	ctx->part = message_part_append(ctx->part_pool, ctx->part);

+	message_part_append(ctx);

 	ctx->part->flags |= MESSAGE_PART_FLAG_IS_MIME;

 	return parse_next_header_init(ctx, block_r);

@@ -312,26 +340,25 @@ static int parse_part_finish(struct mess

 			     struct message_boundary *boundary,

 			     struct message_block *block_r, bool first_line)

 {

-	struct message_part *part;

 	size_t line_size;

+	size_t boundary_len = boundary->len;

+	bool boundary_epilogue_found = boundary->epilogue_found;

 	i_assert(ctx->last_boundary == NULL);

 	/* get back to parent MIME part, summing the child MIME part sizes

 	   into parent's body sizes */

-	for (part = ctx->part; part != boundary->part; part = part->parent) {

-		message_size_add(&part->parent->body_size, &part->body_size);

-		message_size_add(&part->parent->body_size, &part->header_size);

+	while (ctx->part != boundary->part) {

+		message_part_finish(ctx);

+		i_assert(ctx->part != NULL);

 	}

-	i_assert(part != NULL);

-	ctx->part = part;

 	if (boundary->epilogue_found) {

 		/* this boundary isn't needed anymore */

-		ctx->boundaries = boundary->next;

+		boundary_remove_until(ctx, boundary->next);

 	} else {

 		/* forget about the boundaries we possibly skipped */

-		ctx->boundaries = boundary;

+		boundary_remove_until(ctx, boundary);

 	}

 	/* the boundary itself should already be in buffer. add that. */

@@ -348,7 +375,7 @@ static int parse_part_finish(struct mess

 		i_assert(block_r->data[0] == '\n');

 		line_size = 1;

 	}

-	line_size += 2 + boundary->len + (boundary->epilogue_found ? 2 : 0);

+	line_size += 2 + boundary_len + (boundary_epilogue_found ? 2 : 0);

 	i_assert(block_r->size >= ctx->skip + line_size);

 	block_r->size = line_size;

 	parse_body_add_block(ctx, block_r);

@@ -509,8 +536,10 @@ static void parse_content_type(struct me

 	rfc2231_parse(&parser, &results);

 	for (; *results != NULL; results += 2) {

 		if (strcasecmp(results[0], "boundary") == 0) {

+			/* truncate excessively long boundaries */

+			i_free(ctx->last_boundary);

 			ctx->last_boundary =

-				p_strdup(ctx->parser_pool, results[1]);

+				i_strndup(results[1], BOUNDARY_STRING_MAX_LEN);

 			break;

 		}

 	}

@@ -532,6 +561,11 @@ static bool block_is_at_eoh(const struct

 	return FALSE;

 }

+static bool parse_too_many_nested_mime_parts(struct message_parser_ctx *ctx)

+{

+	return ctx->nested_parts_count+1 >= ctx->max_nested_mime_parts;

+}

+

 #define MUTEX_FLAGS \

 	(MESSAGE_PART_FLAG_MESSAGE_RFC822 | MESSAGE_PART_FLAG_MULTIPART)

@@ -556,8 +590,12 @@ static int parse_next_header(struct mess

 		   "\n--boundary" belongs to us or to a previous boundary.

 		   this is a problem if the boundary prefixes are identical,

 		   because MIME requires only the prefix to match. */

-		parse_next_body_multipart_init(ctx);

-		ctx->multipart = TRUE;

+		if (!parse_too_many_nested_mime_parts(ctx)) {

+			parse_next_body_multipart_init(ctx);

+			ctx->multipart = TRUE;

+		} else {

+			part->flags &= ~MESSAGE_PART_FLAG_MULTIPART;

+		}

 	}

 	/* before parsing the header see if we can find a --boundary from here.

@@ -633,7 +671,7 @@ static int parse_next_header(struct mess

 		i_assert(!ctx->multipart);

 		part->flags = 0;

 	}

-	ctx->last_boundary = NULL;

+	i_free(ctx->last_boundary);

 	if (!ctx->part_seen_content_type ||

 	    (part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) {

@@ -661,12 +699,16 @@ static int parse_next_header(struct mess

 		i_assert(ctx->last_boundary == NULL);

 		ctx->multipart = FALSE;

 		ctx->parse_next_block = parse_next_body_to_boundary;

-	} else if (part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822)

+	} else if ((part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822) != 0 &&

+		   !parse_too_many_nested_mime_parts(ctx)) {

 		ctx->parse_next_block = parse_next_body_message_rfc822_init;

-	else if (ctx->boundaries != NULL)

-		ctx->parse_next_block = parse_next_body_to_boundary;

-	else

-		ctx->parse_next_block = parse_next_body_to_eof;

+	} else {

+		part->flags &= ~MESSAGE_PART_FLAG_MESSAGE_RFC822;

+		if (ctx->boundaries != NULL)

+			ctx->parse_next_block = parse_next_body_to_boundary;

+		else

+			ctx->parse_next_block = parse_next_body_to_eof;

+	}

 	ctx->want_count = 1;

@@ -691,358 +733,21 @@ static int parse_next_header_init(struct

 	return parse_next_header(ctx, block_r);

 }

-static int preparsed_parse_eof(struct message_parser_ctx *ctx ATTR_UNUSED,

-			       struct message_block *block_r ATTR_UNUSED)

-{

-	return -1;

-}

-

-static void preparsed_skip_to_next(struct message_parser_ctx *ctx)

-{

-	ctx->parse_next_block = preparsed_parse_next_header_init;

-	while (ctx->part != NULL) {

-		if (ctx->part->next != NULL) {

-			ctx->part = ctx->part->next;

-			break;

-		}

-

-		/* parse epilogue of multipart parent if requested */

-		if (ctx->part->parent != NULL &&

-		    (ctx->part->parent->flags & MESSAGE_PART_FLAG_MULTIPART) != 0 &&

-		    (ctx->flags & MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS) != 0) {

-			/* check for presence of epilogue */

-			uoff_t part_end = ctx->part->physical_pos +

-				ctx->part->header_size.physical_size +

-				ctx->part->body_size.physical_size;

-			uoff_t parent_end = ctx->part->parent->physical_pos +

-				ctx->part->parent->header_size.physical_size +

-				ctx->part->parent->body_size.physical_size;

-

-			if (parent_end > part_end) {

-				ctx->parse_next_block = preparsed_parse_epilogue_init;

-				break;

-			}

-		}

-		ctx->part = ctx->part->parent;

-	}

-	if (ctx->part == NULL)

-		ctx->parse_next_block = preparsed_parse_eof;

-}

-

-static int preparsed_parse_body_finish(struct message_parser_ctx *ctx,

-				       struct message_block *block_r)

-{

-	i_stream_skip(ctx->input, ctx->skip);

-	ctx->skip = 0;

-

-	preparsed_skip_to_next(ctx);

-	return ctx->parse_next_block(ctx, block_r);

-}

-

-static int preparsed_parse_prologue_finish(struct message_parser_ctx *ctx,

-					   struct message_block *block_r)

-{

-	i_stream_skip(ctx->input, ctx->skip);

-	ctx->skip = 0;

-

-	ctx->parse_next_block = preparsed_parse_next_header_init;

-	ctx->part = ctx->part->children;

-	return ctx->parse_next_block(ctx, block_r);

-}

-

-static int preparsed_parse_body_more(struct message_parser_ctx *ctx,

-				     struct message_block *block_r)

-{

-	uoff_t end_offset = ctx->part->physical_pos +

-		ctx->part->header_size.physical_size +

-		ctx->part->body_size.physical_size;

-	bool full;

-	int ret;

-

-	if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0)

-		return ret;

-

-	if (ctx->input->v_offset + block_r->size >= end_offset) {

-		block_r->size = end_offset - ctx->input->v_offset;

-		ctx->parse_next_block = preparsed_parse_body_finish;

-	}

-	ctx->skip = block_r->size;

-	return 1;

-}

-

-static int preparsed_parse_prologue_more(struct message_parser_ctx *ctx,

-					 struct message_block *block_r)

-{

-	uoff_t boundary_min_start, end_offset;

-	const unsigned char *cur;

-	bool full;

-	int ret;

-

-	i_assert(ctx->part->children != NULL);

-	end_offset = ctx->part->children->physical_pos;

-

-	if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0)

-		return ret;

-

-	if (ctx->input->v_offset + block_r->size >= end_offset) {

-		/* we've got the full prologue: clip off the initial boundary */

-		block_r->size = end_offset - ctx->input->v_offset;

-		cur = block_r->data + block_r->size - 1;

-

-		/* [\r]\n--boundary[\r]\n */ 

-		if (block_r->size < 5 || *cur != '\n') {

-			ctx->broken_reason = "Prologue boundary end not at expected position";

-			return -1;

-		}

-		

-		cur--;

-		if (*cur == '\r') cur--;

-

-		/* find newline just before boundary */

-		for (; cur >= block_r->data; cur--) {

-			if (*cur == '\n') break;

-		}

-

-		if (cur[0] != '\n' || cur[1] != '-' || cur[2] != '-') {

-			ctx->broken_reason = "Prologue boundary beginning not at expected position";

-			return -1;

-		}

-

-		if (cur != block_r->data && cur[-1] == '\r') cur--;

-

-		/* clip boundary */

-		block_r->size = cur - block_r->data;			

-

-		ctx->parse_next_block = preparsed_parse_prologue_finish;

-		ctx->skip = block_r->size;

-		return 1;

-	}

-		

-	/* retain enough data in the stream buffer to contain initial boundary */

-	if (end_offset > BOUNDARY_END_MAX_LEN)

-		boundary_min_start = end_offset - BOUNDARY_END_MAX_LEN;

-	else

-		boundary_min_start = 0;

-

-	if (ctx->input->v_offset + block_r->size >= boundary_min_start) {

-		if (boundary_min_start <= ctx->input->v_offset)

-			return 0;

-		block_r->size = boundary_min_start - ctx->input->v_offset;

-	}

-	ctx->skip = block_r->size;

-	return 1;

-}

-

-static int preparsed_parse_epilogue_more(struct message_parser_ctx *ctx,

-					 struct message_block *block_r)

-{

-	uoff_t end_offset = ctx->part->physical_pos +

-		ctx->part->header_size.physical_size +

-		ctx->part->body_size.physical_size;

-	bool full;

-	int ret;

-

-	if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0)

-		return ret;

-

-	if (ctx->input->v_offset + block_r->size >= end_offset) {

-		block_r->size = end_offset - ctx->input->v_offset;

-		ctx->parse_next_block = preparsed_parse_body_finish;

-	}

-	ctx->skip = block_r->size;

-	return 1;

-}

-

-static int preparsed_parse_epilogue_boundary(struct message_parser_ctx *ctx,

-					     struct message_block *block_r)

-{

-	uoff_t end_offset = ctx->part->physical_pos +

-		ctx->part->header_size.physical_size +

-		ctx->part->body_size.physical_size;

-	const unsigned char *data, *cur;

-	size_t size;

-	bool full;

-	int ret;

-

-	if (end_offset - ctx->input->v_offset < 7) {

-		ctx->broken_reason = "Epilogue position is wrong";

-		return -1;

-	}

-

-	if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0)

-		return ret;

-