static void fts_filter_stopwords_destroy(struct fts_filter *filter)
{
struct fts_filter_stopwords *sp = (struct fts_filter_stopwords *)filter;
if (hash_table_is_created(sp->stopwords))
hash_table_destroy(&sp->stopwords);
pool_unref(&sp->pool);
}
static void passwd_file_free(struct passwd_file *pw)
{
if (hash_table_is_created(pw->db->files))
hash_table_remove(pw->db->files, pw->path);
passwd_file_close(pw);
i_free(pw->path);
i_free(pw);
}
void mailbox_guid_cache_refresh(struct mailbox_list *list)
{
struct mailbox_list_iterate_context *ctx;
const struct mailbox_info *info;
struct mailbox *box;
struct mailbox_metadata metadata;
struct mailbox_guid_cache_rec *rec;
uint8_t *guid_p;
if (!hash_table_is_created(list->guid_cache)) {
list->guid_cache_pool =
pool_alloconly_create("guid cache", 1024*16);
hash_table_create(&list->guid_cache, list->guid_cache_pool, 0,
guid_128_hash, guid_128_cmp);
} else {
hash_table_clear(list->guid_cache, TRUE);
p_clear(list->guid_cache_pool);
}
list->guid_cache_invalidated = FALSE;
list->guid_cache_updated = FALSE;
list->guid_cache_errors = FALSE;
ctx = mailbox_list_iter_init(list, "*",
MAILBOX_LIST_ITER_SKIP_ALIASES |
MAILBOX_LIST_ITER_NO_AUTO_BOXES);
while ((info = mailbox_list_iter_next(ctx)) != NULL) {
if ((info->flags &
(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT)) != 0)
continue;
box = mailbox_alloc(list, info->vname, 0);
if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID,
&metadata) < 0) {
i_error("Couldn't get mailbox %s GUID: %s",
info->vname, mailbox_get_last_internal_error(box, NULL));
list->guid_cache_errors = TRUE;
} else if ((rec = hash_table_lookup(list->guid_cache,
(const uint8_t *)metadata.guid)) != NULL) {
i_warning("Mailbox %s has duplicate GUID with %s: %s",
info->vname, rec->vname,
guid_128_to_string(metadata.guid));
} else {
rec = p_new(list->guid_cache_pool,
struct mailbox_guid_cache_rec, 1);
memcpy(rec->guid, metadata.guid, sizeof(rec->guid));
rec->vname = p_strdup(list->guid_cache_pool, info->vname);
guid_p = rec->guid;
hash_table_insert(list->guid_cache, guid_p, rec);
}
mailbox_free(&box);
}
if (mailbox_list_iter_deinit(&ctx) < 0)
list->guid_cache_errors = TRUE;
}
static struct dsync_mailbox_node *
dsync_mailbox_tree_find_sha(struct dsync_mailbox_tree *tree,
struct mail_namespace *ns, const guid_128_t sha128)
{
struct dsync_mailbox_node *node;
if (!hash_table_is_created(tree->name128_hash))
dsync_mailbox_tree_build_name128_hash(tree);
node = hash_table_lookup(tree->name128_hash, sha128);
return node == NULL || node->ns != ns ? NULL : node;
}
static void passwd_file_close(struct passwd_file *pw)
{
if (pw->fd != -1) {
if (close(pw->fd) < 0)
i_error("passwd-file %s: close() failed: %m", pw->path);
pw->fd = -1;
}
if (hash_table_is_created(pw->users))
hash_table_destroy(&pw->users);
if (pw->pool != NULL)
pool_unref(&pw->pool);
}
static int
fts_filter_stopwords_filter(struct fts_filter *filter, const char **token,
const char **error_r)
{
struct fts_filter_stopwords *sp =
(struct fts_filter_stopwords *) filter;
if (!hash_table_is_created(sp->stopwords)) {
hash_table_create(&sp->stopwords, sp->pool, 0, str_hash, strcmp);
if (fts_filter_stopwords_read_list(sp, error_r) < 0)
return -1;
}
return hash_table_lookup(sp->stopwords, *token) == NULL ? 1 : 0;
}
static struct passwd_file *
passwd_file_new(struct db_passwd_file *db, const char *expanded_path)
{
struct passwd_file *pw;
pw = i_new(struct passwd_file, 1);
pw->db = db;
pw->path = i_strdup(expanded_path);
pw->fd = -1;
if (hash_table_is_created(db->files))
hash_table_insert(db->files, pw->path, pw);
return pw;
}
static void sieve_extension_registry_deinit(struct sieve_instance *svinst)
{
struct sieve_extension_registry *ext_reg = svinst->ext_reg;
struct sieve_extension * const *exts;
unsigned int i, ext_count;
if ( !hash_table_is_created(ext_reg->extension_index) ) return;
exts = array_get_modifiable(&ext_reg->extensions, &ext_count);
for ( i = 0; i < ext_count; i++ ) {
_sieve_extension_unload(exts[i]);
}
hash_table_destroy(&ext_reg->extension_index);
}
int mailbox_guid_cache_find(struct mailbox_list *list,
const guid_128_t guid, const char **vname_r)
{
const struct mailbox_guid_cache_rec *rec;
const uint8_t *guid_p = guid;
if (!hash_table_is_created(list->guid_cache) ||
list->guid_cache_invalidated) {
mailbox_guid_cache_refresh(list);
rec = hash_table_lookup(list->guid_cache, guid_p);
} else {
rec = hash_table_lookup(list->guid_cache, guid_p);
if (rec == NULL && list->guid_cache_updated) {
mailbox_guid_cache_refresh(list);
rec = hash_table_lookup(list->guid_cache, guid_p);
}
}
if (rec == NULL) {
*vname_r = NULL;
return list->guid_cache_errors ? -1 : 0;
}
*vname_r = rec->vname;
return 0;
}
static int passwd_file_sync(struct auth_request *request,
struct passwd_file *pw)
{
struct stat st;
const char *error;
if (pw->last_sync_time == ioloop_time)
return hash_table_is_created(pw->users) ? 0 : -1;
pw->last_sync_time = ioloop_time;
if (stat(pw->path, &st) < 0) {
/* with variables don't give hard errors, or errors about
nonexistent files */
if (errno == EACCES) {
auth_request_log_error(request, AUTH_SUBSYS_DB,
"%s", eacces_error_get("stat", pw->path));
} else {
auth_request_log_error(request, AUTH_SUBSYS_DB,
"stat(%s) failed: %m", pw->path);
}
if (pw->db->default_file != pw)
passwd_file_free(pw);
return -1;
}
if (st.st_mtime != pw->stamp || st.st_size != pw->size) {
passwd_file_close(pw);
if (passwd_file_open(pw, FALSE, &error) < 0) {
auth_request_log_error(request, AUTH_SUBSYS_DB,
"%s", error);
return -1;
}
}
return 0;
}