static bool
store_parse_modifiers(struct imap_store_context *ctx,
const struct imap_arg *args)
{
const char *name, *value;
for (; !IMAP_ARG_IS_EOL(args); args += 2) {
if (!imap_arg_get_atom(&args[0], &name) ||
!imap_arg_get_atom(&args[1], &value)) {
client_send_command_error(ctx->cmd,
"Invalid STORE modifiers.");
return FALSE;
}
if (strcasecmp(name, "UNCHANGEDSINCE") == 0) {
if (ctx->cmd->client->nonpermanent_modseqs) {
client_send_command_error(ctx->cmd,
"STORE UNCHANGEDSINCE can't be used with non-permanent modseqs");
return FALSE;
}
if (str_to_uint64(value, &ctx->max_modseq) < 0) {
client_send_command_error(ctx->cmd,
"Invalid modseq");
return FALSE;
}
(void)client_enable(ctx->cmd->client,
MAILBOX_FEATURE_CONDSTORE);
} else {
client_send_command_error(ctx->cmd,
"Unknown STORE modifier");
return FALSE;
}
}
return TRUE;
}
static bool
fetch_parse_modifier(struct imap_fetch_context *ctx,
struct client_command_context *cmd,
struct mail_search_args *search_args,
const char *name, const struct imap_arg **args,
bool *send_vanished)
{
const char *str;
uint64_t modseq;
if (strcmp(name, "CHANGEDSINCE") == 0) {
if (!imap_arg_get_atom(*args, &str) ||
str_to_uint64(str, &modseq) < 0) {
client_send_command_error(cmd,
"Invalid CHANGEDSINCE modseq.");
return FALSE;
}
*args += 1;
imap_search_add_changed_since(search_args, modseq);
imap_fetch_init_nofail_handler(ctx, imap_fetch_modseq_init);
return TRUE;
}
if (strcmp(name, "VANISHED") == 0 && cmd->uid) {
if ((ctx->client->enabled_features &
MAILBOX_FEATURE_QRESYNC) == 0) {
client_send_command_error(cmd, "QRESYNC not enabled");
return FALSE;
}
*send_vanished = TRUE;
return TRUE;
}
client_send_command_error(cmd, "Unknown FETCH modifier");
return FALSE;
}
bool cmd_x_state(struct client_command_context *cmd)
{
/* FIXME: state importing can cause unnecessarily large memory usage
by specifying an old modseq, because the EXPUNGE/FETCH replies
aren't currently sent asynchronously. so this command is disabled
for now. */
#if 0
const struct imap_arg *args;
const char *str, *error;
buffer_t *state, *state_encoded;
int ret;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
state = buffer_create_dynamic(cmd->pool, 256);
if (imap_arg_get_astring(&args[0], &str)) {
if (cmd->client->mailbox != NULL) {
client_send_tagline(cmd,
"BAD Can't be used in SELECTED state");
return TRUE;
}
if (base64_decode(str, strlen(str), NULL, state) < 0)
ret = 0;
else {
ret = imap_state_import_external(cmd->client,
state->data, state->used, &error);
}
if (ret < 0) {
client_send_tagline(cmd, t_strdup_printf(
"NO Failed to restore state: %s", error));
} else if (ret == 0) {
client_send_tagline(cmd, t_strdup_printf(
"BAD Broken state: %s", error));
} else {
client_send_tagline(cmd, "OK State imported.");
}
return TRUE;
} else if (args[0].type == IMAP_ARG_EOL) {
if (!imap_state_export_external(cmd->client, state, &error)) {
client_send_tagline(cmd, t_strdup_printf(
"NO Can't save state: %s", error));
return TRUE;
}
state_encoded = buffer_create_dynamic(cmd->pool,
MAX_BASE64_ENCODED_SIZE(state->used)+10);
str_append(state_encoded, "* STATE ");
base64_encode(state->data, state->used, state_encoded);
client_send_line(cmd->client, str_c(state_encoded));
client_send_tagline(cmd, "OK State exported.");
return TRUE;
} else {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
#else
client_send_command_error(cmd, "Command is disabled for now.");
return TRUE;
#endif
}
static bool
fetch_parse_modifiers(struct imap_fetch_context *ctx,
struct client_command_context *cmd,
struct mail_search_args *search_args,
const struct imap_arg *args, bool *send_vanished_r)
{
const char *name;
*send_vanished_r = FALSE;
while (!IMAP_ARG_IS_EOL(args)) {
if (!imap_arg_get_atom(args, &name)) {
client_send_command_error(cmd,
"FETCH modifiers contain non-atoms.");
return FALSE;
}
args++;
if (!fetch_parse_modifier(ctx, cmd, search_args,
t_str_ucase(name),
&args, send_vanished_r))
return FALSE;
}
if (*send_vanished_r &&
(search_args->args->next == NULL ||
search_args->args->next->type != SEARCH_MODSEQ)) {
client_send_command_error(cmd,
"VANISHED used without CHANGEDSINCE");
return FALSE;
}
return TRUE;
}
bool client_read_string_args(struct client_command_context *cmd,
unsigned int count, ...)
{
const struct imap_arg *imap_args;
va_list va;
const char *str;
unsigned int i;
if (!client_read_args(cmd, count, 0, &imap_args))
return FALSE;
va_start(va, count);
for (i = 0; i < count; i++) {
const char **ret = va_arg(va, const char **);
if (IMAP_ARG_IS_EOL(&imap_args[i])) {
client_send_command_error(cmd, "Missing arguments.");
break;
}
if (!imap_arg_get_astring(&imap_args[i], &str)) {
client_send_command_error(cmd, "Invalid arguments.");
break;
}
if (ret != NULL)
*ret = str;
}
va_end(va);
return i == count;
}
static int
get_sort_program(struct client_command_context *cmd,
const struct imap_arg *args,
enum mail_sort_type program[MAX_SORT_PROGRAM_SIZE])
{
enum mail_sort_type mask = 0;
const char *arg;
unsigned int i, pos;
bool reverse, last_reverse;
if (IMAP_ARG_IS_EOL(args)) {
/* empyty list */
client_send_command_error(cmd, "Empty sort program.");
return -1;
}
pos = 0; reverse = last_reverse = FALSE;
for (; imap_arg_get_astring(args, &arg); args++) {
last_reverse = strcasecmp(arg, "reverse") == 0;
if (last_reverse) {
reverse = !reverse;
continue;
}
for (i = 0; sort_names[i].type != MAIL_SORT_END; i++) {
if (strcasecmp(arg, sort_names[i].name) == 0)
break;
}
if (sort_names[i].type == MAIL_SORT_END) {
client_send_command_error(cmd, t_strconcat(
"Unknown sort argument: ", arg, NULL));
return -1;
}
if ((mask & sort_names[i].type) != 0)
continue;
mask |= sort_names[i].type;
/* @UNSAFE: mask check should prevent us from ever
overflowing */
i_assert(pos < MAX_SORT_PROGRAM_SIZE-1);
program[pos++] = sort_names[i].type |
(reverse ? MAIL_SORT_FLAG_REVERSE : 0);
reverse = FALSE;
}
if (last_reverse) {
client_send_command_error(cmd, "Sort list ends with REVERSE.");
return -1;
}
program[pos] = MAIL_SORT_END;
if (!IMAP_ARG_IS_EOL(args)) {
client_send_command_error(cmd,
"Invalid sort list argument.");
return -1;
}
return 0;
}
static bool
fetch_parse_args(struct imap_fetch_context *ctx,
struct client_command_context *cmd,
const struct imap_arg *arg, const struct imap_arg **next_arg_r)
{
const char *str, *const *macro;
if (cmd->uid) {
if (!imap_fetch_cmd_init_handler(ctx, cmd, "UID", &arg))
return FALSE;
}
if (imap_arg_get_atom(arg, &str)) {
str = t_str_ucase(str);
arg++;
/* handle macros first */
if (strcmp(str, "ALL") == 0)
macro = all_macro;
else if (strcmp(str, "FAST") == 0)
macro = fast_macro;
else if (strcmp(str, "FULL") == 0)
macro = full_macro;
else {
macro = NULL;
if (!imap_fetch_cmd_init_handler(ctx, cmd, str, &arg))
return FALSE;
}
if (macro != NULL) {
while (*macro != NULL) {
if (!imap_fetch_cmd_init_handler(ctx, cmd, *macro, &arg))
return FALSE;
macro++;
}
}
*next_arg_r = arg;
} else {
*next_arg_r = arg + 1;
arg = imap_arg_as_list(arg);
if (IMAP_ARG_IS_EOL(arg)) {
client_send_command_error(cmd,
"FETCH list is empty.");
return FALSE;
}
while (imap_arg_get_atom(arg, &str)) {
str = t_str_ucase(str);
arg++;
if (!imap_fetch_cmd_init_handler(ctx, cmd, str, &arg))
return FALSE;
}
if (!IMAP_ARG_IS_EOL(arg)) {
client_send_command_error(cmd,
"FETCH list contains non-atoms.");
return FALSE;
}
}
return TRUE;
}
int imap_status_parse_items(struct client_command_context *cmd,
const struct imap_arg *args,
struct imap_status_items *items_r)
{
const char *item;
enum mailbox_status_items status = 0;
enum mailbox_metadata_items metadata = 0;
if (IMAP_ARG_IS_EOL(args)) {
client_send_command_error(cmd, "Empty status list.");
return -1;
}
memset(items_r, 0, sizeof(*items_r));
for (; !IMAP_ARG_IS_EOL(args); args++) {
if (!imap_arg_get_atom(args, &item)) {
/* list may contain only atoms */
client_send_command_error(cmd,
"Status list contains non-atoms.");
return -1;
}
item = t_str_ucase(item);
if (strcmp(item, "MESSAGES") == 0)
status |= STATUS_MESSAGES;
else if (strcmp(item, "RECENT") == 0)
status |= STATUS_RECENT;
else if (strcmp(item, "UIDNEXT") == 0)
status |= STATUS_UIDNEXT;
else if (strcmp(item, "UIDVALIDITY") == 0)
status |= STATUS_UIDVALIDITY;
else if (strcmp(item, "UNSEEN") == 0)
status |= STATUS_UNSEEN;
else if (strcmp(item, "HIGHESTMODSEQ") == 0)
status |= STATUS_HIGHESTMODSEQ;
else if (strcmp(item, "X-SIZE") == 0)
metadata |= MAILBOX_METADATA_VIRTUAL_SIZE;
else if (strcmp(item, "X-GUID") == 0)
metadata |= MAILBOX_METADATA_GUID;
else {
client_send_command_error(cmd, t_strconcat(
"Invalid status item ", item, NULL));
return -1;
}
}
items_r->status = status;
items_r->metadata = metadata;
return 0;
}
bool client_read_args(struct client_command_context *cmd, unsigned int count,
unsigned int flags, const struct imap_arg **args_r)
{
string_t *str;
int ret;
i_assert(count <= INT_MAX);
ret = imap_parser_read_args(cmd->parser, count, flags, args_r);
if (ret >= (int)count) {
/* all parameters read successfully */
i_assert(cmd->client->input_lock == NULL ||
cmd->client->input_lock == cmd);
str = t_str_new(256);
imap_write_args(str, *args_r);
cmd->args = p_strdup(cmd->pool, str_c(str));
cmd->start_time = ioloop_timeval;
cmd->client->input_lock = NULL;
return TRUE;
} else if (ret == -2) {
/* need more data */
if (cmd->client->input->closed) {
/* disconnected */
cmd->state = CLIENT_COMMAND_STATE_DONE;
}
return FALSE;
} else {
/* error, or missing arguments */
client_send_command_error(cmd, ret < 0 ? NULL :
"Missing arguments");
return FALSE;
}
}
bool cmd_enable(struct client_command_context *cmd)
{
const struct imap_arg *args;
const char *str;
string_t *reply;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
reply = t_str_new(64);
str_append(reply, "* ENABLED");
for (; !IMAP_ARG_IS_EOL(args); args++) {
if (!imap_arg_get_atom(args, &str)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
str = t_str_ucase(str);
if (strcmp(str, "CONDSTORE") == 0) {
client_enable(cmd->client, MAILBOX_FEATURE_CONDSTORE);
str_append(reply, " CONDSTORE");
}
else if (strcmp(str, "QRESYNC") == 0) {
client_enable(cmd->client, MAILBOX_FEATURE_QRESYNC |
MAILBOX_FEATURE_CONDSTORE);
str_append(reply, " QRESYNC");
}
}
if (str_len(reply) > 9)
client_send_line(cmd->client, str_c(reply));
client_send_tagline(cmd, "OK Enabled.");
return TRUE;
}
bool cmd_cancelupdate(struct client_command_context *cmd)
{
const struct imap_arg *args;
const char *tag;
unsigned int i;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
for (i = 0; args[i].type == IMAP_ARG_STRING; i++) ;
if (!IMAP_ARG_IS_EOL(&args[i]) || i == 0) {
client_send_command_error(cmd, "Invalid parameters.");
return TRUE;
}
while (imap_arg_get_quoted(args, &tag)) {
if (!client_search_update_cancel(cmd->client, tag)) {
client_send_tagline(cmd, "NO Unknown tag.");
return TRUE;
}
args++;
}
client_send_tagline(cmd, "OK Updates cancelled.");
return TRUE;
}
bool client_parse_mail_flags(struct client_command_context *cmd,
const struct imap_arg *args,
enum mail_flags *flags_r,
const char *const **keywords_r)
{
const char *atom;
enum mail_flags flag;
ARRAY(const char *) keywords;
*flags_r = 0;
*keywords_r = NULL;
p_array_init(&keywords, cmd->pool, 16);
while (!IMAP_ARG_IS_EOL(args)) {
if (!imap_arg_get_atom(args, &atom)) {
client_send_command_error(cmd,
"Flags list contains non-atoms.");
return FALSE;
}
if (*atom == '\\') {
/* system flag */
atom = t_str_ucase(atom);
flag = imap_parse_system_flag(atom);
if (flag != 0 && flag != MAIL_RECENT)
*flags_r |= flag;
else {
client_send_command_error(cmd, t_strconcat(
"Invalid system flag ", atom, NULL));
return FALSE;
}
} else {
/* keyword validity checks are done by lib-storage */
array_append(&keywords, &atom, 1);
}
args++;
}
if (array_count(&keywords) == 0)
*keywords_r = NULL;
else {
array_append_zero(&keywords); /* NULL-terminate */
*keywords_r = array_idx(&keywords, 0);
}
return TRUE;
}
static void client_input_append(struct client_command_context *cmd)
{
struct cmd_append_context *ctx = cmd->context;
struct client *client = cmd->client;
const char *reason;
bool finished;
uoff_t lit_offset;
i_assert(!client->destroyed);
client->last_input = ioloop_time;
timeout_reset(client->to_idle);
switch (i_stream_read(client->input)) {
case -1:
/* disconnected */
lit_offset = ctx->litinput == NULL ? 0 :
ctx->litinput->v_offset;
reason = get_disconnect_reason(ctx, lit_offset);
cmd_append_finish(cmd->context);
/* Reset command so that client_destroy() doesn't try to call
cmd_append_continue_message() anymore. */
client_command_free(&cmd);
client_destroy(client, reason);
return;
case -2:
if (ctx->message_input) {
/* message data, this is handled internally by
mailbox_save_continue() */
break;
}
cmd_append_finish(cmd->context);
/* parameter word is longer than max. input buffer size.
this is most likely an error, so skip the new data
until newline is found. */
client->input_skip_line = TRUE;
if (!ctx->failed)
client_send_command_error(cmd, "Too long argument.");
cmd->param_error = TRUE;
client_command_free(&cmd);
return;
}
o_stream_cork(client->output);
finished = command_exec(cmd);
if (!finished)
(void)client_handle_unfinished_cmd(cmd);
else
client_command_free(&cmd);
cmd_sync_delayed(client);
o_stream_uncork(client->output);
if (client->disconnected)
client_destroy(client, NULL);
else
client_continue_pending_input(client);
}
bool cmd_sort(struct client_command_context *cmd)
{
struct imap_search_context *ctx;
struct mail_search_args *sargs;
enum mail_sort_type sort_program[MAX_SORT_PROGRAM_SIZE];
const struct imap_arg *args, *list_args;
const char *charset;
int ret;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
ctx = p_new(cmd->pool, struct imap_search_context, 1);
ctx->cmd = cmd;
if ((ret = cmd_search_parse_return_if_found(ctx, &args)) <= 0) {
/* error / waiting for unambiguity */
return ret < 0;
}
/* sort program */
if (!imap_arg_get_list(args, &list_args)) {
client_send_command_error(cmd, "Invalid sort argument.");
return TRUE;
}
if (get_sort_program(cmd, list_args, sort_program) < 0)
return TRUE;
args++;
/* charset */
if (!imap_arg_get_astring(args, &charset)) {
client_send_command_error(cmd, "Invalid charset argument.");
return TRUE;
}
args++;
ret = imap_search_args_build(cmd, args, charset, &sargs);
if (ret <= 0)
return ret < 0;
return imap_search_start(ctx, sargs, sort_program);
}
bool cmd_genurlauth(struct client_command_context *cmd)
{
const struct imap_arg *args;
string_t *response;
int ret;
if (cmd->client->urlauth_ctx == NULL) {
client_send_command_error(cmd, "URLAUTH disabled.");
return TRUE;
}
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
response = t_str_new(1024);
str_append(response, "* GENURLAUTH");
for (;;) {
const char *url_rump, *mechanism, *url, *error;
if (IMAP_ARG_IS_EOL(args))
break;
if (!imap_arg_get_astring(args++, &url_rump) ||
!imap_arg_get_atom(args++, &mechanism)) {
client_send_command_error(cmd, "Invalid arguments.");
return FALSE;
}
ret = imap_urlauth_generate(cmd->client->urlauth_ctx,
mechanism, url_rump, &url, &error);
if (ret <= 0) {
if (ret < 0)
client_send_internal_error(cmd);
else
client_send_command_error(cmd, error);
return TRUE;
}
str_append_c(response, ' ');
imap_append_astring(response, url);
}
client_send_line(cmd->client, str_c(response));
client_send_tagline(cmd, "OK GENURLAUTH completed.");
return TRUE;
}
static bool cmd_append_finish_parsing(struct client_command_context *cmd)
{
struct cmd_append_context *ctx = cmd->context;
enum mailbox_sync_flags sync_flags;
enum imap_sync_flags imap_flags;
struct mail_transaction_commit_changes changes;
unsigned int save_count;
string_t *msg;
int ret;
/* eat away the trailing CRLF */
cmd->client->input_skip_line = TRUE;
if (ctx->failed) {
/* we failed earlier, error message is sent */
cmd_append_finish(ctx);
return TRUE;
}
if (ctx->count == 0) {
client_send_command_error(cmd, "Missing message size.");
cmd_append_finish(ctx);
return TRUE;
}
ret = mailbox_transaction_commit_get_changes(&ctx->t, &changes);
if (ret < 0) {
client_send_box_error(cmd, ctx->box);
cmd_append_finish(ctx);
return TRUE;
}
msg = t_str_new(256);
save_count = seq_range_count(&changes.saved_uids);
if (save_count == 0 || changes.no_read_perm) {
/* not supported by backend (virtual) */
str_append(msg, "OK Append completed.");
} else {
i_assert(ctx->count == save_count);
str_printfa(msg, "OK [APPENDUID %u ",
changes.uid_validity);
imap_write_seq_range(msg, &changes.saved_uids);
str_append(msg, "] Append completed.");
}
pool_unref(&changes.pool);
if (ctx->box == cmd->client->mailbox) {
sync_flags = 0;
imap_flags = IMAP_SYNC_FLAG_SAFE;
} else {
sync_flags = MAILBOX_SYNC_FLAG_FAST;
imap_flags = 0;
}
cmd_append_finish(ctx);
return cmd_sync(cmd, sync_flags, imap_flags, str_c(msg));
}
bool imap_metadata_verify_entry_name(struct client_command_context *cmd,
const char *name)
{
unsigned int i;
bool ok;
if (name[0] != '/') {
client_send_command_error(cmd,
"Entry name must begin with '/'");
return FALSE;
}
for (i = 0; name[i] != '\0'; i++) {
switch (name[i]) {
case '/':
if (i > 0 && name[i-1] == '/') {
client_send_command_error(cmd,
"Entry name can't contain consecutive '/'");
return FALSE;
}
if (name[i+1] == '\0') {
client_send_command_error(cmd,
"Entry name can't end with '/'");
return FALSE;
}
break;
case '*':
client_send_command_error(cmd,
"Entry name can't contain '*'");
return FALSE;
case '%':
client_send_command_error(cmd,
"Entry name can't contain '%'");
return FALSE;
default:
if (name[i] <= 0x19) {
client_send_command_error(cmd,
"Entry name can't contain control chars");
return FALSE;
}
break;
}
}
T_BEGIN {
const char *prefix, *p = strchr(name+1, '/');
prefix = p == NULL ? name : t_strdup_until(name, p);
ok = strcasecmp(prefix, IMAP_METADATA_PRIVATE_PREFIX) == 0 ||
strcasecmp(prefix, IMAP_METADATA_SHARED_PREFIX) == 0;
} T_END;
if (!ok) {
client_send_command_error(cmd,
"Entry name must begin with /private or /shared");
return FALSE;
}
return TRUE;
}
static bool cmd_setquota(struct client_command_context *cmd)
{
struct quota_root *root;
const struct imap_arg *args, *list_args;
const char *root_name, *name, *value_str, *error;
uint64_t value;
/* <quota root> <resource limits> */
if (!client_read_args(cmd, 2, 0, &args))
return FALSE;
if (!imap_arg_get_astring(&args[0], &root_name) ||
!imap_arg_get_list(&args[1], &list_args)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
root = quota_root_lookup(cmd->client->user, root_name);
if (root == NULL) {
client_send_tagline(cmd, "NO Quota root doesn't exist.");
return TRUE;
}
for (; !IMAP_ARG_IS_EOL(list_args); list_args += 2) {
if (!imap_arg_get_atom(&list_args[0], &name) ||
!imap_arg_get_atom(&list_args[1], &value_str) ||
str_to_uint64(value_str, &value) < 0) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
if (quota_set_resource(root, name, value, &error) < 0) {
client_send_command_error(cmd, error);
return TRUE;
}
}
client_send_tagline(cmd, "OK Setquota completed.");
return TRUE;
}
static int
cmd_append_catenate(struct client_command_context *cmd,
const struct imap_arg *args, bool *nonsync_r)
{
struct cmd_append_context *ctx = cmd->context;
const char *catpart;
*nonsync_r = FALSE;
/* Handle URLs until a TEXT literal is encountered */
while (imap_arg_get_atom(args, &catpart)) {
const char *caturl;
if (strcasecmp(catpart, "URL") == 0 ) {
/* URL <url> */
args++;
if (!imap_arg_get_astring(args, &caturl))
break;
if (cmd_append_catenate_url(cmd, caturl) < 0) {
/* delay failure until we can stop
parsing input */
ctx->failed = TRUE;
}
} else if (strcasecmp(catpart, "TEXT") == 0) {
/* TEXT <literal> */
args++;
if (!imap_arg_get_literal_size(args, &ctx->literal_size))
break;
if (args->literal8 && !ctx->binary_input &&
!ctx->failed) {
client_send_tagline(cmd,
"NO ["IMAP_RESP_CODE_UNKNOWN_CTE"] "
"Binary input allowed only when the first part is binary.");
ctx->failed = TRUE;
}
*nonsync_r = args->type == IMAP_ARG_LITERAL_SIZE_NONSYNC;
cmd_append_catenate_text(cmd);
return 1;
} else {
break;
}
args++;
}
if (IMAP_ARG_IS_EOL(args)) {
/* ")" */
return 0;
}
if (!ctx->failed)
client_send_command_error(cmd, "Invalid arguments.");
return -1;
}
int imap_search_args_build(struct client_command_context *cmd,
const struct imap_arg *args, const char *charset,
struct mail_search_args **search_args_r)
{
struct mail_search_parser *parser;
struct mail_search_args *sargs;
const char *error;
int ret;
if (IMAP_ARG_IS_EOL(args)) {
client_send_command_error(cmd, "Missing search parameters");
return -1;
}
parser = mail_search_parser_init_imap(args);
ret = mail_search_build(mail_search_register_get_imap(),
parser, &charset, &sargs, &error);
mail_search_parser_deinit(&parser);
if (ret < 0) {
if (charset == NULL) {
client_send_tagline(cmd, t_strconcat(
"BAD [BADCHARSET] ", error, NULL));
} else {
client_send_command_error(cmd, error);
}
return -1;
}
if (search_args_have_searchres(sargs->args)) {
if (client_handle_search_save_ambiguity(cmd))
return 0;
}
mail_search_args_init(sargs, cmd->client->mailbox, TRUE,
&cmd->client->search_saved_uidset);
*search_args_r = sargs;
return 1;
}
static void client_input_putscript(struct client *client)
{
struct client_command_context *cmd = &client->cmd;
i_assert(!client->destroyed);
client->last_input = ioloop_time;
timeout_reset(client->to_idle);
switch (i_stream_read(client->input)) {
case -1:
/* disconnected */
cmd_putscript_finish(cmd->context);
/* Reset command so that client_destroy() doesn't try to call
cmd_putscript_continue_script() anymore. */
_client_reset_command(client);
client_destroy(client, "Disconnected in PUTSCRIPT/CHECKSCRIPT");
return;
case -2:
cmd_putscript_finish(cmd->context);
if (client->command_pending) {
/* uploaded script data, this is handled internally by
mailbox_save_continue() */
break;
}
/* parameter word is longer than max. input buffer size.
this is most likely an error, so skip the new data
until newline is found. */
client->input_skip_line = TRUE;
client_send_command_error(cmd, "Too long argument.");
cmd->param_error = TRUE;
_client_reset_command(client);
return;
}
if (cmd->func(cmd)) {
/* command execution was finished. Note that if cmd_sync()
didn't finish, we didn't get here but the input handler
has already been moved. So don't do anything important
here..
reset command once again to reset cmd_sync()'s changes. */
_client_reset_command(client);
if (client->input_pending)
client_input(client);
}
}
bool cmd_setmetadata(struct client_command_context *cmd)
{
struct imap_setmetadata_context *ctx;
const struct imap_arg *args;
const char *mailbox;
int ret;
ret = imap_parser_read_args(cmd->parser, 2,
IMAP_PARSE_FLAG_STOP_AT_LIST, &args);
if (ret == -1) {
client_send_command_error(cmd, NULL);
return TRUE;
}
if (ret == -2)
return FALSE;
if (!imap_arg_get_astring(&args[0], &mailbox) ||
args[1].type != IMAP_ARG_LIST) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
if (!cmd->client->imap_metadata_enabled) {
client_send_command_error(cmd, "METADATA disabled.");
return TRUE;
}
ctx = p_new(cmd->pool, struct imap_setmetadata_context, 1);
ctx->cmd = cmd;
ctx->cmd->context = ctx;
if (mailbox[0] == '\0') {
/* server attribute */
return cmd_setmetadata_server(ctx);
}
return cmd_setmetadata_mailbox(ctx, mailbox);
}
bool cmd_status(struct client_command_context *cmd)
{
struct client *client = cmd->client;
const struct imap_arg *args, *list_args;
struct imap_status_items items;
struct imap_status_result result;
struct mail_namespace *ns;
const char *mailbox, *orig_mailbox;
bool selected_mailbox;
/* <mailbox> <status items> */
if (!client_read_args(cmd, 2, 0, &args))
return FALSE;
if (!imap_arg_get_astring(&args[0], &mailbox) ||
!imap_arg_get_list(&args[1], &list_args)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
/* get the items client wants */
if (imap_status_parse_items(cmd, list_args, &items) < 0)
return TRUE;
orig_mailbox = mailbox;
ns = client_find_namespace(cmd, &mailbox);
if (ns == NULL)
return TRUE;
selected_mailbox = client->mailbox != NULL &&
mailbox_equals(client->mailbox, ns, mailbox);
if (imap_status_get(cmd, ns, mailbox, &items, &result) < 0) {
client_send_tagline(cmd, result.errstr);
return TRUE;
}
imap_status_send(client, orig_mailbox, &items, &result);
if (!selected_mailbox)
client_send_tagline(cmd, "OK Status completed.");
else {
client_send_tagline(cmd, "OK ["IMAP_RESP_CODE_CLIENTBUG"] "
"Status on selected mailbox completed.");
}
return TRUE;
}
void client_input(struct client *client)
{
struct client_command_context *cmd;
struct ostream *output = client->output;
ssize_t bytes;
i_assert(client->io != NULL);
client->last_input = ioloop_time;
timeout_reset(client->to_idle);
if (client->to_delayed_input != NULL)
timeout_remove(&client->to_delayed_input);
bytes = i_stream_read(client->input);
if (bytes == -1) {
/* disconnected */
client_destroy(client, NULL);
return;
}
o_stream_ref(output);
o_stream_cork(output);
if (!client_handle_input(client) && bytes == -2) {
/* parameter word is longer than max. input buffer size.
this is most likely an error, so skip the new data
until newline is found. */
client->input_skip_line = TRUE;
cmd = client->input_lock != NULL ? client->input_lock :
client_command_new(client);
cmd->param_error = TRUE;
client_send_command_error(cmd, "Too long argument.");
client_command_free(&cmd);
}
o_stream_uncork(output);
o_stream_unref(&output);
imap_refresh_proctitle();
if (client->disconnected)
client_destroy(client, NULL);
else
client_continue_pending_input(client);
}
bool cmd_search(struct client_command_context *cmd)
{
struct imap_search_context *ctx;
struct mail_search_args *sargs;
const struct imap_arg *args;
const char *charset;
int ret;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
ctx = p_new(cmd->pool, struct imap_search_context, 1);
ctx->cmd = cmd;
if ((ret = cmd_search_parse_return_if_found(ctx, &args)) <= 0) {
/* error / waiting for unambiguity */
return ret < 0;
}
if (imap_arg_atom_equals(args, "CHARSET")) {
/* CHARSET specified */
if (!imap_arg_get_astring(&args[1], &charset)) {
client_send_command_error(cmd,
"Invalid charset argument.");
imap_search_context_free(ctx);
return TRUE;
}
args += 2;
} else {
charset = "UTF-8";
}
ret = imap_search_args_build(cmd, args, charset, &sargs);
if (ret <= 0) {
imap_search_context_free(ctx);
return ret < 0;
}
return imap_search_start(ctx, sargs, NULL);
}
static bool
store_parse_args(struct imap_store_context *ctx, const struct imap_arg *args)
{
struct client_command_context *cmd = ctx->cmd;
const struct imap_arg *list_args;
const char *type;
const char *const *keywords_list = NULL;
ctx->max_modseq = (uint64_t)-1;
if (imap_arg_get_list(args, &list_args)) {
if (!store_parse_modifiers(ctx, list_args))
return FALSE;
args++;
}
if (!imap_arg_get_astring(args, &type) ||
!get_modify_type(ctx, type)) {
client_send_command_error(cmd, "Invalid arguments.");
return FALSE;
}
args++;
if (imap_arg_get_list(args, &list_args)) {
if (!client_parse_mail_flags(cmd, list_args,
&ctx->flags, &keywords_list))
return FALSE;
} else {
if (!client_parse_mail_flags(cmd, args,
&ctx->flags, &keywords_list))
return FALSE;
}
if (keywords_list != NULL || ctx->modify_type == MODIFY_REPLACE) {
if (mailbox_keywords_create(cmd->client->mailbox, keywords_list,
&ctx->keywords) < 0) {
/* invalid keywords */
client_send_box_error(cmd, cmd->client->mailbox);
return FALSE;
}
}
return TRUE;
}
static bool
imap_fetch_cmd_init_handler(struct imap_fetch_context *ctx,
struct client_command_context *cmd,
const char *name, const struct imap_arg **args)
{
struct imap_fetch_init_context init_ctx;
memset(&init_ctx, 0, sizeof(init_ctx));
init_ctx.fetch_ctx = ctx;
init_ctx.pool = ctx->ctx_pool;
init_ctx.name = name;
init_ctx.args = *args;
if (!imap_fetch_init_handler(&init_ctx)) {
i_assert(init_ctx.error != NULL);
client_send_command_error(cmd, init_ctx.error);
return FALSE;
}
*args = init_ctx.args;
return TRUE;
}
bool cmd_uid_expunge(struct client_command_context *cmd)
{
const struct imap_arg *args;
struct mail_search_args *search_args;
const char *uidset;
int ret;
if (!client_read_args(cmd, 1, 0, &args))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
if (!imap_arg_get_astring(&args[0], &uidset)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
ret = imap_search_get_seqset(cmd, uidset, TRUE, &search_args);
if (ret <= 0)
return ret < 0;
return cmd_expunge_finish(cmd, search_args);
}
bool cmd_fetch(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct imap_fetch_context *ctx;
const struct imap_arg *args, *next_arg, *list_arg;
struct mail_search_args *search_args;
struct imap_fetch_qresync_args qresync_args;
const char *messageset;
bool send_vanished = FALSE;
int ret;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
/* <messageset> <field(s)> [(modifiers)] */
if (!imap_arg_get_atom(&args[0], &messageset) ||
(args[1].type != IMAP_ARG_LIST && args[1].type != IMAP_ARG_ATOM) ||
(!IMAP_ARG_IS_EOL(&args[2]) && args[2].type != IMAP_ARG_LIST)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
/* UID FETCH VANISHED needs the uidset, so convert it to
sequence set later */
ret = imap_search_get_anyset(cmd, messageset, cmd->uid, &search_args);
if (ret <= 0)
return ret < 0;
ctx = imap_fetch_alloc(client, cmd->pool);
if (!fetch_parse_args(ctx, cmd, &args[1], &next_arg) ||
(imap_arg_get_list(next_arg, &list_arg) &&
!fetch_parse_modifiers(ctx, cmd, search_args, list_arg,
&send_vanished))) {
imap_fetch_free(&ctx);
mail_search_args_unref(&search_args);
return TRUE;
}
if (send_vanished) {
memset(&qresync_args, 0, sizeof(qresync_args));
if (imap_fetch_send_vanished(client, client->mailbox,
search_args, &qresync_args) < 0) {
mail_search_args_unref(&search_args);
return cmd_fetch_finish(ctx, cmd);
}
}
imap_fetch_begin(ctx, client->mailbox, search_args);
mail_search_args_unref(&search_args);
if (imap_fetch_more(ctx, cmd) == 0) {
/* unfinished */
cmd->state = CLIENT_COMMAND_STATE_WAIT_OUTPUT;
cmd->func = cmd_fetch_continue;
cmd->context = ctx;
return FALSE;
}
return cmd_fetch_finish(ctx, cmd);
}
bool cmd_store(struct client_command_context *cmd)
{
struct client *client = cmd->client;
const struct imap_arg *args;
struct mail_search_args *search_args;
struct mail_search_context *search_ctx;
struct mailbox_transaction_context *t;
struct mail *mail;
struct imap_store_context ctx;
ARRAY_TYPE(seq_range) modified_set, uids;
enum mailbox_transaction_flags flags = 0;
enum imap_sync_flags imap_sync_flags = 0;
const char *set, *reply, *tagged_reply;
string_t *str;
int ret;
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
if (!imap_arg_get_atom(args, &set)) {
client_send_command_error(cmd, "Invalid arguments.");
return TRUE;
}
ret = imap_search_get_seqset(cmd, set, cmd->uid, &search_args);
if (ret <= 0)
return ret < 0;
memset(&ctx, 0, sizeof(ctx));
ctx.cmd = cmd;
if (!store_parse_args(&ctx, ++args)) {
mail_search_args_unref(&search_args);
return TRUE;
}
if (client->mailbox_examined) {
mail_search_args_unref(&search_args);
if (ctx.max_modseq < (uint64_t)-1)
reply = "NO CONDSTORE failed: Mailbox is read-only.";
else
reply = "OK Store ignored with read-only mailbox.";
return cmd_sync(cmd, MAILBOX_SYNC_FLAG_FAST |
(cmd->uid ? 0 : MAILBOX_SYNC_FLAG_NO_EXPUNGES),
0, reply);
}
if (ctx.silent)
flags |= MAILBOX_TRANSACTION_FLAG_HIDE;
if (ctx.max_modseq < (uint64_t)-1) {
/* update modseqs so we can check them early */
flags |= MAILBOX_TRANSACTION_FLAG_REFRESH;
}
t = mailbox_transaction_begin(client->mailbox, flags);
search_ctx = mailbox_search_init(t, search_args, NULL,
MAIL_FETCH_FLAGS, NULL);
mail_search_args_unref(&search_args);
i_array_init(&modified_set, 64);
if (ctx.max_modseq < (uint32_t)-1) {
/* STORE UNCHANGEDSINCE is being used */
mailbox_transaction_set_max_modseq(t, ctx.max_modseq,
&modified_set);
}
while (mailbox_search_next(search_ctx, &mail)) {
if (ctx.max_modseq < (uint64_t)-1) {
/* check early so there's less work for transaction
commit if something has to be cancelled */
if (mail_get_modseq(mail) > ctx.max_modseq) {
seq_range_array_add(&modified_set, mail->seq);
continue;
}
}
if (ctx.modify_type == MODIFY_REPLACE || ctx.flags != 0)
mail_update_flags(mail, ctx.modify_type, ctx.flags);
if (ctx.modify_type == MODIFY_REPLACE || ctx.keywords != NULL) {
mail_update_keywords(mail, ctx.modify_type,
ctx.keywords);
}
}
if (ctx.keywords != NULL)
mailbox_keywords_unref(&ctx.keywords);
ret = mailbox_search_deinit(&search_ctx);
if (ret < 0)
mailbox_transaction_rollback(&t);
else
ret = mailbox_transaction_commit(&t);
if (ret < 0) {
array_free(&modified_set);
client_send_box_error(cmd, client->mailbox);
return TRUE;
}
if (array_count(&modified_set) == 0)
tagged_reply = "OK Store completed.";
else {
if (cmd->uid) {
i_array_init(&uids, array_count(&modified_set)*2);
mailbox_get_uid_range(client->mailbox, &modified_set,
&uids);
array_free(&modified_set);
modified_set = uids;
}
str = str_new(cmd->pool, 256);
str_append(str, "OK [MODIFIED ");
imap_write_seq_range(str, &modified_set);
str_append(str, "] Conditional store failed.");
tagged_reply = str_c(str);
}
array_free(&modified_set);
/* With UID STORE we have to return UID for the flags as well.
Unfortunately we don't have the ability to separate those
flag changes that were caused by UID STORE and those that
came externally, so we'll just send the UID for all flag
changes that we see. */
if (cmd->uid && (!ctx.silent || (client->enabled_features &
MAILBOX_FEATURE_CONDSTORE) != 0))
imap_sync_flags |= IMAP_SYNC_FLAG_SEND_UID;
return cmd_sync(cmd, (cmd->uid ? 0 : MAILBOX_SYNC_FLAG_NO_EXPUNGES),
imap_sync_flags, tagged_reply);
}