static struct acl_object *
acl_backend_vfile_object_init(struct acl_backend *_backend,
const char *name)
{
struct acl_backend_vfile *backend =
(struct acl_backend_vfile *)_backend;
struct acl_object_vfile *aclobj;
const char *dir, *vname, *error;
aclobj = i_new(struct acl_object_vfile, 1);
aclobj->aclobj.backend = _backend;
aclobj->aclobj.name = i_strdup(name);
T_BEGIN {
if (*name == '\0' ||
mailbox_list_is_valid_name(_backend->list, name, &error)) {
vname = *name == '\0' ? "" :
mailbox_list_get_vname(_backend->list, name);
dir = acl_backend_vfile_get_local_dir(_backend, name, vname);
aclobj->local_path = dir == NULL ? NULL :
i_strconcat(dir, "/"ACL_FILENAME, NULL);
if (backend->global_path != NULL &&
_backend->global_file == NULL) {
aclobj->global_path =
i_strconcat(backend->global_path, "/", vname, NULL);
}
} else {
/* Invalid mailbox name, just use the default
global ACL files */
}
} T_END;
return &aclobj->aclobj;
}
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);
}
}
static void
acl_mailbox_try_list_fast(struct acl_mailbox_list_iterate_context *ctx)
{
struct acl_mailbox_list *alist = ACL_LIST_CONTEXT(ctx->ctx.list);
struct acl_backend *backend = alist->rights.backend;
const unsigned int *idxp;
const struct acl_mask *acl_mask;
struct acl_mailbox_list_context *nonowner_list_ctx;
struct mail_namespace *ns = ctx->ctx.list->ns;
struct mailbox_list_iter_update_context update_ctx;
const char *name;
int ret;
if ((ctx->ctx.flags & (MAILBOX_LIST_ITER_RAW_LIST |
MAILBOX_LIST_ITER_SELECT_SUBSCRIBED)) != 0)
return;
if (ns->type == MAIL_NAMESPACE_TYPE_PUBLIC) {
/* mailboxes in public namespace should all be listable to
someone. we don't benefit from fast listing. */
return;
}
/* if this namespace's default rights contain LOOKUP, we'll need to
go through all mailboxes in any case. */
idxp = alist->rights.acl_storage_right_idx + ACL_STORAGE_RIGHT_LOOKUP;
if (acl_backend_get_default_rights(backend, &acl_mask) < 0 ||
acl_cache_mask_isset(acl_mask, *idxp))
return;
/* no LOOKUP right by default, we can optimize this */
memset(&update_ctx, 0, sizeof(update_ctx));
update_ctx.iter_ctx = &ctx->ctx;
update_ctx.glob =
imap_match_init(pool_datastack_create(), "*",
(ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0,
ctx->sep);
update_ctx.match_parents = TRUE;
update_ctx.tree_ctx = mailbox_tree_init(ctx->sep);
nonowner_list_ctx = acl_backend_nonowner_lookups_iter_init(backend);
while ((ret = acl_backend_nonowner_lookups_iter_next(nonowner_list_ctx,
&name)) > 0) {
T_BEGIN {
const char *vname =
mailbox_list_get_vname(ns->list, name);
mailbox_list_iter_update(&update_ctx, vname);
} T_END;
}
acl_backend_nonowner_lookups_iter_deinit(&nonowner_list_ctx);
if (ret == 0)
ctx->lookup_boxes = update_ctx.tree_ctx;
else
mailbox_tree_deinit(&update_ctx.tree_ctx);
}
static bool
acl_backend_vfile_has_acl(struct acl_backend *_backend, const char *name)
{
struct acl_backend_vfile *backend =
(struct acl_backend_vfile *)_backend;
struct acl_backend_vfile_validity *old_validity, new_validity;
const char *path, *local_path, *global_path, *dir, *vname = "";
const char *error;
int ret;
old_validity = acl_cache_get_validity(_backend->cache, name);
if (old_validity != NULL)
new_validity = *old_validity;
else
memset(&new_validity, 0, sizeof(new_validity));
/* See if the mailbox exists. If we wanted recursive lookups we could
skip this, but at least for now we assume that if an existing
mailbox has no ACL it's equivalent to default ACLs. */
if (mailbox_list_get_path(_backend->list, name,
MAILBOX_LIST_PATH_TYPE_MAILBOX, &path) <= 0)
ret = -1;
else {
ret = acl_backend_vfile_exists(backend, path,
&new_validity.mailbox_validity);
}
if (ret == 0 &&
(*name == '\0' ||
mailbox_list_is_valid_name(_backend->list, name, &error))) {
vname = *name == '\0' ? "" :
mailbox_list_get_vname(_backend->list, name);
dir = acl_backend_vfile_get_local_dir(_backend, name, vname);
if (dir != NULL) {
local_path = t_strconcat(dir, "/", name, NULL);
ret = acl_backend_vfile_exists(backend, local_path,
&new_validity.local_validity);
}
}
if (ret == 0 && backend->global_path != NULL) {
if (_backend->global_file != NULL) {
ret = acl_global_file_refresh(_backend->global_file);
if (ret == 0 && acl_global_file_have_any(_backend->global_file, vname))
ret = 1;
} else {
global_path = t_strconcat(backend->global_path, "/", name, NULL);
ret = acl_backend_vfile_exists(backend, global_path,
&new_validity.global_validity);
}
}
acl_cache_set_validity(_backend->cache, name, &new_validity);
return ret > 0;
}
static int
maildir_fill_readdir(struct maildir_list_iterate_context *ctx,
struct imap_match_glob *glob, bool update_only)
{
struct mailbox_list *list = ctx->ctx.list;
struct mail_namespace *ns = list->ns;
DIR *dirp;
struct dirent *d;
const char *vname;
int ret = 0;
dirp = opendir(ctx->dir);
if (dirp == NULL) {
if (errno == EACCES) {
mailbox_list_set_critical(list, "%s",
mail_error_eacces_msg("opendir", ctx->dir));
} else if (errno != ENOENT) {
mailbox_list_set_critical(list,
"opendir(%s) failed: %m", ctx->dir);
return -1;
}
return 0;
}
while ((d = readdir(dirp)) != NULL) {
T_BEGIN {
ret = maildir_fill_readdir_entry(ctx, glob, d,
update_only);
} T_END;
if (ret < 0)
break;
}
if (closedir(dirp) < 0) {
mailbox_list_set_critical(list, "readdir(%s) failed: %m",
ctx->dir);
return -1;
}
if (ret < 0)
return -1;
if ((ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0) {
/* make sure INBOX is listed */
return maildir_fill_inbox(ctx, glob, "INBOX", update_only);
} else if ((ns->flags & NAMESPACE_FLAG_INBOX_ANY) != 0) {
/* show shared INBOX. */
vname = mailbox_list_get_vname(ns->list, "INBOX");
return maildir_fill_inbox(ctx, glob, vname, update_only);
} else {
return 0;
}
}
static const char *
imapc_list_to_vname(struct imapc_mailbox_list *list, const char *imapc_name)
{
const char *list_name;
/* typically mailbox_list_escape_name() is used to escape vname into
a list name. but we want to convert remote IMAP name to a list name,
so we need to use the remote IMAP separator. */
list_name = mailbox_list_escape_name_params(imapc_name, "", list->root_sep,
mailbox_list_get_hierarchy_sep(&list->list),
list->list.set.escape_char, "");
/* list_name is now valid, so we can convert it to vname */
return mailbox_list_get_vname(&list->list, list_name);
}
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);
}
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;
}
static int
maildir_fill_readdir_entry(struct maildir_list_iterate_context *ctx,
struct imap_match_glob *glob, const struct dirent *d,
bool update_only)
{
struct mailbox_list *list = ctx->ctx.list;
const char *fname, *storage_name, *vname;
enum mailbox_info_flags flags;
enum imap_match_result match;
struct mailbox_node *node;
bool created;
int ret;
fname = d->d_name;
if (fname[0] == ctx->prefix_char)
storage_name = fname + 1;
else {
if (ctx->prefix_char != '\0' || fname[0] == '.')
return 0;
storage_name = fname;
}
/* skip . and .. */
if (fname[0] == '.' &&
(fname[1] == '\0' || (fname[1] == '.' && fname[2] == '\0')))
return 0;
vname = mailbox_list_get_vname(list, storage_name);
if (!uni_utf8_str_is_valid(vname)) {
/* the storage_name is completely invalid, rename it to
something more sensible. we could do this for all names that
aren't valid mUTF-7, but that might lead to accidents in
future when UTF-8 storage names are used */
const char *src = t_strdup_printf("%s/%s", ctx->dir, fname);
string_t *destvname = t_str_new(128);
string_t *dest = t_str_new(128);
(void)uni_utf8_get_valid_data((const void *)fname,
strlen(fname), destvname);
str_append(dest, ctx->dir);
str_append_c(dest, '/');
(void)imap_utf8_to_utf7(str_c(destvname), dest);
if (rename(src, str_c(dest)) < 0 && errno != ENOENT)
i_error("rename(%s, %s) failed: %m", src, str_c(dest));
/* just skip this in this iteration, we'll see it on the
next list */
return 0;
}
/* make sure the pattern matches */
match = imap_match(glob, vname);
if ((match & (IMAP_MATCH_YES | IMAP_MATCH_PARENT)) == 0)
return 0;
/* check if this is an actual mailbox */
if (maildir_delete_trash_dir(ctx, fname))
return 0;
if ((ctx->ctx.flags & MAILBOX_LIST_ITER_SKIP_ALIASES) != 0) {
ret = mailbox_list_dirent_is_alias_symlink(list, ctx->dir, d);
if (ret != 0)
return ret < 0 ? -1 : 0;
}
T_BEGIN {
ret = list->v.get_mailbox_flags(list, ctx->dir, fname,
mailbox_list_get_file_type(d), &flags);
} T_END;
if (ret <= 0)
return ret;
/* we know the children flags ourself, so ignore if any of
them were set. */
flags &= ~(MAILBOX_NOINFERIORS | MAILBOX_CHILDREN | MAILBOX_NOCHILDREN);
if ((match & IMAP_MATCH_PARENT) != 0)
maildir_fill_parents(ctx, glob, update_only, vname);
else {
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)
node->flags = MAILBOX_NOCHILDREN;
else
node->flags &= ~MAILBOX_NONEXISTENT;
if (!update_only)
node->flags |= MAILBOX_MATCHED;
node->flags |= flags;
node_fix_parents(node);
} else {
i_assert(update_only);
maildir_set_children(ctx, vname);
}
}
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;
}
