static void dsync_brain_check_namespaces(struct dsync_brain *brain)
{
struct mail_namespace *ns, *first_ns = NULL;
char sep;
i_assert(brain->hierarchy_sep == '\0');
if (brain->sync_ns != NULL) {
brain->hierarchy_sep = mail_namespace_get_sep(brain->sync_ns);
return;
}
for (ns = brain->user->namespaces; ns != NULL; ns = ns->next) {
if (!dsync_brain_want_namespace(brain, ns))
continue;
sep = mail_namespace_get_sep(ns);
if (first_ns == NULL) {
brain->hierarchy_sep = sep;
first_ns = ns;
} else if (brain->hierarchy_sep != sep) {
i_fatal("Synced namespaces have conflicting separators "
"('%c' for prefix=\"%s\", '%c' for prefix=\"%s\")",
brain->hierarchy_sep, first_ns->prefix,
sep, ns->prefix);
}
}
if (brain->hierarchy_sep != '\0')
return;
i_fatal("All your namespaces have a location setting. "
"Only namespaces with empty location settings are converted. "
"(One namespace should default to mail_location setting)");
}
static void
dsync_fix_mailbox_name(struct mail_namespace *ns, string_t *vname,
char alt_char)
{
const char *old_vname;
char *p, list_sep = mailbox_list_get_hierarchy_sep(ns->list);
guid_128_t guid;
/* replace control chars */
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if ((unsigned char)*p < ' ')
*p = alt_char;
}
/* make it valid UTF8 */
if (!uni_utf8_str_is_valid(str_c(vname))) {
old_vname = t_strdup(str_c(vname));
str_truncate(vname, 0);
if (uni_utf8_get_valid_data((const void *)old_vname,
strlen(old_vname), vname))
i_unreached();
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 1) change any real separators to alt separators (this wouldn't
be necessary with listescape, but don't bother detecting it) */
if (list_sep != mail_namespace_get_sep(ns)) {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == list_sep)
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 2) '/' characters aren't valid without listescape */
if (mail_namespace_get_sep(ns) != '/' && list_sep != '/') {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == '/')
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 3) probably some reserved name (e.g. dbox-Mails) */
str_insert(vname, ns->prefix_len, "_");
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 4) name is too long? just give up and generate a unique name */
guid_128_generate(guid);
str_truncate(vname, 0);
str_append(vname, ns->prefix);
str_append(vname, guid_128_to_string(guid));
i_assert(dsync_is_valid_name(ns, str_c(vname)));
}
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 bool
dsync_namespace_match_parts(struct mail_namespace *ns,
const char *const *name_parts)
{
const char *part, *prefix = ns->prefix;
unsigned int part_len;
char ns_sep = mail_namespace_get_sep(ns);
if ((ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
strcmp(name_parts[0], "INBOX") == 0 && name_parts[1] == NULL)
return TRUE;
for (; *name_parts != NULL && *prefix != '\0'; name_parts++) {
part = *name_parts;
part_len = strlen(part);
if (strncmp(prefix, part, part_len) != 0)
return FALSE;
if (prefix[part_len] != ns_sep)
return FALSE;
prefix += part_len + 1;
}
if (*name_parts != NULL) {
/* namespace prefix found with a mailbox */
return TRUE;
}
if (*prefix == '\0') {
/* namespace prefix itself matched */
return TRUE;
}
return FALSE;
}
struct mailbox_list_iterate_context *
mailbox_list_subscriptions_iter_init(struct mailbox_list *list,
const char *const *patterns,
enum mailbox_list_iter_flags flags)
{
struct subscriptions_mailbox_list_iterate_context *ctx;
pool_t pool;
char sep = mail_namespace_get_sep(list->ns);
pool = pool_alloconly_create("mailbox list subscriptions iter", 1024);
ctx = p_new(pool, struct subscriptions_mailbox_list_iterate_context, 1);
ctx->ctx.pool = pool;
ctx->ctx.list = list;
ctx->ctx.flags = flags;
ctx->ctx.glob = imap_match_init_multiple(pool, patterns, TRUE, sep);
array_create(&ctx->ctx.module_contexts, pool, sizeof(void *), 5);
ctx->tree = mailbox_tree_init(sep);
mailbox_list_subscriptions_fill(&ctx->ctx, ctx->tree, FALSE);
ctx->info.ns = list->ns;
/* the tree usually has only those entries we want to iterate through,
but there are also non-matching root entries (e.g. "LSUB foo/%" will
include the "foo"), which we'll drop with MAILBOX_MATCHED. */
ctx->iter = mailbox_tree_iterate_init(ctx->tree, NULL, MAILBOX_MATCHED);
return &ctx->ctx;
}
struct mailbox_list_iterate_context *
mailbox_list_index_iter_init(struct mailbox_list *list,
const char *const *patterns,
enum mailbox_list_iter_flags flags)
{
struct mailbox_list_index *ilist = INDEX_LIST_CONTEXT(list);
struct mailbox_list_index_iterate_context *ctx;
pool_t pool;
char ns_sep = mail_namespace_get_sep(list->ns);
pool = pool_alloconly_create("mailbox list index iter", 2048);
ctx = p_new(pool, struct mailbox_list_index_iterate_context, 1);
ctx->ctx.pool = pool;
ctx->ctx.list = list;
ctx->ctx.flags = flags;
ctx->ctx.glob = imap_match_init_multiple(pool, patterns, TRUE, ns_sep);
array_create(&ctx->ctx.module_contexts, pool, sizeof(void *), 5);
ctx->info_pool = pool_alloconly_create("mailbox list index iter info", 128);
if (!iter_use_index(ctx)) {
/* no indexing */
ctx->backend_ctx = ilist->module_ctx.super.
iter_init(list, patterns, flags);
} else {
/* listing mailboxes from index */
ctx->info.ns = list->ns;
ctx->path = str_new(pool, 128);
ctx->next_node = ilist->mailbox_tree;
ctx->mailbox_pool = ilist->mailbox_pool;
pool_ref(ctx->mailbox_pool);
}
return &ctx->ctx;
}
static int
dsync_get_mailbox_name(struct dsync_brain *brain, const char *const *name_parts,
const char **name_r, struct mail_namespace **ns_r)
{
struct mail_namespace *ns;
const char *p;
string_t *vname;
char ns_sep;
i_assert(*name_parts != NULL);
ns = dsync_find_namespace(brain, name_parts);
if (ns == NULL)
return -1;
ns_sep = mail_namespace_get_sep(ns);
/* build the mailbox name */
vname = t_str_new(128);
for (; *name_parts != NULL; name_parts++) {
for (p = *name_parts; *p != '\0'; p++) {
if (*p != ns_sep)
str_append_c(vname, *p);
else
str_append_c(vname, brain->alt_char);
}
str_append_c(vname, ns_sep);
}
str_truncate(vname, str_len(vname)-1);
dsync_fix_mailbox_name(ns, vname, brain->alt_char);
*name_r = str_c(vname);
*ns_r = ns;
return 0;
}
static const char *get_user_visible_mailbox_name(struct mailbox *box)
{
if (ns_is_visible(box->list->ns))
return box->vname;
else {
return t_strdup_printf("<hidden>%c%s",
mail_namespace_get_sep(box->list->ns),
box->vname);
}
}
struct mailbox_list_iterate_context *
maildir_list_iter_init(struct mailbox_list *_list, const char *const *patterns,
enum mailbox_list_iter_flags flags)
{
struct maildir_mailbox_list *list =
(struct maildir_mailbox_list *)_list;
struct maildir_list_iterate_context *ctx;
pool_t pool;
char ns_sep = mail_namespace_get_sep(_list->ns);
int ret;
pool = pool_alloconly_create("mailbox list maildir iter", 1024);
ctx = p_new(pool, struct maildir_list_iterate_context, 1);
ctx->ctx.pool = pool;
ctx->ctx.list = _list;
ctx->ctx.flags = flags;
ctx->ctx.glob = imap_match_init_multiple(pool, patterns, TRUE, ns_sep);
array_create(&ctx->ctx.module_contexts, pool, sizeof(void *), 5);
ctx->tree_ctx = mailbox_tree_init(ns_sep);
ctx->info.ns = _list->ns;
ctx->prefix_char = strcmp(_list->name, MAILBOX_LIST_NAME_IMAPDIR) == 0 ?
'\0' : list->sep;
ctx->dir = _list->set.root_dir;
if ((flags & MAILBOX_LIST_ITER_SELECT_SUBSCRIBED) != 0) {
/* Listing only subscribed mailboxes.
Flags are set later if needed. */
bool default_nonexistent =
(flags & MAILBOX_LIST_ITER_RETURN_NO_FLAGS) == 0;
mailbox_list_subscriptions_fill(&ctx->ctx, ctx->tree_ctx,
default_nonexistent);
}
if ((flags & MAILBOX_LIST_ITER_SELECT_SUBSCRIBED) == 0 ||
(flags & MAILBOX_LIST_ITER_RETURN_NO_FLAGS) == 0) {
/* Add/update mailbox list with flags */
bool update_only =
(flags & MAILBOX_LIST_ITER_SELECT_SUBSCRIBED) != 0;
T_BEGIN {
ret = maildir_fill_readdir(ctx, ctx->ctx.glob,
update_only);
} T_END;
if (ret < 0) {
ctx->ctx.failed = TRUE;
return &ctx->ctx;
}
}
static struct mailbox_list_iterate_context *
acl_mailbox_list_iter_init(struct mailbox_list *list,
const char *const *patterns,
enum mailbox_list_iter_flags flags)
{
struct acl_mailbox_list *alist = ACL_LIST_CONTEXT(list);
struct acl_mailbox_list_iterate_context *ctx;
pool_t pool;
const char *p;
unsigned int i;
bool inboxcase;
pool = pool_alloconly_create("mailbox list acl iter", 1024);
ctx = p_new(pool, struct acl_mailbox_list_iterate_context, 1);
ctx->ctx.pool = pool;
ctx->ctx.list = list;
ctx->ctx.flags = flags;
if (list->ns->type != MAIL_NAMESPACE_TYPE_PRIVATE &&
(list->ns->flags & NAMESPACE_FLAG_SUBSCRIPTIONS) != 0) {
/* non-private namespace with subscriptions=yes. this could be
a site-global subscriptions file, so hide subscriptions for
mailboxes the user doesn't see. */
ctx->hide_nonlistable_subscriptions = TRUE;
}
inboxcase = (list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0;
ctx->sep = mail_namespace_get_sep(list->ns);
ctx->ctx.glob = imap_match_init_multiple(pool, patterns,
inboxcase, ctx->sep);
/* see if all patterns have only a single '*' and it's at the end.
we can use it to do some optimizations. */
ctx->simple_star_glob = TRUE;
for (i = 0; patterns[i] != NULL; i++) {
p = strchr(patterns[i], '*');
if (p == NULL || p[1] != '\0') {
ctx->simple_star_glob = FALSE;
break;
}
}
/* Try to avoid reading ACLs from all mailboxes by getting a smaller
list of mailboxes that have even potential to be visible. If we
couldn't get such a list, we'll go through all mailboxes. */
T_BEGIN {
acl_mailbox_try_list_fast(ctx);
} T_END;
ctx->super_ctx = alist->module_ctx.super.
iter_init(list, patterns, flags);
return &ctx->ctx;
}
static void
maildir_fill_parents(struct maildir_list_iterate_context *ctx,
struct imap_match_glob *glob, bool update_only,
const char *vname)
{
struct mail_namespace *ns = ctx->ctx.list->ns;
struct mailbox_node *node;
const char *p;
unsigned int vname_len = strlen(vname);
bool created;
char ns_sep = mail_namespace_get_sep(ns);
while ((p = strrchr(vname, ns_sep)) != NULL) {
vname = t_strdup_until(vname, p);
if (imap_match(glob, vname) != IMAP_MATCH_YES)
continue;
if (ns->prefix_len > 0 && vname_len == ns->prefix_len-1 &&
strncmp(vname, ns->prefix, ns->prefix_len - 1) == 0 &&
vname[ns->prefix_len-1] == ns_sep) {
/* don't return matches to namespace prefix itself */
continue;
}
created = FALSE;
node = update_only ?
mailbox_tree_lookup(ctx->tree_ctx, vname) :
mailbox_tree_get(ctx->tree_ctx, vname, &created);
if (node != NULL) {
if (created) {
/* we haven't yet seen this mailbox,
but we might see it later */
node->flags = MAILBOX_NONEXISTENT;
}
if (!update_only)
node->flags |= MAILBOX_MATCHED;
node->flags |= MAILBOX_CHILDREN;
node->flags &= ~MAILBOX_NOCHILDREN;
node_fix_parents(node);
}
}
}
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;
}
static void maildir_set_children(struct maildir_list_iterate_context *ctx,
const char *vname)
{
struct mailbox_node *node;
const char *p;
char hierarchy_sep;
hierarchy_sep = mail_namespace_get_sep(ctx->ctx.list->ns);
/* mark the first existing parent as containing children */
while ((p = strrchr(vname, hierarchy_sep)) != NULL) {
vname = t_strdup_until(vname, p);
node = mailbox_tree_lookup(ctx->tree_ctx, vname);
if (node != NULL) {
node->flags &= ~MAILBOX_NOCHILDREN;
node->flags |= MAILBOX_CHILDREN;
break;
}
}
}
static void list_namespaces(struct mail_namespace *ns,
enum mail_namespace_type type, string_t *str)
{
string_t *mutf7_prefix = t_str_new(64);
char ns_sep;
bool found = FALSE;
while (ns != NULL) {
if (ns->type == type &&
(ns->flags & NAMESPACE_FLAG_HIDDEN) == 0) {
if (!found) {
str_append_c(str, '(');
found = TRUE;
}
ns_sep = mail_namespace_get_sep(ns);
str_append_c(str, '(');
str_truncate(mutf7_prefix, 0);
if (imap_utf8_to_utf7(ns->prefix, mutf7_prefix) < 0) {
i_panic("LIST: Namespace prefix not UTF-8: %s",
ns->prefix);
}
imap_append_string(str, str_c(mutf7_prefix));
str_append(str, " \"");
if (ns_sep == '\\')
str_append_c(str, '\\');
str_append_c(str, ns_sep);
str_append(str, "\")");
}
ns = ns->next;
}
if (found)
str_append_c(str, ')');
else
str_append(str, "NIL");
}
struct mail_namespace *
client_find_namespace_full(struct client *client,
const char **mailbox, const char **error_r)
{
struct mail_namespace *namespaces = client->user->namespaces;
struct mail_namespace *ns;
string_t *utf8_name;
utf8_name = t_str_new(64);
if (imap_utf7_to_utf8(*mailbox, utf8_name) < 0) {
*error_r = "NO Mailbox name is not valid mUTF-7";
return NULL;
}
ns = mail_namespace_find(namespaces, str_c(utf8_name));
if ((ns->flags & NAMESPACE_FLAG_AUTOCREATED) != 0 &&
ns->prefix_len == 0) {
/* this matched only the autocreated prefix="" namespace.
give a nice human-readable error message */
*error_r = t_strdup_printf(
"NO Client tried to access nonexistent namespace. "
"(Mailbox name should probably be prefixed with: %s)",
mail_namespace_find_inbox(namespaces)->prefix);
return NULL;
}
if ((client->set->parsed_workarounds &
WORKAROUND_TB_EXTRA_MAILBOX_SEP) != 0 &&
str_len(utf8_name) > 0 &&
str_c(utf8_name)[str_len(utf8_name)-1] == mail_namespace_get_sep(ns)) {
/* drop the extra trailing hierarchy separator */
str_truncate(utf8_name, str_len(utf8_name)-1);
}
*mailbox = str_c(utf8_name);
return ns;
}
static const char *
imapc_list_get_fs_name(struct imapc_mailbox_list *list, const char *name)
{
struct mailbox_list *fs_list = imapc_list_get_fs(list);
struct mail_namespace *ns = list->list.ns;
const char *vname;
char ns_sep = mail_namespace_get_sep(ns);
if (name == NULL)
return NULL;
vname = mailbox_list_get_vname(&list->list, name);
if (list->set->imapc_list_prefix[0] != '\0') {
/* put back the prefix, so it gets included in the filesystem. */
unsigned int vname_len = strlen(vname);
if (ns->prefix_len > 0) {
/* skip over the namespace prefix */
i_assert(strncmp(vname, ns->prefix, ns->prefix_len-1) == 0);
if (vname_len == ns->prefix_len-1)
vname = "";
else {
i_assert(vname[ns->prefix_len-1] == ns_sep);
vname += ns->prefix_len;
}
}
if (vname[0] == '\0') {
vname = t_strconcat(ns->prefix,
list->set->imapc_list_prefix, NULL);
} else {
vname = t_strdup_printf("%s%s%c%s", ns->prefix,
list->set->imapc_list_prefix,
ns_sep, vname);
}
}
return mailbox_list_get_storage_name(fs_list, vname);
}
static int
mailbox_list_subscription_fill_one(struct mailbox_list *list,
struct mailbox_list *src_list,
const char *name)
{
struct mail_namespace *ns, *default_ns = list->ns;
struct mail_namespace *namespaces = default_ns->user->namespaces;
struct mailbox_node *node;
const char *vname, *ns_name, *error;
unsigned int len;
bool created;
/* default_ns is whatever namespace we're currently listing.
if we have e.g. prefix="" and prefix=pub/ namespaces with
pub/ namespace having subscriptions=no, we want to:
1) when listing "" namespace we want to skip over any names
that begin with pub/. */
if (src_list->ns->prefix_len == 0)
ns_name = name;
else {
/* we could have two-level namespace: ns/ns2/ */
ns_name = t_strconcat(src_list->ns->prefix, name, NULL);
}
ns = mail_namespace_find_unsubscribable(namespaces, ns_name);
if (ns != NULL && ns != default_ns) {
if (ns->prefix_len > 0)
return 0;
/* prefix="" namespace=no : catching this is basically the
same as not finding any namespace. */
ns = NULL;
}
/* 2) when listing pub/ namespace, skip over entries that don't
begin with pub/. */
if (ns == NULL &&
(default_ns->flags & NAMESPACE_FLAG_SUBSCRIPTIONS) == 0)
return 0;
/* When listing shared namespace's subscriptions, we need to
autocreate all the visible child namespaces. their subscriptions
are listed later. */
if (ns != NULL && mail_namespace_is_shared_user_root(ns)) {
/* we'll need to get the namespace autocreated.
one easy way is to just ask to join a reference and
pattern */
(void)mailbox_list_join_refpattern(ns->list, ns_name, "");
}
/* When listing pub/ namespace, skip over the namespace
prefix in the name. the rest of the name is storage_name. */
if (ns == NULL)
ns = default_ns;
else if (strncmp(ns_name, ns->prefix, ns->prefix_len) == 0) {
ns_name += ns->prefix_len;
name = ns_name;
} else {
/* "pub" entry - this shouldn't be possible normally, because
it should be saved as "pub/", but handle it anyway */
i_assert(strncmp(ns_name, ns->prefix, ns->prefix_len-1) == 0 &&
ns_name[ns->prefix_len-1] == '\0');
name = ns_name = "";
}
len = strlen(name);
if (len > 0 && name[len-1] == mail_namespace_get_sep(ns)) {
/* entry ends with hierarchy separator, remove it.
this exists mainly for backwards compatibility with old
Dovecot versions and non-Dovecot software that added them */
name = t_strndup(name, len-1);
}
if (!mailbox_list_is_valid_name(list, name, &error)) {
/* we'll only get into trouble if we show this */
return -1;
} else {
vname = mailbox_list_get_vname(list, name);
if (!uni_utf8_str_is_valid(vname))
return -1;
node = mailbox_tree_get(list->subscriptions, vname, &created);
node->flags = MAILBOX_SUBSCRIBED;
}
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;
}
int dsync_mailbox_tree_fill(struct dsync_mailbox_tree *tree,
struct mail_namespace *ns, const char *box_name,
const guid_128_t box_guid,
const char *const *exclude_mailboxes,
enum mail_error *error_r)
{
const enum mailbox_list_iter_flags list_flags =
/* FIXME: we'll skip symlinks, because we can't handle them
currently. in future we could detect them and create them
by creating the symlink. */
MAILBOX_LIST_ITER_SKIP_ALIASES |
MAILBOX_LIST_ITER_NO_AUTO_BOXES;
const enum mailbox_list_iter_flags subs_list_flags =
MAILBOX_LIST_ITER_NO_AUTO_BOXES |
MAILBOX_LIST_ITER_SELECT_SUBSCRIBED |
MAILBOX_LIST_ITER_RETURN_NO_FLAGS;
struct mailbox_list_iterate_context *iter;
struct dsync_mailbox_node *node, *dup_node1, *dup_node2;
const struct mailbox_info *info;
const char *list_pattern =
box_name != NULL && box_name[0] != '\\' ? box_name : "*";
int ret = 0;
i_assert(mail_namespace_get_sep(ns) == tree->sep);
/* assign namespace to its root, so it gets copied to children */
if (ns->prefix_len > 0) {
node = dsync_mailbox_tree_get(tree,
t_strndup(ns->prefix, ns->prefix_len-1));
node->ns = ns;
} else {
tree->root.ns = ns;
}
/* first add all of the existing mailboxes */
iter = mailbox_list_iter_init(ns->list, list_pattern, list_flags);
while ((info = mailbox_list_iter_next(iter)) != NULL) T_BEGIN {
if (dsync_mailbox_info_is_wanted(info, box_name,
exclude_mailboxes)) {
if (dsync_mailbox_tree_add(tree, info, box_guid, error_r) < 0)
ret = -1;
}
} T_END;
if (mailbox_list_iter_deinit(&iter) < 0) {
i_error("Mailbox listing for namespace '%s' failed: %s",
ns->prefix, mailbox_list_get_last_internal_error(ns->list, error_r));
ret = -1;
}
/* add subscriptions */
iter = mailbox_list_iter_init(ns->list, list_pattern, subs_list_flags);
while ((info = mailbox_list_iter_next(iter)) != NULL) {
if (dsync_mailbox_tree_add_node(tree, info, &node) == 0)
node->subscribed = TRUE;
else {
*error_r = MAIL_ERROR_TEMP;
ret = -1;
}
}
if (mailbox_list_iter_deinit(&iter) < 0) {
i_error("Mailbox listing for namespace '%s' failed: %s",
ns->prefix, mailbox_list_get_last_internal_error(ns->list, error_r));
ret = -1;
}
if (ret < 0)
return -1;
while (dsync_mailbox_tree_build_guid_hash(tree, &dup_node1,
&dup_node2) < 0) {
if (dsync_mailbox_tree_fix_guid_duplicate(tree, dup_node1, dup_node2) < 0)
return -1;
}
/* add timestamps */
if (dsync_mailbox_tree_add_change_timestamps(tree, ns) < 0)
return -1;
return 0;
}
static int
shared_storage_create(struct mail_storage *_storage, struct mail_namespace *ns,
const char **error_r)
{
struct shared_storage *storage = (struct shared_storage *)_storage;
struct mail_storage *storage_class;
const char *driver, *p;
char *wildcardp, key;
bool have_username;
/* location must begin with the actual mailbox driver */
p = strchr(ns->set->location, ':');
if (p == NULL) {
*error_r = "Shared mailbox location not prefixed with driver";
return -1;
}
driver = t_strdup_until(ns->set->location, p);
storage->location = p_strdup(_storage->pool, ns->set->location);
storage->unexpanded_location =
p_strdup(_storage->pool, ns->unexpanded_set->location);
storage->storage_class_name = p_strdup(_storage->pool, driver);
storage_class = mail_user_get_storage_class(_storage->user, driver);
if (storage_class != NULL)
_storage->class_flags = storage_class->class_flags;
else if (strcmp(driver, "auto") != 0) {
*error_r = t_strconcat("Unknown shared storage driver: ",
driver, NULL);
return -1;
}
wildcardp = strchr(ns->prefix, '%');
if (wildcardp == NULL) {
*error_r = "Shared namespace prefix doesn't contain %";
return -1;
}
storage->ns_prefix_pattern = p_strdup(_storage->pool, wildcardp);
have_username = FALSE;
for (p = storage->ns_prefix_pattern; *p != '\0'; p++) {
if (*p != '%')
continue;
key = p[1];
if (key == 'u' || key == 'n')
have_username = TRUE;
else if (key != '%' && key != 'd')
break;
}
if (*p != '\0') {
*error_r = "Shared namespace prefix contains unknown variables";
return -1;
}
if (!have_username) {
*error_r = "Shared namespace prefix doesn't contain %u or %n";
return -1;
}
if (p[-1] != mail_namespace_get_sep(ns) &&
(ns->flags & (NAMESPACE_FLAG_LIST_PREFIX |
NAMESPACE_FLAG_LIST_CHILDREN)) != 0) {
*error_r = "Shared namespace prefix doesn't end with hierarchy separator";
return -1;
}
/* truncate prefix after the above checks are done, so they can log
the full prefix in error conditions */
*wildcardp = '\0';
ns->prefix_len = strlen(ns->prefix);
return 0;
}
static int
maildir_rename_children(struct mailbox_list *oldlist, const char *oldname,
struct mailbox_list *newlist, const char *newname)
{
struct mailbox_list_iterate_context *iter;
const struct mailbox_info *info;
ARRAY(const char *) names_arr;
const char *pattern, *oldpath, *newpath, *old_childname, *new_childname;
const char *const *names, *old_vname, *new_vname;
unsigned int i, count, old_vnamelen;
pool_t pool;
char old_ns_sep;
int ret;
ret = 0;
/* first get the list of the children and save them to memory, because
we can't rely on readdir() not skipping files while the directory
is being modified. this doesn't protect against modifications by
other processes though. */
pool = pool_alloconly_create("Maildir++ children list", 1024);
i_array_init(&names_arr, 64);
old_vname = mailbox_list_get_vname(oldlist, oldname);
old_vnamelen = strlen(old_vname);
new_vname = mailbox_list_get_vname(newlist, newname);
old_ns_sep = mail_namespace_get_sep(oldlist->ns);
pattern = t_strdup_printf("%s%c*", old_vname, old_ns_sep);
iter = mailbox_list_iter_init(oldlist, pattern,
MAILBOX_LIST_ITER_RETURN_NO_FLAGS |
MAILBOX_LIST_ITER_RAW_LIST);
while ((info = mailbox_list_iter_next(iter)) != NULL) {
const char *name;
/* verify that the prefix matches, otherwise we could have
problems with mailbox names containing '%' and '*' chars */
if (strncmp(info->vname, old_vname, old_vnamelen) == 0 &&
info->vname[old_vnamelen] == old_ns_sep) {
name = p_strdup(pool, info->vname + old_vnamelen);
array_append(&names_arr, &name, 1);
}
}
if (mailbox_list_iter_deinit(&iter) < 0) {
ret = -1;
names = NULL; count = 0;
} else {
names = array_get(&names_arr, &count);
}
for (i = 0; i < count; i++) {
old_childname = mailbox_list_get_storage_name(oldlist,
t_strconcat(old_vname, names[i], NULL));
if (strcmp(old_childname, new_vname) == 0) {
/* When doing RENAME "a" "a.b" we see "a.b" here.
We don't want to rename it anymore to "a.b.b". */
continue;
}
new_childname = mailbox_list_get_storage_name(newlist,
t_strconcat(new_vname, names[i], NULL));
if (mailbox_list_get_path(oldlist, old_childname,
MAILBOX_LIST_PATH_TYPE_MAILBOX,
&oldpath) <= 0 ||
mailbox_list_get_path(newlist, new_childname,
MAILBOX_LIST_PATH_TYPE_MAILBOX,
&newpath) <= 0)
i_unreached();
/* FIXME: it's possible to merge two mailboxes if either one of
them doesn't have existing root mailbox. We could check this
but I'm not sure if it's worth it. It could be even
considered as a feature.
Anyway, the bug with merging is that if both mailboxes have
identically named child mailbox they conflict. Just ignore
those and leave them under the old mailbox. */
if (rename(oldpath, newpath) == 0 || EDESTDIREXISTS(errno))
ret = 1;
else {
mailbox_list_set_critical(oldlist,
"rename(%s, %s) failed: %m", oldpath, newpath);
ret = -1;
break;
}
(void)rename_dir(oldlist, old_childname, newlist, new_childname,
MAILBOX_LIST_PATH_TYPE_CONTROL);
(void)rename_dir(oldlist, old_childname, newlist, new_childname,
MAILBOX_LIST_PATH_TYPE_INDEX);
}
array_free(&names_arr);
pool_unref(&pool);
return ret;
}
