ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen

46552a931924c2d743f045e95b08c3ce6beda91aTimo Sirainen#include "lib.h"

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen#include "ioloop.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "array.h"

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen#include "llist.h"

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen#include "istream.h"

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen#include "eacces-error.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "mkdir-parents.h"

45155bb1250cf5a120278f349465aded513a100fTimo Sirainen#include "var-expand.h"

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen#include "mail-index-private.h"

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen#include "mail-index-alloc-cache.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "mailbox-list-private.h"

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen#include "mail-storage-private.h"

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen#include "mail-storage-settings.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "mail-namespace.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "mail-search.h"

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen#include "mail-search-register.h"

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen#include "mailbox-search-result-private.h"

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen#include <stdlib.h>

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen#include <ctype.h>

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen#define MAILBOX_DELETE_RETRY_SECS (60*5)

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainenextern struct mail_search_register *mail_search_register_imap;

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainenextern struct mail_search_register *mail_search_register_human;

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainenstruct mail_storage_module_register mail_storage_module_register = { 0 };

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainenstruct mail_module_register mail_module_register = { 0 };

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainenstruct mail_storage_mail_index_module mail_storage_mail_index_module =

9508ac436fff0e1dcea975855c139cd251deb703Timo Sirainen MODULE_CONTEXT_INIT(&mail_index_module_register);

ddbdc644a15f56f4b43596f1b8c0fc196c101445Timo SirainenARRAY_TYPE(mail_storage) mail_storage_classes;

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen

b55f914c0ade77252cfd798ea8eb9a84bda56315Timo Sirainenvoid mail_storage_init(void)

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen{

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen mailbox_lists_init();

493123e38ca1f27b07ac30dcbc59663c5fcdcba2Timo Sirainen mail_storage_hooks_init();

ddbdc644a15f56f4b43596f1b8c0fc196c101445Timo Sirainen i_array_init(&mail_storage_classes, 8);

ddbdc644a15f56f4b43596f1b8c0fc196c101445Timo Sirainen}

b55f914c0ade77252cfd798ea8eb9a84bda56315Timo Sirainen

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainenvoid mail_storage_deinit(void)

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen{

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen if (mail_search_register_human != NULL)

ddbdc644a15f56f4b43596f1b8c0fc196c101445Timo Sirainen mail_search_register_deinit(&mail_search_register_human);

ddbdc644a15f56f4b43596f1b8c0fc196c101445Timo Sirainen if (mail_search_register_imap != NULL)

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen mail_search_register_deinit(&mail_search_register_imap);

89795c6bbbc52bb382e88bc8617d22092223e9a5Timo Sirainen if (array_is_created(&mail_storage_classes))

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen array_free(&mail_storage_classes);

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen mail_storage_hooks_deinit();

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen mailbox_lists_deinit();

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen}

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainenvoid mail_storage_class_register(struct mail_storage *storage_class)

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen{

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen i_assert(mail_storage_find_class(storage_class->name) == NULL);

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen /* append it after the list, so the autodetection order is correct */

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen array_append(&mail_storage_classes, &storage_class, 1);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen}

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenvoid mail_storage_class_unregister(struct mail_storage *storage_class)

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen{

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen struct mail_storage *const *classes;

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen unsigned int i, count;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen classes = array_get(&mail_storage_classes, &count);

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen for (i = 0; i < count; i++) {

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen if (classes[i] == storage_class) {

686ad6d723004b807fd558f3ef9d1f88afa7e127Timo Sirainen array_delete(&mail_storage_classes, i, 1);

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen break;

686ad6d723004b807fd558f3ef9d1f88afa7e127Timo Sirainen }

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen }

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen}

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenstruct mail_storage *mail_storage_find_class(const char *name)

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen{

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen struct mail_storage *const *classes;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen unsigned int i, count;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen i_assert(name != NULL);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen classes = array_get(&mail_storage_classes, &count);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen for (i = 0; i < count; i++) {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen if (strcasecmp(classes[i]->name, name) == 0)

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return classes[i];

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen }

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return NULL;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen}

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenstatic struct mail_storage *

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenmail_storage_autodetect(const struct mail_namespace *ns,

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen struct mailbox_list_settings *set)

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen{

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen struct mail_storage *const *classes;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen unsigned int i, count;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen classes = array_get(&mail_storage_classes, &count);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen for (i = 0; i < count; i++) {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen if (classes[i]->v.autodetect != NULL) {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen if (classes[i]->v.autodetect(ns, set))

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return classes[i];

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen }

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen }

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return NULL;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen}

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainenstatic void

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainenmail_storage_set_autodetection(const char **data, const char **driver)

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen{

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen const char *p;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen /* check if data is in driver:data format (eg. mbox:~/mail) */

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen p = *data;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen while (i_isalnum(*p)) p++;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (*p == ':' && p != *data) {

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen /* no autodetection if the storage driver is given. */

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen *driver = t_strdup_until(*data, p);

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen *data = p + 1;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen }

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen}

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen

53d564c421ca7292d7b1bd945f86894a34b75370Timo Sirainenstatic struct mail_storage *

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainenmail_storage_get_class(struct mail_namespace *ns, const char *driver,

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen struct mailbox_list_settings *list_set,

53d564c421ca7292d7b1bd945f86894a34b75370Timo Sirainen enum mail_storage_flags flags, const char **error_r)

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen{

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen struct mail_storage *storage_class = NULL;

53d564c421ca7292d7b1bd945f86894a34b75370Timo Sirainen const char *home;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (driver != NULL) {

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen storage_class = mail_storage_find_class(driver);

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen if (storage_class == NULL) {

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen *error_r = t_strdup_printf(

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen "Unknown mail storage driver %s", driver);

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen return NULL;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen }

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen }

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen if (list_set->root_dir == NULL || *list_set->root_dir == '\0') {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen /* no root directory given. is this allowed? */

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen const struct mailbox_list *list;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen list = list_set->layout == NULL ? NULL :

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen mailbox_list_find_class(list_set->layout);

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen if (storage_class == NULL &&

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen (flags & MAIL_STORAGE_FLAG_NO_AUTODETECTION) == 0) {

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen /* autodetection should take care of this */

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen } else if (list != NULL &&

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen (list->props & MAILBOX_LIST_PROP_NO_ROOT) != 0) {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen /* root not required for this layout */

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen } else {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen *error_r = "Root mail directory not given";

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen return NULL;

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen }

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen }

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen if (storage_class != NULL) {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen storage_class->v.get_list_settings(ns, list_set);

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen return storage_class;

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen }

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen storage_class = mail_storage_autodetect(ns, list_set);

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen if (storage_class != NULL)

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen return storage_class;

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen if (ns->set->location == NULL || *ns->set->location == '\0') {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen (void)mail_user_get_home(ns->user, &home);

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen if (home == NULL || *home == '\0') home = "(not set)";

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen *error_r = t_strdup_printf(

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen "Mail storage autodetection failed with home=%s", home);

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen } else {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen *error_r = t_strdup_printf(

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen "Ambiguous mail location setting, "

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen "don't know what to do with it: %s "

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen "(try prefixing it with mbox: or maildir:)",

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen ns->set->location);

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen }

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen return NULL;

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen}

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainenstatic int

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainenmail_storage_create_root(struct mailbox_list *list,

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen enum mail_storage_flags flags, const char **error_r)

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen{

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen const char *root_dir, *origin;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen struct stat st;

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen mode_t mode;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen gid_t gid;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen root_dir = mailbox_list_get_path(list, NULL,

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen MAILBOX_LIST_PATH_TYPE_MAILBOX);

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen if (root_dir == NULL) {

feb665db52583259a1f42037c6e8a22852aa8889Timo Sirainen /* storage doesn't use directories (e.g. shared root) */

9bc0204ec8bda657ce2e96e6ae715e4034f1538bTimo Sirainen return 0;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen }

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (stat(root_dir, &st) == 0) {

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen /* ok */

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen return 0;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen } else if (errno == EACCES) {

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen *error_r = mail_error_eacces_msg("stat", root_dir);

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen return -1;

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen } else if (errno != ENOENT && errno != ENOTDIR) {

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen *error_r = t_strdup_printf("stat(%s) failed: %m", root_dir);

8372fc7efb6d64dff2e5f55fb4a3822c56869cfeTimo Sirainen return -1;

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen } else if (list->ns->type == NAMESPACE_SHARED) {

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen /* can't create a new user, but we don't want to fail

27d50b3aa143964143e4bef66c0bfe3c72aea233Timo Sirainen } else if ((flags & MAIL_STORAGE_FLAG_NO_AUTOCREATE) != 0) {

27d50b3aa143964143e4bef66c0bfe3c72aea233Timo Sirainen *error_r = t_strdup_printf(

9c47edf0d1aa8afa6d05dde93e7aa5169059c94aTimo Sirainen "Root mail directory doesn't exist: %s", root_dir);

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen return -1;

9c47edf0d1aa8afa6d05dde93e7aa5169059c94aTimo Sirainen }

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen /* we need to create the root directory. */

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen mailbox_list_get_dir_permissions(list, NULL, &mode, &gid, &origin);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen if (mkdir_parents_chgrp(root_dir, mode, gid, origin) < 0 &&

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen errno != EEXIST) {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen *error_r = mail_error_create_eacces_msg("mkdir", root_dir);

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return -1;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen } else {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen /* created */

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen return 0;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen }

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen}

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenstatic struct mail_storage *

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainenmail_storage_find(struct mail_user *user,

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen const struct mail_storage *storage_class,

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen const struct mailbox_list_settings *set)

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen{

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen struct mail_storage *storage = user->storages;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen for (; storage != NULL; storage = storage->next) {

d229d26d263a57a77eec8fe7cba24fbfd9509966Timo Sirainen if (strcmp(storage->name, storage_class->name) == 0 &&

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen ((storage->class_flags &

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen MAIL_STORAGE_CLASS_FLAG_UNIQUE_ROOT) == 0 ||

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen strcmp(storage->unique_root_dir, set->root_dir) == 0))

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen return storage;

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen }

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen return NULL;

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen}

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainenint mail_storage_create(struct mail_namespace *ns, const char *driver,

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen enum mail_storage_flags flags, const char **error_r)

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen{

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen struct mail_storage *storage_class, *storage = NULL;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen struct mailbox_list_settings list_set;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen enum mailbox_list_flags list_flags = 0;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen const char *data = ns->set->location;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen const char *p;

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen if ((flags & MAIL_STORAGE_FLAG_KEEP_HEADER_MD5) == 0 &&

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen ns->mail_set->pop3_uidl_format != NULL) {

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen /* if pop3_uidl_format contains %m, we want to keep the

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen p = ns->mail_set->pop3_uidl_format;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen while ((p = strchr(p, '%')) != NULL) {

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen if (p[1] == '%')

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen p += 2;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen else if (var_get_key(++p) == 'm') {

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen flags |= MAIL_STORAGE_FLAG_KEEP_HEADER_MD5;

1093de32efb2a231949566d4bd8aa55a8f43fb70Timo Sirainen break;

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen }

e95dba8921087afebb8a92c592af3b8ca22ae796Timo Sirainen }

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen }

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen memset(&list_set, 0, sizeof(list_set));

8e50329e2c5e3a199674ae9f6d3dfcddab02487bTimo Sirainen if (data == NULL) {

be71a9de88d1266597eb8c5e0b6f519d90e14397Timo Sirainen /* autodetect */

e2a88d59c0d47d63ce1ad5b1fd95e487124a3fd4Timo Sirainen } else if (driver != NULL && strcmp(driver, "shared") == 0) {

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen /* internal shared namespace */

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen list_set.root_dir = ns->user->set->base_dir;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen } else {

eb188b2a2d5395b2c6125f875ec053b04a10e5fbTimo Sirainen if (driver == NULL)

ccef83820a01bb37ad48653a05a9c5aa6560826aTimo Sirainen mail_storage_set_autodetection(&data, &driver);

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen if (mailbox_list_settings_parse(ns->user, data, &list_set,

ac45ba9c603b67cc43fa7bceffdef0a19100720bTimo Sirainen error_r) < 0)

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen return -1;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen }

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen storage_class = mail_storage_get_class(ns, driver, &list_set, flags,

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen error_r);

6e8ad595d0603295f57bef576da8a3a00b55c5e2Timo Sirainen if (storage_class == NULL)

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen return -1;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen i_assert(list_set.layout != NULL);

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen if (ns->list == NULL) {

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen /* first storage for namespace */

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen if (mail_storage_is_mailbox_file(storage_class))

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen list_flags |= MAILBOX_LIST_FLAG_MAILBOX_FILES;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen if (mailbox_list_create(list_set.layout, ns, &list_set,

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen list_flags, error_r) < 0) {

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen *error_r = t_strdup_printf("Mailbox list driver %s: %s",

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen list_set.layout, *error_r);

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen return -1;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen }

00fa8dcbc66f56daa737487c9dec7166c37de79eTimo Sirainen if (mail_storage_create_root(ns->list, flags, error_r) < 0)

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen return -1;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen }

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen storage = mail_storage_find(ns->user, storage_class, &list_set);

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen if (storage != NULL) {

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen /* using an existing storage */

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen storage->refcount++;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen mail_namespace_add_storage(ns, storage);

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen return 0;

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen }

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen storage = storage_class->v.alloc();

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen storage->refcount = 1;

e3a838c80f54f024115fade93c6c87a0998f1fabTimo Sirainen storage->storage_class = storage_class;

80980955bb1bbcc1bd73623fe0912f334194ddd2Timo Sirainen storage->user = ns->user;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen storage->set = ns->mail_set;

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen storage->flags = flags;

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen p_array_init(&storage->module_contexts, storage->pool, 5);

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (storage->v.create != NULL &&

3cb26db7f4756b71ba06c6e4950fa4f8ce7fad66Timo Sirainen storage->v.create(storage, ns, error_r) < 0) {

31750e7fddc514c68c4eaf85b4f8c00000c281e0Timo Sirainen *error_r = t_strdup_printf("%s: %s", storage->name, *error_r);

31750e7fddc514c68c4eaf85b4f8c00000c281e0Timo Sirainen pool_unref(&storage->pool);

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen return -1;

31750e7fddc514c68c4eaf85b4f8c00000c281e0Timo Sirainen }

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen T_BEGIN {

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen hook_mail_storage_created(storage);

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen } T_END;

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen DLLIST_PREPEND(&ns->user->storages, storage);

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen mail_namespace_add_storage(ns, storage);

00fa8dcbc66f56daa737487c9dec7166c37de79eTimo Sirainen return 0;

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainen}

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen

087eb3d719a5667631cc7ce9de6c372ddea19f4dTimo Sirainenvoid mail_storage_unref(struct mail_storage **_storage)

9c47edf0d1aa8afa6d05dde93e7aa5169059c94aTimo Sirainen{

9c47edf0d1aa8afa6d05dde93e7aa5169059c94aTimo Sirainen struct mail_storage *storage = *_storage;

9c47edf0d1aa8afa6d05dde93e7aa5169059c94aTimo Sirainen

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen i_assert(storage->refcount > 0);

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen /* set *_storage=NULL only after calling destroy() callback.

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (--storage->refcount > 0) {

f30577ff7cf29858f1878abe963b4f40a436434fTimo Sirainen *_storage = NULL;

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen return;

d7cd49f01fad7c87c5a0865ebf54a548275e9feeTimo Sirainen }

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen

e248fe370c4047cee921a91b48edc37944ab0526Timo Sirainen if (storage->obj_refcount != 0)

3612ee5c737954d5fb88fd1775aad80f7bf1dc4eTimo Sirainen i_panic("Trying to deinit storage before freeing its objects");

ba90e657bc68a72ab3b3021e2f4a874fac9965baTimo Sirainen

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen DLLIST_REMOVE(&storage->user->storages, storage);

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen if (storage->v.destroy != NULL)

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen storage->v.destroy(storage);

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen i_free(storage->error_string);

9f627b360ed38fdc54cb02ec5e67246c3f0d5b0fTimo Sirainen

*_storage = NULL;

pool_unref(&storage->pool);

mail_index_alloc_cache_destroy_unrefed();

}

void mail_storage_obj_ref(struct mail_storage *storage)

{

i_assert(storage->refcount > 0);

storage->obj_refcount++;

}

void mail_storage_obj_unref(struct mail_storage *storage)

{

i_assert(storage->refcount > 0);

i_assert(storage->obj_refcount > 0);

storage->obj_refcount--;

}

void mail_storage_clear_error(struct mail_storage *storage)

{

i_free_and_null(storage->error_string);

storage->error = MAIL_ERROR_NONE;

}

void mail_storage_set_error(struct mail_storage *storage,

enum mail_error error, const char *string)

{

i_free(storage->error_string);

storage->error_string = i_strdup(string);

storage->error = error;

}

void mail_storage_set_internal_error(struct mail_storage *storage)

{

struct tm *tm;

char str[256];

tm = localtime(&ioloop_time);

i_free(storage->error_string);

storage->error_string =

strftime(str, sizeof(str),

MAIL_ERRSTR_CRITICAL_MSG_STAMP, tm) > 0 ?

i_strdup(str) : i_strdup(MAIL_ERRSTR_CRITICAL_MSG);

storage->error = MAIL_ERROR_TEMP;

}

void mail_storage_set_critical(struct mail_storage *storage,

const char *fmt, ...)

{

va_list va;

mail_storage_clear_error(storage);

if (fmt != NULL) {

va_start(va, fmt);

i_error("%s", t_strdup_vprintf(fmt, va));

va_end(va);

/* critical errors may contain sensitive data, so let user

mail_storage_set_internal_error(storage);

}

}

void mail_storage_copy_list_error(struct mail_storage *storage,

struct mailbox_list *list)

{

const char *str;

enum mail_error error;

str = mailbox_list_get_last_error(list, &error);

mail_storage_set_error(storage, error, str);

}

void mail_storage_set_index_error(struct mailbox *box)

{

if (mail_index_is_deleted(box->index))

mailbox_set_deleted(box);

else

mail_storage_set_internal_error(box->storage);

mail_index_reset_error(box->index);

}

const struct mail_storage_settings *

mail_storage_get_settings(struct mail_storage *storage)

{

return storage->set;

}

struct mail_user *mail_storage_get_user(struct mail_storage *storage)

{

return storage->user;

}

void mail_storage_set_callbacks(struct mail_storage *storage,

struct mail_storage_callbacks *callbacks,

void *context)

{

storage->callbacks = *callbacks;

storage->callback_context = context;

}

int mail_storage_purge(struct mail_storage *storage)

{

return storage->v.purge == NULL ? 0 :

storage->v.purge(storage);

}

const char *mail_storage_get_last_error(struct mail_storage *storage,

enum mail_error *error_r)

{

/* We get here only in error situations, so we have to return some

if (storage->error == MAIL_ERROR_NONE) {

if (error_r != NULL)

*error_r = MAIL_ERROR_TEMP;

return storage->error_string != NULL ? storage->error_string :

"BUG: Unknown internal error";

}

if (storage->error_string == NULL) {

/* This shouldn't happen.. */

storage->error_string =

i_strdup_printf("BUG: Unknown 0x%x error",

storage->error);

}

if (error_r != NULL)

*error_r = storage->error;

return storage->error_string;

}

bool mail_storage_is_mailbox_file(struct mail_storage *storage)

{

return (storage->class_flags &

MAIL_STORAGE_CLASS_FLAG_MAILBOX_IS_FILE) != 0;

}

bool mail_storage_set_error_from_errno(struct mail_storage *storage)

{

const char *error_string;

enum mail_error error;

if (!mail_error_from_errno(&error, &error_string))

return FALSE;

if (storage->set->mail_debug && error != MAIL_ERROR_NOTFOUND) {

/* debugging is enabled - admin may be debugging a

return FALSE;

}

mail_storage_set_error(storage, error, error_string);

return TRUE;

}

struct mailbox *mailbox_alloc(struct mailbox_list *list, const char *name,

enum mailbox_flags flags)

{

struct mailbox_list *new_list = list;

struct mail_storage *storage;

struct mailbox *box;

if (mailbox_list_get_storage(&new_list, &name, &storage) < 0) {

/* just use the first storage. FIXME: does this break? */

storage = list->ns->storage;

}

T_BEGIN {

box = storage->v.mailbox_alloc(storage, new_list, name, flags);

hook_mailbox_allocated(box);

} T_END;

mail_storage_obj_ref(box->storage);

return box;

}

static int mailbox_open_full(struct mailbox *box, struct istream *input)

{

int ret;

if (box->opened)

return 0;

if (!mailbox_list_is_valid_existing_name(box->list, box->name)) {

mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,

"Invalid mailbox name");

return -1;

}

if (input != NULL) {

if ((box->storage->class_flags &

MAIL_STORAGE_CLASS_FLAG_OPEN_STREAMS) == 0) {

mail_storage_set_critical(box->storage,

"Storage doesn't support streamed mailboxes");

return -1;

}

box->input = input;

box->flags |= MAILBOX_FLAG_READONLY;

i_stream_ref(box->input);

}

T_BEGIN {

ret = box->v.open(box);

} T_END;

if (ret < 0 && box->storage->error == MAIL_ERROR_NOTFOUND &&

box->input == NULL && box->inbox_user) T_BEGIN {

/* INBOX should always exist. try to create it and retry. */

(void)mailbox_create(box, NULL, FALSE);

mailbox_close(box);

ret = box->v.open(box);

if (ret < 0 && !box->storage->user->inbox_open_error_logged) {

box->storage->user->inbox_open_error_logged = TRUE;

i_error("Opening INBOX failed: %s",

mail_storage_get_last_error(box->storage, NULL));

}

} T_END;

if (ret < 0) {

if (box->input != NULL)

i_stream_unref(&box->input);

return -1;

}

box->list->ns->flags |= NAMESPACE_FLAG_USABLE;

return 0;

}

int mailbox_open(struct mailbox *box)

{

return mailbox_open_full(box, NULL);

}

int mailbox_open_stream(struct mailbox *box, struct istream *input)

{

return mailbox_open_full(box, input);

}

int mailbox_enable(struct mailbox *box, enum mailbox_feature features)

{

return box->v.enable(box, features);

}

enum mailbox_feature mailbox_get_enabled_features(struct mailbox *box)

{

return box->enabled_features;

}

void mailbox_close(struct mailbox *box)

{

if (!box->opened)

return;

if (box->transaction_count != 0) {

i_panic("Trying to close mailbox %s with open transactions",

box->name);

}

box->v.close(box);

box->opened = FALSE;

box->mailbox_deleted = FALSE;

box->backend_readonly = FALSE;

array_clear(&box->search_results);

}

void mailbox_free(struct mailbox **_box)

{

struct mailbox *box = *_box;

*_box = NULL;

mailbox_close(box);

box->v.free(box);

mail_storage_obj_unref(box->storage);

pool_unref(&box->pool);

}

int mailbox_create(struct mailbox *box, const struct mailbox_update *update,

bool directory)

{

if (!mailbox_list_is_valid_create_name(box->list, box->name)) {

mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,

"Invalid mailbox name");

return -1;

}

if (box->list->v.create_mailbox_dir(box->list, box->name,

directory) < 0) {

mail_storage_copy_list_error(box->storage, box->list);

return -1;

}

mailbox_refresh_permissions(box);

return box->v.create(box, update, directory);

}

int mailbox_update(struct mailbox *box, const struct mailbox_update *update)

{

return box->v.update(box, update);

}

int mailbox_mark_index_deleted(struct mailbox *box, bool del)

{

enum mail_index_transaction_flags trans_flags = 0;

struct mail_index_transaction *trans;

trans_flags = del ? 0 : MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL;

trans = mail_index_transaction_begin(box->view, trans_flags);

if (del)

mail_index_set_deleted(trans);

else

mail_index_set_undeleted(trans);

if (mail_index_transaction_commit(&trans) < 0) {

mail_storage_set_index_error(box);

return -1;

}

/* sync the mailbox. this finishes the index deletion and it can

return mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ);

}

static bool mailbox_try_undelete(struct mailbox *box)

{

time_t mtime;

if (mail_index_get_modification_time(box->index, &mtime) < 0)

return FALSE;

if (mtime + MAILBOX_DELETE_RETRY_SECS > time(NULL))

return FALSE;

if (mailbox_mark_index_deleted(box, FALSE) < 0)

return FALSE;

box->mailbox_deleted = FALSE;

return TRUE;

}

int mailbox_delete(struct mailbox *box)

{

enum mail_error error;

int ret;

if (*box->name == '\0') {

mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,

"Storage root can't be deleted");

return -1;

}

if (box->inbox_any) {

mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,

"INBOX can't be deleted.");

return -1;

}

box->deleting = TRUE;

if (mailbox_open(box) < 0) {

(void)mail_storage_get_last_error(box->storage, &error);

if (error != MAIL_ERROR_NOTFOUND)

return -1;

if (!box->mailbox_deleted) {

/* \noselect mailbox */

} else {

/* if deletion happened a long time ago, it means it

if (!mailbox_try_undelete(box))

return -1;

/* retry */

if (mailbox_open(box) < 0)

return -1;

}

}

ret = box->v.delete(box);

box->deleting = FALSE;

mailbox_close(box);

return ret;

}

static bool

mail_storages_rename_compatible(struct mail_storage *storage1,

struct mail_storage *storage2)

{

if (storage1 == storage2)

return TRUE;

if (strcmp(storage1->name, storage2->name) != 0)

return FALSE;

if ((storage1->class_flags & MAIL_STORAGE_CLASS_FLAG_UNIQUE_ROOT) != 0)

return FALSE;

return TRUE;

}

static bool nullequals(const void *p1, const void *p2)

{

return (p1 == NULL && p2 == NULL) || (p1 != NULL && p2 != NULL);

}

static bool

mailbox_lists_rename_compatible(struct mailbox_list *list1,

struct mailbox_list *list2)

{

return nullequals(list1->set.alt_dir, list2->set.alt_dir) &&

nullequals(list1->set.index_dir, list2->set.index_dir) &&

nullequals(list1->set.control_dir, list2->set.control_dir);

}

int mailbox_rename(struct mailbox *src, struct mailbox *dest,

bool rename_children)

{

if (!mailbox_list_is_valid_existing_name(src->list, src->name) ||

*src->name == '\0' ||

!mailbox_list_is_valid_create_name(dest->list, dest->name)) {

mail_storage_set_error(src->storage, MAIL_ERROR_PARAMS,

"Invalid mailbox name");

return -1;

}

if (!mail_storages_rename_compatible(src->storage, dest->storage) ||

!mailbox_lists_rename_compatible(src->list, dest->list)) {

mail_storage_set_error(src->storage, MAIL_ERROR_NOTPOSSIBLE,

"Can't rename mailboxes across specified storages.");

return -1;

}

if (src->list->ns->type != NAMESPACE_PRIVATE ||

dest->list->ns->type != NAMESPACE_PRIVATE) {

mail_storage_set_error(src->storage, MAIL_ERROR_NOTPOSSIBLE,

"Renaming not supported across non-private namespaces.");

return -1;

}

return src->v.rename(src, dest, rename_children);

}

struct mail_storage *mailbox_get_storage(const struct mailbox *box)

{

return box->storage;

}

struct mail_namespace *

mailbox_get_namespace(const struct mailbox *box)

{

return box->list->ns;

}

const struct mail_storage_settings *mailbox_get_settings(struct mailbox *box)

{

return box->storage->set;

}

const char *mailbox_get_name(const struct mailbox *box)

{

return box->name;

}

const char *mailbox_get_vname(const struct mailbox *box)

{

return box->vname;

}

bool mailbox_is_readonly(struct mailbox *box)

{

return box->v.is_readonly(box);

}

bool mailbox_allow_new_keywords(struct mailbox *box)

{

return box->v.allow_new_keywords(box);

}

bool mailbox_backends_equal(const struct mailbox *box1,

const struct mailbox *box2)

{

struct mail_namespace *ns1 = box1->list->ns, *ns2 = box2->list->ns;

if (strcmp(box1->name, box2->name) != 0)

return FALSE;

while (ns1->alias_for != NULL)

ns1 = ns1->alias_for;

while (ns2->alias_for != NULL)

ns2 = ns2->alias_for;

return ns1 == ns2;

}

void mailbox_get_status(struct mailbox *box,

enum mailbox_status_items items,

struct mailbox_status *status_r)

{

box->v.get_status(box, items, status_r);

}

int mailbox_get_guid(struct mailbox *box, uint8_t guid[MAIL_GUID_128_SIZE])

{

if (box->v.get_guid == NULL) {

mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,

"Storage doesn't support mailbox GUIDs");

}

if (!box->opened) {

if (mailbox_open(box) < 0)

return -1;

}

if (box->v.get_guid(box, guid) < 0)

return -1;

i_assert(!mail_guid_128_is_empty(guid));

return 0;

}

struct mailbox_sync_context *

mailbox_sync_init(struct mailbox *box, enum mailbox_sync_flags flags)

{

struct mailbox_sync_context *ctx;

if (box->transaction_count != 0) {

i_panic("Trying to sync mailbox %s with open transactions",

box->name);

}

T_BEGIN {

ctx = box->v.sync_init(box, flags);

} T_END;

return ctx;

}

bool mailbox_sync_next(struct mailbox_sync_context *ctx,

struct mailbox_sync_rec *sync_rec_r)

{

return ctx->box->v.sync_next(ctx, sync_rec_r);

}

int mailbox_sync_deinit(struct mailbox_sync_context **_ctx,

struct mailbox_sync_status *status_r)

{

struct mailbox_sync_context *ctx = *_ctx;

struct mailbox *box = ctx->box;

const char *errormsg;

enum mail_error error;

int ret;

*_ctx = NULL;

memset(status_r, 0, sizeof(*status_r));

ret = box->v.sync_deinit(ctx, status_r);

if (ret < 0 && box->inbox_user &&

!box->storage->user->inbox_open_error_logged) {

errormsg = mail_storage_get_last_error(box->storage, &error);

if (error == MAIL_ERROR_NOTPOSSIBLE) {

box->storage->user->inbox_open_error_logged = TRUE;

i_error("Syncing INBOX failed: %s", errormsg);

}

}

return ret;

}

int mailbox_sync(struct mailbox *box, enum mailbox_sync_flags flags)

{

struct mailbox_sync_context *ctx;

struct mailbox_sync_status status;

if (array_count(&box->search_results) == 0) {

/* we don't care about mailbox's current state, so we might

flags |= MAILBOX_SYNC_FLAG_FIX_INCONSISTENT;

}

ctx = mailbox_sync_init(box, flags);

return mailbox_sync_deinit(&ctx, &status);

}

#undef mailbox_notify_changes

void mailbox_notify_changes(struct mailbox *box, unsigned int min_interval,

mailbox_notify_callback_t *callback, void *context)

{

box->notify_min_interval = min_interval;

box->notify_callback = callback;

box->notify_context = context;

box->v.notify_changes(box);

}

void mailbox_notify_changes_stop(struct mailbox *box)

{

mailbox_notify_changes(box, 0, NULL, NULL);

}

int mailbox_keywords_create(struct mailbox *box, const char *const keywords[],

struct mail_keywords **keywords_r)

{

const char *empty_keyword_list = NULL;

if (keywords == NULL)

keywords = &empty_keyword_list;

return box->v.keywords_create(box, keywords, keywords_r, FALSE);

}

struct mail_keywords *

mailbox_keywords_create_valid(struct mailbox *box,

const char *const keywords[])

{

const char *empty_keyword_list = NULL;

struct mail_keywords *kw;

if (keywords == NULL)

keywords = &empty_keyword_list;

if (box->v.keywords_create(box, keywords, &kw, TRUE) < 0)

i_unreached();

return kw;

}

struct mail_keywords *

mailbox_keywords_create_from_indexes(struct mailbox *box,

const ARRAY_TYPE(keyword_indexes) *idx)

{

return box->v.keywords_create_from_indexes(box, idx);

}

void mailbox_keywords_ref(struct mailbox *box, struct mail_keywords *keywords)

{

box->v.keywords_ref(keywords);

}

void mailbox_keywords_unref(struct mailbox *box,

struct mail_keywords **_keywords)

{

struct mail_keywords *keywords = *_keywords;

*_keywords = NULL;

box->v.keywords_unref(keywords);

}

bool mailbox_keyword_is_valid(struct mailbox *box, const char *keyword,

const char **error_r)

{

return box->v.keyword_is_valid(box, keyword, error_r);

}

void mailbox_get_seq_range(struct mailbox *box, uint32_t uid1, uint32_t uid2,

uint32_t *seq1_r, uint32_t *seq2_r)

{

box->v.get_seq_range(box, uid1, uid2, seq1_r, seq2_r);

}

void mailbox_get_uid_range(struct mailbox *box,

const ARRAY_TYPE(seq_range) *seqs,

ARRAY_TYPE(seq_range) *uids)

{

box->v.get_uid_range(box, seqs, uids);

}

bool mailbox_get_expunges(struct mailbox *box, uint64_t prev_modseq,

const ARRAY_TYPE(seq_range) *uids_filter,

ARRAY_TYPE(mailbox_expunge_rec) *expunges)

{

return box->v.get_expunges(box, prev_modseq,

uids_filter, expunges);

}

bool mailbox_get_virtual_uid(struct mailbox *box, const char *backend_mailbox,

uint32_t backend_uidvalidity,

uint32_t backend_uid, uint32_t *uid_r)

{

if (box->v.get_virtual_uid == NULL)

return FALSE;

return box->v.get_virtual_uid(box, backend_mailbox, backend_uidvalidity,

backend_uid, uid_r);

}

void mailbox_get_virtual_backend_boxes(struct mailbox *box,

ARRAY_TYPE(mailboxes) *mailboxes,

bool only_with_msgs)

{

if (box->v.get_virtual_backend_boxes == NULL)

array_append(mailboxes, &box, 1);

else

box->v.get_virtual_backend_boxes(box, mailboxes, only_with_msgs);

}

void mailbox_get_virtual_box_patterns(struct mailbox *box,

ARRAY_TYPE(mailbox_virtual_patterns) *includes,

ARRAY_TYPE(mailbox_virtual_patterns) *excludes)

{

if (box->v.get_virtual_box_patterns == NULL) {

struct mailbox_virtual_pattern pat;

memset(&pat, 0, sizeof(pat));

pat.ns = box->list->ns;

pat.pattern = box->name;

array_append(includes, &pat, 1);

} else {

box->v.get_virtual_box_patterns(box, includes, excludes);

}

}

struct mailbox_header_lookup_ctx *

mailbox_header_lookup_init(struct mailbox *box, const char *const headers[])

{

return box->v.header_lookup_init(box, headers);

}

void mailbox_header_lookup_ref(struct mailbox_header_lookup_ctx *ctx)

{

i_assert(ctx->refcount > 0);

ctx->refcount++;

}

void mailbox_header_lookup_unref(struct mailbox_header_lookup_ctx **_ctx)

{

struct mailbox_header_lookup_ctx *ctx = *_ctx;

*_ctx = NULL;

i_assert(ctx->refcount > 0);

if (--ctx->refcount > 0)

return;

ctx->box->v.header_lookup_deinit(ctx);

}

struct mail_search_context *

mailbox_search_init(struct mailbox_transaction_context *t,

struct mail_search_args *args,

const enum mail_sort_type *sort_program)

{

mail_search_args_ref(args);

if (!args->simplified)

mail_search_args_simplify(args);

return t->box->v.search_init(t, args, sort_program);

}

int mailbox_search_deinit(struct mail_search_context **_ctx)

{

struct mail_search_context *ctx = *_ctx;

struct mail_search_args *args = ctx->args;

int ret;

*_ctx = NULL;

mailbox_search_results_initial_done(ctx);

ret = ctx->transaction->box->v.search_deinit(ctx);

mail_search_args_unref(&args);

return ret;

}

bool mailbox_search_next(struct mail_search_context *ctx, struct mail *mail)

{

bool tryagain;

while (!mailbox_search_next_nonblock(ctx, mail, &tryagain)) {

if (!tryagain)

return FALSE;

}

return TRUE;

}

bool mailbox_search_next_nonblock(struct mail_search_context *ctx,

struct mail *mail, bool *tryagain_r)

{

struct mailbox *box = ctx->transaction->box;

if (!box->v.search_next_nonblock(ctx, mail, tryagain_r))

return FALSE;

else {

mailbox_search_results_add(ctx, mail->uid);

return TRUE;

}

}

bool mailbox_search_seen_lost_data(struct mail_search_context *ctx)

{

return ctx->seen_lost_data;

}

int mailbox_search_result_build(struct mailbox_transaction_context *t,

struct mail_search_args *args,

enum mailbox_search_result_flags flags,

struct mail_search_result **result_r)

{

struct mail_search_context *ctx;

struct mail *mail;

int ret;

ctx = mailbox_search_init(t, args, NULL);

*result_r = mailbox_search_result_save(ctx, flags);

mail = mail_alloc(t, 0, NULL);

while (mailbox_search_next(ctx, mail)) ;

mail_free(&mail);

ret = mailbox_search_deinit(&ctx);

if (ret < 0)

mailbox_search_result_free(result_r);

return ret;

}

struct mailbox_transaction_context *

mailbox_transaction_begin(struct mailbox *box,

enum mailbox_transaction_flags flags)

{

struct mailbox_transaction_context *trans;

box->transaction_count++;

trans = box->v.transaction_begin(box, flags);

trans->flags = flags;

return trans;

}

int mailbox_transaction_commit(struct mailbox_transaction_context **t)

{

struct mail_transaction_commit_changes changes;

int ret;

/* Store changes temporarily so that plugins overriding

changes.pool = NULL;

ret = mailbox_transaction_commit_get_changes(t, &changes);

if (changes.pool != NULL)

pool_unref(&changes.pool);

return ret;

}

int mailbox_transaction_commit_get_changes(

struct mailbox_transaction_context **_t,

struct mail_transaction_commit_changes *changes_r)

{

struct mailbox_transaction_context *t = *_t;

int ret;

t->box->transaction_count--;

*_t = NULL;

T_BEGIN {

ret = t->box->v.transaction_commit(t, changes_r);

} T_END;

return ret;

}

void mailbox_transaction_rollback(struct mailbox_transaction_context **_t)

{

struct mailbox_transaction_context *t = *_t;

t->box->transaction_count--;

*_t = NULL;

t->box->v.transaction_rollback(t);

}

unsigned int mailbox_transaction_get_count(const struct mailbox *box)

{

return box->transaction_count;

}

void mailbox_transaction_set_max_modseq(struct mailbox_transaction_context *t,

uint64_t max_modseq,

ARRAY_TYPE(seq_range) *seqs)

{

t->box->v.transaction_set_max_modseq(t, max_modseq, seqs);

}

struct mailbox *

mailbox_transaction_get_mailbox(const struct mailbox_transaction_context *t)

{

return t->box;

}

struct mail_save_context *

mailbox_save_alloc(struct mailbox_transaction_context *t)

{

struct mail_save_context *ctx;

ctx = t->box->v.save_alloc(t);

ctx->received_date = (time_t)-1;

ctx->save_date = (time_t)-1;

return ctx;

}

void mailbox_save_set_flags(struct mail_save_context *ctx,

enum mail_flags flags,

struct mail_keywords *keywords)

{

ctx->flags = flags;

ctx->keywords = keywords;

if (keywords != NULL)

mailbox_keywords_ref(ctx->transaction->box, keywords);

}

void mailbox_save_copy_flags(struct mail_save_context *ctx, struct mail *mail)

{

const char *const *keywords_list;

keywords_list = mail_get_keywords(mail);

ctx->keywords = str_array_length(keywords_list) == 0 ? NULL :

mailbox_keywords_create_valid(ctx->transaction->box,

keywords_list);

ctx->flags = mail_get_flags(mail);

}

void mailbox_save_set_min_modseq(struct mail_save_context *ctx,

uint64_t min_modseq)

{

ctx->min_modseq = min_modseq;

}

void mailbox_save_set_received_date(struct mail_save_context *ctx,

time_t received_date, int timezone_offset)

{

ctx->received_date = received_date;

ctx->received_tz_offset = timezone_offset;

}

void mailbox_save_set_save_date(struct mail_save_context *ctx,

time_t save_date)

{

ctx->save_date = save_date;

}

void mailbox_save_set_from_envelope(struct mail_save_context *ctx,

const char *envelope)

{

i_free(ctx->from_envelope);

ctx->from_envelope = i_strdup(envelope);

}

void mailbox_save_set_uid(struct mail_save_context *ctx, uint32_t uid)

{

ctx->uid = uid;

}

void mailbox_save_set_guid(struct mail_save_context *ctx, const char *guid)