Lines Matching refs:storage
26 #include "mail-storage-private.h"
27 #include "mail-storage-settings.h"
45 .name = "storage",
160 /* no autodetection if the storage driver is given. */
187 "Unknown mail storage driver %s", driver);
203 /* root not required for this storage */
227 "Mail storage autodetection failed with home=%s", home);
283 /* storage doesn't use directories (e.g. shared root) */
294 i_debug("Namespace %s: Creating storage despite: %s",
309 mail_storage_match_class(struct mail_storage *storage,
313 if (strcmp(storage->name, storage_class->name) != 0)
316 if ((storage->class_flags & MAIL_STORAGE_CLASS_FLAG_UNIQUE_ROOT) != 0 &&
317 strcmp(storage->unique_root_dir,
321 if (strcmp(storage->name, "shared") == 0) {
333 struct mail_storage *storage = user->storages;
335 for (; storage != NULL; storage = storage->next) {
336 if (mail_storage_match_class(storage, storage_class, set))
337 return storage;
347 struct mail_storage *storage_class, *storage = NULL;
390 /* first storage for namespace */
409 storage = mail_storage_find(ns->user, storage_class, &list_set);
410 if (storage != NULL) {
411 /* using an existing storage */
412 storage->refcount++;
413 mail_namespace_add_storage(ns, storage);
414 *storage_r = storage;
418 storage = storage_class->v.alloc();
419 storage->refcount = 1;
420 storage->storage_class = storage_class;
421 storage->user = ns->user;
422 storage->set = ns->mail_set;
423 storage->flags = flags;
424 p_array_init(&storage->module_contexts, storage->pool, 5);
426 if (storage->v.create != NULL &&
427 storage->v.create(storage, ns, error_r) < 0) {
428 *error_r = t_strdup_printf("%s: %s", storage->name, *error_r);
429 pool_unref(&storage->pool);
434 hook_mail_storage_created(storage);
437 i_assert(storage->unique_root_dir != NULL ||
438 (storage->class_flags & MAIL_STORAGE_CLASS_FLAG_UNIQUE_ROOT) == 0);
439 DLLIST_PREPEND(&ns->user->storages, storage);
440 mail_namespace_add_storage(ns, storage);
441 *storage_r = storage;
448 struct mail_storage *storage;
451 flags, &storage, error_r);
456 struct mail_storage *storage = *_storage;
458 i_assert(storage->refcount > 0);
461 for example mdbox wants to access ns->storage */
462 if (--storage->refcount > 0) {
467 if (storage->mailboxes != NULL) {
468 i_panic("Trying to deinit storage without freeing mailbox %s",
469 storage->mailboxes->vname);
471 if (storage->obj_refcount != 0)
472 i_panic("Trying to deinit storage before freeing its objects");
474 DLLIST_REMOVE(&storage->user->storages, storage);
476 storage->v.destroy(storage);
477 i_free(storage->last_internal_error);
478 i_free(storage->error_string);
479 if (array_is_created(&storage->error_stack)) {
480 i_assert(array_count(&storage->error_stack) == 0);
481 array_free(&storage->error_stack);
485 pool_unref(&storage->pool);
490 void mail_storage_obj_ref(struct mail_storage *storage)
492 i_assert(storage->refcount > 0);
494 if (storage->obj_refcount++ == 0)
495 mail_user_ref(storage->user);
498 void mail_storage_obj_unref(struct mail_storage *storage)
500 i_assert(storage->refcount > 0);
501 i_assert(storage->obj_refcount > 0);
503 if (--storage->obj_refcount == 0) {
504 struct mail_user *user = storage->user;
509 void mail_storage_clear_error(struct mail_storage *storage)
511 i_free_and_null(storage->error_string);
513 i_free(storage->last_internal_error);
514 storage->last_error_is_internal = FALSE;
515 storage->error = MAIL_ERROR_NONE;
518 void mail_storage_set_error(struct mail_storage *storage,
521 if (storage->error_string != string) {
522 i_free(storage->error_string);
523 storage->error_string = i_strdup(string);
525 storage->last_error_is_internal = FALSE;
526 storage->error = error;
529 void mail_storage_set_internal_error(struct mail_storage *storage)
535 i_free(storage->error_string);
536 storage->error_string = i_strdup(str);
537 storage->error = MAIL_ERROR_TEMP;
541 storage->last_error_is_internal = FALSE;
544 void mail_storage_set_critical(struct mail_storage *storage,
547 char *old_error = storage->error_string;
548 char *old_internal_error = storage->last_internal_error;
551 storage->error_string = NULL;
552 storage->last_internal_error = NULL;
556 mail_storage_set_internal_error(storage);
559 storage->last_internal_error = i_strdup_vprintf(fmt, va);
561 storage->last_error_is_internal = TRUE;
562 e_error(storage->user->event, "%s", storage->last_internal_error);
576 mail_storage_set_critical(box->storage, "Mailbox %s: %s",
599 const char *mail_storage_get_last_internal_error(struct mail_storage *storage,
603 *error_r = storage->error;
604 if (storage->last_error_is_internal) {
605 i_assert(storage->last_internal_error != NULL);
606 return storage->last_internal_error;
608 return mail_storage_get_last_error(storage, error_r);
631 void mail_storage_copy_list_error(struct mail_storage *storage,
638 mail_storage_set_error(storage, error, str);
647 mail_storage_set_index_error(box->storage, box->index);
651 void mail_storage_set_index_error(struct mail_storage *storage,
656 mail_storage_set_internal_error(storage);
661 storage->last_internal_error = i_strdup(index_error);
662 storage->last_error_is_internal = TRUE;
667 mail_storage_get_settings(struct mail_storage *storage)
669 return storage->set;
672 struct mail_user *mail_storage_get_user(struct mail_storage *storage)
674 return storage->user;
677 void mail_storage_set_callbacks(struct mail_storage *storage,
681 storage->callbacks = *callbacks;
682 storage->callback_context = context;
685 int mail_storage_purge(struct mail_storage *storage)
687 return storage->v.purge == NULL ? 0 :
688 storage->v.purge(storage);
691 const char *mail_storage_get_last_error(struct mail_storage *storage,
695 error. If storage->error is NONE, it means we forgot to set it at
697 if (storage->error == MAIL_ERROR_NONE) {
700 return storage->error_string != NULL ? storage->error_string :
704 if (storage->error_string == NULL) {
706 storage->error_string =
708 storage->error);
712 *error_r = storage->error;
713 return storage->error_string;
719 return mail_storage_get_last_error(box->storage, error_r);
726 mail_storage_get_last_error(box->storage, &error);
730 void mail_storage_last_error_push(struct mail_storage *storage)
734 if (!array_is_created(&storage->error_stack))
735 i_array_init(&storage->error_stack, 2);
736 err = array_append_space(&storage->error_stack);
737 err->error_string = i_strdup(storage->error_string);
738 err->error = storage->error;
739 err->last_error_is_internal = storage->last_error_is_internal;
741 err->last_internal_error = i_strdup(storage->last_internal_error);
744 void mail_storage_last_error_pop(struct mail_storage *storage)
746 unsigned int count = array_count(&storage->error_stack);
748 array_idx(&storage->error_stack, count-1);
750 i_free(storage->error_string);
751 i_free(storage->last_internal_error);
752 storage->error_string = err->error_string;
753 storage->error = err->error;
754 storage->last_error_is_internal = err->last_error_is_internal;
755 storage->last_internal_error = err->last_internal_error;
756 array_delete(&storage->error_stack, count-1, 1);
759 bool mail_storage_is_mailbox_file(struct mail_storage *storage)
761 return (storage->class_flags &
765 bool mail_storage_set_error_from_errno(struct mail_storage *storage)
772 if (storage->set->mail_debug && error != MAIL_ERROR_NOTFOUND) {
779 mail_storage_set_error(storage, error, error_string);
811 struct mail_storage *storage;
841 if (mailbox_list_get_storage(&new_list, vname, &storage) < 0) {
843 storage = mail_namespace_get_default_storage(list->ns);
848 box = storage->v.mailbox_alloc(storage, new_list, vname, flags);
852 mail_storage_set_error(storage, open_error, errstr);
856 DLLIST_PREPEND(&box->storage->mailboxes, box);
857 mail_storage_obj_ref(box->storage);
992 !box->storage->user->inbox_open_error_logged) {
993 box->storage->user->inbox_open_error_logged = TRUE;
1082 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1099 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS, t_strdup_printf(
1108 !box->storage->set->mail_full_filesystem_access) {
1109 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1116 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1137 if (box->storage->error != MAIL_ERROR_NOTFOUND ||
1172 check vname instead of storage name, because vname is what is
1173 visible to users, while storage name may be a fixed length GUID. */
1179 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1184 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1194 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1202 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1261 have_listable_namespace_prefix(box->storage->user->namespaces,
1283 if (box->storage->set->mail_debug && box->reason != NULL) {
1292 mail_storage_set_error(box->storage, MAIL_ERROR_NOTFOUND,
1296 mail_storage_set_internal_error(box->storage);
1297 box->storage->error = box->open_error;
1305 if ((box->storage->class_flags &
1320 if (ret < 0 && box->storage->error == MAIL_ERROR_NOTFOUND &&
1344 a loop: mdbox storage rebuild -> mailbox_open() ->
1346 mdbox storage rebuild. */
1365 /* check that the storage supports stubs if require them */
1367 ((box->storage->storage_class->class_flags & MAIL_STORAGE_CLASS_FLAG_STUBS) == 0)) {
1368 mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,
1410 box->index_pvt = mail_index_alloc_cache_get(box->storage->user->event,
1413 box->storage->set->parsed_fsync_mode, 0);
1415 box->storage->set->parsed_lock_method,
1416 mail_storage_get_lock_timeout(box->storage, UINT_MAX));
1433 mail_storage_settings_to_index_flags(box->storage->set);
1459 void mail_storage_free_binary_cache(struct mail_storage *storage)
1461 if (storage->binary_cache.box == NULL)
1464 timeout_remove(&storage->binary_cache.to);
1465 i_stream_destroy(&storage->binary_cache.input);
1466 i_zero(&storage->binary_cache);
1480 if (box->storage->binary_cache.box == box)
1481 mail_storage_free_binary_cache(box->storage);
1506 DLLIST_REMOVE(&box->storage->mailboxes, box);
1507 mail_storage_obj_unref(box->storage);
1537 mail_namespace_find_inbox(box->storage->user->namespaces);
1576 mail_storage_copy_list_error(box->storage, box->list);
1591 mail_storage_last_error_push(box->storage);
1593 mail_storage_last_error_pop(box->storage);
1674 mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
1688 mail_storage_copy_list_error(box->storage, box->list);
1734 *error_r = t_strdup_printf("storage %s != %s",
1739 /* e.g. mdbox where all mails are in storage/ directory and
1741 *error_r = t_strdup_printf("storage %s uses unique root",
1802 mail_storage_set_error(src->storage, MAIL_ERROR_PARAMS,
1811 mail_storage_copy_list_error(src->storage, src->list);
1825 mail_storage_set_error(src->storage, MAIL_ERROR_PARAMS,
1830 mail_storage_copy_error(src->storage, dest->storage);
1837 if (!mail_storages_rename_compatible(src->storage,
1838 dest->storage, &error) ||
1841 if (src->storage->set->mail_debug) {
1845 mail_storage_set_error(src->storage, MAIL_ERROR_NOTPOSSIBLE,
1852 mail_storage_set_error(src->storage, MAIL_ERROR_NOTPOSSIBLE,
1857 mail_storage_set_error(src->storage, MAIL_ERROR_EXISTS,
1866 mail_storage_copy_list_error(src->storage, dest->list);
1883 mail_storage_copy_list_error(box->storage, box->list);
1903 return box->storage;
1914 return box->storage->set;
1954 if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_HAVE_MAIL_GUIDS) != 0)
1956 if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_HAVE_MAIL_SAVE_GUIDS) != 0)
1958 if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_HAVE_MAIL_GUID128) != 0)
2068 !box->storage->user->inbox_open_error_logged) {
2071 box->storage->user->inbox_open_error_logged = TRUE;
2453 mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,
2599 /* bypass virtual storage, so hard linking can be used whenever
2674 mail_storage_set_error(box->storage, MAIL_ERROR_NOTFOUND,
2694 mail_storage_copy_list_error(box->storage, box->list);
2789 mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,
2792 } else if (mail_storage_set_error_from_errno(box->storage)) {
2826 mail_storage_copy_list_error(box->storage, box->list);
2838 mail_storage_set_error(box->storage, MAIL_ERROR_NOTPOSSIBLE,
2841 } else if (mail_storage_set_error_from_errno(box->storage)) {
2878 if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_NO_ROOT) == 0 &&
2891 unsigned int mail_storage_get_lock_timeout(struct mail_storage *storage,
2894 return storage->set->mail_max_lock_timeout == 0 ? secs :
2895 I_MIN(secs, storage->set->mail_max_lock_timeout);
2968 /* update also the storage's internal error */
3032 mail_storage_get_lock_timeout(box->storage, lock_secs);
3033 set.lock_method = box->storage->set->parsed_lock_method;
3059 box->storage->set, lock_r, error_r);