summaryrefslogtreecommitdiffstats
path: root/src/imap/imap-fetch-body.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/imap/imap-fetch-body.c')
-rw-r--r--src/imap/imap-fetch-body.c722
1 files changed, 722 insertions, 0 deletions
diff --git a/src/imap/imap-fetch-body.c b/src/imap/imap-fetch-body.c
new file mode 100644
index 0000000..b467334
--- /dev/null
+++ b/src/imap/imap-fetch-body.c
@@ -0,0 +1,722 @@
+/* Copyright (c) 2002-2018 Dovecot authors, see the included COPYING file */
+
+#include "imap-common.h"
+#include "buffer.h"
+#include "str.h"
+#include "strescape.h"
+#include "istream.h"
+#include "ostream.h"
+#include "istream-header-filter.h"
+#include "message-parser.h"
+#include "mail-storage-private.h"
+#include "imap-quote.h"
+#include "imap-parser.h"
+#include "imap-msgpart.h"
+#include "imap-fetch.h"
+
+#include <ctype.h>
+#include <unistd.h>
+
+struct imap_fetch_body_data {
+ const char *section; /* NOTE: always uppercased */
+ struct imap_msgpart *msgpart;
+
+ bool partial:1;
+ bool binary:1;
+ bool binary_size:1;
+};
+
+struct imap_fetch_preview_data {
+ /* If TRUE, lazy modifier is specified. */
+ bool lazy:1;
+ /* Uses the pre-RFC 8970 standard (requires algorithm to be returned
+ * as part of FETCH response). */
+ bool old_standard:1;
+ /* If TRUE, uses "PREVIEW" command; if FALSE, uses older "SNIPPET"
+ * command. */
+ bool preview_cmd:1;
+};
+
+static void fetch_read_error(struct imap_fetch_context *ctx,
+ const char **disconnect_reason_r)
+{
+ struct imap_fetch_state *state = &ctx->state;
+
+ if (state->cur_input->stream_errno == ENOENT) {
+ if (state->cur_mail->expunged) {
+ *disconnect_reason_r = "Mail expunged while it was being FETCHed";
+ return;
+ }
+ }
+ mail_set_critical(state->cur_mail,
+ "read(%s) failed: %s (FETCH %s)",
+ i_stream_get_name(state->cur_input),
+ i_stream_get_error(state->cur_input),
+ state->cur_human_name);
+ *disconnect_reason_r = "FETCH read() failed";
+}
+
+static const char *get_body_name(const struct imap_fetch_body_data *body)
+{
+ string_t *str;
+
+ str = t_str_new(128);
+ if (body->binary_size)
+ str_append(str, "BINARY.SIZE");
+ else if (body->binary)
+ str_append(str, "BINARY");
+ else
+ str_append(str, "BODY");
+ str_printfa(str, "[%s]", body->section);
+ if (body->partial) {
+ str_printfa(str, "<%"PRIuUOFF_T">",
+ imap_msgpart_get_partial_offset(body->msgpart));
+ }
+ return str_c(str);
+}
+
+static string_t *get_prefix(struct imap_fetch_state *state,
+ const struct imap_fetch_body_data *body,
+ uoff_t size, bool has_nuls)
+{
+ string_t *str;
+
+ str = t_str_new(128);
+ if (state->cur_first)
+ state->cur_first = FALSE;
+ else
+ str_append_c(str, ' ');
+
+ str_append(str, get_body_name(body));
+
+ if (size == UOFF_T_MAX)
+ str_append(str, " NIL");
+ else if (has_nuls && body->binary)
+ str_printfa(str, " ~{%"PRIuUOFF_T"}\r\n", size);
+ else
+ str_printfa(str, " {%"PRIuUOFF_T"}\r\n", size);
+ return str;
+}
+
+static int fetch_stream_continue(struct imap_fetch_context *ctx)
+{
+ struct imap_fetch_state *state = &ctx->state;
+ const char *disconnect_reason;
+ uoff_t orig_input_offset = state->cur_input->v_offset;
+ enum ostream_send_istream_result res;
+
+ o_stream_set_max_buffer_size(ctx->client->output, 0);
+ res = o_stream_send_istream(ctx->client->output, state->cur_input);
+ o_stream_set_max_buffer_size(ctx->client->output, SIZE_MAX);
+
+ if (ctx->state.cur_stats_sizep != NULL) {
+ *ctx->state.cur_stats_sizep +=
+ state->cur_input->v_offset - orig_input_offset;
+ }
+
+ switch (res) {
+ case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
+ if (state->cur_input->v_offset != state->cur_size) {
+ /* Input stream gave less data than expected */
+ mail_set_cache_corrupted(state->cur_mail,
+ state->cur_size_field, t_strdup_printf(
+ "read(%s): FETCH %s got too little data: "
+ "%"PRIuUOFF_T" vs %"PRIuUOFF_T,
+ i_stream_get_name(state->cur_input),
+ state->cur_human_name,
+ state->cur_input->v_offset, state->cur_size));
+ client_disconnect(ctx->client, "FETCH failed");
+ return -1;
+ }
+ return 1;
+ case OSTREAM_SEND_ISTREAM_RESULT_WAIT_INPUT:
+ i_unreached();
+ case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:
+ return 0;
+ case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:
+ fetch_read_error(ctx, &disconnect_reason);
+ client_disconnect(ctx->client, disconnect_reason);
+ return -1;
+ case OSTREAM_SEND_ISTREAM_RESULT_ERROR_OUTPUT:
+ /* client disconnected */
+ return -1;
+ }
+ i_unreached();
+}
+
+static const char *
+get_body_human_name(pool_t pool, struct imap_fetch_body_data *body)
+{
+ string_t *str;
+ uoff_t partial_offset, partial_size;
+
+ str = t_str_new(64);
+ if (body->binary)
+ str_append(str, "BINARY[");
+ else
+ str_append(str, "BODY[");
+ str_append(str, body->section);
+ str_append_c(str, ']');
+
+ partial_offset = imap_msgpart_get_partial_offset(body->msgpart);
+ partial_size = imap_msgpart_get_partial_size(body->msgpart);
+ if (partial_offset != 0 || partial_size != UOFF_T_MAX) {
+ str_printfa(str, "<%"PRIuUOFF_T, partial_offset);
+ if (partial_size != UOFF_T_MAX)
+ str_printfa(str, ".%"PRIuUOFF_T, partial_size);
+ str_append_c(str, '>');
+ }
+ return p_strdup(pool, str_c(str));
+}
+
+static void fetch_state_update_stats(struct imap_fetch_context *ctx,
+ const struct imap_msgpart *msgpart)
+{
+ if (!imap_msgpart_contains_body(msgpart)) {
+ ctx->client->fetch_hdr_count++;
+ ctx->state.cur_stats_sizep = &ctx->client->fetch_hdr_bytes;
+ } else {
+ ctx->client->fetch_body_count++;
+ ctx->state.cur_stats_sizep = &ctx->client->fetch_body_bytes;
+ }
+}
+
+static int fetch_body_msgpart(struct imap_fetch_context *ctx, struct mail *mail,
+ struct imap_fetch_body_data *body)
+{
+ struct imap_msgpart_open_result result;
+ string_t *str;
+
+ if (mail == NULL) {
+ imap_msgpart_free(&body->msgpart);
+ return 1;
+ }
+
+ if (imap_msgpart_open(mail, body->msgpart, &result) < 0)
+ return -1;
+ i_assert(result.input->v_offset == 0);
+ ctx->state.cur_input = result.input;
+ ctx->state.cur_size = result.size;
+ ctx->state.cur_size_field = result.size_field;
+ ctx->state.cur_human_name = get_body_human_name(ctx->ctx_pool, body);
+
+ fetch_state_update_stats(ctx, body->msgpart);
+ str = get_prefix(&ctx->state, body, ctx->state.cur_size,
+ result.binary_decoded_input_has_nuls);
+ o_stream_nsend(ctx->client->output, str_data(str), str_len(str));
+
+ ctx->state.cont_handler = fetch_stream_continue;
+ return ctx->state.cont_handler(ctx);
+}
+
+static int fetch_binary_size(struct imap_fetch_context *ctx, struct mail *mail,
+ struct imap_fetch_body_data *body)
+{
+ string_t *str;
+ uoff_t size;
+
+ if (mail == NULL) {
+ imap_msgpart_free(&body->msgpart);
+ return 1;
+ }
+
+ if (imap_msgpart_size(mail, body->msgpart, &size) < 0)
+ return -1;
+
+ str = t_str_new(128);
+ if (ctx->state.cur_first)
+ ctx->state.cur_first = FALSE;
+ else
+ str_append_c(str, ' ');
+ str_printfa(str, "%s %"PRIuUOFF_T, get_body_name(body), size);
+
+ if (o_stream_send(ctx->client->output, str_data(str), str_len(str)) < 0)
+ return -1;
+ return 1;
+}
+
+/* Parse next digits in string into integer. Returns -1 if the integer
+ becomes too big and wraps. */
+static int read_uoff_t(const char **p, uoff_t *value)
+{
+ return str_parse_uoff(*p, value, p);
+}
+
+static int
+body_header_fields_parse(struct imap_fetch_init_context *ctx,
+ struct imap_fetch_body_data *body, const char *prefix,
+ const struct imap_arg *args, unsigned int args_count)
+{
+ string_t *str;
+ const char *value;
+ size_t i;
+
+ ctx->fetch_ctx->fetch_header_fields = TRUE;
+
+ str = str_new(ctx->pool, 128);
+ str_append(str, prefix);
+ str_append(str, " (");
+
+ for (i = 0; i < args_count; i++) {
+ if (!imap_arg_get_astring(&args[i], &value)) {
+ ctx->error = "Invalid BODY[..] parameter: "
+ "Header list contains non-strings";
+ return -1;
+ }
+ value = t_str_ucase(value);
+
+ if (i != 0)
+ str_append_c(str, ' ');
+
+ if (args[i].type == IMAP_ARG_ATOM)
+ str_append(str, value);
+ else
+ imap_append_quoted(str, value);
+ }
+ str_append_c(str, ')');
+ body->section = str_c(str);
+ return 0;
+}
+
+static int body_parse_partial(struct imap_fetch_body_data *body,
+ const char *p, const char **error_r)
+{
+ uoff_t offset, size = UOFF_T_MAX;
+
+ if (*p == '\0')
+ return 0;
+ /* <start.end> */
+ if (*p != '<') {
+ *error_r = "Unexpected data after ']'";
+ return -1;
+ }
+
+ p++;
+ body->partial = TRUE;
+
+ if (read_uoff_t(&p, &offset) < 0 || offset > OFF_T_MAX) {
+ /* wrapped */
+ *error_r = "Too big partial start";
+ return -1;
+ }
+
+ if (*p == '.') {
+ p++;
+ if (read_uoff_t(&p, &size) < 0 || size > OFF_T_MAX) {
+ /* wrapped */
+ *error_r = "Too big partial end";
+ return -1;
+ }
+ }
+
+ if (*p != '>') {
+ *error_r = "Missing '>' in partial";
+ return -1;
+ }
+ if (p[1] != '\0') {
+ *error_r = "Unexpected data after '>'";
+ return -1;
+ }
+ imap_msgpart_set_partial(body->msgpart, offset, size);
+ return 0;
+}
+
+bool imap_fetch_body_section_init(struct imap_fetch_init_context *ctx)
+{
+ struct imap_fetch_body_data *body;
+ const struct imap_arg *list_args;
+ unsigned int list_count;
+ const char *str, *p, *error;
+
+ i_assert(str_begins(ctx->name, "BODY"));
+ p = ctx->name + 4;
+
+ body = p_new(ctx->pool, struct imap_fetch_body_data, 1);
+
+ if (str_begins(p, ".PEEK"))
+ p += 5;
+ else
+ ctx->fetch_ctx->flags_update_seen = TRUE;
+ if (*p != '[') {
+ ctx->error = "Invalid BODY[..] parameter: Missing '['";
+ return FALSE;
+ }
+
+ if (imap_arg_get_list_full(&ctx->args[0], &list_args, &list_count)) {
+ /* BODY[HEADER.FIELDS.. (headers list)] */
+ if (!imap_arg_get_atom(&ctx->args[1], &str) ||
+ str[0] != ']') {
+ ctx->error = "Invalid BODY[..] parameter: Missing ']'";
+ return FALSE;
+ }
+ if (body_header_fields_parse(ctx, body, p+1,
+ list_args, list_count) < 0)
+ return FALSE;
+ p = str+1;
+ ctx->args += 2;
+ } else {
+ /* no headers list */
+ body->section = p+1;
+ p = strchr(body->section, ']');
+ if (p == NULL) {
+ ctx->error = "Invalid BODY[..] parameter: Missing ']'";
+ return FALSE;
+ }
+ body->section = p_strdup_until(ctx->pool, body->section, p);
+ p++;
+ }
+ if (imap_msgpart_parse(body->section, &body->msgpart) < 0) {
+ ctx->error = "Invalid BODY[..] section";
+ return FALSE;
+ }
+ ctx->fetch_ctx->fetch_data |=
+ imap_msgpart_get_fetch_data(body->msgpart);
+ imap_msgpart_get_wanted_headers(body->msgpart, &ctx->fetch_ctx->all_headers);
+
+ if (body_parse_partial(body, p, &error) < 0) {
+ ctx->error = p_strdup_printf(ctx->pool,
+ "Invalid BODY[..] parameter: %s", error);
+ return FALSE;
+ }
+
+ /* update the section name for the imap_fetch_add_handler() */
+ ctx->name = p_strdup(ctx->pool, get_body_name(body));
+ imap_fetch_add_handler(ctx, IMAP_FETCH_HANDLER_FLAG_WANT_DEINIT,
+ "NIL", fetch_body_msgpart, body);
+ return TRUE;
+}
+
+bool imap_fetch_binary_init(struct imap_fetch_init_context *ctx)
+{
+ struct imap_fetch_body_data *body;
+ const struct imap_arg *list_args;
+ unsigned int list_count;
+ const char *str, *p, *error;
+
+ i_assert(str_begins(ctx->name, "BINARY"));
+ p = ctx->name + 6;
+
+ body = p_new(ctx->pool, struct imap_fetch_body_data, 1);
+ body->binary = TRUE;
+
+ if (str_begins(p, ".SIZE")) {
+ /* fetch decoded size of the section */
+ p += 5;
+ body->binary_size = TRUE;
+ } else if (str_begins(p, ".PEEK")) {
+ p += 5;
+ } else {
+ ctx->fetch_ctx->flags_update_seen = TRUE;
+ }
+ if (*p != '[') {
+ ctx->error = "Invalid BINARY[..] parameter: Missing '['";
+ return FALSE;
+ }
+
+ if (imap_arg_get_list_full(&ctx->args[0], &list_args, &list_count)) {
+ /* BINARY[HEADER.FIELDS.. (headers list)] */
+ if (!imap_arg_get_atom(&ctx->args[1], &str) ||
+ str[0] != ']') {
+ ctx->error = "Invalid BINARY[..] parameter: Missing ']'";
+ return FALSE;
+ }
+ if (body_header_fields_parse(ctx, body, p+1,
+ list_args, list_count) < 0)
+ return FALSE;
+ p = str+1;
+ ctx->args += 2;
+ } else {
+ /* no headers list */
+ body->section = p+1;
+ p = strchr(body->section, ']');
+ if (p == NULL) {
+ ctx->error = "Invalid BINARY[..] parameter: Missing ']'";
+ return FALSE;
+ }
+ body->section = p_strdup_until(ctx->pool, body->section, p);
+ p++;
+ }
+ if (imap_msgpart_parse(body->section, &body->msgpart) < 0) {
+ ctx->error = "Invalid BINARY[..] section";
+ return FALSE;
+ }
+ imap_msgpart_set_decode_to_binary(body->msgpart);
+ ctx->fetch_ctx->fetch_data |=
+ imap_msgpart_get_fetch_data(body->msgpart);
+
+ if (!body->binary_size) {
+ if (body_parse_partial(body, p, &error) < 0) {
+ ctx->error = p_strdup_printf(ctx->pool,
+ "Invalid BINARY[..] parameter: %s", error);
+ return FALSE;
+ }
+ }
+
+ /* update the section name for the imap_fetch_add_handler() */
+ ctx->name = p_strdup(ctx->pool, get_body_name(body));
+ if (body->binary_size) {
+ imap_fetch_add_handler(ctx, IMAP_FETCH_HANDLER_FLAG_WANT_DEINIT,
+ "0", fetch_binary_size, body);
+ } else {
+ imap_fetch_add_handler(ctx, IMAP_FETCH_HANDLER_FLAG_WANT_DEINIT,
+ "NIL", fetch_body_msgpart, body);
+ }
+ return TRUE;
+}
+
+static int ATTR_NULL(3)
+fetch_rfc822_size(struct imap_fetch_context *ctx, struct mail *mail,
+ void *context ATTR_UNUSED)
+{
+ uoff_t size;
+
+ if (mail_get_virtual_size(mail, &size) < 0)
+ return -1;
+
+ str_printfa(ctx->state.cur_str, "RFC822.SIZE %"PRIuUOFF_T" ", size);
+ return 1;
+}
+
+static int
+fetch_and_free_msgpart(struct imap_fetch_context *ctx,
+ struct mail *mail, struct imap_msgpart **_msgpart)
+{
+ struct imap_msgpart_open_result result;
+ int ret;
+
+ ret = imap_msgpart_open(mail, *_msgpart, &result);
+ imap_msgpart_free(_msgpart);
+ if (ret < 0)
+ return -1;
+ i_assert(result.input->v_offset == 0);
+ ctx->state.cur_input = result.input;
+ ctx->state.cur_size = result.size;
+ ctx->state.cur_size_field = result.size_field;
+ ctx->state.cont_handler = fetch_stream_continue;
+ return 0;
+}
+
+static int ATTR_NULL(3)
+fetch_rfc822(struct imap_fetch_context *ctx, struct mail *mail,
+ void *context ATTR_UNUSED)
+{
+ struct imap_msgpart *msgpart;
+ const char *str;
+
+ msgpart = imap_msgpart_full();
+ fetch_state_update_stats(ctx, msgpart);
+ if (fetch_and_free_msgpart(ctx, mail, &msgpart) < 0)
+ return -1;
+
+ str = t_strdup_printf(" RFC822 {%"PRIuUOFF_T"}\r\n",
+ ctx->state.cur_size);
+ if (ctx->state.cur_first) {
+ str++; ctx->state.cur_first = FALSE;
+ }
+ o_stream_nsend_str(ctx->client->output, str);
+
+ ctx->state.cur_human_name = "RFC822";
+ return ctx->state.cont_handler(ctx);
+}
+
+static int ATTR_NULL(3)
+fetch_rfc822_header(struct imap_fetch_context *ctx,
+ struct mail *mail, void *context ATTR_UNUSED)
+{
+ struct imap_msgpart *msgpart;
+ const char *str;
+
+ msgpart = imap_msgpart_header();
+ fetch_state_update_stats(ctx, msgpart);
+ if (fetch_and_free_msgpart(ctx, mail, &msgpart) < 0)
+ return -1;
+
+ str = t_strdup_printf(" RFC822.HEADER {%"PRIuUOFF_T"}\r\n",
+ ctx->state.cur_size);
+ if (ctx->state.cur_first) {
+ str++; ctx->state.cur_first = FALSE;
+ }
+ o_stream_nsend_str(ctx->client->output, str);
+
+ ctx->state.cur_human_name = "RFC822.HEADER";
+ return ctx->state.cont_handler(ctx);
+}
+
+static int ATTR_NULL(3)
+fetch_rfc822_text(struct imap_fetch_context *ctx, struct mail *mail,
+ void *context ATTR_UNUSED)
+{
+ struct imap_msgpart *msgpart;
+ const char *str;
+
+ msgpart = imap_msgpart_body();
+ fetch_state_update_stats(ctx, msgpart);
+ if (fetch_and_free_msgpart(ctx, mail, &msgpart) < 0)
+ return -1;
+
+ str = t_strdup_printf(" RFC822.TEXT {%"PRIuUOFF_T"}\r\n",
+ ctx->state.cur_size);
+ if (ctx->state.cur_first) {
+ str++; ctx->state.cur_first = FALSE;
+ }
+ o_stream_nsend_str(ctx->client->output, str);
+
+ ctx->state.cur_human_name = "RFC822.TEXT";
+ return ctx->state.cont_handler(ctx);
+}
+
+bool imap_fetch_rfc822_init(struct imap_fetch_init_context *ctx)
+{
+ const char *name = ctx->name;
+
+ if (name[6] == '\0') {
+ ctx->fetch_ctx->fetch_data |= MAIL_FETCH_STREAM_HEADER |
+ MAIL_FETCH_STREAM_BODY;
+ ctx->fetch_ctx->flags_update_seen = TRUE;
+ imap_fetch_add_handler(ctx, 0, "NIL",
+ fetch_rfc822, NULL);
+ return TRUE;
+ }
+
+ if (strcmp(name+6, ".SIZE") == 0) {
+ ctx->fetch_ctx->fetch_data |= MAIL_FETCH_VIRTUAL_SIZE;
+ imap_fetch_add_handler(ctx, IMAP_FETCH_HANDLER_FLAG_BUFFERED,
+ "0", fetch_rfc822_size, NULL);
+ return TRUE;
+ }
+ if (strcmp(name+6, ".HEADER") == 0) {
+ ctx->fetch_ctx->fetch_data |= MAIL_FETCH_STREAM_HEADER;
+ imap_fetch_add_handler(ctx, 0, "NIL",
+ fetch_rfc822_header, NULL);
+ return TRUE;
+ }
+ if (strcmp(name+6, ".TEXT") == 0) {
+ ctx->fetch_ctx->fetch_data |= MAIL_FETCH_STREAM_BODY;
+ ctx->fetch_ctx->flags_update_seen = TRUE;
+ imap_fetch_add_handler(ctx, 0, "NIL",
+ fetch_rfc822_text, NULL);
+ return TRUE;
+ }
+
+ ctx->error = t_strconcat("Unknown parameter ", name, NULL);
+ return FALSE;
+}
+
+static int ATTR_NULL(3)
+fetch_snippet(struct imap_fetch_context *ctx, struct mail *mail,
+ struct imap_fetch_preview_data *preview)
+{
+ enum mail_lookup_abort temp_lookup_abort = preview->lazy ? MAIL_LOOKUP_ABORT_NOT_IN_CACHE_START_CACHING : mail->lookup_abort;
+ enum mail_lookup_abort orig_lookup_abort = mail->lookup_abort;
+ const char *resp, *snippet;
+ int ret;
+
+ mail->lookup_abort = temp_lookup_abort;
+ ret = mail_get_special(mail, MAIL_FETCH_BODY_SNIPPET, &snippet);
+ mail->lookup_abort = orig_lookup_abort;
+
+ resp = preview->preview_cmd ? "PREVIEW" : "SNIPPET";
+
+ if (ret == 0) {
+ /* got it => nothing to do */
+ snippet++; /* skip over snippet version byte */
+ } else if (mailbox_get_last_mail_error(mail->box) != MAIL_ERROR_LOOKUP_ABORTED) {
+ /* actual error => bail */
+ return -1;
+ } else {
+ /*
+ * Two ways to get here:
+ * - not in cache && lazy => give up
+ * - not in cache && !lazy => someone higher up set
+ * MAIL_LOOKUP_ABORT_NOT_IN_CACHE and so even though we got
+ * a non-lazy request we failed the cache lookup.
+ *
+ * This is not an error, but since the scenario is
+ * sufficiently convoluted this else branch serves to
+ * document it.
+ *
+ * This path will return NIL as the preview response.
+ */
+ }
+
+ str_append(ctx->state.cur_str, resp);
+ if (preview->old_standard)
+ str_append(ctx->state.cur_str, " (FUZZY ");
+ else
+ str_append(ctx->state.cur_str, " ");
+ if (ret == 0)
+ imap_append_string(ctx->state.cur_str, snippet);
+ else
+ str_append(ctx->state.cur_str, "NIL");
+ if (preview->old_standard)
+ str_append(ctx->state.cur_str, ")");
+ str_append_c(ctx->state.cur_str, ' ');
+
+ return 1;
+}
+
+static bool fetch_preview_init(struct imap_fetch_init_context *ctx,
+ bool preview_cmd)
+{
+ const struct imap_arg *list_args;
+ unsigned int list_count;
+ struct imap_fetch_preview_data *preview;
+
+ preview = p_new(ctx->pool, struct imap_fetch_preview_data, 1);
+ preview->preview_cmd = preview_cmd;
+ /* We can tell we are using the "Old" (pre-RFC 8970) standard
+ * if:
+ * 1) SNIPPET command is used
+ * 2) FUZZY algorithm is explicitly requested
+ * The one usage we cannot catch is if PREVIEW command is used, and
+ * no algorithm is specified - the pre-RFC standard requires that the
+ * algorithm must be output as part of the response; the RFC standard
+ * does not output the algorithm. There is unfortunately nothing we
+ * can do about this, so we need to send the standards compliant
+ * way. */
+ preview->old_standard = !preview_cmd;
+
+ if (imap_arg_get_list_full(&ctx->args[0], &list_args, &list_count)) {
+ unsigned int i;
+
+ for (i = 0; i < list_count; i++) {
+ const char *str;
+
+ if (!imap_arg_get_atom(&list_args[i], &str)) {
+ ctx->error = "Invalid PREVIEW modifier";
+ return FALSE;
+ }
+
+ if (strcasecmp(str, "LAZY") == 0) {
+ preview->lazy = TRUE;
+ } else if (strcasecmp(str, "LAZY=FUZZY") == 0) {
+ preview->lazy = TRUE;
+ preview->old_standard = TRUE;
+ } else if (strcasecmp(str, "FUZZY") == 0) {
+ preview->old_standard = TRUE;
+ } else {
+ ctx->error = t_strdup_printf("'%s' is not a "
+ "supported PREVIEW modifier",
+ str);
+ return FALSE;
+ }
+ }
+
+ ctx->args += list_count;
+ }
+
+ ctx->fetch_ctx->fetch_data |= MAIL_FETCH_BODY_SNIPPET;
+ imap_fetch_add_handler(ctx, IMAP_FETCH_HANDLER_FLAG_BUFFERED,
+ "NIL", fetch_snippet, preview);
+ return TRUE;
+}
+
+bool imap_fetch_preview_init(struct imap_fetch_init_context *ctx)
+{
+ return fetch_preview_init(ctx, TRUE);
+}
+
+bool imap_fetch_snippet_init(struct imap_fetch_init_context *ctx)
+{
+ return fetch_preview_init(ctx, FALSE);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-25 15:23:46 +0000