int mail_transaction_log_open(struct mail_transaction_log *log)
{
struct mail_transaction_log_file *file;
const char *reason;
int ret;
i_free(log->filepath);
i_free(log->filepath2);
log->filepath = i_strconcat(log->index->filepath,
MAIL_TRANSACTION_LOG_SUFFIX, NULL);
log->filepath2 = i_strconcat(log->filepath, ".2", NULL);
/* these settings aren't available at alloc() time, so we need to
set them here: */
log->nfs_flush =
(log->index->flags & MAIL_INDEX_OPEN_FLAG_NFS_FLUSH) != 0;
if (log->open_file != NULL)
mail_transaction_log_file_free(&log->open_file);
if (MAIL_INDEX_IS_IN_MEMORY(log->index))
return 0;
file = mail_transaction_log_file_alloc(log, log->filepath);
if ((ret = mail_transaction_log_file_open(file, &reason)) <= 0) {
/* leave the file for _create() */
log->open_file = file;
return ret;
}
mail_transaction_log_set_head(log, file);
return 1;
}
struct mdbox_map *
mdbox_map_init(struct mdbox_storage *storage, struct mailbox_list *root_list)
{
struct mdbox_map *map;
const char *root, *index_root;
root = mailbox_list_get_root_forced(root_list, MAILBOX_LIST_PATH_TYPE_DIR);
index_root = mailbox_list_get_root_forced(root_list, MAILBOX_LIST_PATH_TYPE_INDEX);
map = i_new(struct mdbox_map, 1);
map->storage = storage;
map->set = storage->set;
map->path = i_strconcat(root, "/"MDBOX_GLOBAL_DIR_NAME, NULL);
map->index_path =
i_strconcat(index_root, "/"MDBOX_GLOBAL_DIR_NAME, NULL);
map->index = mail_index_alloc(map->index_path,
MDBOX_GLOBAL_INDEX_PREFIX);
mail_index_set_fsync_mode(map->index,
MAP_STORAGE(map)->set->parsed_fsync_mode, 0);
mail_index_set_lock_method(map->index,
MAP_STORAGE(map)->set->parsed_lock_method,
mail_storage_get_lock_timeout(MAP_STORAGE(map), UINT_MAX));
map->root_list = root_list;
map->map_ext_id = mail_index_ext_register(map->index, "map",
sizeof(struct mdbox_map_mail_index_header),
sizeof(struct mdbox_map_mail_index_record),
sizeof(uint32_t));
map->ref_ext_id = mail_index_ext_register(map->index, "ref", 0,
sizeof(uint16_t), sizeof(uint16_t));
return map;
}
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;
}
struct maildir_keywords *
maildir_keywords_init_readonly(struct mailbox *box)
{
struct maildir_keywords *mk;
const char *dir;
if (mailbox_get_path_to(box, MAILBOX_LIST_PATH_TYPE_CONTROL, &dir) <= 0)
i_unreached();
mk = i_new(struct maildir_keywords, 1);
mk->storage = box->storage;
mk->path = i_strconcat(dir, "/" MAILDIR_KEYWORDS_NAME, NULL);
mk->pool = pool_alloconly_create("maildir keywords", 512);
i_array_init(&mk->list, MAILDIR_MAX_KEYWORDS);
hash_table_create(&mk->hash, mk->pool, 0, strcase_hash, strcasecmp);
mk->dotlock_settings.use_excl_lock =
box->storage->set->dotlock_use_excl;
mk->dotlock_settings.nfs_flush =
box->storage->set->mail_nfs_storage;
mk->dotlock_settings.timeout =
mail_storage_get_lock_timeout(box->storage,
KEYWORDS_LOCK_STALE_TIMEOUT + 2);
mk->dotlock_settings.stale_timeout = KEYWORDS_LOCK_STALE_TIMEOUT;
mk->dotlock_settings.temp_prefix =
mailbox_list_get_temp_prefix(box->list);
return mk;
}
void testsuite_binary_init(void)
{
testsuite_binary_tmp = i_strconcat
(testsuite_tmp_dir_get(), "/binaries", NULL);
if ( mkdir(testsuite_binary_tmp, 0700) < 0 ) {
i_fatal("failed to create temporary directory '%s': %m.",
testsuite_binary_tmp);
}
}
struct squat_uidlist *squat_uidlist_init(struct squat_trie *trie)
{
struct squat_uidlist *uidlist;
uidlist = i_new(struct squat_uidlist, 1);
uidlist->trie = trie;
uidlist->path = i_strconcat(trie->path, ".uids", NULL);
uidlist->fd = -1;
return uidlist;
}
void mail_transaction_log_move_to_memory(struct mail_transaction_log *log)
{
struct mail_transaction_log_file *file;
if (!log->index->initial_mapped && log->files != NULL &&
log->files->hdr.prev_file_seq != 0) {
/* we couldn't read dovecot.index and we don't have the first
.log file, so just start from scratch */
mail_transaction_log_close(log);
}
i_free(log->filepath);
i_free(log->filepath2);
log->filepath = i_strconcat(log->index->filepath,
MAIL_TRANSACTION_LOG_SUFFIX, NULL);
log->filepath2 = i_strconcat(log->filepath, ".2", NULL);
if (log->head != NULL)
mail_transaction_log_file_move_to_memory(log->head);
else {
file = mail_transaction_log_file_alloc_in_memory(log);
mail_transaction_log_set_head(log, file);
}
}
int32_t elasticsearch_connection_init(const char *url, bool debug,
struct elasticsearch_connection **conn_r,
const char **error_r)
{
struct http_client_settings http_set;
struct elasticsearch_connection *conn = NULL;
struct http_url *http_url = NULL;
const char *error = NULL;
if (error_r == NULL || url == NULL || conn_r == NULL) {
i_debug("fts_elasticsearch: error initialising ElasticSearch connection");
return -1;
} else {
/* safe to continue */
}
/* validate the url */
if (http_url_parse(url, NULL, 0, pool_datastack_create(),
&http_url, &error) < 0) {
*error_r = t_strdup_printf(
"fts_elasticsearch: Failed to parse HTTP url: %s", error);
return -1;
}
conn = i_new(struct elasticsearch_connection, 1);
conn->http_host = i_strdup(http_url->host_name);
conn->http_port = http_url->port;
conn->http_base_url = i_strconcat(http_url->path, http_url->enc_query, NULL);
conn->http_ssl = http_url->have_ssl;
conn->debug = debug;
/* guard against init being called multiple times */
if (elasticsearch_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 5 * 1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.debug = debug;
elasticsearch_http_client = http_client_init(&http_set);
}
*conn_r = conn;
return 0;
}
int solr_connection_init(const char *url, bool debug,
struct solr_connection **conn_r, const char **error_r)
{
struct http_client_settings http_set;
struct solr_connection *conn;
struct http_url *http_url;
const char *error;
if (http_url_parse(url, NULL, 0, pool_datastack_create(),
&http_url, &error) < 0) {
*error_r = t_strdup_printf(
"fts_solr: Failed to parse HTTP url: %s", error);
return -1;
}
conn = i_new(struct solr_connection, 1);
conn->http_host = i_strdup(http_url->host.name);
conn->http_port = http_url->port;
conn->http_base_url = i_strconcat(http_url->path, http_url->enc_query, NULL);
conn->http_ssl = http_url->have_ssl;
conn->debug = debug;
if (solr_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 5*1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.debug = debug;
http_set.connect_timeout_msecs = 5*1000;
http_set.request_timeout_msecs = 60*1000;
solr_http_client = http_client_init(&http_set);
}
conn->xml_parser = XML_ParserCreate("UTF-8");
if (conn->xml_parser == NULL) {
i_fatal_status(FATAL_OUTOFMEM,
"fts_solr: Failed to allocate XML parser");
}
*conn_r = conn;
return 0;
}
static void
fs_quota_mount_init(struct fs_quota_root *root,
struct fs_quota_mountpoint *mount, const char *dir)
{
struct quota_root *const *roots;
unsigned int i, count;
#ifdef FS_QUOTA_SOLARIS
#ifdef HAVE_RQUOTA
if (mount_type_is_nfs(mount)) {
/* using rquota for this mount */
} else
#endif
if (mount->path == NULL) {
mount->path = i_strconcat(mount->mount_path, "/quotas", NULL);
mount->fd = open(mount->path, O_RDONLY);
if (mount->fd == -1 && errno != ENOENT)
i_error("open(%s) failed: %m", mount->path);
}
#endif
root->mount = mount;
if (root->root.quota->set->debug) {
i_debug("fs quota add mailbox dir = %s", dir);
i_debug("fs quota block device = %s", mount->device_path);
i_debug("fs quota mount point = %s", mount->mount_path);
i_debug("fs quota mount type = %s", mount->type);
}
/* if there are more unused quota roots, copy this mount to them */
roots = array_get(&root->root.quota->roots, &count);
for (i = 0; i < count; i++) {
root = (struct fs_quota_root *)roots[i];
if (QUOTA_ROOT_MATCH(root, mount) && root->mount == NULL) {
mount->refcount++;
root->mount = mount;
}
}
}
