Mercurial > dovecot > original-hg > dovecot-1.2
annotate src/lib-mail/message-parser.c @ 8590:b9faf4db2a9f HEAD
Updated copyright notices to include year 2009.
author | Timo Sirainen <tss@iki.fi> |
---|---|
date | Tue, 06 Jan 2009 09:25:38 -0500 |
parents | 5adb665bfc0c |
children | 00cd9aacd03c |
rev | line source |
---|---|
8590
b9faf4db2a9f
Updated copyright notices to include year 2009.
Timo Sirainen <tss@iki.fi>
parents:
8237
diff
changeset
|
1 /* Copyright (c) 2002-2009 Dovecot authors, see the included COPYING file */ |
0 | 2 |
3 #include "lib.h" | |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
4 #include "str.h" |
764
f57c52738f90
Renamed IBuffer and OBuffer to IStream and OStream which describes their
Timo Sirainen <tss@iki.fi>
parents:
579
diff
changeset
|
5 #include "istream.h" |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
6 #include "rfc822-parser.h" |
7950
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
7 #include "rfc2231-parser.h" |
0 | 8 #include "message-parser.h" |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
9 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
10 /* RFC-2046 requires boundaries are max. 70 chars + "--" prefix + "--" suffix. |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
11 We'll add a bit more just in case. */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
12 #define BOUNDARY_END_MAX_LEN (70 + 2 + 2 + 10) |
0 | 13 |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
14 struct message_boundary { |
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
15 struct message_boundary *next; |
0 | 16 |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
17 struct message_part *part; |
0 | 18 const char *boundary; |
184 | 19 size_t len; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
20 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
21 unsigned int epilogue_found:1; |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
22 }; |
0 | 23 |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
24 struct message_parser_ctx { |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
25 pool_t parser_pool, part_pool; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
26 struct istream *input; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
27 struct message_part *parts, *part; |
0 | 28 |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
29 enum message_header_parser_flags hdr_flags; |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
30 enum message_parser_flags flags; |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
31 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
32 const char *last_boundary; |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
33 struct message_boundary *boundaries; |
0 | 34 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
35 size_t skip; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
36 char last_chr; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
37 unsigned int want_count; |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
38 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
39 struct message_header_parser_ctx *hdr_parser_ctx; |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
40 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
41 int (*parse_next_block)(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
42 struct message_block *block_r); |
1534
676995d7c0ca
IMAP protocol doesn't allow server to send NULs to client. Send ascii #128
Timo Sirainen <tss@iki.fi>
parents:
1532
diff
changeset
|
43 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
44 unsigned int part_seen_content_type:1; |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
45 unsigned int broken:1; |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
46 unsigned int eof:1; |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
47 }; |
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
48 |
4903
204d7edc7cdc
Added context parameter type safety checks for most callback APIs.
Timo Sirainen <tss@iki.fi>
parents:
4673
diff
changeset
|
49 message_part_header_callback_t *null_message_part_header_callback = NULL; |
204d7edc7cdc
Added context parameter type safety checks for most callback APIs.
Timo Sirainen <tss@iki.fi>
parents:
4673
diff
changeset
|
50 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
51 static int parse_next_header_init(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
52 struct message_block *block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
53 static int parse_next_body_to_boundary(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
54 struct message_block *block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
55 static int parse_next_body_to_eof(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
56 struct message_block *block_r); |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
57 static int preparsed_parse_next_header_init(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
58 struct message_block *block_r); |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
59 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
60 static struct message_boundary * |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
61 boundary_find(struct message_boundary *boundaries, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
62 const unsigned char *data, size_t len) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
63 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
64 /* As MIME spec says: search from latest one to oldest one so that we |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
65 don't break if the same boundary is used in nested parts. Also the |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
66 full message line doesn't have to match the boundary, only the |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
67 beginning. */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
68 while (boundaries != NULL) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
69 if (boundaries->len <= len && |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
70 memcmp(boundaries->boundary, data, boundaries->len) == 0) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
71 return boundaries; |
0 | 72 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
73 boundaries = boundaries->next; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
74 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
75 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
76 return NULL; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
77 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
78 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
79 static void parse_body_add_block(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
80 struct message_block *block) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
81 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
82 unsigned int missing_cr_count = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
83 const unsigned char *data = block->data; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
84 size_t i; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
85 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
86 block->hdr = NULL; |
0 | 87 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
88 for (i = 0; i < block->size; i++) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
89 if (data[i] <= '\n') { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
90 if (data[i] == '\n') { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
91 ctx->part->body_size.lines++; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
92 if ((i > 0 && data[i-1] != '\r') || |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
93 (i == 0 && ctx->last_chr != '\r')) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
94 missing_cr_count++; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
95 } else if (data[i] == '\0') |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
96 ctx->part->flags |= MESSAGE_PART_FLAG_HAS_NULS; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
97 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
98 } |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
99 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
100 ctx->part->body_size.physical_size += block->size; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
101 ctx->part->body_size.virtual_size += block->size + missing_cr_count; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
102 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
103 ctx->last_chr = data[i-1]; |
5244 | 104 ctx->skip += block->size; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
105 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
106 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
107 static int message_parser_read_more(struct message_parser_ctx *ctx, |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
108 struct message_block *block_r, bool *full_r) |
0 | 109 { |
5112 | 110 int ret; |
111 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
112 if (ctx->skip > 0) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
113 i_stream_skip(ctx->input, ctx->skip); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
114 ctx->skip = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
115 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
116 |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
117 *full_r = FALSE; |
5112 | 118 ret = i_stream_read_data(ctx->input, &block_r->data, |
119 &block_r->size, ctx->want_count); | |
6586
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
120 if (ret <= 0) { |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
121 switch (ret) { |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
122 case 0: |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
123 if (!ctx->input->eof) { |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
124 i_assert(!ctx->input->blocking); |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
125 return 0; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
126 } |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
127 break; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
128 case -1: |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
129 i_assert(ctx->input->eof || |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
130 ctx->input->stream_errno != 0); |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
131 ctx->eof = TRUE; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
132 if (block_r->size != 0) { |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
133 /* EOF, but we still have some data. |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
134 return it. */ |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
135 return 1; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
136 } |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
137 return -1; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
138 case -2: |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
139 *full_r = TRUE; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
140 break; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
141 default: |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
142 i_unreached(); |
5112 | 143 } |
5109 | 144 } |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
145 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
146 ctx->want_count = 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
147 return 1; |
0 | 148 } |
149 | |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
150 static struct message_part * |
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
151 message_part_append(pool_t pool, struct message_part *parent) |
0 | 152 { |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
153 struct message_part *part, **list; |
0 | 154 |
903
fd8888f6f037
Naming style changes, finally got tired of most of the typedefs. Also the
Timo Sirainen <tss@iki.fi>
parents:
898
diff
changeset
|
155 part = p_new(pool, struct message_part, 1); |
0 | 156 part->parent = parent; |
157 | |
212
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
158 /* set child position */ |
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
159 part->physical_pos = |
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
160 parent->physical_pos + |
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
161 parent->body_size.physical_size + |
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
162 parent->header_size.physical_size; |
4327b1266604
message/rfc822 mime parts weren't parsed correctly
Timo Sirainen <tss@iki.fi>
parents:
184
diff
changeset
|
163 |
0 | 164 list = &part->parent->children; |
165 while (*list != NULL) | |
166 list = &(*list)->next; | |
167 | |
168 *list = part; | |
169 return part; | |
170 } | |
171 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
172 static void parse_next_body_multipart_init(struct message_parser_ctx *ctx) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
173 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
174 struct message_boundary *b; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
175 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
176 b = p_new(ctx->parser_pool, struct message_boundary, 1); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
177 b->part = ctx->part; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
178 b->boundary = ctx->last_boundary; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
179 b->len = strlen(b->boundary); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
180 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
181 b->next = ctx->boundaries; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
182 ctx->boundaries = b; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
183 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
184 ctx->last_boundary = NULL; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
185 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
186 |
7214
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
187 static int parse_next_body_message_rfc822_init(struct message_parser_ctx *ctx, |
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
188 struct message_block *block_r) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
189 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
190 ctx->part = message_part_append(ctx->part_pool, ctx->part); |
7214
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
191 return parse_next_header_init(ctx, block_r); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
192 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
193 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
194 static int |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
195 boundary_line_find(struct message_parser_ctx *ctx, |
5109 | 196 const unsigned char *data, size_t size, bool full, |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
197 struct message_boundary **boundary_r) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
198 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
199 size_t i; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
200 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
201 *boundary_r = NULL; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
202 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
203 if (size < 2) { |
5109 | 204 i_assert(!full); |
205 | |
206 if (ctx->input->eof) | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
207 return -1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
208 ctx->want_count = 2; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
209 return 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
210 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
211 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
212 if (data[0] != '-' || data[1] != '-') { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
213 /* not a boundary, just skip this line */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
214 return -1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
215 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
216 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
217 /* need to find the end of line */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
218 for (i = 2; i < size; i++) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
219 if (data[i] == '\n') |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
220 break; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
221 } |
5109 | 222 if (i == size && i < BOUNDARY_END_MAX_LEN && |
223 !ctx->input->eof && !full) { | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
224 /* no LF found */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
225 ctx->want_count = BOUNDARY_END_MAX_LEN; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
226 return 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
227 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
228 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
229 data += 2; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
230 size -= 2; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
231 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
232 *boundary_r = boundary_find(ctx->boundaries, data, size); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
233 if (*boundary_r == NULL) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
234 return -1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
235 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
236 (*boundary_r)->epilogue_found = |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
237 size >= (*boundary_r)->len + 2 && |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
238 memcmp(data + (*boundary_r)->len, "--", 2) == 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
239 return 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
240 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
241 |
6900
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
242 static int parse_next_mime_header_init(struct message_parser_ctx *ctx, |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
243 struct message_block *block_r) |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
244 { |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
245 ctx->part = message_part_append(ctx->part_pool, ctx->part); |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
246 ctx->part->flags |= MESSAGE_PART_FLAG_IS_MIME; |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
247 |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
248 return parse_next_header_init(ctx, block_r); |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
249 } |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
250 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
251 static int parse_next_body_skip_boundary_line(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
252 struct message_block *block_r) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
253 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
254 size_t i; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
255 int ret; |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
256 bool full; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
257 |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
258 if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
259 return ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
260 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
261 for (i = 0; i < block_r->size; i++) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
262 if (block_r->data[i] == '\n') |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
263 break; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
264 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
265 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
266 if (i == block_r->size) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
267 parse_body_add_block(ctx, block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
268 return 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
269 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
270 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
271 /* found the LF */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
272 block_r->size = i + 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
273 parse_body_add_block(ctx, block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
274 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
275 /* a new MIME part begins */ |
6900
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
276 ctx->parse_next_block = parse_next_mime_header_init; |
950ce0b5edb5
Message parser wasn't returning body blocks correctly, causing problems with
Timo Sirainen <tss@iki.fi>
parents:
6729
diff
changeset
|
277 return 1; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
278 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
279 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
280 static int parse_part_finish(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
281 struct message_boundary *boundary, |
5305
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
282 struct message_block *block_r, bool first_line) |
0 | 283 { |
5111 | 284 struct message_part *part; |
285 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
286 /* get back to parent MIME part, summing the child MIME part sizes |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
287 into parent's body sizes */ |
5111 | 288 for (part = ctx->part; part != boundary->part; part = part->parent) { |
289 message_size_add(&part->parent->body_size, &part->body_size); | |
290 message_size_add(&part->parent->body_size, &part->header_size); | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
291 } |
5111 | 292 ctx->part = part; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
293 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
294 if (boundary->epilogue_found) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
295 /* this boundary isn't needed anymore */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
296 ctx->boundaries = boundary->next; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
297 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
298 if (ctx->boundaries != NULL) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
299 ctx->parse_next_block = parse_next_body_to_boundary; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
300 else |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
301 ctx->parse_next_block = parse_next_body_to_eof; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
302 return ctx->parse_next_block(ctx, block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
303 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
304 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
305 /* forget about the boundaries we possibly skipped */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
306 ctx->boundaries = boundary; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
307 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
308 /* the boundary itself should already be in buffer. add that. */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
309 block_r->data = i_stream_get_data(ctx->input, &block_r->size); |
5305
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
310 i_assert(block_r->size >= ctx->skip + 2 + boundary->len + |
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
311 (first_line ? 0 : 1)); |
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
312 block_r->data += ctx->skip; |
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
313 /* [\n]--<boundary> */ |
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
314 block_r->size = (first_line ? 0 : 1) + 2 + boundary->len; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
315 parse_body_add_block(ctx, block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
316 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
317 ctx->parse_next_block = parse_next_body_skip_boundary_line; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
318 return 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
319 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
320 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
321 static int parse_next_body_to_boundary(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
322 struct message_block *block_r) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
323 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
324 struct message_boundary *boundary = NULL; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
325 const unsigned char *data; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
326 size_t i, boundary_start; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
327 int ret; |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
328 bool full; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
329 |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
330 if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
331 return ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
332 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
333 data = block_r->data; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
334 if (ctx->last_chr == '\n') { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
335 /* handle boundary in first line of message. alternatively |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
336 it's an empty line. */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
337 ret = boundary_line_find(ctx, block_r->data, |
5109 | 338 block_r->size, full, &boundary); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
339 if (ret >= 0) { |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
340 return ret == 0 ? 0 : |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
341 parse_part_finish(ctx, boundary, block_r, TRUE); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
342 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
343 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
344 |
8103
360ade35792f
Fixed infinite looping when parsing some (not all) broken multipart mails
Timo Sirainen <tss@iki.fi>
parents:
7950
diff
changeset
|
345 i_assert(block_r->size > 0); |
5109 | 346 for (i = boundary_start = 0; i < block_r->size; i++) { |
5411 | 347 /* skip to beginning of the next line. the first line was |
348 handled already. */ | |
5440 | 349 size_t next_line_idx = block_r->size; |
350 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
351 for (; i < block_r->size; i++) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
352 if (data[i] == '\n') { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
353 boundary_start = i; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
354 if (i > 0 && data[i-1] == '\r') |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
355 boundary_start--; |
5440 | 356 next_line_idx = i + 1; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
357 break; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
358 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
359 } |
5411 | 360 if (boundary_start != 0) { |
361 /* we can skip the first lines. input buffer can't be | |
362 full anymore. */ | |
5109 | 363 full = FALSE; |
6586
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
364 } else if (next_line_idx == block_r->size) { |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
365 /* no linefeeds in this block. we can just skip it. */ |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
366 boundary_start = block_r->size; |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
367 full = FALSE; |
5411 | 368 } |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
369 |
5440 | 370 ret = boundary_line_find(ctx, block_r->data + next_line_idx, |
371 block_r->size - next_line_idx, full, | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
372 &boundary); |
5109 | 373 if (ret >= 0) { |
374 /* found / need more data */ | |
5112 | 375 if (ret == 0 && boundary_start == 0) |
5440 | 376 ctx->want_count += next_line_idx; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
377 break; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
378 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
379 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
380 |
5111 | 381 if (i >= block_r->size) { |
5109 | 382 /* the boundary wasn't found from this data block, |
383 we'll need more data. */ | |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
384 ret = 0; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
385 ctx->want_count = (block_r->size - boundary_start) + 1; |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
386 } else { |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
387 /* found / need more data */ |
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
388 i_assert(ret >= 0); |
5109 | 389 } |
390 i_assert(!(ret == 0 && full)); | |
391 | |
8237
5adb665bfc0c
Earlier changes broke message parsing near EOF.
Timo Sirainen <tss@iki.fi>
parents:
8128
diff
changeset
|
392 if (ret > 0 || (ret == 0 && !ctx->eof)) { |
5adb665bfc0c
Earlier changes broke message parsing near EOF.
Timo Sirainen <tss@iki.fi>
parents:
8128
diff
changeset
|
393 /* a) we found the boundary |
5adb665bfc0c
Earlier changes broke message parsing near EOF.
Timo Sirainen <tss@iki.fi>
parents:
8128
diff
changeset
|
394 b) we need more data and haven't reached EOF yet |
5adb665bfc0c
Earlier changes broke message parsing near EOF.
Timo Sirainen <tss@iki.fi>
parents:
8128
diff
changeset
|
395 so leave CR+LF + last line to buffer */ |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
396 block_r->size = boundary_start; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
397 } |
6904
275d22eb25ba
Another fix to returning body blocks.
Timo Sirainen <tss@iki.fi>
parents:
6900
diff
changeset
|
398 if (block_r->size != 0) { |
5244 | 399 parse_body_add_block(ctx, block_r); |
6904
275d22eb25ba
Another fix to returning body blocks.
Timo Sirainen <tss@iki.fi>
parents:
6900
diff
changeset
|
400 return 1; |
275d22eb25ba
Another fix to returning body blocks.
Timo Sirainen <tss@iki.fi>
parents:
6900
diff
changeset
|
401 } |
275d22eb25ba
Another fix to returning body blocks.
Timo Sirainen <tss@iki.fi>
parents:
6900
diff
changeset
|
402 return ret <= 0 ? ret : |
5305
43d3955ce03f
Fixes to counting MIME part sizes
Timo Sirainen <tss@iki.fi>
parents:
5244
diff
changeset
|
403 parse_part_finish(ctx, boundary, block_r, FALSE); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
404 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
405 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
406 static int parse_next_body_to_eof(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
407 struct message_block *block_r) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
408 { |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
409 bool full; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
410 int ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
411 |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
412 if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
413 return ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
414 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
415 parse_body_add_block(ctx, block_r); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
416 return 1; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
417 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
418 |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
419 static void parse_content_type(struct message_parser_ctx *ctx, |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
420 struct message_header_line *hdr) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
421 { |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
422 struct rfc822_parser_context parser; |
7950
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
423 const char *const *results; |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
424 string_t *content_type; |
0 | 425 |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
426 if (ctx->part_seen_content_type) |
0 | 427 return; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
428 ctx->part_seen_content_type = TRUE; |
0 | 429 |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
430 rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL); |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
431 (void)rfc822_skip_lwsp(&parser); |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
432 |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
433 content_type = t_str_new(64); |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
434 if (rfc822_parse_content_type(&parser, content_type) < 0) |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
435 return; |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
436 |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
437 if (strcasecmp(str_c(content_type), "message/rfc822") == 0) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
438 ctx->part->flags |= MESSAGE_PART_FLAG_MESSAGE_RFC822; |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
439 else if (strncasecmp(str_c(content_type), "text", 4) == 0 && |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
440 (str_len(content_type) == 4 || |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
441 str_data(content_type)[4] == '/')) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
442 ctx->part->flags |= MESSAGE_PART_FLAG_TEXT; |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
443 else if (strncasecmp(str_c(content_type), "multipart/", 10) == 0) { |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
444 ctx->part->flags |= MESSAGE_PART_FLAG_MULTIPART; |
0 | 445 |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
446 if (strcasecmp(str_c(content_type)+10, "digest") == 0) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
447 ctx->part->flags |= MESSAGE_PART_FLAG_MULTIPART_DIGEST; |
0 | 448 } |
449 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
450 if ((ctx->part->flags & MESSAGE_PART_FLAG_MULTIPART) == 0 || |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
451 ctx->last_boundary != NULL) |
0 | 452 return; |
453 | |
7950
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
454 (void)rfc2231_parse(&parser, &results); |
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
455 for (; *results != NULL; results += 2) { |
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
456 if (strcasecmp(results[0], "boundary") == 0) { |
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
457 ctx->last_boundary = |
3412c43d6707
Merge RFC 2231 header continuations in BODY/BODYSTRUCTURE replies. Also use
Timo Sirainen <tss@iki.fi>
parents:
7938
diff
changeset
|
458 p_strdup(ctx->parser_pool, results[1]); |
6117
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
459 break; |
9214044ce1f1
Removed message-content-parser. Instead added rfc822_parse_content_type()
Timo Sirainen <tss@iki.fi>
parents:
6082
diff
changeset
|
460 } |
0 | 461 } |
462 } | |
463 | |
874 | 464 #define MUTEX_FLAGS \ |
465 (MESSAGE_PART_FLAG_MESSAGE_RFC822 | MESSAGE_PART_FLAG_MULTIPART) | |
466 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
467 static int parse_next_header(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
468 struct message_block *block_r) |
0 | 469 { |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
470 struct message_part *part = ctx->part; |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
471 struct message_header_line *hdr; |
6654 | 472 size_t size; |
2430
7c1dc4a7db3a
message_parse_header_next() can now return "need more data" with nonblocking
Timo Sirainen <tss@iki.fi>
parents:
2404
diff
changeset
|
473 int ret; |
0 | 474 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
475 if (ctx->skip > 0) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
476 i_stream_skip(ctx->input, ctx->skip); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
477 ctx->skip = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
478 } |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
479 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
480 ret = message_parse_header_next(ctx->hdr_parser_ctx, &hdr); |
6654 | 481 if (ret == 0 || (ret < 0 && ctx->input->stream_errno != 0)) { |
482 (void)i_stream_get_data(ctx->input, &size); | |
483 ctx->want_count = size + 1; | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
484 return ret; |
6654 | 485 } |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
486 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
487 if (hdr != NULL) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
488 if (hdr->eoh) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
489 ; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
490 else if (strcasecmp(hdr->name, "Mime-Version") == 0) { |
1618
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
491 /* it's MIME. Content-* headers are valid */ |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
492 part->flags |= MESSAGE_PART_FLAG_IS_MIME; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
493 } else if (strcasecmp(hdr->name, "Content-Type") == 0) { |
6156
e18086698ebf
By default assume MIME message if Content-Type: exists even if Mime-Version:
Timo Sirainen <tss@iki.fi>
parents:
6117
diff
changeset
|
494 if ((ctx->flags & |
e18086698ebf
By default assume MIME message if Content-Type: exists even if Mime-Version:
Timo Sirainen <tss@iki.fi>
parents:
6117
diff
changeset
|
495 MESSAGE_PARSER_FLAG_MIME_VERSION_STRICT) == 0) |
e18086698ebf
By default assume MIME message if Content-Type: exists even if Mime-Version:
Timo Sirainen <tss@iki.fi>
parents:
6117
diff
changeset
|
496 part->flags |= MESSAGE_PART_FLAG_IS_MIME; |
e18086698ebf
By default assume MIME message if Content-Type: exists even if Mime-Version:
Timo Sirainen <tss@iki.fi>
parents:
6117
diff
changeset
|
497 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
498 if (hdr->continues) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
499 hdr->use_full_value = TRUE; |
7226
e6693a0ec8e1
Renamed T_FRAME_BEGIN/END to T_BEGIN/END. Removed T_FRAME() macro and
Timo Sirainen <tss@iki.fi>
parents:
7214
diff
changeset
|
500 else T_BEGIN { |
e6693a0ec8e1
Renamed T_FRAME_BEGIN/END to T_BEGIN/END. Removed T_FRAME() macro and
Timo Sirainen <tss@iki.fi>
parents:
7214
diff
changeset
|
501 parse_content_type(ctx, hdr); |
e6693a0ec8e1
Renamed T_FRAME_BEGIN/END to T_BEGIN/END. Removed T_FRAME() macro and
Timo Sirainen <tss@iki.fi>
parents:
7214
diff
changeset
|
502 } T_END; |
1618
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
503 } |
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
504 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
505 block_r->hdr = hdr; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
506 block_r->size = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
507 return 1; |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
508 } |
1618
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
509 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
510 /* end of headers */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
511 if ((part->flags & MESSAGE_PART_FLAG_MULTIPART) != 0 && |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
512 ctx->last_boundary == NULL) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
513 /* multipart type but no message boundary */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
514 part->flags = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
515 } |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
516 if ((part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) { |
1618
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
517 /* It's not MIME. Reset everything we found from |
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
518 Content-Type. */ |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
519 part->flags = 0; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
520 ctx->last_boundary = NULL; |
1618
149ade487f48
Ignore Content-* headers if there's no MIME-Version header. Note that this
Timo Sirainen <tss@iki.fi>
parents:
1543
diff
changeset
|
521 } |
874 | 522 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
523 if (!ctx->part_seen_content_type || |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
524 (part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) { |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
525 if (part->parent != NULL && |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
526 (part->parent->flags & |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
527 MESSAGE_PART_FLAG_MULTIPART_DIGEST) != 0) { |
0 | 528 /* when there's no content-type specified and we're |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
529 below multipart/digest, assume message/rfc822 |
0 | 530 content-type */ |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
531 part->flags |= MESSAGE_PART_FLAG_MESSAGE_RFC822; |
0 | 532 } else { |
533 /* otherwise we default to text/plain */ | |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
534 part->flags |= MESSAGE_PART_FLAG_TEXT; |
0 | 535 } |
536 } | |
537 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
538 if (message_parse_header_has_nuls(ctx->hdr_parser_ctx)) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
539 part->flags |= MESSAGE_PART_FLAG_HAS_NULS; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
540 message_parse_header_deinit(&ctx->hdr_parser_ctx); |
0 | 541 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
542 i_assert((part->flags & MUTEX_FLAGS) != MUTEX_FLAGS); |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
543 |
5244 | 544 ctx->last_chr = '\n'; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
545 if (ctx->last_boundary != NULL) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
546 parse_next_body_multipart_init(ctx); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
547 ctx->parse_next_block = parse_next_body_to_boundary; |
7214
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
548 } else if (part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822) |
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
549 ctx->parse_next_block = parse_next_body_message_rfc822_init; |
2d58b1c2dfd0
The header ending a message/rfc822 doesn't belong to its child MIME part.
Timo Sirainen <tss@iki.fi>
parents:
7086
diff
changeset
|
550 else if (ctx->boundaries != NULL) |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
551 ctx->parse_next_block = parse_next_body_to_boundary; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
552 else |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
553 ctx->parse_next_block = parse_next_body_to_eof; |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
554 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
555 ctx->want_count = 1; |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
556 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
557 /* return empty block as end of headers */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
558 block_r->hdr = NULL; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
559 block_r->size = 0; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
560 return 1; |
0 | 561 } |
562 | |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
563 static int parse_next_header_init(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
564 struct message_block *block_r) |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
565 { |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
566 i_assert(ctx->hdr_parser_ctx == NULL); |
1253
39b899338c99
A few small fixes to MIME and mail address parsers.
Timo Sirainen <tss@iki.fi>
parents:
1061
diff
changeset
|
567 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
568 ctx->hdr_parser_ctx = |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
569 message_parse_header_init(ctx->input, &ctx->part->header_size, |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
570 ctx->hdr_flags); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
571 ctx->part_seen_content_type = FALSE; |
0 | 572 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
573 ctx->parse_next_block = parse_next_header; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
574 return parse_next_header(ctx, block_r); |
0 | 575 } |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
576 |
6411
6a64e64fa3a3
Renamed __attr_*__ to ATTR_*. Renamed __attrs_used__ to ATTRS_DEFINED.
Timo Sirainen <tss@iki.fi>
parents:
6156
diff
changeset
|
577 static int preparsed_parse_eof(struct message_parser_ctx *ctx ATTR_UNUSED, |
6a64e64fa3a3
Renamed __attr_*__ to ATTR_*. Renamed __attrs_used__ to ATTRS_DEFINED.
Timo Sirainen <tss@iki.fi>
parents:
6156
diff
changeset
|
578 struct message_block *block_r ATTR_UNUSED) |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
579 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
580 return -1; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
581 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
582 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
583 static void preparsed_skip_to_next(struct message_parser_ctx *ctx) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
584 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
585 ctx->parse_next_block = preparsed_parse_next_header_init; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
586 while (ctx->part != NULL) { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
587 if (ctx->part->next != NULL) { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
588 ctx->part = ctx->part->next; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
589 break; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
590 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
591 ctx->part = ctx->part->parent; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
592 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
593 if (ctx->part == NULL) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
594 ctx->parse_next_block = preparsed_parse_eof; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
595 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
596 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
597 static int preparsed_parse_body_finish(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
598 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
599 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
600 i_stream_skip(ctx->input, ctx->skip); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
601 ctx->skip = 0; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
602 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
603 preparsed_skip_to_next(ctx); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
604 return ctx->parse_next_block(ctx, block_r); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
605 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
606 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
607 static int preparsed_parse_body_more(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
608 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
609 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
610 uoff_t end_offset = ctx->part->physical_pos + |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
611 ctx->part->header_size.physical_size + |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
612 ctx->part->body_size.physical_size; |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
613 bool full; |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
614 int ret; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
615 |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
616 if ((ret = message_parser_read_more(ctx, block_r, &full)) <= 0) |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
617 return ret; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
618 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
619 if (ctx->input->v_offset + block_r->size >= end_offset) { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
620 block_r->size = end_offset - ctx->input->v_offset; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
621 ctx->parse_next_block = preparsed_parse_body_finish; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
622 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
623 ctx->skip = block_r->size; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
624 return 1; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
625 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
626 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
627 static int preparsed_parse_body_init(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
628 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
629 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
630 uoff_t offset = ctx->part->physical_pos + |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
631 ctx->part->header_size.physical_size; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
632 |
7597
f27e6f583817
If cached message part showed header's size to be smaller than in reality,
Timo Sirainen <tss@iki.fi>
parents:
7272
diff
changeset
|
633 if (offset < ctx->input->v_offset) { |
f27e6f583817
If cached message part showed header's size to be smaller than in reality,
Timo Sirainen <tss@iki.fi>
parents:
7272
diff
changeset
|
634 /* header was actually larger than the cached size suggested */ |
f27e6f583817
If cached message part showed header's size to be smaller than in reality,
Timo Sirainen <tss@iki.fi>
parents:
7272
diff
changeset
|
635 ctx->broken = TRUE; |
f27e6f583817
If cached message part showed header's size to be smaller than in reality,
Timo Sirainen <tss@iki.fi>
parents:
7272
diff
changeset
|
636 return -1; |
f27e6f583817
If cached message part showed header's size to be smaller than in reality,
Timo Sirainen <tss@iki.fi>
parents:
7272
diff
changeset
|
637 } |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
638 i_stream_skip(ctx->input, offset - ctx->input->v_offset); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
639 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
640 ctx->parse_next_block = preparsed_parse_body_more; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
641 return preparsed_parse_body_more(ctx, block_r); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
642 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
643 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
644 static int preparsed_parse_finish_header(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
645 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
646 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
647 if (ctx->part->children != NULL) { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
648 ctx->parse_next_block = preparsed_parse_next_header_init; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
649 ctx->part = ctx->part->children; |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
650 } else if ((ctx->flags & MESSAGE_PARSER_FLAG_SKIP_BODY_BLOCK) == 0) { |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
651 ctx->parse_next_block = preparsed_parse_body_init; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
652 } else { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
653 preparsed_skip_to_next(ctx); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
654 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
655 return ctx->parse_next_block(ctx, block_r); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
656 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
657 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
658 static int preparsed_parse_next_header(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
659 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
660 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
661 struct message_header_line *hdr; |
6654 | 662 size_t size; |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
663 int ret; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
664 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
665 ret = message_parse_header_next(ctx->hdr_parser_ctx, &hdr); |
6654 | 666 if (ret == 0 || (ret < 0 && ctx->input->stream_errno != 0)) { |
667 (void)i_stream_get_data(ctx->input, &size); | |
668 ctx->want_count = size + 1; | |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
669 return ret; |
6654 | 670 } |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
671 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
672 if (hdr != NULL) { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
673 block_r->hdr = hdr; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
674 block_r->size = 0; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
675 return 1; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
676 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
677 message_parse_header_deinit(&ctx->hdr_parser_ctx); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
678 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
679 ctx->parse_next_block = preparsed_parse_finish_header; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
680 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
681 /* return empty block as end of headers */ |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
682 block_r->hdr = NULL; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
683 block_r->size = 0; |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
684 |
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
685 i_assert(ctx->skip == 0); |
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
686 if (ctx->input->v_offset != ctx->part->physical_pos + |
8121
d95770cfd935
message_parser_init_from_parts(): If parts were broken, we may have assert-crashed.
Timo Sirainen <tss@iki.fi>
parents:
8103
diff
changeset
|
687 ctx->part->header_size.physical_size) { |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
688 ctx->broken = TRUE; |
8121
d95770cfd935
message_parser_init_from_parts(): If parts were broken, we may have assert-crashed.
Timo Sirainen <tss@iki.fi>
parents:
8103
diff
changeset
|
689 return -1; |
d95770cfd935
message_parser_init_from_parts(): If parts were broken, we may have assert-crashed.
Timo Sirainen <tss@iki.fi>
parents:
8103
diff
changeset
|
690 } |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
691 return 1; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
692 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
693 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
694 static int preparsed_parse_next_header_init(struct message_parser_ctx *ctx, |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
695 struct message_block *block_r) |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
696 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
697 i_assert(ctx->hdr_parser_ctx == NULL); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
698 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
699 i_assert(ctx->part->physical_pos >= ctx->input->v_offset); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
700 i_stream_skip(ctx->input, ctx->part->physical_pos - |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
701 ctx->input->v_offset); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
702 |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
703 ctx->hdr_parser_ctx = |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
704 message_parse_header_init(ctx->input, NULL, ctx->hdr_flags); |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
705 |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
706 ctx->parse_next_block = preparsed_parse_next_header; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
707 return preparsed_parse_next_header(ctx, block_r); |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
708 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
709 |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
710 struct message_parser_ctx * |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
711 message_parser_init(pool_t part_pool, struct istream *input, |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
712 enum message_header_parser_flags hdr_flags, |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
713 enum message_parser_flags flags) |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
714 { |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
715 struct message_parser_ctx *ctx; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
716 pool_t pool; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
717 |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
718 pool = pool_alloconly_create("Message Parser", 1024); |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
719 ctx = p_new(pool, struct message_parser_ctx, 1); |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
720 ctx->parser_pool = pool; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
721 ctx->part_pool = part_pool; |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
722 ctx->hdr_flags = hdr_flags; |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
723 ctx->flags = flags; |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
724 ctx->input = input; |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
725 ctx->parts = ctx->part = part_pool == NULL ? NULL : |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
726 p_new(part_pool, struct message_part, 1); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
727 ctx->parse_next_block = parse_next_header_init; |
6082
d62bddb414ef
ref/unref stream when parsing it.
Timo Sirainen <tss@iki.fi>
parents:
5989
diff
changeset
|
728 i_stream_ref(input); |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
729 return ctx; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
730 } |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
731 |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
732 struct message_parser_ctx * |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
733 message_parser_init_from_parts(struct message_part *parts, |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
734 struct istream *input, |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
735 enum message_header_parser_flags hdr_flags, |
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
736 enum message_parser_flags flags) |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
737 { |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
738 struct message_parser_ctx *ctx; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
739 |
5522
5dee807e53cf
Header parser has now flags parameter to tell it how to handle linefeeds.
Timo Sirainen <tss@iki.fi>
parents:
5506
diff
changeset
|
740 ctx = message_parser_init(NULL, input, hdr_flags, flags); |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
741 ctx->parts = ctx->part = parts; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
742 ctx->parse_next_block = preparsed_parse_next_header_init; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
743 return ctx; |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
744 } |
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
745 |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
746 int message_parser_deinit(struct message_parser_ctx **_ctx, |
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
747 struct message_part **parts_r) |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
748 { |
3879
928229f8b3e6
deinit, unref, destroy, close, free, etc. functions now take a pointer to
Timo Sirainen <tss@iki.fi>
parents:
3863
diff
changeset
|
749 struct message_parser_ctx *ctx = *_ctx; |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
750 int ret = ctx->broken ? -1 : 0; |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
751 |
3879
928229f8b3e6
deinit, unref, destroy, close, free, etc. functions now take a pointer to
Timo Sirainen <tss@iki.fi>
parents:
3863
diff
changeset
|
752 *_ctx = NULL; |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
753 *parts_r = ctx->parts; |
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
754 |
7245 | 755 if (ctx->hdr_parser_ctx != NULL) |
756 message_parse_header_deinit(&ctx->hdr_parser_ctx); | |
6082
d62bddb414ef
ref/unref stream when parsing it.
Timo Sirainen <tss@iki.fi>
parents:
5989
diff
changeset
|
757 i_stream_unref(&ctx->input); |
6428
7cad076906eb
pool_unref() now takes ** pointer.
Timo Sirainen <tss@iki.fi>
parents:
6411
diff
changeset
|
758 pool_unref(&ctx->parser_pool); |
7243
289765861d66
Changed message_parser_deinit() to return -1 if the parser was using
Timo Sirainen <tss@iki.fi>
parents:
7226
diff
changeset
|
759 return ret; |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
760 } |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
761 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
762 int message_parser_parse_next_block(struct message_parser_ctx *ctx, |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
763 struct message_block *block_r) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
764 { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
765 int ret; |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
766 bool eof = FALSE, full; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
767 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
768 while ((ret = ctx->parse_next_block(ctx, block_r)) == 0) { |
8128
fcf0c5ac5975
message parser: Cleaned up the code and another attempt at fixing infinite looping.
Timo Sirainen <tss@iki.fi>
parents:
8121
diff
changeset
|
769 ret = message_parser_read_more(ctx, block_r, &full); |
6586
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
770 if (ret == 0) { |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
771 i_assert(!ctx->input->blocking); |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
772 return 0; |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
773 } |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
774 if (ret == -1) { |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
775 i_assert(!eof); |
d6b2343238f9
Handle lines longer than 8192 bytes without going to infinite loop.
Timo Sirainen <tss@iki.fi>
parents:
6529
diff
changeset
|
776 eof = TRUE; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
777 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
778 } |
5109 | 779 |
4673
f5bef033a9ac
message_parser_parse_next_block() returned body part wrong for first header
Timo Sirainen <tss@iki.fi>
parents:
4267
diff
changeset
|
780 block_r->part = ctx->part; |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
781 |
5506
6cd889c652b0
Removed message_parse_from_parts(). Added message_parser_init_from_parts()
Timo Sirainen <tss@iki.fi>
parents:
5440
diff
changeset
|
782 if (ret < 0 && ctx->part != NULL) { |
7272 | 783 /* Successful EOF or unexpected failure */ |
784 i_assert(ctx->input->eof || ctx->input->closed || | |
7938
e06d4049d282
Message parser: Fixed assert-crash if cached MIME structure was broken.
Timo Sirainen <tss@iki.fi>
parents:
7798
diff
changeset
|
785 ctx->input->stream_errno != 0 || ctx->broken); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
786 while (ctx->part->parent != NULL) { |
4265
75d5843153f1
Added message_part to struct message_block and some cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4259
diff
changeset
|
787 message_size_add(&ctx->part->parent->body_size, |
75d5843153f1
Added message_part to struct message_block and some cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4259
diff
changeset
|
788 &ctx->part->body_size); |
4267
bd99e8f5e3ac
Some fixes and added message_parser_set_crlfs().
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4265
diff
changeset
|
789 message_size_add(&ctx->part->parent->body_size, |
bd99e8f5e3ac
Some fixes and added message_parser_set_crlfs().
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4265
diff
changeset
|
790 &ctx->part->header_size); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
791 ctx->part = ctx->part->parent; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
792 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
793 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
794 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
795 return ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
796 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
797 |
4903
204d7edc7cdc
Added context parameter type safety checks for most callback APIs.
Timo Sirainen <tss@iki.fi>
parents:
4673
diff
changeset
|
798 #undef message_parser_parse_header |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
799 void message_parser_parse_header(struct message_parser_ctx *ctx, |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
800 struct message_size *hdr_size, |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
801 message_part_header_callback_t *callback, |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
802 void *context) |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
803 { |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
804 struct message_block block; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
805 int ret; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
806 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
807 while ((ret = message_parser_parse_next_block(ctx, &block)) > 0) { |
4265
75d5843153f1
Added message_part to struct message_block and some cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4259
diff
changeset
|
808 callback(block.part, block.hdr, context); |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
809 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
810 if (block.hdr == NULL) |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
811 break; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
812 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
813 i_assert(ret != 0); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
814 |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
815 if (ret < 0) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
816 /* well, can't return error so fake end of headers */ |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
817 callback(ctx->part, NULL, context); |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
818 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
819 |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
820 *hdr_size = ctx->part->header_size; |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
821 } |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
822 |
4903
204d7edc7cdc
Added context parameter type safety checks for most callback APIs.
Timo Sirainen <tss@iki.fi>
parents:
4673
diff
changeset
|
823 #undef message_parser_parse_body |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
824 void message_parser_parse_body(struct message_parser_ctx *ctx, |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
825 message_part_header_callback_t *hdr_callback, |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
826 void *context) |
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
827 { |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
828 struct message_block block; |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
829 int ret; |
1697
ef79ce6507ff
Message parsing can now be done in two parts - header and body. We're now
Timo Sirainen <tss@iki.fi>
parents:
1689
diff
changeset
|
830 |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
831 while ((ret = message_parser_parse_next_block(ctx, &block)) > 0) { |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
832 if (block.size == 0 && hdr_callback != NULL) |
4265
75d5843153f1
Added message_part to struct message_block and some cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
4259
diff
changeset
|
833 hdr_callback(block.part, block.hdr, context); |
4259
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
834 } |
fd315deac28f
Rewrote the message bodystructure parser to allow parsing from non-blocking streams. Also did a couple of API changes and cleanups.
Timo Sirainen <timo.sirainen@movial.fi>
parents:
3879
diff
changeset
|
835 i_assert(ret != 0); |
1322
97f8c00b8d4c
Better handling for multiline headers. Before we skipped headers larger than
Timo Sirainen <tss@iki.fi>
parents:
1253
diff
changeset
|
836 } |