mail-storage.c revision 5a077c8c1666edb34479cca42105449c8f89ffc2
/* Copyright (c) 2002-2009 Dovecot authors, see the included COPYING file */
#include "lib.h"
#include "ioloop.h"
#include "array.h"
#include "var-expand.h"
#include "mail-index-private.h"
#include "mailbox-list-private.h"
#include "mail-storage-private.h"
#include "mail-storage-settings.h"
#include "mail-namespace.h"
#include "mail-search.h"
#include "mailbox-search-result-private.h"
#include <stdlib.h>
#include <ctype.h>
struct mail_storage_module_register mail_storage_module_register = { 0 };
struct mail_module_register mail_module_register = { 0 };
void mail_storage_init(void)
{
}
void mail_storage_deinit(void)
{
}
{
storage_class->v.class_init();
/* append it after the list, so the autodetection order is correct */
}
{
struct mail_storage *const *classes;
unsigned int i, count;
for (i = 0; i < count; i++) {
if (classes[i] == storage_class) {
break;
}
}
storage_class->v.class_deinit();
}
{
struct mail_storage *const *classes;
unsigned int i, count;
for (i = 0; i < count; i++) {
return classes[i];
}
return NULL;
}
static struct mail_storage *
{
struct mail_storage *const *classes;
unsigned int i, count;
for (i = 0; i < count; i++) {
return classes[i];
}
return NULL;
}
static void
enum mail_storage_flags *flags)
{
const char *p;
/* check if data is in driver:data format (eg. mbox:~/mail) */
p = *data;
while (i_isalnum(*p)) p++;
if (*p == ':' && p != *data) {
/* no autodetection if the storage format is given. */
*data = p + 1;
}
}
{
struct mail_storage *const *classes;
const char *home, *p;
unsigned int i, count;
if ((flags & MAIL_STORAGE_FLAG_KEEP_HEADER_MD5) == 0 &&
/* if pop3_uidl_format contains %m, we want to keep the
header MD5 sums stored even if we're not running POP3
right now. */
if (p[1] == '%')
p += 2;
else if (var_get_key(++p) == 'm') {
break;
}
}
}
data = "";
/* use the first driver that works */
if (storage_class == NULL) {
"Ambiguous mail location setting, "
"don't know what to do with it: %s "
"(try prefixing it with mbox: or maildir:)",
data);
return -1;
}
classes = &storage_class;
count = 1;
} else {
if (storage_class == NULL) {
"Unknown mail storage driver %s", driver);
return -1;
}
classes = &storage_class;
count = 1;
}
for (i = 0; i < count; i++) {
&storage->lock_method)) {
i_fatal("Unknown lock_method: %s",
}
break;
i_info("%s: Couldn't create mail storage %s: %s",
}
/* try the next one */
}
if (i == count) {
if (count <= 1) {
*error_r);
return -1;
}
"Mail storage autodetection failed with home=%s", home);
return -1;
}
if (hook_mail_storage_created != NULL) {
T_BEGIN {
} T_END;
}
return 0;
}
{
}
{
}
{
}
{
char str[256];
MAIL_ERRSTR_CRITICAL_MSG_STAMP, tm) > 0 ?
}
const char *fmt, ...)
{
/* critical errors may contain sensitive data, so let user
see only "Internal error" with a timestamp to make it
easier to look from log files the actual error message. */
}
}
{
}
{
}
struct mail_namespace *
{
}
const struct mail_storage_settings *
{
}
struct mail_storage_callbacks *callbacks,
void *context)
{
}
bool directory)
{
"Invalid mailbox name");
return -1;
}
}
{
}
enum mail_error *error_r)
{
/* We get here only in error situations, so we have to return some
error. If storage->error is NONE, it means we forgot to set it at
some point.. */
"BUG: Unknown internal error";
}
/* This shouldn't happen.. */
i_strdup_printf("BUG: Unknown 0x%x error",
}
return storage->error_string;
}
{
if (*name == '\0')
}
const char *name)
{
if (*name == '\0')
}
const char *name)
{
if (*name == '\0')
}
{
const char *dir;
}
return storage->temp_path_prefix;
}
{
const char *error_string;
enum mail_error error;
return FALSE;
/* debugging is enabled - admin may be debugging a
(permission) problem, so return FALSE to get the caller to
log the full error message. */
return FALSE;
}
return TRUE;
}
enum mailbox_open_flags flags)
{
return NULL;
}
"Invalid mailbox name");
return NULL;
}
T_BEGIN {
} T_END;
return box;
}
{
}
{
return box->enabled_features;
}
{
if (box->transaction_count != 0) {
i_panic("Trying to close mailbox %s with open transactions",
}
}
{
}
{
}
{
}
{
}
{
}
enum mailbox_status_items items,
struct mailbox_status *status_r)
{
}
struct mailbox_sync_context *
{
if (box->transaction_count != 0) {
i_panic("Trying to sync mailbox %s with open transactions",
}
}
struct mailbox_sync_rec *sync_rec_r)
{
}
struct mailbox_status *status_r)
{
}
struct mailbox_status *status_r)
{
struct mailbox_sync_context *ctx;
/* we don't care about mailbox's current state, so we might
as well fix inconsistency state */
}
}
{
}
{
}
struct mail_keywords **keywords_r)
{
const char *empty_keyword_list = NULL;
}
struct mail_keywords *
const char *const keywords[])
{
const char *empty_keyword_list = NULL;
struct mail_keywords *kw;
i_unreached();
return kw;
}
struct mail_keywords **_keywords)
{
}
const char **error_r)
{
}
{
}
{
}
{
}
{
return FALSE;
backend_uid, uid_r);
}
bool only_with_msgs)
{
else
}
{
struct mailbox_virtual_pattern pat;
} else {
}
}
struct mailbox_header_lookup_ctx *
{
}
{
}
{
}
struct mail_search_context *
mailbox_search_init(struct mailbox_transaction_context *t,
struct mail_search_args *args,
const enum mail_sort_type *sort_program)
{
if (!args->simplified)
}
{
int ret;
return ret;
}
{
bool tryagain;
int ret;
&tryagain)) == 0) {
if (!tryagain)
break;
}
return ret;
}
{
int ret;
if (ret > 0)
return ret;
}
{
return ctx->seen_lost_data;
}
int mailbox_search_result_build(struct mailbox_transaction_context *t,
struct mail_search_args *args,
struct mail_search_result **result_r)
{
struct mail_search_context *ctx;
int ret;
if (ret < 0)
return ret;
}
struct mailbox_transaction_context *
{
struct mailbox_transaction_context *trans;
box->transaction_count++;
return trans;
}
int mailbox_transaction_commit(struct mailbox_transaction_context **t)
{
/* Store the return values to separate temporary variables so that
plugins overriding transaction_commit() can look at them. */
return mailbox_transaction_commit_get_uids(t, &uidvalidity,
}
{
struct mailbox_transaction_context *t = *_t;
t->box->transaction_count--;
}
{
struct mailbox_transaction_context *t = *_t;
t->box->transaction_count--;
t->box->v.transaction_rollback(t);
}
{
return box->transaction_count;
}
void mailbox_transaction_set_max_modseq(struct mailbox_transaction_context *t,
{
}
struct mailbox *
mailbox_transaction_get_mailbox(const struct mailbox_transaction_context *t)
{
return t->box;
}
struct mail_save_context *
mailbox_save_alloc(struct mailbox_transaction_context *t)
{
struct mail_save_context *ctx;
return ctx;
}
enum mail_flags flags,
struct mail_keywords *keywords)
{
}
{
}
const char *envelope)
{
}
{
}
{
}
{
int ret;
"Saving messages not supported");
ret = -1;
} else {
}
if (ret < 0) {
return -1;
}
return 0;
}
{
}
{
}
{
}
{
}
{
}
{
"Mailbox was deleted under us");
}