struct maildir_keywords *
maildir_keywords_init_readonly(struct mailbox *box)
{
struct maildir_keywords *mk;
const char *dir;
if (mailbox_get_path_to(box, MAILBOX_LIST_PATH_TYPE_CONTROL, &dir) <= 0)
i_unreached();
mk = i_new(struct maildir_keywords, 1);
mk->storage = box->storage;
mk->path = i_strconcat(dir, "/" MAILDIR_KEYWORDS_NAME, NULL);
mk->pool = pool_alloconly_create("maildir keywords", 512);
i_array_init(&mk->list, MAILDIR_MAX_KEYWORDS);
hash_table_create(&mk->hash, mk->pool, 0, strcase_hash, strcasecmp);
mk->dotlock_settings.use_excl_lock =
box->storage->set->dotlock_use_excl;
mk->dotlock_settings.nfs_flush =
box->storage->set->mail_nfs_storage;
mk->dotlock_settings.timeout =
mail_storage_get_lock_timeout(box->storage,
KEYWORDS_LOCK_STALE_TIMEOUT + 2);
mk->dotlock_settings.stale_timeout = KEYWORDS_LOCK_STALE_TIMEOUT;
mk->dotlock_settings.temp_prefix =
mailbox_list_get_temp_prefix(box->list);
return mk;
}
static int
mbox_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
const char **error_r)
{
struct mbox_storage *storage = (struct mbox_storage *)_storage;
struct stat st;
const char *dir;
if (master_service_get_client_limit(master_service) > 1) {
/* we can't handle locking related problems. */
*error_r = "mbox requires client_limit=1 for service";
return -1;
}
storage->set = mail_storage_get_driver_settings(_storage);
if (mailbox_list_get_root_path(ns->list, MAILBOX_LIST_PATH_TYPE_INDEX, &dir)) {
_storage->temp_path_prefix = p_strconcat(_storage->pool, dir,
"/", mailbox_list_get_temp_prefix(ns->list), NULL);
}
if (stat(ns->list->set.root_dir, &st) == 0 && !S_ISDIR(st.st_mode)) {
*error_r = t_strdup_printf(
"mbox root directory can't be a file: %s "
"(http://wiki2.dovecot.org/MailLocation/Mbox)",
ns->list->set.root_dir);
return -1;
}
return 0;
}
static const char *
imapc_list_get_temp_prefix(struct mailbox_list *_list, bool global)
{
struct imapc_mailbox_list *list = (struct imapc_mailbox_list *)_list;
struct mailbox_list *fs_list = imapc_list_get_fs(list);
if (fs_list != NULL) {
return global ?
mailbox_list_get_global_temp_prefix(fs_list) :
mailbox_list_get_temp_prefix(fs_list);
} else {
i_panic("imapc: Can't return a temp prefix for '%s'",
_list->ns->prefix);
return NULL;
}
}
storage->storage.pool = pool;
return &storage->storage;
}
static int
maildir_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
const char **error_r ATTR_UNUSED)
{
struct maildir_storage *storage = (struct maildir_storage *)_storage;
struct mailbox_list *list = ns->list;
const char *dir;
storage->set = mail_storage_get_driver_settings(_storage);
storage->temp_prefix = p_strdup(_storage->pool,
mailbox_list_get_temp_prefix(list));
if (list->set.control_dir == NULL && list->set.inbox_path == NULL &&
(ns->flags & NAMESPACE_FLAG_INBOX_ANY) != 0) {
/* put the temp files into tmp/ directory preferrably */
storage->temp_prefix = p_strconcat(_storage->pool, "tmp/",
storage->temp_prefix, NULL);
dir = mailbox_list_get_root_forced(list, MAILBOX_LIST_PATH_TYPE_DIR);
} else {
/* control dir should also be writable */
dir = mailbox_list_get_root_forced(list, MAILBOX_LIST_PATH_TYPE_CONTROL);
}
_storage->temp_path_prefix = p_strconcat(_storage->pool, dir, "/",
storage->temp_prefix, NULL);
return 0;
}
int mailbox_list_subscriptions_refresh(struct mailbox_list *src_list,
struct mailbox_list *dest_list)
{
struct subsfile_list_context *subsfile_ctx;
struct stat st;
enum mailbox_list_path_type type;
const char *path, *name;
char sep;
int ret;
/* src_list is subscriptions=yes, dest_list is subscriptions=no
(or the same as src_list) */
i_assert((src_list->ns->flags & NAMESPACE_FLAG_SUBSCRIPTIONS) != 0);
if (dest_list->subscriptions == NULL) {
sep = mail_namespace_get_sep(src_list->ns);
dest_list->subscriptions = mailbox_tree_init(sep);
}
type = src_list->set.control_dir != NULL ?
MAILBOX_LIST_PATH_TYPE_CONTROL : MAILBOX_LIST_PATH_TYPE_DIR;
if (!mailbox_list_get_root_path(src_list, type, &path) ||
src_list->set.subscription_fname == NULL) {
/* no subscriptions (e.g. pop3c) */
return 0;
}
path = t_strconcat(path, "/", src_list->set.subscription_fname, NULL);
if (stat(path, &st) < 0) {
if (errno == ENOENT) {
/* no subscriptions */
mailbox_tree_clear(dest_list->subscriptions);
dest_list->subscriptions_mtime = 0;
return 0;
}
mailbox_list_set_critical(dest_list, "stat(%s) failed: %m",
path);
return -1;
}
if (st.st_mtime == dest_list->subscriptions_mtime &&
st.st_mtime < dest_list->subscriptions_read_time-1) {
/* we're up to date */
return 0;
}
mailbox_tree_clear(dest_list->subscriptions);
dest_list->subscriptions_read_time = ioloop_time;
subsfile_ctx = subsfile_list_init(dest_list, path);
if (subsfile_list_fstat(subsfile_ctx, &st) == 0)
dest_list->subscriptions_mtime = st.st_mtime;
while ((name = subsfile_list_next(subsfile_ctx)) != NULL) T_BEGIN {
T_BEGIN {
ret = mailbox_list_subscription_fill_one(dest_list,
src_list, name);
} T_END;
if (ret < 0) {
i_warning("Subscriptions file %s: "
"Removing invalid entry: %s",
path, name);
(void)subsfile_set_subscribed(src_list, path,
mailbox_list_get_temp_prefix(src_list),
name, FALSE);
}
} T_END;
if (subsfile_list_deinit(&subsfile_ctx) < 0) {
dest_list->subscriptions_mtime = (time_t)-1;
return -1;
}
return 0;
}
