static void snarf_mailbox_allocated(struct mailbox *box)
{
struct snarf_mail_storage *sstorage = SNARF_CONTEXT(box->storage);
struct mailbox_vfuncs *v = box->vlast;
struct snarf_mailbox *sbox;
struct mailbox_list *snarf_list;
const char *snarf_name;
if (!box->inbox_user)
return;
if (sstorage != NULL && sstorage->snarfing_disabled)
return;
if (!snarf_box_find(box->storage->user, &snarf_list, &snarf_name))
return;
sbox = p_new(box->pool, struct snarf_mailbox, 1);
sbox->module_ctx.super = *v;
box->vlast = &sbox->module_ctx.super;
sbox->snarf_box = mailbox_alloc(snarf_list, snarf_name,
MAILBOX_FLAG_KEEP_LOCKED);
v->sync_init = snarf_sync_init;
v->free = snarf_mailbox_free;
MODULE_CONTEXT_SET(box, snarf_storage_module, sbox);
}
raw_mailbox_alloc_common(struct mail_user *user, struct istream *input,
const char *path, time_t received_time,
const char *envelope_sender, struct mailbox **box_r)
{
struct mail_namespace *ns = user->namespaces;
struct mailbox *box;
struct raw_mailbox *raw_box;
const char *name;
name = path != NULL ? path : i_stream_get_name(input);
box = *box_r = mailbox_alloc(ns->list, name,
MAILBOX_FLAG_NO_INDEX_FILES);
if (input != NULL) {
if (mailbox_open_stream(box, input) < 0)
return -1;
} else {
if (mailbox_open(box) < 0)
return -1;
}
if (mailbox_sync(box, 0) < 0)
return -1;
i_assert(strcmp(box->storage->name, RAW_STORAGE_NAME) == 0);
raw_box = (struct raw_mailbox *)box;
raw_box->envelope_sender = envelope_sender;
raw_box->mtime = received_time;
return 0;
}
static bool cmd_getquotaroot(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct quota_user *quser = QUOTA_USER_CONTEXT(client->user);
struct mail_namespace *ns;
struct mailbox *box;
struct quota_root_iter *iter;
struct quota_root *root;
const char *mailbox, *storage_name, *name;
string_t *quotaroot_reply, *quota_reply;
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
if (ns == NULL)
return TRUE;
if (quser == NULL) {
client_send_tagline(cmd, "OK No quota.");
return TRUE;
}
if (ns->owner != NULL && ns->owner != client->user &&
!client->user->admin) {
client_send_tagline(cmd, "NO Not showing other users' quota.");
return TRUE;
}
box = mailbox_alloc(ns->list, storage_name, MAILBOX_FLAG_READONLY |
MAILBOX_FLAG_KEEP_RECENT);
/* build QUOTAROOT reply and QUOTA reply for all quota roots */
quotaroot_reply = t_str_new(128);
quota_reply = t_str_new(256);
str_append(quotaroot_reply, "* QUOTAROOT ");
imap_quote_append_string(quotaroot_reply, mailbox, FALSE);
iter = quota_root_iter_init(box);
while ((root = quota_root_iter_next(iter)) != NULL) {
str_append_c(quotaroot_reply, ' ');
name = imap_quota_root_get_name(client->user, ns->owner, root);
imap_quote_append_string(quotaroot_reply, name, FALSE);
quota_reply_write(quota_reply, client->user, ns->owner, root);
}
quota_root_iter_deinit(&iter);
mailbox_free(&box);
/* send replies */
if (str_len(quota_reply) == 0)
client_send_tagline(cmd, "OK No quota.");
else {
client_send_line(client, str_c(quotaroot_reply));
o_stream_send(client->output, str_data(quota_reply),
str_len(quota_reply));
client_send_tagline(cmd, "OK Getquotaroot completed.");
}
return TRUE;
}
static int
cmd_acl_mailbox_open(struct mail_user *user, const char *mailbox,
struct mailbox **box_r)
{
struct acl_user *auser = ACL_USER_CONTEXT(user);
struct mail_namespace *ns;
struct mailbox *box;
const char *storage_name;
if (auser == NULL) {
i_error("ACL not enabled for %s", user->username);
return -1;
}
storage_name = mailbox;
ns = mail_namespace_find(user->namespaces, &storage_name);
if (ns == NULL) {
i_error("No namespace found for mailbox %s", mailbox);
return -1;
}
box = mailbox_alloc(ns->list, storage_name,
MAILBOX_FLAG_READONLY | MAILBOX_FLAG_KEEP_RECENT |
MAILBOX_FLAG_IGNORE_ACLS);
if (mailbox_open(box) < 0) {
i_error("Can't open mailbox %s: %s", mailbox,
mail_storage_get_last_error(box->storage, NULL));
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
static int
cmd_acl_mailbox_open(struct doveadm_mail_cmd_context *ctx,
struct mail_user *user, const char *mailbox,
struct mailbox **box_r)
{
struct acl_user *auser = ACL_USER_CONTEXT(user);
struct mail_namespace *ns;
struct mailbox *box;
if (auser == NULL) {
i_error("ACL not enabled for %s", user->username);
doveadm_mail_failed_error(ctx, MAIL_ERROR_NOTFOUND);
return -1;
}
ns = mail_namespace_find(user->namespaces, mailbox);
box = mailbox_alloc(ns->list, mailbox,
MAILBOX_FLAG_READONLY | MAILBOX_FLAG_IGNORE_ACLS);
if (mailbox_open(box) < 0) {
i_error("Can't open mailbox %s: %s", mailbox,
mailbox_get_last_error(box, NULL));
doveadm_mail_failed_mailbox(ctx, box);
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
static bool
cmd_setmetadata_mailbox(struct imap_setmetadata_context *ctx,
const char *mailbox)
{
struct client_command_context *cmd = ctx->cmd;
struct client *client = cmd->client;
struct mail_namespace *ns;
ns = client_find_namespace(cmd, &mailbox);
if (ns == NULL)
return TRUE;
if (client->mailbox != NULL && !client->mailbox_examined &&
mailbox_equals(client->mailbox, ns, mailbox))
ctx->box = client->mailbox;
else {
ctx->box = mailbox_alloc(ns->list, mailbox, 0);
if (mailbox_open(ctx->box) < 0) {
client_send_box_error(cmd, ctx->box);
mailbox_free(&ctx->box);
return TRUE;
}
}
ctx->trans = imap_metadata_transaction_begin(ctx->box);
return cmd_setmetadata_start(ctx);
}
int fts_backend_reset_last_uids(struct fts_backend *backend)
{
struct mailbox_list_iterate_context *iter;
const struct mailbox_info *info;
struct mailbox *box;
int ret = 0;
iter = mailbox_list_iter_init(backend->ns->list, "*",
MAILBOX_LIST_ITER_SKIP_ALIASES |
MAILBOX_LIST_ITER_NO_AUTO_BOXES);
while ((info = mailbox_list_iter_next(iter)) != NULL) {
if ((info->flags &
(MAILBOX_NONEXISTENT | MAILBOX_NOSELECT)) != 0)
continue;
box = mailbox_alloc(info->ns->list, info->vname, 0);
if (mailbox_open(box) == 0) {
if (fts_index_set_last_uid(box, 0) < 0)
ret = -1;
}
mailbox_free(&box);
}
if (mailbox_list_iter_deinit(&iter) < 0)
ret = -1;
return ret;
}
static int
lmtp_rcpt_to_is_over_quota(struct client *client,
const struct mail_recipient *rcpt)
{
struct mail_user *user;
struct mail_namespace *ns;
struct mailbox *box;
struct mailbox_status status;
const char *errstr;
enum mail_error error;
int ret;
if (!client->lmtp_set->lmtp_rcpt_check_quota)
return 0;
ret = mail_storage_service_next(storage_service,
rcpt->service_user, &user);
if (ret < 0)
return -1;
ns = mail_namespace_find_inbox(user->namespaces);
box = mailbox_alloc(ns->list, "INBOX", 0);
ret = mailbox_get_status(box, STATUS_CHECK_OVER_QUOTA, &status);
if (ret < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error == MAIL_ERROR_NOSPACE) {
client_send_line(client, "552 5.2.2 <%s> %s",
rcpt->address, errstr);
ret = 1;
}
}
mailbox_free(&box);
mail_user_unref(&user);
return ret;
}
static void
mailbox_list_index_update_info(struct mailbox_list_index_iterate_context *ctx)
{
struct mailbox_list_index_node *node = ctx->next_node;
struct mailbox *box;
p_clear(ctx->info_pool);
str_truncate(ctx->path, ctx->parent_len);
/* the root directory may have an empty name. in that case we'll still
want to insert the separator, so check for non-NULL parent rather
than non-empty path. */
if (node->parent != NULL) {
str_append_c(ctx->path,
mailbox_list_get_hierarchy_sep(ctx->ctx.list));
}
str_append(ctx->path, node->name);
ctx->info.vname = mailbox_list_get_vname(ctx->ctx.list, str_c(ctx->path));
ctx->info.flags = node->children != NULL ?
MAILBOX_CHILDREN : MAILBOX_NOCHILDREN;
if (strcmp(ctx->info.vname, "INBOX") != 0) {
/* non-INBOX */
ctx->info.vname = p_strdup(ctx->info_pool, ctx->info.vname);
} else if (!ctx->prefix_inbox_list) {
/* listing INBOX itself */
ctx->info.vname = "INBOX";
if (mail_namespace_is_inbox_noinferiors(ctx->info.ns)) {
ctx->info.flags &= ~(MAILBOX_CHILDREN|MAILBOX_NOCHILDREN);
ctx->info.flags |= MAILBOX_NOINFERIORS;
}
} else {
/* listing INBOX/INBOX */
ctx->info.vname = p_strconcat(ctx->info_pool,
ctx->ctx.list->ns->prefix, "INBOX", NULL);
ctx->info.flags |= MAILBOX_NONEXISTENT;
}
if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NONEXISTENT) != 0)
ctx->info.flags |= MAILBOX_NONEXISTENT;
else if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOSELECT) != 0)
ctx->info.flags |= MAILBOX_NOSELECT;
if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOINFERIORS) != 0)
ctx->info.flags |= MAILBOX_NOINFERIORS;
if ((ctx->ctx.flags & (MAILBOX_LIST_ITER_SELECT_SUBSCRIBED |
MAILBOX_LIST_ITER_RETURN_SUBSCRIBED)) != 0) {
mailbox_list_set_subscription_flags(ctx->ctx.list,
ctx->info.vname,
&ctx->info.flags);
}
if ((ctx->ctx.flags & MAILBOX_LIST_ITER_RETURN_NO_FLAGS) == 0) {
box = mailbox_alloc(ctx->ctx.list, ctx->info.vname, 0);
mailbox_list_index_status_set_info_flags(box, node->uid,
&ctx->info.flags);
mailbox_free(&box);
}
}
bool cmd_create(struct client_command_context *cmd)
{
enum mailbox_name_status status;
struct mail_namespace *ns;
const char *mailbox, *storage_name;
struct mailbox *box;
bool directory;
size_t len;
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
if (ns == NULL)
return TRUE;
len = strlen(mailbox);
if (len == 0 || mailbox[len-1] != ns->sep)
directory = FALSE;
else if (*storage_name == '\0') {
client_send_tagline(cmd, "NO ["IMAP_RESP_CODE_ALREADYEXISTS
"] Namespace already exists.");
return TRUE;
} else {
/* name ends with hierarchy separator - client is just
informing us that it wants to create children under this
mailbox. */
directory = TRUE;
storage_name = t_strndup(storage_name, strlen(storage_name)-1);
mailbox = t_strndup(mailbox, len-1);
}
ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
if (ns == NULL)
return TRUE;
switch (status) {
case MAILBOX_NAME_VALID:
break;
case MAILBOX_NAME_EXISTS_DIR:
if (!directory)
break;
/* fall through */
case MAILBOX_NAME_EXISTS_MAILBOX:
case MAILBOX_NAME_INVALID:
case MAILBOX_NAME_NOINFERIORS:
client_fail_mailbox_name_status(cmd, mailbox, NULL, status);
return TRUE;
}
box = mailbox_alloc(ns->list, storage_name, 0);
if (mailbox_create(box, NULL, directory) < 0)
client_send_storage_error(cmd, mailbox_get_storage(box));
else
client_send_tagline(cmd, "OK Create completed.");
mailbox_free(&box);
return TRUE;
}
static int dsync_mailbox_tree_add(struct dsync_mailbox_tree *tree,
const struct mailbox_info *info,
const guid_128_t box_guid,
enum mail_error *error_r)
{
struct dsync_mailbox_node *node;
struct mailbox *box;
struct mailbox_metadata metadata;
struct mailbox_status status;
const char *errstr;
enum mail_error error;
int ret = 0;
if ((info->flags & MAILBOX_NONEXISTENT) != 0)
return 0;
if ((info->flags & MAILBOX_NOSELECT) != 0) {
return !guid_128_is_empty(box_guid) ? 0 :
dsync_mailbox_tree_add_exists_node(tree, info, &node, error_r);
}
/* get GUID and UIDVALIDITY for selectable mailbox */
box = mailbox_alloc(info->ns->list, info->vname, MAILBOX_FLAG_READONLY);
if (dsync_mailbox_tree_get_selectable(box, &metadata, &status) < 0) {
errstr = mailbox_get_last_internal_error(box, &error);
switch (error) {
case MAIL_ERROR_NOTFOUND:
/* mailbox was just deleted? */
break;
case MAIL_ERROR_NOTPOSSIBLE:
/* invalid mbox files? ignore */
break;
default:
i_error("Failed to access mailbox %s: %s",
info->vname, errstr);
*error_r = error;
ret = -1;
}
mailbox_free(&box);
return ret;
}
mailbox_free(&box);
if (!guid_128_is_empty(box_guid) &&
!guid_128_equals(box_guid, metadata.guid)) {
/* unwanted mailbox */
return 0;
}
if (dsync_mailbox_tree_add_exists_node(tree, info, &node, error_r) < 0)
return -1;
memcpy(node->mailbox_guid, metadata.guid,
sizeof(node->mailbox_guid));
node->uid_validity = status.uidvalidity;
node->uid_next = status.uidnext;
return 0;
}
static bool
dsync_is_valid_name(struct mail_namespace *ns, const char *vname)
{
struct mailbox *box;
bool ret;
box = mailbox_alloc(ns->list, vname, MAILBOX_FLAG_READONLY);
ret = mailbox_verify_create_name(box) == 0;
mailbox_free(&box);
return ret;
}
static int
quota_count_mailbox(struct quota_root *root, struct mail_namespace *ns,
const char *vname, uint64_t *bytes_r, uint64_t *count_r)
{
struct quota_rule *rule;
struct mailbox *box;
struct mailbox_transaction_context *trans;
struct mail_search_context *ctx;
struct mail *mail;
struct mail_search_args *search_args;
enum mail_error error;
uoff_t size;
int ret = 0;
rule = quota_root_rule_find(root->set, vname);
if (rule != NULL && rule->ignore) {
/* mailbox not included in quota */
return 0;
}
box = mailbox_alloc(ns->list, vname, MAILBOX_FLAG_READONLY);
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
error = mailbox_get_last_mail_error(box);
mailbox_free(&box);
if (error == MAIL_ERROR_TEMP)
return -1;
/* non-temporary error, e.g. ACLs denied access. */
return 0;
}
trans = mailbox_transaction_begin(box, 0);
search_args = mail_search_build_init();
mail_search_build_add_all(search_args);
ctx = mailbox_search_init(trans, search_args, NULL,
MAIL_FETCH_PHYSICAL_SIZE, NULL);
mail_search_args_unref(&search_args);
while (mailbox_search_next(ctx, &mail)) {
if (mail_get_physical_size(mail, &size) == 0)
*bytes_r += size;
*count_r += 1;
}
if (mailbox_search_deinit(&ctx) < 0)
ret = -1;
if (ret < 0)
mailbox_transaction_rollback(&trans);
else
(void)mailbox_transaction_commit(&trans);
mailbox_free(&box);
return ret;
}
void mailbox_guid_cache_refresh(struct mailbox_list *list)
{
struct mailbox_list_iterate_context *ctx;
const struct mailbox_info *info;
struct mailbox *box;
struct mailbox_metadata metadata;
struct mailbox_guid_cache_rec *rec;
uint8_t *guid_p;
if (!hash_table_is_created(list->guid_cache)) {
list->guid_cache_pool =
pool_alloconly_create("guid cache", 1024*16);
hash_table_create(&list->guid_cache, list->guid_cache_pool, 0,
guid_128_hash, guid_128_cmp);
} else {
hash_table_clear(list->guid_cache, TRUE);
p_clear(list->guid_cache_pool);
}
list->guid_cache_invalidated = FALSE;
list->guid_cache_updated = FALSE;
list->guid_cache_errors = FALSE;
ctx = mailbox_list_iter_init(list, "*",
MAILBOX_LIST_ITER_SKIP_ALIASES |
MAILBOX_LIST_ITER_NO_AUTO_BOXES);
while ((info = mailbox_list_iter_next(ctx)) != NULL) {
if ((info->flags &
(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT)) != 0)
continue;
box = mailbox_alloc(list, info->vname, 0);
if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID,
&metadata) < 0) {
i_error("Couldn't get mailbox %s GUID: %s",
info->vname, mailbox_get_last_internal_error(box, NULL));
list->guid_cache_errors = TRUE;
} else if ((rec = hash_table_lookup(list->guid_cache,
(const uint8_t *)metadata.guid)) != NULL) {
i_warning("Mailbox %s has duplicate GUID with %s: %s",
info->vname, rec->vname,
guid_128_to_string(metadata.guid));
} else {
rec = p_new(list->guid_cache_pool,
struct mailbox_guid_cache_rec, 1);
memcpy(rec->guid, metadata.guid, sizeof(rec->guid));
rec->vname = p_strdup(list->guid_cache_pool, info->vname);
guid_p = rec->guid;
hash_table_insert(list->guid_cache, guid_p, rec);
}
mailbox_free(&box);
}
if (mailbox_list_iter_deinit(&ctx) < 0)
list->guid_cache_errors = TRUE;
}
static int
dest_mailbox_open_or_create(struct import_cmd_context *ctx,
struct mail_user *user,
const struct mailbox_info *info,
struct mailbox **box_r)
{
struct mail_namespace *ns;
struct mailbox *box;
enum mail_error error;
const char *name, *errstr;
if (*ctx->dest_parent != '\0') {
/* prefix destination mailbox name with given parent mailbox */
ns = mail_namespace_find(user->namespaces, ctx->dest_parent);
} else {
ns = mail_namespace_find(user->namespaces, info->vname);
}
name = convert_vname_separators(info->vname,
mail_namespace_get_sep(info->ns),
mail_namespace_get_sep(ns));
if (*ctx->dest_parent != '\0') {
name = t_strdup_printf("%s%c%s", ctx->dest_parent,
mail_namespace_get_sep(ns), name);
}
box = mailbox_alloc(ns->list, name, MAILBOX_FLAG_SAVEONLY);
if (mailbox_create(box, NULL, FALSE) < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error != MAIL_ERROR_EXISTS) {
i_error("Couldn't create mailbox %s: %s", name, errstr);
doveadm_mail_failed_mailbox(&ctx->ctx, box);
mailbox_free(&box);
return -1;
}
}
if (ctx->subscribe) {
if (mailbox_set_subscribed(box, TRUE) < 0) {
i_error("Couldn't subscribe to mailbox %s: %s",
name, mailbox_get_last_error(box, NULL));
}
}
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
i_error("Syncing mailbox %s failed: %s", name,
mailbox_get_last_error(box, NULL));
doveadm_mail_failed_mailbox(&ctx->ctx, box);
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
static int
cmd_mailbox_metadata_open_mailbox(struct metadata_cmd_context *mctx,
struct mail_user *user,
const char *op,
struct mail_namespace **ns_r,
struct mailbox **box_r)
{
mctx->empty_mailbox_name = mctx->mailbox[0] == '\0';
if (mctx->empty_mailbox_name) {
if (!mctx->ctx.allow_empty_mailbox_name) {
i_error("Failed to %s: %s", op,
"mailbox name cannot be empty");
mctx->ctx.exit_code = EX_USAGE;
return -1;
}
/* server attribute */
*ns_r = mail_namespace_find_inbox(user->namespaces);
*box_r = mailbox_alloc((*ns_r)->list, "INBOX", 0);
mctx->key = t_strconcat(MAILBOX_ATTRIBUTE_PREFIX_DOVECOT_PVT_SERVER,
mctx->key, NULL);
} else {
/* mailbox attributes */
*ns_r = mail_namespace_find(user->namespaces, mctx->mailbox);
*box_r = mailbox_alloc((*ns_r)->list, mctx->mailbox, 0);
}
if (mailbox_open(*box_r) < 0) {
i_error("Failed to open mailbox: %s",
mailbox_get_last_error(*box_r, NULL));
doveadm_mail_failed_mailbox(&mctx->ctx, *box_r);
mailbox_free(box_r);
return -1;
}
return 0;
}
static int
dest_mailbox_open_or_create(struct import_cmd_context *ctx,
struct mail_user *user, const char *name,
struct mailbox **box_r)
{
struct mail_namespace *ns;
struct mailbox *box;
enum mail_error error;
const char *errstr, *storage_name;
if (*ctx->dest_parent != '\0') {
/* prefix destination mailbox name with given parent mailbox */
storage_name = ctx->dest_parent;
ns = mail_namespace_find(user->namespaces, &storage_name);
if (ns == NULL) {
i_error("Can't find namespace for parent mailbox %s",
ctx->dest_parent);
return -1;
}
name = t_strdup_printf("%s%c%s", ctx->dest_parent,
ns->sep, name);
}
storage_name = name;
ns = mail_namespace_find(user->namespaces, &storage_name);
if (ns == NULL) {
i_error("Can't find namespace for mailbox %s", name);
return -1;
}
box = mailbox_alloc(ns->list, storage_name, MAILBOX_FLAG_SAVEONLY |
MAILBOX_FLAG_KEEP_RECENT);
if (mailbox_create(box, NULL, FALSE) < 0) {
errstr = mail_storage_get_last_error(mailbox_get_storage(box),
&error);
if (error != MAIL_ERROR_EXISTS) {
i_error("Couldn't create mailbox %s: %s", name, errstr);
mailbox_free(&box);
return -1;
}
}
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
i_error("Syncing mailbox %s failed: %s", name,
mail_storage_get_last_error(mailbox_get_storage(box),
NULL));
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
static int
cmd_save_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
{
struct save_cmd_context *ctx = (struct save_cmd_context *)_ctx;
struct mail_namespace *ns;
struct mailbox *box;
int ret;
ns = mail_namespace_find(user->namespaces, ctx->mailbox);
box = mailbox_alloc(ns->list, ctx->mailbox, MAILBOX_FLAG_SAVEONLY);
ret = cmd_save_to_mailbox(ctx, box, _ctx->cmd_input);
mailbox_free(&box);
return ret;
}
static bool acl_ns_prefix_exists(struct mail_namespace *ns)
{
struct mailbox *box;
const char *vname;
enum mailbox_existence existence;
bool ret;
if (ns->list->mail_set->mail_shared_explicit_inbox)
return FALSE;
vname = t_strndup(ns->prefix, ns->prefix_len-1);
box = mailbox_alloc(ns->list, vname, 0);
ret = mailbox_exists(box, FALSE, &existence) == 0 &&
existence == MAILBOX_EXISTENCE_SELECT;
mailbox_free(&box);
return ret;
}
int imap_msgpart_url_open_mailbox(struct imap_msgpart_url *mpurl,
struct mailbox **box_r, enum mail_error *error_code_r,
const char **error_r)
{
struct mailbox_status box_status;
enum mailbox_flags flags = MAILBOX_FLAG_READONLY;
struct mail_namespace *ns;
struct mailbox *box;
if (mpurl->box != NULL) {
*box_r = mpurl->box;
*error_code_r = MAIL_ERROR_NONE;
return 1;
}
/* find mailbox namespace */
ns = mail_namespace_find(mpurl->user->namespaces, mpurl->mailbox);
/* open mailbox */
if (mpurl->selected_box != NULL &&
mailbox_equals(mpurl->selected_box, ns, mpurl->mailbox))
box = mpurl->selected_box;
else
box = mailbox_alloc(ns->list, mpurl->mailbox, flags);
if (mailbox_open(box) < 0) {
*error_r = mail_storage_get_last_error(mailbox_get_storage(box),
error_code_r);
if (box != mpurl->selected_box)
mailbox_free(&box);
return *error_code_r == MAIL_ERROR_TEMP ? -1 : 0;
}
/* verify UIDVALIDITY */
mailbox_get_open_status(box, STATUS_UIDVALIDITY, &box_status);
if (mpurl->uidvalidity > 0 &&
box_status.uidvalidity != mpurl->uidvalidity) {
*error_r = "Invalid UIDVALIDITY";
*error_code_r = MAIL_ERROR_EXPUNGED;
if (box != mpurl->selected_box)
mailbox_free(&box);
return 0;
}
mpurl->box = box;
*box_r = box;
return 1;
}
int fts_backend_rescan(struct fts_backend *backend)
{
struct mailbox *box;
bool virtual_storage;
box = mailbox_alloc(backend->ns->list, "", 0);
virtual_storage = box->virtual_vfuncs != NULL;
mailbox_free(&box);
if (virtual_storage) {
/* just reset the last-uids for a virtual storage. */
return fts_backend_reset_last_uids(backend);
}
return backend->v.rescan == NULL ? 0 :
backend->v.rescan(backend);
}
static int
cmd_copy_run(struct doveadm_mail_cmd_context *_ctx, struct mail_user *user)
{
struct copy_cmd_context *ctx = (struct copy_cmd_context *)_ctx;
const enum mailbox_list_iter_flags iter_flags =
MAILBOX_LIST_ITER_NO_AUTO_BOXES |
MAILBOX_LIST_ITER_RETURN_NO_FLAGS;
struct doveadm_mailbox_list_iter *iter;
struct mail_user *src_user;
struct mail_namespace *ns;
struct mailbox *destbox;
const struct mailbox_info *info;
int ret = 0;
if (ctx->source_username != NULL && ctx->source_user == NULL)
cmd_copy_alloc_source_user(ctx);
ns = mail_namespace_find(user->namespaces, ctx->destname);
destbox = mailbox_alloc(ns->list, ctx->destname, MAILBOX_FLAG_SAVEONLY);
if (mailbox_open(destbox) < 0) {
i_error("Can't open mailbox '%s': %s", ctx->destname,
mailbox_get_last_error(destbox, NULL));
doveadm_mail_failed_mailbox(&ctx->ctx, destbox);
mailbox_free(&destbox);
return -1;
}
src_user = ctx->source_user != NULL ? ctx->source_user : user;
iter = doveadm_mailbox_list_iter_init(_ctx, src_user, _ctx->search_args,
iter_flags);
while ((info = doveadm_mailbox_list_iter_next(iter)) != NULL) T_BEGIN {
if (cmd_copy_box(ctx, destbox, info) < 0)
ret = -1;
} T_END;
if (doveadm_mailbox_list_iter_deinit(&iter) < 0)
ret = -1;
if (mailbox_sync(destbox, 0) < 0) {
i_error("Syncing mailbox '%s' failed: %s", ctx->destname,
mailbox_get_last_error(destbox, NULL));
doveadm_mail_failed_mailbox(&ctx->ctx, destbox);
ret = -1;
}
mailbox_free(&destbox);
return ret;
}
static int
quota_count_mailbox(struct quota_root *root, struct mail_namespace *ns,
const char *vname, uint64_t *bytes, uint64_t *count)
{
struct quota_rule *rule;
struct mailbox *box;
struct mailbox_metadata metadata;
struct mailbox_status status;
enum mail_error error;
const char *errstr;
int ret;
rule = quota_root_rule_find(root->set, vname);
if (rule != NULL && rule->ignore) {
/* mailbox not included in quota */
return 0;
}
box = mailbox_alloc(ns->list, vname, MAILBOX_FLAG_READONLY);
if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_NOQUOTA) != 0) {
/* quota doesn't exist for this mailbox/storage */
ret = 0;
} else if (mailbox_get_metadata(box, root->quota->set->vsizes ?
MAILBOX_METADATA_VIRTUAL_SIZE :
MAILBOX_METADATA_PHYSICAL_SIZE,
&metadata) < 0 ||
mailbox_get_status(box, STATUS_MESSAGES, &status) < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error == MAIL_ERROR_TEMP) {
i_error("quota: Couldn't get size of mailbox %s: %s",
vname, errstr);
ret = -1;
} else {
/* non-temporary error, e.g. ACLs denied access. */
ret = 0;
}
} else {
ret = 1;
*bytes += root->quota->set->vsizes ?
metadata.virtual_size : metadata.physical_size;
*count += status.messages;
}
mailbox_free(&box);
return ret;
}
static int
mbox_mailbox_get_guid(struct mbox_mailbox *mbox, guid_128_t guid_r)
{
const char *errstr;
if (mail_index_is_in_memory(mbox->box.index)) {
errstr = "Mailbox GUIDs are not permanent without index files";
if (mbox->storage->set->mbox_min_index_size != 0) {
errstr = t_strconcat(errstr,
" (mbox_min_index_size is non-zero)", NULL);
}
mail_storage_set_error(mbox->box.storage,
MAIL_ERROR_NOTPOSSIBLE, errstr);
return -1;
}
if (mbox_sync_header_refresh(mbox) < 0)
return -1;
if (!guid_128_is_empty(mbox->mbox_hdr.mailbox_guid)) {
/* we have the GUID */
} else if (mbox_file_open(mbox) < 0)
return -1;
else if (mbox->backend_readonly) {
mail_storage_set_error(mbox->box.storage, MAIL_ERROR_PERM,
"Can't set mailbox GUID to a read-only mailbox");
return -1;
} else {
/* create another mailbox and sync */
struct mailbox *box2;
struct mbox_mailbox *mbox2;
int ret;
i_assert(mbox->mbox_lock_type == F_UNLCK);
box2 = mailbox_alloc(mbox->box.list, mbox->box.vname, 0);
ret = mailbox_sync(box2, 0);
mbox2 = (struct mbox_mailbox *)box2;
memcpy(guid_r, mbox2->mbox_hdr.mailbox_guid, GUID_128_SIZE);
mailbox_free(&box2);
return ret;
}
memcpy(guid_r, mbox->mbox_hdr.mailbox_guid, GUID_128_SIZE);
return 0;
}
static int pop3_mailbox_open(struct mail_storage *storage)
{
struct pop3_migration_mail_storage *mstorage =
POP3_MIGRATION_CONTEXT(storage);
struct mail_namespace *ns;
if (mstorage->pop3_box != NULL)
return 0;
ns = mail_namespace_find(storage->user->namespaces,
mstorage->pop3_box_vname);
mstorage->pop3_box = mailbox_alloc(ns->list, mstorage->pop3_box_vname,
MAILBOX_FLAG_READONLY |
MAILBOX_FLAG_POP3_SESSION);
mstorage->all_mailboxes =
mail_user_plugin_getenv(storage->user,
"pop3_migration_all_mailboxes") != NULL;
return 0;
}
static int
dsync_mailbox_tree_fix_guid_duplicate(struct dsync_mailbox_tree *tree,
struct dsync_mailbox_node *node1,
struct dsync_mailbox_node *node2)
{
struct mailbox *box;
struct mailbox_update update;
struct dsync_mailbox_node *change_node;
const char *change_vname;
int ret = 0;
i_zero(&update);
guid_128_generate(update.mailbox_guid);
/* just in case the duplication exists in both sides,
make them choose the same node */
if (strcmp(dsync_mailbox_node_get_full_name(tree, node1),
dsync_mailbox_node_get_full_name(tree, node2)) <= 0)
change_node = node1;
else
change_node = node2;
change_vname = dsync_mailbox_node_get_full_name(tree, change_node);
i_error("Duplicate mailbox GUID %s for mailboxes %s and %s - "
"giving a new GUID %s to %s",
guid_128_to_string(node1->mailbox_guid),
dsync_mailbox_node_get_full_name(tree, node1),
dsync_mailbox_node_get_full_name(tree, node2),
guid_128_to_string(update.mailbox_guid), change_vname);
i_assert(node1->ns != NULL && node2->ns != NULL);
box = mailbox_alloc(change_node->ns->list, change_vname, 0);
if (mailbox_update(box, &update) < 0) {
i_error("Couldn't update mailbox %s GUID: %s",
change_vname, mailbox_get_last_internal_error(box, NULL));
ret = -1;
} else {
memcpy(change_node->mailbox_guid, update.mailbox_guid,
sizeof(change_node->mailbox_guid));
}
mailbox_free(&box);
return ret;
}
bool cmd_create(struct client_command_context *cmd)
{
struct mail_namespace *ns;
const char *mailbox, *orig_mailbox;
struct mailbox *box;
bool directory;
size_t len;
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
orig_mailbox = mailbox;
ns = client_find_namespace(cmd, &mailbox);
if (ns == NULL)
return TRUE;
len = strlen(orig_mailbox);
if (len == 0 || orig_mailbox[len-1] != mail_namespace_get_sep(ns))
directory = FALSE;
else {
/* name ends with hierarchy separator - client is just
informing us that it wants to create children under this
mailbox. */
directory = TRUE;
/* drop separator from mailbox. it's already dropped when
WORKAROUND_TB_EXTRA_MAILBOX_SEP is enabled */
if (len == strlen(mailbox))
mailbox = t_strndup(mailbox, len-1);
}
box = mailbox_alloc(ns->list, mailbox, 0);
mailbox_set_reason(box, "CREATE");
if (mailbox_create(box, NULL, directory) < 0)
client_send_box_error(cmd, box);
else
client_send_tagline(cmd, "OK Create completed.");
mailbox_free(&box);
return TRUE;
}
int imap_status_get(struct client_command_context *cmd,
struct mail_namespace *ns, const char *mailbox,
const struct imap_status_items *items,
struct imap_status_result *result_r)
{
struct client *client = cmd->client;
struct mailbox *box;
const char *errstr;
int ret = 0;
if (client->mailbox != NULL &&
mailbox_equals(client->mailbox, ns, mailbox)) {
/* this mailbox is selected */
box = client->mailbox;
} else {
/* open the mailbox */
box = mailbox_alloc(ns->list, mailbox, MAILBOX_FLAG_READONLY);
mailbox_set_reason(box, "STATUS");
if (client->enabled_features != 0)
(void)mailbox_enable(box, client->enabled_features);
}
if ((items->status & STATUS_HIGHESTMODSEQ) != 0)
(void)client_enable(client, MAILBOX_FEATURE_CONDSTORE);
ret = mailbox_get_status(box, items->status, &result_r->status);
if (items->metadata != 0 && ret == 0) {
ret = mailbox_get_metadata(box, items->metadata,
&result_r->metadata);
}
if (ret < 0) {
errstr = mailbox_get_last_error(box, &result_r->error);
result_r->errstr = imap_get_error_string(cmd, errstr,
result_r->error);
}
if (box != client->mailbox)
mailbox_free(&box);
return ret;
}
int client_open_save_dest_box(struct client_command_context *cmd,
const char *name, struct mailbox **destbox_r)
{
struct mail_namespace *ns;
struct mailbox *box;
const char *error_string;
enum mail_error error;
ns = client_find_namespace(cmd, &name);
if (ns == NULL)
return -1;
if (cmd->client->mailbox != NULL &&
mailbox_equals(cmd->client->mailbox, ns, name)) {
*destbox_r = cmd->client->mailbox;
return 0;
}
box = mailbox_alloc(ns->list, name, MAILBOX_FLAG_SAVEONLY);
if (mailbox_open(box) < 0) {
error_string = mailbox_get_last_error(box, &error);
if (error == MAIL_ERROR_NOTFOUND) {
client_send_tagline(cmd, t_strdup_printf(
"NO [TRYCREATE] %s", error_string));
} else {
client_send_box_error(cmd, box);
}
mailbox_free(&box);
return -1;
}
if (cmd->client->enabled_features != 0) {
if (mailbox_enable(box, cmd->client->enabled_features) < 0) {
client_send_box_error(cmd, box);
mailbox_free(&box);
return -1;
}
}
*destbox_r = box;
return 0;
}
static void
mailbox_list_index_update_info(struct mailbox_list_index_iterate_context *ctx)
{
struct mailbox_list_index_node *node = ctx->next_node;
struct mailbox *box;
p_clear(ctx->info_pool);
str_truncate(ctx->path, ctx->parent_len);
if (str_len(ctx->path) > 0) {
str_append_c(ctx->path,
mailbox_list_get_hierarchy_sep(ctx->ctx.list));
}
str_append(ctx->path, node->name);
ctx->info.vname = mailbox_list_get_vname(ctx->ctx.list, str_c(ctx->path));
ctx->info.vname = p_strdup(ctx->info_pool, ctx->info.vname);
ctx->info.flags = 0;
if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NONEXISTENT) != 0)
ctx->info.flags |= MAILBOX_NONEXISTENT;
else if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOSELECT) != 0)
ctx->info.flags |= MAILBOX_NOSELECT;
if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOINFERIORS) != 0)
ctx->info.flags |= MAILBOX_NOINFERIORS;
ctx->info.flags |= node->children != NULL ?
MAILBOX_CHILDREN : MAILBOX_NOCHILDREN;
if ((ctx->ctx.flags & (MAILBOX_LIST_ITER_SELECT_SUBSCRIBED |
MAILBOX_LIST_ITER_RETURN_SUBSCRIBED)) != 0) {
mailbox_list_set_subscription_flags(ctx->ctx.list,
ctx->info.vname,
&ctx->info.flags);
}
box = mailbox_alloc(ctx->ctx.list, ctx->info.vname, 0);
mailbox_list_index_status_set_info_flags(box, node->uid,
&ctx->info.flags);
mailbox_free(&box);
}
