static bool fts_autoindex_exclude_match(struct mailbox *box)
{
const char *const *exclude_list;
unsigned int i;
const struct mailbox_settings *set;
const char *const *special_use;
struct mail_user *user = box->storage->user;
exclude_list = fts_exclude_get_patterns(user);
if (exclude_list == NULL)
return FALSE;
set = mailbox_settings_find(mailbox_get_namespace(box),
mailbox_get_vname(box));
special_use = set == NULL ? NULL :
t_strsplit_spaces(set->special_use, " ");
for (i = 0; exclude_list[i] != NULL; i++) {
if (exclude_list[i][0] == '\\') {
/* \Special-use flag */
if (str_array_icase_find(special_use, exclude_list[i]))
return TRUE;
} else {
/* mailbox name with wildcards */
if (wildcard_match(box->name, exclude_list[i]))
return TRUE;
}
}
return FALSE;
}
static int
index_storage_get_dict(struct mailbox *box, enum mail_attribute_type type,
struct dict **dict_r, const char **mailbox_prefix_r)
{
struct mail_storage *storage = box->storage;
struct mail_namespace *ns;
struct mailbox_metadata metadata;
struct dict_settings set;
const char *error;
if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0)
return -1;
*mailbox_prefix_r = guid_128_to_string(metadata.guid);
ns = mailbox_get_namespace(box);
if (type == MAIL_ATTRIBUTE_TYPE_PRIVATE) {
/* private attributes are stored in user's own dict */
return index_storage_get_user_dict(storage, storage->user, dict_r);
} else if (ns->user == ns->owner) {
/* user owns the mailbox. shared attributes are stored in
the same dict. */
return index_storage_get_user_dict(storage, storage->user, dict_r);
} else if (ns->owner != NULL) {
/* accessing shared attribute of a shared mailbox.
use the owner's dict. */
return index_storage_get_user_dict(storage, ns->owner, dict_r);
}
/* accessing shared attributes of a public mailbox. no user owns it,
so use the storage's dict. */
if (storage->_shared_attr_dict != NULL) {
*dict_r = storage->_shared_attr_dict;
return 0;
}
if (*storage->set->mail_attribute_dict == '\0') {
mail_storage_set_error(storage, MAIL_ERROR_NOTPOSSIBLE,
"Mailbox attributes not enabled");
return -1;
}
if (storage->shared_attr_dict_failed) {
mail_storage_set_internal_error(storage);
return -1;
}
memset(&set, 0, sizeof(set));
set.username = storage->user->username;
set.base_dir = storage->user->set->base_dir;
if (mail_user_get_home(storage->user, &set.home_dir) <= 0)
set.home_dir = NULL;
if (dict_init_full(storage->set->mail_attribute_dict, &set,
&storage->_shared_attr_dict, &error) < 0) {
mail_storage_set_critical(storage,
"mail_attribute_dict: dict_init(%s) failed: %s",
storage->set->mail_attribute_dict, error);
storage->shared_attr_dict_failed = TRUE;
return -1;
}
*dict_r = storage->_shared_attr_dict;
return 0;
}
static int mail_crypt_istream_get_private_key(const char *pubkey_digest,
struct dcrypt_private_key **priv_key_r,
const char **error_r,
void *context)
{
/* mailbox_crypt_search_all_private_keys requires error_r != NULL */
i_assert(error_r != NULL);
int ret;
struct mail *_mail = context;
struct mail_crypt_user *muser =
MAIL_CRYPT_USER_CONTEXT(_mail->box->storage->user);
i_assert(muser != NULL);
*priv_key_r = mail_crypt_global_key_find(&muser->global_keys,
pubkey_digest);
if (*priv_key_r != NULL) return 1;
struct mail_namespace *ns = mailbox_get_namespace(_mail->box);
if (ns->type == MAIL_NAMESPACE_TYPE_SHARED) {
ret = mail_crypt_box_get_shared_key(_mail->box, pubkey_digest,
priv_key_r, error_r);
} else if (ns->type != MAIL_NAMESPACE_TYPE_PUBLIC) {
ret = mail_crypt_get_private_key(_mail->box, pubkey_digest,
FALSE, FALSE, priv_key_r,
error_r);
} else {
*error_r = "Public emails cannot have keys";
ret = -1;
}
i_assert(ret <= 0 || *priv_key_r != NULL);
return ret;
}
static void pop3_migration_mail_allocated(struct mail *_mail)
{
struct pop3_migration_mail_storage *mstorage =
POP3_MIGRATION_CONTEXT(_mail->box->storage);
struct mail_private *mail = (struct mail_private *)_mail;
struct mail_vfuncs *v = mail->vlast;
union mail_module_context *mmail;
struct mail_namespace *ns;
if (mstorage == NULL ||
(!mstorage->all_mailboxes && !_mail->box->inbox_user)) {
/* assigns UIDLs only for INBOX */
return;
}
ns = mail_namespace_find(_mail->box->storage->user->namespaces,
mstorage->pop3_box_vname);
if (ns == mailbox_get_namespace(_mail->box)) {
/* we're accessing the pop3-migration namespace itself */
return;
}
mmail = p_new(mail->pool, union mail_module_context, 1);
mmail->super = *v;
mail->vlast = &mmail->super;
v->get_special = pop3_migration_get_special;
MODULE_CONTEXT_SET_SELF(mail, pop3_migration_mail_module, mmail);
}
static void *
replication_mail_transaction_begin(struct mailbox_transaction_context *t)
{
struct replication_mail_txn_context *ctx;
ctx = i_new(struct replication_mail_txn_context, 1);
ctx->ns = mailbox_get_namespace(t->box);
return ctx;
}
static void copy_update_trashed(struct client *client, struct mailbox *box,
unsigned int count)
{
const struct mailbox_settings *set;
set = mailbox_settings_find(mailbox_get_namespace(box),
mailbox_get_vname(box));
if (set != NULL && set->special_use[0] != '\0' &&
str_array_icase_find(t_strsplit_spaces(set->special_use, " "),
"\\Trash"))
client->trashed_count += count;
}
static const char *
fts_box_get_root(struct mailbox *box, struct mail_namespace **ns_r)
{
struct mail_namespace *ns = mailbox_get_namespace(box);
const char *name;
if (t_imap_utf8_to_utf7(box->name, &name) < 0)
i_unreached();
fts_box_name_get_root(&ns, &name);
*ns_r = ns;
return name;
}
