Lines Matching refs:list
24 #include "mailbox-list-private.h"
40 struct mailbox_list *list;
74 void mailbox_list_register(const struct mailbox_list *list)
78 if (mailbox_list_driver_find(list->name, &idx)) {
80 list->name);
83 array_append(&mailbox_list_drivers, &list, 1);
86 void mailbox_list_unregister(const struct mailbox_list *list)
90 if (!mailbox_list_driver_find(list->name, &idx)) {
92 list->name);
116 struct mailbox_list *list;
118 i_assert(ns->list == NULL ||
143 list = class->v.alloc();
144 array_create(&list->module_contexts, list->pool, sizeof(void *), 5);
146 list->ns = ns;
147 list->mail_set = ns->mail_set;
148 list->flags = flags;
149 list->root_permissions.file_create_mode = (mode_t)-1;
150 list->root_permissions.dir_create_mode = (mode_t)-1;
151 list->root_permissions.file_create_gid = (gid_t)-1;
152 list->changelog_timestamp = (time_t)-1;
154 list->props |= MAILBOX_LIST_PROP_NO_NOSELECT;
158 list->set.root_dir = p_strdup(list->pool, set->root_dir);
159 list->set.index_dir = set->index_dir == NULL ||
161 p_strdup(list->pool, set->index_dir);
162 list->set.index_pvt_dir = set->index_pvt_dir == NULL ||
164 p_strdup(list->pool, set->index_pvt_dir);
165 list->set.index_cache_dir = set->index_cache_dir == NULL ||
167 p_strdup(list->pool, set->index_cache_dir);
168 list->set.control_dir = set->control_dir == NULL ||
170 p_strdup(list->pool, set->control_dir);
173 list->set.inbox_path = p_strdup(list->pool, set->inbox_path);
174 list->set.subscription_fname =
175 p_strdup(list->pool, set->subscription_fname);
176 list->set.list_index_fname =
177 p_strdup(list->pool, set->list_index_fname);
178 list->set.list_index_dir =
179 p_strdup(list->pool, set->list_index_dir);
180 list->set.maildir_name =
181 p_strdup(list->pool, set->maildir_name);
182 list->set.mailbox_dir_name =
183 p_strdup(list->pool, set->mailbox_dir_name);
184 list->set.alt_dir = p_strdup(list->pool, set->alt_dir);
185 list->set.alt_dir_nocheck = set->alt_dir_nocheck;
186 list->set.volatile_dir = p_strdup(list->pool, set->volatile_dir);
187 list->set.index_control_use_maildir_name =
189 list->set.iter_from_index_dir = set->iter_from_index_dir;
190 list->set.no_noselect = set->no_noselect;
193 list->set.mailbox_dir_name = "";
195 list->set.mailbox_dir_name =
196 p_strdup(list->pool, set->mailbox_dir_name);
198 list->set.mailbox_dir_name =
199 p_strconcat(list->pool, set->mailbox_dir_name, "/", NULL);
201 list->set.escape_char = set->escape_char;
202 list->set.broken_char = set->broken_char;
203 list->set.utf8 = set->utf8;
205 if (list->v.init != NULL) {
206 if (list->v.init(list, error_r) < 0) {
207 list->v.deinit(list);
214 list->name,
215 list->set.root_dir == NULL ? "" : list->set.root_dir,
216 list->set.index_dir == NULL ? "" : list->set.index_dir,
217 list->set.index_pvt_dir == NULL ? "" : list->set.index_pvt_dir,
218 list->set.control_dir == NULL ?
219 "" : list->set.control_dir,
220 list->set.inbox_path == NULL ?
221 "" : list->set.inbox_path,
222 list->set.alt_dir == NULL ? "" : list->set.alt_dir);
225 mail_namespace_finish_list_init(ns, list);
227 *list_r = list;
229 hook_mailbox_list_created(list);
419 const char *mailbox_list_get_unexpanded_path(struct mailbox_list *list,
423 const char *location = list->ns->unexpanded_set->location;
424 struct mail_user *user = list->ns->user;
519 mailbox_list_escape_name(struct mailbox_list *list, const char *vname)
521 return mailbox_list_escape_name_params(vname, list->ns->prefix,
522 mail_namespace_get_sep(list->ns),
523 mailbox_list_get_hierarchy_sep(list),
524 list->set.escape_char, list->set.maildir_name);
528 mailbox_list_unescape_broken_chars(struct mailbox_list *list, char *name)
533 if ((src = strchr(name, list->set.broken_char)) == NULL)
538 if (*src == list->set.broken_char) {
574 const char *mailbox_list_default_get_storage_name(struct mailbox_list *list,
577 struct mail_namespace *ns = list->ns;
586 else if (list->set.escape_char != '\0')
587 storage_name = mailbox_list_escape_name(list, vname);
605 if (!list->set.utf8) {
613 list_sep = mailbox_list_get_hierarchy_sep(list);
618 !list->mail_set->mail_shared_explicit_inbox) {
623 if (list_sep != ns_sep && list->set.escape_char == '\0') {
633 } else if (list->set.broken_char == '\0' ||
634 strchr(storage_name, list->set.broken_char) == NULL) {
641 if (list->set.broken_char != '\0') {
642 if (mailbox_list_unescape_broken_chars(list, ret) < 0) {
650 const char *mailbox_list_get_storage_name(struct mailbox_list *list,
653 return list->v.get_storage_name(list, vname);
693 mailbox_list_unescape_name(struct mailbox_list *list, const char *src)
695 return mailbox_list_unescape_name_params(src, list->ns->prefix,
696 mail_namespace_get_sep(list->ns),
697 mailbox_list_get_hierarchy_sep(list),
698 list->set.escape_char);
702 mailbox_list_escape_broken_chars(struct mailbox_list *list, string_t *str)
707 if (strchr(str_c(str), list->set.broken_char) == NULL)
711 if (str_c(str)[i] == list->set.broken_char) {
713 list->set.broken_char);
721 mailbox_list_escape_broken_name(struct mailbox_list *list,
727 str_printfa(str, "%c%02x", list->set.broken_char,
735 const char *mailbox_list_default_get_vname(struct mailbox_list *list,
742 if ((list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
744 list->ns->user == list->ns->owner) {
751 list->ns->type == MAIL_NAMESPACE_TYPE_SHARED &&
752 (list->ns->flags & NAMESPACE_FLAG_INBOX_ANY) != 0 &&
753 !list->mail_set->mail_shared_explicit_inbox) {
760 if (list->ns->prefix_len == 0)
761 return list->ns->prefix;
763 return t_strndup(list->ns->prefix,
764 list->ns->prefix_len - 1);
766 } else if (!list->set.utf8) {
770 if (list->set.broken_char != '\0')
771 mailbox_list_escape_broken_chars(list, str);
773 } else if (list->set.broken_char != '\0') {
774 mailbox_list_escape_broken_name(list, vname, str);
779 prefix_len = strlen(list->ns->prefix);
780 if (list->set.escape_char != '\0') {
781 vname = mailbox_list_unescape_name(list, vname);
783 t_strconcat(list->ns->prefix, vname, NULL);
786 list_sep = mailbox_list_get_hierarchy_sep(list);
787 ns_sep = mail_namespace_get_sep(list->ns);
793 memcpy(ret, list->ns->prefix, prefix_len);
804 const char *mailbox_list_get_vname(struct mailbox_list *list, const char *name)
806 return list->v.get_vname(list, name);
811 struct mailbox_list *list = *_list;
814 i_free_and_null(list->error_string);
815 i_free(list->last_internal_error);
817 if (hash_table_is_created(list->guid_cache)) {
818 hash_table_destroy(&list->guid_cache);
819 pool_unref(&list->guid_cache_pool);
822 if (list->subscriptions != NULL)
823 mailbox_tree_deinit(&list->subscriptions);
824 if (list->changelog != NULL)
825 mailbox_log_free(&list->changelog);
827 if (array_is_created(&list->error_stack)) {
828 i_assert(array_count(&list->error_stack) == 0);
829 array_free(&list->error_stack);
831 list->v.deinit(list);
834 const char *mailbox_list_get_driver_name(const struct mailbox_list *list)
836 return list->name;
840 mailbox_list_get_settings(const struct mailbox_list *list)
842 return &list->set;
845 enum mailbox_list_flags mailbox_list_get_flags(const struct mailbox_list *list)
847 return list->flags;
851 mailbox_list_get_namespace(const struct mailbox_list *list)
853 return list->ns;
866 mailbox_list_get_user(const struct mailbox_list *list)
868 return list->ns->user;
872 mailbox_list_get_storage_driver(struct mailbox_list *list, const char *driver,
878 array_foreach(&list->ns->all_storages, storagep) {
885 data = i_strchr_to_next(list->ns->set->location, ':');
888 if (mail_storage_create_full(list->ns, driver, data, 0,
890 mailbox_list_set_critical(list,
892 list->ns->prefix, driver, error);
898 int mailbox_list_get_storage(struct mailbox_list **list, const char *vname,
903 if ((*list)->v.get_storage != NULL)
904 return (*list)->v.get_storage(list, vname, storage_r);
906 set = mailbox_settings_find((*list)->ns, vname);
908 return mailbox_list_get_storage_driver(*list, set->driver,
911 *storage_r = mail_namespace_get_default_storage((*list)->ns);
915 void mailbox_list_get_default_storage(struct mailbox_list *list,
918 *storage = mail_namespace_get_default_storage(list->ns);
921 char mailbox_list_get_hierarchy_sep(struct mailbox_list *list)
924 looks at the list's last error. make sure the error is cleared
926 mailbox_list_clear_error(list);
927 return list->v.get_hierarchy_sep(list);
931 mailbox_list_get_permissions_stat(struct mailbox_list *list, const char *path,
938 mailbox_list_set_critical(list, "%s",
941 mailbox_list_set_critical(list, "stat(%s) failed: %m",
943 } else if (list->mail_set->mail_debug) {
946 list->ns->prefix, path);
996 mailbox_list_get_permissions_internal(struct mailbox_list *list,
1012 if (list->set.iter_from_index_dir ||
1013 (list->flags & MAILBOX_LIST_FLAG_NO_MAIL_FILES) != 0) {
1019 (void)mailbox_list_get_path(list, name,
1024 if (mailbox_list_get_path(list, name, MAILBOX_LIST_PATH_TYPE_DIR,
1029 (void)mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_DIR,
1035 } else if (mailbox_list_get_permissions_stat(list, path, permissions_r)) {
1040 p = strrchr(name, mailbox_list_get_hierarchy_sep(list));
1047 mailbox_list_get_permissions(list, parent_name,
1057 mailbox_permissions_copy(&list->root_permissions, permissions_r,
1058 list->pool);
1061 if (list->mail_set->mail_debug && name == NULL) {
1063 "mode=0%o gid=%s", list->ns->prefix,
1071 void mailbox_list_get_permissions(struct mailbox_list *list, const char *name,
1074 mailbox_list_get_permissions_internal(list, name, permissions_r);
1077 void mailbox_list_get_root_permissions(struct mailbox_list *list,
1080 if (list->root_permissions.file_create_mode != (mode_t)-1)
1081 *permissions_r = list->root_permissions;
1083 mailbox_list_get_permissions_internal(list, NULL,
1140 mailbox_list_try_mkdir_root_parent(struct mailbox_list *list,
1152 unexpanded = mailbox_list_get_unexpanded_path(list, type);
1157 if (!mailbox_list_get_root_path(list, type, &expanded))
1167 if (!mailbox_list_get_root_path(list, type, &expanded))
1223 int mailbox_list_try_mkdir_root(struct mailbox_list *list, const char *path,
1242 mailbox_list_get_root_permissions(list, &perm);
1244 if (!mailbox_list_get_root_path(list, type, &root_dir))
1251 if (mailbox_list_try_mkdir_root_parent(list, type,
1271 int mailbox_list_mkdir_root(struct mailbox_list *list, const char *path,
1276 if (mailbox_list_try_mkdir_root(list, path, type, &error) < 0) {
1277 mailbox_list_set_critical(list, "%s", error);
1281 list->index_root_dir_created = TRUE;
1286 mailbox_list_is_valid_fs_name(struct mailbox_list *list, const char *name,
1293 if (list->mail_set->mail_full_filesystem_access ||
1294 list->set.no_fs_validation)
1297 /* either the list backend uses '/' as the hierarchy separator or
1299 if ((list->props & MAILBOX_LIST_PROP_NO_ROOT) == 0 &&
1300 mailbox_list_get_hierarchy_sep(list) != '/' &&
1323 allow_internal_dirs = list->v.is_internal_name == NULL ||
1324 *list->set.maildir_name != '\0' ||
1325 (list->props & MAILBOX_LIST_PROP_NO_INTERNAL_NAMES) != 0;
1347 if (*list->set.maildir_name != '\0' &&
1348 strcmp(list->set.maildir_name, n) == 0) {
1355 list->v.is_internal_name(list, n)) {
1367 bool mailbox_list_is_valid_name(struct mailbox_list *list,
1371 if (*list->ns->prefix != '\0') {
1380 return mailbox_list_is_valid_fs_name(list, name, error_r);
1383 int mailbox_list_get_path(struct mailbox_list *list, const char *name,
1389 if ((ret = list->v.get_path(list, name, type, path_r)) <= 0)
1396 bool mailbox_list_get_root_path(struct mailbox_list *list,
1402 if ((ret = list->v.get_path(list, NULL, type, path_r)) < 0)
1411 const char *mailbox_list_get_root_forced(struct mailbox_list *list,
1416 if (!mailbox_list_get_root_path(list, type, &path))
1496 const char *mailbox_list_get_temp_prefix(struct mailbox_list *list)
1498 return list->v.get_temp_prefix(list, FALSE);
1501 const char *mailbox_list_get_global_temp_prefix(struct mailbox_list *list)
1503 return list->v.get_temp_prefix(list, TRUE);
1506 const char *mailbox_list_join_refpattern(struct mailbox_list *list,
1509 if (list->v.join_refpattern != NULL)
1510 return list->v.join_refpattern(list, ref, pattern);
1520 int mailbox_has_children(struct mailbox_list *list, const char *name)
1527 mail_namespace_get_sep(list->ns));
1528 iter = mailbox_list_iter_init(list, pattern,
1536 int mailbox_list_mailbox(struct mailbox_list *list, const char *name,
1544 if ((list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
1554 list=Maildir++ (for indexes), but list->ns->list=imapc */
1555 box = mailbox_alloc(list->ns->list, "INBOX", 0);
1564 mailbox_list_set_error(list, error, errstr);
1580 if (list->v.get_mailbox_flags == NULL) {
1586 vname = mailbox_list_get_vname(list, name);
1587 iter = mailbox_list_iter_init(list, vname, 0);
1596 if (!list->set.iter_from_index_dir) {
1597 rootdir = mailbox_list_get_root_forced(list, MAILBOX_LIST_PATH_TYPE_MAILBOX);
1598 if (mailbox_list_get_path(list, name, MAILBOX_LIST_PATH_TYPE_DIR, &path) <= 0)
1601 rootdir = mailbox_list_get_root_forced(list, MAILBOX_LIST_PATH_TYPE_INDEX);
1602 if (mailbox_list_get_path(list, name, MAILBOX_LIST_PATH_TYPE_INDEX, &path) <= 0)
1618 } else if ((list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
1627 (list->ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0) {
1630 if (mailbox_list_get_path(list, "INBOX",
1639 return list->v.get_mailbox_flags(list, dir, fname,
1644 static bool mailbox_list_init_changelog(struct mailbox_list *list)
1649 if (list->changelog != NULL)
1654 if (!mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_INDEX, &path))
1658 list->changelog = mailbox_log_alloc(path);
1660 mailbox_list_get_root_permissions(list, &perm);
1661 mailbox_log_set_permissions(list->changelog, perm.file_create_mode,
1667 int mailbox_list_mkdir_missing_index_root(struct mailbox_list *list)
1671 if (list->index_root_dir_created)
1677 if (!mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_INDEX,
1681 if (mailbox_list_mkdir_root(list, index_dir,
1684 list->index_root_dir_created = TRUE;
1688 int mailbox_list_mkdir_missing_list_index_root(struct mailbox_list *list)
1692 if (list->set.list_index_dir == NULL)
1693 return mailbox_list_mkdir_missing_index_root(list);
1696 if (list->list_index_root_dir_created)
1699 if (!mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_LIST_INDEX,
1702 if (mailbox_list_mkdir_root(list, index_dir,
1705 list->list_index_root_dir_created = TRUE;
1709 void mailbox_list_add_change(struct mailbox_list *list,
1716 if (!mailbox_list_init_changelog(list) ||
1720 if (mailbox_list_mkdir_missing_index_root(list) <= 0)
1723 stamp = list->changelog_timestamp != (time_t)-1 ?
1724 list->changelog_timestamp : ioloop_time;
1730 (void)mailbox_log_append(list->changelog, &rec);
1733 int mailbox_list_set_subscribed(struct mailbox_list *list,
1738 /* make sure we'll refresh the file on next list */
1739 list->subscriptions_mtime = (time_t)-1;
1741 if ((ret = list->v.set_subscribed(list, name, set)) <= 0)
1746 int mailbox_list_delete_dir(struct mailbox_list *list, const char *name)
1750 if (!mailbox_list_is_valid_name(list, name, &error) || *name == '\0') {
1751 mailbox_list_set_error(list, MAIL_ERROR_PARAMS,
1755 return list->v.delete_dir(list, name);
1758 int mailbox_list_delete_symlink(struct mailbox_list *list, const char *name)
1762 if (!mailbox_list_is_valid_name(list, name, &error) || *name == '\0') {
1763 mailbox_list_set_error(list, MAIL_ERROR_PARAMS,
1767 return list->v.delete_symlink(list, name);
1778 struct mailbox_log *mailbox_list_get_changelog(struct mailbox_list *list)
1780 return !mailbox_list_init_changelog(list) ? NULL : list->changelog;
1783 void mailbox_list_set_changelog_timestamp(struct mailbox_list *list,
1786 list->changelog_timestamp = stamp;
1818 int mailbox_list_dirent_is_alias_symlink(struct mailbox_list *list,
1833 mailbox_list_set_critical(list,
1852 mailbox_list_try_get_home_path(struct mailbox_list *list, const char **name)
1856 if (mail_user_try_home_expand(list->ns->user, name) < 0)
1866 bool mailbox_list_try_get_absolute_path(struct mailbox_list *list,
1872 if (!list->mail_set->mail_full_filesystem_access)
1877 if (!mailbox_list_try_get_home_path(list, name)) {
1888 root_dir = mailbox_list_get_root_forced(list, MAILBOX_LIST_PATH_TYPE_MAILBOX);
1892 if (mailbox_list_get_path(list, mailbox_name,
1906 const char *mailbox_list_get_last_error(struct mailbox_list *list,
1910 *error_r = list->error;
1912 return list->error_string != NULL ? list->error_string :
1913 "Unknown internal list error";
1916 enum mail_error mailbox_list_get_last_mail_error(struct mailbox_list *list)
1918 return list->error;
1921 const char *mailbox_list_get_last_internal_error(struct mailbox_list *list,
1925 *error_r = list->error;
1926 if (list->last_error_is_internal) {
1927 i_assert(list->last_internal_error != NULL);
1928 return list->last_internal_error;
1930 return mailbox_list_get_last_error(list, error_r);
1933 void mailbox_list_clear_error(struct mailbox_list *list)
1935 i_free_and_null(list->error_string);
1937 i_free(list->last_internal_error);
1938 list->last_error_is_internal = FALSE;
1939 list->error = MAIL_ERROR_NONE;
1942 void mailbox_list_set_error(struct mailbox_list *list,
1945 i_free(list->error_string);
1946 list->error_string = i_strdup(string);
1948 list->last_error_is_internal = FALSE;
1949 list->error = error;
1952 void mailbox_list_set_internal_error(struct mailbox_list *list)
1957 i_free(list->error_string);
1958 list->error_string = i_strdup(str);
1959 list->error = MAIL_ERROR_TEMP;
1962 void mailbox_list_set_critical(struct mailbox_list *list, const char *fmt, ...)
1966 i_free(list->last_internal_error);
1968 list->last_internal_error = i_strdup_vprintf(fmt, va);
1970 list->last_error_is_internal = TRUE;
1971 i_error("%s", list->last_internal_error);
1976 mailbox_list_set_internal_error(list);
1979 bool mailbox_list_set_error_from_errno(struct mailbox_list *list)
1987 mailbox_list_set_error(list, error, error_string);
1991 void mailbox_list_last_error_push(struct mailbox_list *list)
1995 if (!array_is_created(&list->error_stack))
1996 i_array_init(&list->error_stack, 2);
1997 err = array_append_space(&list->error_stack);
1998 err->error_string = i_strdup(list->error_string);
1999 err->error = list->error;
2000 err->last_error_is_internal = list->last_error_is_internal;
2002 err->last_internal_error = i_strdup(list->last_internal_error);
2005 void mailbox_list_last_error_pop(struct mailbox_list *list)
2007 unsigned int count = array_count(&list->error_stack);
2009 array_idx(&list->error_stack, count-1);
2011 i_free(list->error_string);
2012 i_free(list->last_internal_error);
2013 list->error_string = err->error_string;
2014 list->error = err->error;
2015 list->last_error_is_internal = err->last_error_is_internal;
2016 list->last_internal_error = err->last_internal_error;
2017 array_delete(&list->error_stack, count-1, 1);
2020 int mailbox_list_init_fs(struct mailbox_list *list, const char *driver,
2031 mail_user_init_fs_settings(list->ns->user, &fs_set, &ssl_set);
2033 fs_set.temp_file_prefix = mailbox_list_get_global_temp_prefix(list);
2043 ctx = p_new(list->pool, struct mailbox_list_fs_context, 1);
2044 ctx->list = list;
2061 return ctx == NULL ? NULL : ctx->list;
2064 int mailbox_list_lock(struct mailbox_list *list)
2070 if (list->lock_refcount > 0) {
2071 list->lock_refcount++;
2075 mailbox_list_get_root_permissions(list, &perm);
2077 set.lock_timeout_secs = list->mail_set->mail_max_lock_timeout == 0 ?
2079 I_MIN(MAILBOX_LIST_LOCK_SECS, list->mail_set->mail_max_lock_timeout);
2080 set.lock_method = list->mail_set->parsed_lock_method;
2086 if (list->set.volatile_dir != NULL) {
2091 sha1_get_digest(list->ns->prefix, list->ns->prefix_len,
2095 lock_dir = list->set.volatile_dir;
2097 } else if (mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_INDEX,
2100 if (mailbox_list_mkdir_missing_index_root(list) < 0)
2102 } else if (mailbox_list_get_root_path(list, MAILBOX_LIST_PATH_TYPE_DIR,
2105 if (mailbox_list_mkdir_root(list, lock_dir,
2109 /* No filesystem used by mailbox list (e.g. imapc).
2111 list->lock_refcount = 1;
2115 if (mail_storage_lock_create(lock_path, &set, list->mail_set,
2116 &list->lock, &error) <= 0) {
2117 mailbox_list_set_critical(list,
2118 "Couldn't create mailbox list lock %s: %s",
2123 list->lock_refcount = 1;
2127 void mailbox_list_unlock(struct mailbox_list *list)
2129 i_assert(list->lock_refcount > 0);
2130 if (--list->lock_refcount > 0)
2133 file_lock_free(&list->lock);