bool cmd_expunge(struct client_command_context *cmd)
{
if (!client_verify_open_mailbox(cmd))
return TRUE;
return cmd_expunge_finish(cmd, NULL);
}
bool cmd_check(struct client_command_context *cmd)
{
if (!client_verify_open_mailbox(cmd))
return TRUE;
return cmd_sync(cmd, MAILBOX_SYNC_FLAG_FULL_READ |
MAILBOX_SYNC_FLAG_FULL_WRITE, IMAP_SYNC_FLAG_SAFE,
"OK Check completed.");
}
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_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);
}
bool cmd_unselect(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct mailbox *mailbox = client->mailbox;
if (!client_verify_open_mailbox(cmd))
return TRUE;
client_search_updates_free(client);
i_assert(client->mailbox_change_lock == NULL);
client->mailbox = NULL;
mailbox_free(&mailbox);
client_update_mailbox_flags(client, NULL);
client_send_tagline(cmd, "OK Unselect completed.");
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_close(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct mailbox *mailbox = client->mailbox;
struct mail_storage *storage;
if (!client_verify_open_mailbox(cmd))
return TRUE;
i_assert(client->mailbox_change_lock == NULL);
client->mailbox = NULL;
storage = mailbox_get_storage(mailbox);
if (imap_expunge(mailbox, NULL) < 0)
client_send_untagged_storage_error(client, storage);
if (mailbox_sync(mailbox, 0) < 0)
client_send_untagged_storage_error(client, storage);
mailbox_free(&mailbox);
client_update_mailbox_flags(client, NULL);
client_send_tagline(cmd, "OK Close completed.");
return TRUE;
}
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);
}
static bool cmd_copy_full(struct client_command_context *cmd, bool move)
{
struct client *client = cmd->client;
struct mail_storage *dest_storage;
struct mailbox *destbox;
struct mailbox_transaction_context *t, *src_trans;
struct mail_search_args *search_args;
const char *messageset, *mailbox, *src_uidset;
enum mailbox_sync_flags sync_flags = 0;
enum imap_sync_flags imap_flags = 0;
struct mail_transaction_commit_changes changes;
unsigned int copy_count;
string_t *msg;
int ret;
/* <message set> <mailbox> */
if (!client_read_string_args(cmd, 2, &messageset, &mailbox))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
ret = imap_search_get_seqset(cmd, messageset, cmd->uid, &search_args);
if (ret <= 0)
return ret < 0;
if (client_open_save_dest_box(cmd, mailbox, &destbox) < 0) {
mail_search_args_unref(&search_args);
return TRUE;
}
t = mailbox_transaction_begin(destbox,
MAILBOX_TRANSACTION_FLAG_EXTERNAL |
MAILBOX_TRANSACTION_FLAG_ASSIGN_UIDS);
ret = fetch_and_copy(client, move, t, &src_trans, search_args,
&src_uidset, ©_count);
mail_search_args_unref(&search_args);
msg = t_str_new(256);
if (ret <= 0)
mailbox_transaction_rollback(&t);
else if (mailbox_transaction_commit_get_changes(&t, &changes) < 0)
ret = -1;
else if (copy_count == 0) {
str_append(msg, "OK No messages found.");
pool_unref(&changes.pool);
} else if (seq_range_count(&changes.saved_uids) == 0 ||
changes.no_read_perm) {
/* not supported by backend (virtual) or no read permissions
for mailbox */
str_append(msg, move ? "OK Move completed." :
"OK Copy completed.");
pool_unref(&changes.pool);
} else if (move) {
i_assert(copy_count == seq_range_count(&changes.saved_uids));
str_printfa(msg, "* OK [COPYUID %u %s ",
changes.uid_validity, src_uidset);
imap_write_seq_range(msg, &changes.saved_uids);
str_append(msg, "] Moved UIDs.");
client_send_line(client, str_c(msg));
str_truncate(msg, 0);
str_append(msg, "OK Move completed.");
pool_unref(&changes.pool);
} else {
i_assert(copy_count == seq_range_count(&changes.saved_uids));
str_printfa(msg, "OK [COPYUID %u %s ", changes.uid_validity,
src_uidset);
imap_write_seq_range(msg, &changes.saved_uids);
str_append(msg, "] Copy completed.");
pool_unref(&changes.pool);
}
if (ret <= 0 && move) {
/* move failed, don't expunge anything */
mailbox_transaction_rollback(&src_trans);
} else {
if (mailbox_transaction_commit(&src_trans) < 0)
ret = -1;
}
dest_storage = mailbox_get_storage(destbox);
if (destbox != client->mailbox) {
if (move)
sync_flags |= MAILBOX_SYNC_FLAG_EXPUNGE;
else
sync_flags |= MAILBOX_SYNC_FLAG_FAST;
imap_flags |= IMAP_SYNC_FLAG_SAFE;
mailbox_free(&destbox);
} else if (move) {
sync_flags |= MAILBOX_SYNC_FLAG_EXPUNGE;
imap_flags |= IMAP_SYNC_FLAG_SAFE;
}
if (ret > 0)
return cmd_sync(cmd, sync_flags, imap_flags, str_c(msg));
else if (ret == 0) {
/* some messages were expunged, sync them */
return cmd_sync(cmd, 0, 0,
"NO ["IMAP_RESP_CODE_EXPUNGEISSUED"] "
"Some of the requested messages no longer exist.");
} else {
client_send_storage_error(cmd, dest_storage);
return TRUE;
}
}
bool cmd_copy(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct mail_namespace *dest_ns;
struct mail_storage *dest_storage;
struct mailbox *destbox;
struct mailbox_transaction_context *t;
struct mail_search_args *search_args;
const char *messageset, *mailbox, *storage_name, *src_uidset;
enum mailbox_name_status status;
enum mailbox_sync_flags sync_flags = 0;
enum imap_sync_flags imap_flags = 0;
struct mail_transaction_commit_changes changes;
unsigned int copy_count;
string_t *msg;
int ret;
/* <message set> <mailbox> */
if (!client_read_string_args(cmd, 2, &messageset, &mailbox))
return FALSE;
if (!client_verify_open_mailbox(cmd))
return TRUE;
ret = imap_search_get_seqset(cmd, messageset, cmd->uid, &search_args);
if (ret <= 0)
return ret < 0;
/* open the destination mailbox */
dest_ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
if (dest_ns == NULL) {
mail_search_args_unref(&search_args);
return TRUE;
}
switch (status) {
case MAILBOX_NAME_EXISTS_MAILBOX:
break;
case MAILBOX_NAME_EXISTS_DIR:
status = MAILBOX_NAME_VALID;
/* fall through */
case MAILBOX_NAME_VALID:
case MAILBOX_NAME_INVALID:
case MAILBOX_NAME_NOINFERIORS:
client_fail_mailbox_name_status(cmd, mailbox,
"TRYCREATE", status);
mail_search_args_unref(&search_args);
return TRUE;
}
if (mailbox_equals(client->mailbox, dest_ns, storage_name))
destbox = client->mailbox;
else {
destbox = mailbox_alloc(dest_ns->list, storage_name,
MAILBOX_FLAG_SAVEONLY |
MAILBOX_FLAG_KEEP_RECENT);
if (mailbox_open(destbox) < 0) {
client_send_storage_error(cmd,
mailbox_get_storage(destbox));
mailbox_free(&destbox);
mail_search_args_unref(&search_args);
return TRUE;
}
if (client->enabled_features != 0)
mailbox_enable(destbox, client->enabled_features);
}
t = mailbox_transaction_begin(destbox,
MAILBOX_TRANSACTION_FLAG_EXTERNAL |
MAILBOX_TRANSACTION_FLAG_ASSIGN_UIDS);
ret = fetch_and_copy(client, t, search_args, &src_uidset, ©_count);
mail_search_args_unref(&search_args);
msg = t_str_new(256);
if (ret <= 0)
mailbox_transaction_rollback(&t);
else if (mailbox_transaction_commit_get_changes(&t, &changes) < 0)
ret = -1;
else if (copy_count == 0) {
str_append(msg, "OK No messages copied.");
pool_unref(&changes.pool);
} else if (seq_range_count(&changes.saved_uids) == 0) {
/* not supported by backend (virtual) */
str_append(msg, "OK Copy completed.");
pool_unref(&changes.pool);
} else {
i_assert(copy_count == seq_range_count(&changes.saved_uids));
str_printfa(msg, "OK [COPYUID %u %s ", changes.uid_validity,
src_uidset);
imap_write_seq_range(msg, &changes.saved_uids);
str_append(msg, "] Copy completed.");
pool_unref(&changes.pool);
}
dest_storage = mailbox_get_storage(destbox);
if (destbox != client->mailbox) {
sync_flags |= MAILBOX_SYNC_FLAG_FAST;
imap_flags |= IMAP_SYNC_FLAG_SAFE;
mailbox_free(&destbox);
}
if (ret > 0)
return cmd_sync(cmd, sync_flags, imap_flags, str_c(msg));
else if (ret == 0) {
/* some messages were expunged, sync them */
return cmd_sync(cmd, 0, 0,
"NO ["IMAP_RESP_CODE_EXPUNGEISSUED"] "
"Some of the requested messages no longer exist.");
} else {
client_send_storage_error(cmd, dest_storage);
return TRUE;
}
}
